public void testSmallCache() { // Check that we have the correctly configured cache assertEquals(smallCache.getCacheConfiguration().memory().size(), 10); } }
public void testTinyCache() { // Check that we have the correctly configured cache assertEquals(tinyCache.getCacheConfiguration().memory().size(), 1); }
public void testSuperLargeCache() { assertEquals(superLargeCache.getCacheConfiguration().memory().size(), 20); } }
public void testLargeCache() { assertEquals(largeCache.getCacheConfiguration().memory().size(), 10); }
public void testLargeCache() { assertEquals(largeCache.getCacheConfiguration().memory().size(), 100); }
public void testDefaultConfiguration() { assertEquals(cache.getCacheConfiguration().memory().size(), 16); assertEquals(cache.getName(), DEFAULT_CACHE_NAME); }
public void testSmallCache() { assertEquals(smallCache.getCacheConfiguration().memory().size(), 7); assertEquals(observers.getCacheStartedEventCount(), 1); }
public void testSpecificCacheManager() throws Exception { assertEquals(largeCache.getCacheConfiguration().memory().size(), 2000); assertEquals(largeCache.getCacheManager().getDefaultCacheConfiguration().memory().size(), 4000); assertEquals(smallCache.getCacheConfiguration().memory().size(), 20); assertEquals(smallCache.getCacheManager().getDefaultCacheConfiguration().memory().size(), 4000); // asserts that the small and large cache are defined in the same cache manager assertTrue(smallCache.getCacheManager().equals(largeCache.getCacheManager())); assertFalse(smallCache.getCacheManager().equals(cache.getCacheManager())); // check that the default configuration has not been modified assertEquals(cache.getCacheConfiguration().memory().size(), -1); } }
@Test public void testEvictionSize() { Configuration configuration = new ConfigurationBuilder() .memory().size(20) .build(); Assert.assertEquals(configuration.memory().size(), 20); }
public void testVeryLargeCache() { assertEquals(largeCache.getCacheConfiguration().memory().size(), 1000); }
@Override public void registerAttributes(ManagementResourceRegistration resourceRegistration) { final OperationStepHandler restartCacheWriteHandler = new RestartServiceWriteAttributeHandler( resource.getPathElement().getKey(), resource.getServiceInstaller(), CacheServiceName.CONFIGURATION, attributes); resourceRegistration.registerReadWriteAttribute(STRATEGY, CacheReadAttributeHandler.INSTANCE, restartCacheWriteHandler); resourceRegistration.registerReadWriteAttribute(SIZE, CacheReadAttributeHandler.INSTANCE, new RuntimeCacheConfigurationWriteAttributeHandler(SIZE, (configuration, newSize) -> configuration.memory().size(newSize.asLong()))); } }
@Override public void registerAttributes(ManagementResourceRegistration resourceRegistration) { final OperationStepHandler restartCacheWriteHandler = new RestartServiceWriteAttributeHandler( resource.getPathElement().getKey(), resource.getServiceInstaller(), CacheServiceName.CONFIGURATION, attributes); resourceRegistration.registerReadWriteAttribute(EVICTION, CacheReadAttributeHandler.INSTANCE, restartCacheWriteHandler); resourceRegistration.registerReadWriteAttribute(STRATEGY, CacheReadAttributeHandler.INSTANCE, restartCacheWriteHandler); resourceRegistration.registerReadWriteAttribute(SIZE, CacheReadAttributeHandler.INSTANCE, new RuntimeCacheConfigurationWriteAttributeHandler(SIZE, (configuration, newSize) -> configuration.memory().size(newSize.asLong()))); } }
@Override public void registerAttributes(ManagementResourceRegistration resourceRegistration) { final OperationStepHandler restartCacheWriteHandler = new RestartServiceWriteAttributeHandler( resource.getPathElement().getKey(), resource.getServiceInstaller(), CacheServiceName.CONFIGURATION, attributes); resourceRegistration.registerReadWriteAttribute(EVICTION, CacheReadAttributeHandler.INSTANCE, restartCacheWriteHandler); resourceRegistration.registerReadWriteAttribute(ADDRESS_COUNT, CacheReadAttributeHandler.INSTANCE, restartCacheWriteHandler); resourceRegistration.registerReadWriteAttribute(STRATEGY, CacheReadAttributeHandler.INSTANCE, restartCacheWriteHandler); resourceRegistration.registerReadWriteAttribute(SIZE, CacheReadAttributeHandler.INSTANCE, new RuntimeCacheConfigurationWriteAttributeHandler(SIZE, (configuration, newSize) -> configuration.memory().size(newSize.asLong()))); } }
public void testEvictionSize() throws Exception { ObjectName defaultOn = getCacheObjectName(JMX_DOMAIN, "___defaultcache(local)", "Configuration"); assertEquals(1000L, (long) server.getAttribute(defaultOn, "evictionSize")); assertEquals(1000, cache().getCacheConfiguration().memory().size()); DefaultDataContainer<Object, Object> dataContainer = (DefaultDataContainer<Object, Object>) cache() .getAdvancedCache().getDataContainer(); assertEquals(1000, dataContainer.capacity()); server.setAttribute(defaultOn, new Attribute("evictionSize", 2000L)); assertEquals(2000, cache().getCacheConfiguration().memory().size()); assertEquals(2000, dataContainer.capacity()); } }
public void testQuickCache() { assertEquals(quickCache.getCacheConfiguration().memory().size(), 1000); assertEquals(quickCache.getCacheConfiguration().expiration().wakeUpInterval(), 1); } }
@Test public void testBuildQueryRegionWithCustomRegionName() { final String queryRegionName = "myquery"; Properties p = createProperties(); p.setProperty("hibernate.cache.infinispan.myquery.cfg", "timestamps-none-eviction"); p.setProperty("hibernate.cache.infinispan.myquery.memory.eviction.type", "MEMORY"); p.setProperty("hibernate.cache.infinispan.myquery.expiration.wake_up_interval", "2222"); p.setProperty("hibernate.cache.infinispan.myquery.memory.size", "11111"); TestRegionFactory factory = createRegionFactory(p); try { assertTrue(isDefinedCache(factory, "local-query")); InfinispanBaseRegion region = factory.buildQueryResultsRegion(queryRegionName); assertNotNull(factory.getBaseConfiguration(queryRegionName)); assertTrue(isDefinedCache(factory, queryRegionName)); AdvancedCache cache = region.getCache(); Configuration cacheCfg = cache.getCacheConfiguration(); assertEquals(EvictionType.COUNT, cacheCfg.memory().evictionType()); assertEquals(2222, cacheCfg.expiration().wakeUpInterval()); assertEquals( 11111, cacheCfg.memory().size() ); } finally { factory.stop(); } }
public void testPartialOverride() { ConfigurationBuilder baseBuilder = new ConfigurationBuilder(); baseBuilder.memory().size(200).storageType(StorageType.BINARY); Configuration base = baseBuilder.build(); ConfigurationBuilder overrideBuilder = new ConfigurationBuilder(); overrideBuilder.read(base).locking().concurrencyLevel(31); Configuration override = overrideBuilder.build(); assertEquals(200, base.memory().size()); assertEquals(200, override.memory().size()); assertEquals(StorageType.BINARY, base.memory().storageType()); assertEquals(StorageType.BINARY, override.memory().storageType()); assertEquals(32, base.locking().concurrencyLevel()); assertEquals(31, override.locking().concurrencyLevel()); }
@Override public void check(ConfigurationBuilderHolder holder) { GlobalConfiguration globalConfiguration = getGlobalConfiguration(holder); assertEquals(4, globalConfiguration.transport().initialClusterSize()); assertEquals(30000, globalConfiguration.transport().initialClusterTimeout()); MemoryConfiguration mc = getConfiguration(holder, "off-heap-memory").memory(); assertEquals(StorageType.OFF_HEAP, mc.storageType()); assertEquals(10000000, mc.size()); assertEquals(4, mc.addressCount()); assertEquals(EvictionType.MEMORY, mc.evictionType()); mc = getConfiguration(holder, "binary-memory").memory(); assertEquals(StorageType.BINARY, mc.storageType()); assertEquals(1, mc.size()); mc = getConfiguration(holder, "object-memory").memory(); assertEquals(StorageType.OBJECT, mc.storageType()); } },
public void testConfigurationOverride() throws Exception { ConfigurationBuilder defaultCfgBuilder = new ConfigurationBuilder(); defaultCfgBuilder.memory().size(200).storageType(StorageType.BINARY); cm = TestCacheManagerFactory.createCacheManager(defaultCfgBuilder); final ConfigurationBuilder cacheCfgBuilder = new ConfigurationBuilder().read(defaultCfgBuilder.build()); cm.defineConfiguration("my-cache", cacheCfgBuilder.build()); Cache<?, ?> cache = cm.getCache("my-cache"); assertEquals(200, cache.getCacheConfiguration().memory().size()); assertEquals(StorageType.BINARY, cache.getCacheConfiguration().memory().storageType()); }
public void testDefiningConfigurationOverridingBooleans() { EmbeddedCacheManager cm = createCacheManager(false); ConfigurationBuilder c = new ConfigurationBuilder(); c.memory().storageType(StorageType.BINARY); Configuration lazy = cm.defineConfiguration("storeAsBinary", c.build()); assertEquals(StorageType.BINARY, lazy.memory().storageType()); c = new ConfigurationBuilder().read(lazy); c.memory().storageType(StorageType.OFF_HEAP).size(1); Configuration lazyOffHeap = cm.defineConfiguration("lazyDeserializationWithOffHeap", c.build()); assertEquals(StorageType.OFF_HEAP, lazyOffHeap.memory().storageType()); assertEquals(1, lazyOffHeap.memory().size()); }