@Before
public void init() {
CacheConfiguration<Long, String> cacheConfiguration =
CacheConfigurationBuilder.newCacheConfigurationBuilder()
.withResourcePools(
ResourcePoolsBuilder.newResourcePoolsBuilder().heap(10, EntryUnit.ENTRIES).build())
.buildConfig(Long.class, String.class);
service = new DefaultSharedManagementService();
cacheManager1 =
CacheManagerBuilder.newCacheManagerBuilder()
.withCache("aCache1", cacheConfiguration)
.using(service)
.using(new DefaultManagementRegistryConfiguration().setCacheManagerAlias("myCM1"))
.build(true);
cacheManager2 =
CacheManagerBuilder.newCacheManagerBuilder()
.withCache("aCache2", cacheConfiguration)
.withCache("aCache3", cacheConfiguration)
.using(service)
.using(new DefaultManagementRegistryConfiguration().setCacheManagerAlias("myCM2"))
.build(true);
// this serie of calls make sure the registry still works after a full init / close / init loop
cacheManager1.close();
cacheManager1.init();
cacheManager2.close();
cacheManager2.init();
}
@Test
public void testStoreByValue() {
CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder().build(false);
cacheManager.init();
DefaultCopierConfiguration<String> copierConfiguration =
new DefaultCopierConfiguration(SerializingCopier.class, CopierConfiguration.Type.VALUE);
final Cache<Long, String> cache1 =
cacheManager.createCache(
"cache1",
CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class)
.withResourcePools(
ResourcePoolsBuilder.newResourcePoolsBuilder().heap(1, EntryUnit.ENTRIES))
.build());
performAssertions(cache1, true);
final Cache<Long, String> cache2 =
cacheManager.createCache(
"cache2",
CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class)
.add(copierConfiguration)
.build());
performAssertions(cache2, false);
final Cache<Long, String> cache3 =
cacheManager.createCache(
"cache3",
CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class)
.build());
performAssertions(cache3, true);
cacheManager.close();
}
@Test
public void testAddingCacheEventListenerConfigurationAtCacheLevel() {
CacheManagerBuilder<CacheManager> cacheManagerBuilder =
CacheManagerBuilder.newCacheManagerBuilder();
CacheEventListenerConfiguration cacheEventListenerConfiguration =
CacheEventListenerConfigurationBuilder.newEventListenerConfiguration(
ListenerObject.class, EventType.CREATED)
.unordered()
.asynchronous()
.build();
CacheManager cacheManager = cacheManagerBuilder.build(true);
final Cache<Long, String> cache =
cacheManager.createCache(
"cache",
CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class)
.add(cacheEventListenerConfiguration)
.withResourcePools(
ResourcePoolsBuilder.newResourcePoolsBuilder()
.heap(100, EntryUnit.ENTRIES)
.build())
.build());
Collection<ServiceConfiguration<?>> serviceConfiguration =
cache.getRuntimeConfiguration().getServiceConfigurations();
assertThat(
serviceConfiguration,
IsCollectionContaining.<ServiceConfiguration<?>>hasItem(
instanceOf(DefaultCacheEventListenerConfiguration.class)));
cacheManager.close();
}
@Test
public void testCanGetContext() {
CacheConfiguration<Long, String> cacheConfiguration =
CacheConfigurationBuilder.newCacheConfigurationBuilder()
.withResourcePools(
ResourcePoolsBuilder.newResourcePoolsBuilder().heap(10, EntryUnit.ENTRIES).build())
.buildConfig(Long.class, String.class);
ManagementRegistry managementRegistry =
new DefaultManagementRegistry(
new DefaultManagementRegistryConfiguration().setCacheManagerAlias("myCM"));
CacheManager cacheManager1 =
CacheManagerBuilder.newCacheManagerBuilder()
.withCache("aCache", cacheConfiguration)
.using(managementRegistry)
.build(true);
assertThat(managementRegistry.getContext().getName(), equalTo("cacheManagerName"));
assertThat(managementRegistry.getContext().getValue(), equalTo("myCM"));
assertThat(managementRegistry.getContext().getSubContexts(), hasSize(1));
assertThat(
managementRegistry.getContext().getSubContexts().iterator().next().getName(),
equalTo("cacheName"));
assertThat(
managementRegistry.getContext().getSubContexts().iterator().next().getValue(),
equalTo("aCache"));
cacheManager1.close();
}
@Test
public void testCopiers() throws Exception {
Configuration configuration =
new XmlConfiguration(this.getClass().getResource("/configs/cache-copiers.xml"));
final CacheManager cacheManager = CacheManagerBuilder.newCacheManager(configuration);
cacheManager.init();
Cache<Description, Person> bar = cacheManager.getCache("bar", Description.class, Person.class);
Description desc = new Description(1234, "foo");
Person person = new Person("Bar", 24);
bar.put(desc, person);
assertEquals(person, bar.get(desc));
assertNotSame(person, bar.get(desc));
Cache<Long, Person> baz = cacheManager.getCache("baz", Long.class, Person.class);
baz.put(1L, person);
assertEquals(person, baz.get(1L));
assertNotSame(person, baz.get(1L));
Employee empl = new Employee(1234, "foo", 23);
Cache<Long, Employee> bak = cacheManager.getCache("bak", Long.class, Employee.class);
bak.put(1L, empl);
assertSame(empl, bak.get(1L));
cacheManager.close();
}
@Test
public void testThreadPoolsUsingDefaultPool() throws Exception {
Configuration configuration =
new XmlConfiguration(this.getClass().getResource("/configs/thread-pools.xml"));
final CacheManager cacheManager = CacheManagerBuilder.newCacheManager(configuration);
cacheManager.init();
try {
Cache<String, String> cache =
cacheManager.createCache(
"testThreadPools",
newCacheConfigurationBuilder()
.add(
new DefaultCacheLoaderWriterConfiguration(
ThreadRememberingLoaderWriter.class))
.add(newUnBatchedWriteBehindConfiguration())
.buildConfig(String.class, String.class));
cache.put("foo", "bar");
ThreadRememberingLoaderWriter.USED.acquireUninterruptibly();
assertThat(ThreadRememberingLoaderWriter.LAST_SEEN_THREAD.getName(), containsString("[big]"));
} finally {
cacheManager.close();
}
}
@Test
public void testCanGetStats() {
CacheConfiguration<Long, String> cacheConfiguration =
CacheConfigurationBuilder.newCacheConfigurationBuilder()
.withResourcePools(
ResourcePoolsBuilder.newResourcePoolsBuilder().heap(10, EntryUnit.ENTRIES).build())
.buildConfig(Long.class, String.class);
ManagementRegistry managementRegistry =
new DefaultManagementRegistry(
new DefaultManagementRegistryConfiguration().setCacheManagerAlias("myCM"));
CacheManager cacheManager1 =
CacheManagerBuilder.newCacheManagerBuilder()
.withCache("aCache1", cacheConfiguration)
.withCache("aCache2", cacheConfiguration)
.using(managementRegistry)
.build(true);
Map<String, String> context1 = new HashMap<String, String>();
context1.put("cacheManagerName", "myCM");
context1.put("cacheName", "aCache1");
Map<String, String> context2 = new HashMap<String, String>();
context2.put("cacheManagerName", "myCM");
context2.put("cacheName", "aCache2");
cacheManager1.getCache("aCache1", Long.class, String.class).put(1L, "1");
cacheManager1.getCache("aCache1", Long.class, String.class).put(2L, "2");
cacheManager1.getCache("aCache2", Long.class, String.class).put(3L, "3");
cacheManager1.getCache("aCache2", Long.class, String.class).put(4L, "4");
cacheManager1.getCache("aCache2", Long.class, String.class).put(5L, "5");
Collection<Counter> counters =
managementRegistry.collectStatistics(context1, "StatisticsCapability", "PutCounter");
assertThat(counters, hasSize(1));
assertThat(counters.iterator().next().getValue(), equalTo(2L));
List<Collection<Counter>> allCounters =
managementRegistry.collectStatistics(
Arrays.asList(context1, context2), "StatisticsCapability", "PutCounter");
assertThat(allCounters, hasSize(2));
assertThat(allCounters.get(0), hasSize(1));
assertThat(allCounters.get(1), hasSize(1));
assertThat(allCounters.get(0).iterator().next().getValue(), equalTo(2L));
assertThat(allCounters.get(1).iterator().next().getValue(), equalTo(3L));
cacheManager1.close();
}
@Test
public void testCanGetCapabilities() {
CacheConfiguration<Long, String> cacheConfiguration =
CacheConfigurationBuilder.newCacheConfigurationBuilder()
.withResourcePools(
ResourcePoolsBuilder.newResourcePoolsBuilder().heap(10, EntryUnit.ENTRIES).build())
.buildConfig(Long.class, String.class);
ManagementRegistry managementRegistry =
new DefaultManagementRegistry(
new DefaultManagementRegistryConfiguration().setCacheManagerAlias("myCM"));
CacheManager cacheManager1 =
CacheManagerBuilder.newCacheManagerBuilder()
.withCache("aCache", cacheConfiguration)
.using(managementRegistry)
.build(true);
assertThat(managementRegistry.getCapabilities(), hasSize(2));
assertThat(
new ArrayList<Capability>(managementRegistry.getCapabilities()).get(0).getName(),
equalTo("ActionsCapability"));
assertThat(
new ArrayList<Capability>(managementRegistry.getCapabilities()).get(1).getName(),
equalTo("StatisticsCapability"));
assertThat(
new ArrayList<Capability>(managementRegistry.getCapabilities()).get(0).getDescriptions(),
hasSize(4));
assertThat(
new ArrayList<Capability>(managementRegistry.getCapabilities()).get(1).getDescriptions(),
hasSize(16));
assertThat(
new ArrayList<Capability>(managementRegistry.getCapabilities())
.get(0)
.getCapabilityContext()
.getAttributes(),
hasSize(2));
assertThat(
new ArrayList<Capability>(managementRegistry.getCapabilities())
.get(1)
.getCapabilityContext()
.getAttributes(),
hasSize(2));
cacheManager1.close();
}
@Test
public void testSerializers() throws Exception {
Configuration configuration =
new XmlConfiguration(this.getClass().getResource("/configs/default-serializer.xml"));
final CacheManager cacheManager = CacheManagerBuilder.newCacheManager(configuration);
cacheManager.init();
Cache<Long, Double> bar = cacheManager.getCache("bar", Long.class, Double.class);
bar.put(1L, 1.0);
assertThat(bar.get(1L), equalTo(1.0));
Cache<String, String> baz = cacheManager.getCache("baz", String.class, String.class);
baz.put("1", "one");
assertThat(baz.get("1"), equalTo("one"));
Cache<String, Object> bam =
cacheManager.createCache(
"bam", newCacheConfigurationBuilder().buildConfig(String.class, Object.class));
bam.put("1", "one");
assertThat(bam.get("1"), equalTo((Object) "one"));
cacheManager.close();
}
@After()
public void close() {
cacheManager2.close();
cacheManager1.close();
}