public void testSmallCache() { // Check that we have the correctly configured cache assertEquals(smallCache.getCacheConfiguration().memory().size(), 10); } }
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); }
private CacheNotifierImpl newNotifier() { CacheNotifierImpl notifier = new CacheNotifierImpl(); AdvancedCache mockCache = mock(AdvancedCache.class, RETURNS_DEEP_STUBS); ComponentRegistry registry = mock(ComponentRegistry.class); Configuration config = mock(Configuration.class, RETURNS_DEEP_STUBS); when(config.clustering().cacheMode()).thenReturn(CacheMode.LOCAL); when(config.memory().storageType()).thenReturn(StorageType.OBJECT); TestingUtil.inject(notifier, mockCache, new ClusteringDependentLogic.LocalLogic(), config, new InternalEntryFactoryImpl(), mock(ClusterEventManager.class), mock(BasicComponentRegistry.class)); return notifier; }
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); }
@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()))); } }
private static void validateMetadataCache(Cache<?, ?> cache, String indexName) { Configuration configuration = cache.getCacheConfiguration(); if (configuration.memory().isEvictionEnabled()) { throw log.evictionNotAllowedInMetadataCache(indexName, cache.getName()); } if (configuration.persistence().usingStores() && !configuration.persistence().preload()) { throw log.preloadNeededIfPersistenceIsEnabledForMetadataCache(indexName, cache.getName()); } }
private static void validateMetadataCache(Cache<?, ?> cache, String indexName) { Configuration configuration = cache.getCacheConfiguration(); if (configuration.memory().isEvictionEnabled()) { throw log.evictionNotAllowedInMetadataCache(indexName, cache.getName()); } if (configuration.persistence().usingStores() && !configuration.persistence().preload()) { throw log.preloadNeededIfPersistenceIsEnabledForMetadataCache(indexName, cache.getName()); } }
@Override public void call() { Configuration cfg = cm.getDefaultCacheConfiguration(); assertTrue(cfg.dataContainer().<byte[]>keyEquivalence() instanceof AnyEquivalence); assertTrue(cfg.dataContainer().valueEquivalence() instanceof AnyEquivalence); assertEquals(StorageType.OFF_HEAP, cfg.memory().storageType()); assertEquals(EvictionStrategy.MANUAL, cfg.memory().evictionStrategy()); } });
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()); }
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); } }
public void testBackwardCompatibility() { ConfigurationBuilder c = new ConfigurationBuilder(); c.memory().storageType(StorageType.BINARY); ecm = TestCacheManagerFactory.createCacheManager(c); assertEquals(StorageType.BINARY, ecm.getCache().getCacheConfiguration().memory().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()); }
@Override public void call() { Configuration cfg = cm.getDefaultCacheConfiguration(); assertTrue(cfg.dataContainer().<byte[]>keyEquivalence() instanceof AnyEquivalence); assertTrue(cfg.dataContainer().<byte[]>valueEquivalence() instanceof AnyEquivalence); assertEquals(StorageType.BINARY, cfg.memory().storageType()); } });
@Override public void call() { Configuration cfg = cm.getDefaultCacheConfiguration(); assertTrue(cfg.dataContainer().<byte[]>keyEquivalence() instanceof AnyEquivalence); assertTrue(cfg.dataContainer().<byte[]>valueEquivalence() instanceof AnyEquivalence); assertEquals(StorageType.OBJECT, cfg.memory().storageType()); } });
public void testConfigCloning() { ConfigurationBuilder c = new ConfigurationBuilder(); c.memory().storageType(StorageType.BINARY); ConfigurationBuilder builder = new ConfigurationBuilder().read(c.build()); Configuration clone = builder.build(); assertEquals(StorageType.BINARY, clone.memory().storageType()); }
public void testConfigOverriding() { ConfigurationBuilder c = new ConfigurationBuilder(); c.memory().storageType(StorageType.BINARY); ecm = TestCacheManagerFactory.createCacheManager(c); ecm.defineConfiguration("newCache", new ConfigurationBuilder().read(c.build()).memory().storageType(StorageType.OBJECT).build()); assertEquals(StorageType.OBJECT, ecm.getCache("newCache").getCacheConfiguration().memory().storageType()); }
@Override public void check(ConfigurationBuilderHolder holder) { GlobalStateConfiguration gs = getGlobalConfiguration(holder).globalState(); assertEquals(ConfigurationStorage.OVERLAY, gs.configurationStorage()); assertEquals("sharedPath", gs.sharedPersistentLocation()); EncodingConfiguration encoding = getConfiguration(holder, "local").encoding(); assertEquals(MediaType.APPLICATION_OBJECT, encoding.keyDataType().mediaType()); assertEquals(MediaType.APPLICATION_OBJECT, encoding.valueDataType().mediaType()); MemoryConfiguration memory = getConfiguration(holder, "dist-template").memory(); assertEquals(EvictionStrategy.REMOVE, memory.evictionStrategy()); } },