@Override Boolean runTask() throws Exception { return cache.containsKey(2L); } }.run();
@Test public void testSimpleRemove2ArgsWithLoaderAndWriter_absent() throws Exception { when(cacheLoaderWriter.load(eq(1))).thenAnswer((Answer) invocation -> null); assertThat(testCache.containsKey(1), is(false)); assertThat(testCache.remove(1, "one"), is(false)); verify(cacheLoaderWriter, times(1)).load(eq(1)); verifyNoMoreInteractions(cacheLoaderWriter); }
@Test public void testSimpleReplace2ArgsWithLoaderAndWriter_absent() throws Exception { when(cacheLoaderWriter.load(eq(1))).thenAnswer((Answer) invocation -> null); assertThat(testCache.containsKey(1), is(false)); assertThat(testCache.replace(1, "one"), is(nullValue())); verify(cacheLoaderWriter, times(1)).load(eq(1)); verifyNoMoreInteractions(cacheLoaderWriter); }
@Test public void testSimpleReplace3ArgsWithLoaderAndWriter_absent() throws Exception { when(cacheLoaderWriter.load(eq(1))).thenAnswer((Answer) invocation -> null); assertThat(testCache.containsKey(1), is(false)); assertThat(testCache.replace(1, "un", "one"), is(false)); verify(cacheLoaderWriter, times(1)).load(eq(1)); verifyNoMoreInteractions(cacheLoaderWriter); }
@Test public void testSimpleRemove2ArgsWithLoaderAndWriter_existsInSor() throws Exception { when(cacheLoaderWriter.load(eq(1))).thenAnswer((Answer) invocation -> "un"); assertThat(testCache.containsKey(1), is(false)); assertThat(testCache.remove(1, "un"), is(true)); verify(cacheLoaderWriter, times(1)).load(eq(1)); verify(cacheLoaderWriter, times(1)).delete(eq(1)); }
@Test public void testSimpleRemove2ArgsWithLoaderAndWriter_existsInSor_notEquals() throws Exception { when(cacheLoaderWriter.load(eq(1))).thenAnswer((Answer) invocation -> "un"); assertThat(testCache.containsKey(1), is(false)); assertThat(testCache.remove(1, "one"), is(false)); verify(cacheLoaderWriter, times(1)).load(eq(1)); verifyNoMoreInteractions(cacheLoaderWriter); }
@Test public void testSimplePutIfAbsentWithLoaderAndWriter_existsInSor() throws Exception { when(cacheLoaderWriter.load(eq(1))).thenAnswer((Answer) invocation -> "un"); assertThat(testCache.containsKey(1), is(false)); assertThat(testCache.putIfAbsent(1, "one"), Matchers.<CharSequence>equalTo("un")); assertThat(testCache.get(1), Matchers.<CharSequence>equalTo("un")); verify(cacheLoaderWriter, times(1)).load(eq(1)); verifyNoMoreInteractions(cacheLoaderWriter); }
@Test public void testSimplePutIfAbsentWithLoaderAndWriter_absent() throws Exception { assertThat(testCache.containsKey(1), is(false)); assertThat(testCache.putIfAbsent(1, "one"), is(nullValue())); assertThat(testCache.get(1), Matchers.<CharSequence>equalTo("one")); verify(cacheLoaderWriter, times(1)).load(eq(1)); verify(cacheLoaderWriter, times(1)).write(eq(1), eq("one")); }
@Test public void testSimpleReplace2ArgsWithLoaderAndWriter_existsInSor() throws Exception { when(cacheLoaderWriter.load(eq(1))).thenAnswer((Answer) invocation -> "un"); assertThat(testCache.containsKey(1), is(false)); assertThat(testCache.replace(1, "one"), Matchers.<CharSequence>equalTo("un")); assertThat(testCache.get(1), Matchers.<CharSequence>equalTo("one")); verify(cacheLoaderWriter, times(1)).load(eq(1)); verify(cacheLoaderWriter, times(1)).write(eq(1), eq("one")); }
@Test public void testSimpleReplace3ArgsWithLoaderAndWriter_existsInSor() throws Exception { when(cacheLoaderWriter.load(eq(1))).thenAnswer((Answer) invocation -> "un"); assertThat(testCache.containsKey(1), is(false)); assertThat(testCache.replace(1, "un", "one"), is(true)); assertThat(testCache.get(1), Matchers.<CharSequence>equalTo("one")); verify(cacheLoaderWriter, times(1)).load(eq(1)); verify(cacheLoaderWriter, times(1)).write(eq(1), eq("one")); }
@Test public void testSimpleReplace3ArgsWithLoaderAndWriter_existsInSor_notEquals() throws Exception { when(cacheLoaderWriter.load(eq(1))).thenAnswer((Answer) invocation -> "un"); assertThat(testCache.containsKey(1), is(false)); assertThat(testCache.replace(1, "uno", "one"), is(false)); assertThat(testCache.get(1), Matchers.<CharSequence>equalTo("un")); verify(cacheLoaderWriter, times(1)).load(eq(1)); verifyNoMoreInteractions(cacheLoaderWriter); }
@Test public void testSimpleContainsKey() throws Exception { Cache<Number, CharSequence> testCache = cacheManager.createCache("testCache", newCacheConfigurationBuilder(Number.class, CharSequence.class, heap(10))); testCache.put(1, "one"); assertThat(testCache.containsKey(1), is(true)); assertThat(testCache.containsKey(2), is(false)); }
@Test public void containsKey() { expect(cache.containsKey(1)).isFalse(); changesOf(0, 0, 0, 0); cache.put(1, "a"); changesOf(0, 0, 1, 0); expect(cache.containsKey(1)).isTrue(); changesOf(0, 0, 0, 0); }
@Test public void containsKey() { expect(cache.containsKey(1)).isFalse(); changesOf(0, 0, 0, 0); cache.put(1, "a"); changesOf(0, 0, 1, 0); expect(cache.containsKey(1)).isTrue(); changesOf(0, 0, 0, 0); }
@Test public void testContainsKeyExpiredTwoClients() { TestTimeSource timeSource = new TestTimeSource(); TimeSourceConfiguration timeSourceConfiguration = new TimeSourceConfiguration(timeSource); final CacheManagerBuilder<PersistentCacheManager> clusteredCacheManagerBuilder = commonClusteredCacheManagerBuilder.using(timeSourceConfiguration); final PersistentCacheManager cacheManager1 = clusteredCacheManagerBuilder.build(true); final PersistentCacheManager cacheManager2 = clusteredCacheManagerBuilder.build(true); final Cache<Long, String> cache1 = cacheManager1.getCache("clustered-cache", Long.class, String.class); final Cache<Long, String> cache2 = cacheManager2.getCache("clustered-cache", Long.class, String.class); assertThat(cache2.get(1L), nullValue()); cache1.put(1L, "value1"); assertThat(cache1.containsKey(1L), is(true)); timeSource.advanceTime(1L); assertThat(cache1.containsKey(1L), is(false)); assertThat(cache2.containsKey(1L), is(false)); cacheManager2.close(); cacheManager1.close(); }
assertThat(cache.containsKey(2L), is(false)); cache.put(2L, "The two"); assertThat(cache.containsKey(2L), is(true)); cache.put(1L, "Another one"); cache.put(3L, "The three");
assertEquals(1, listener2.removed.get()); cache.containsKey(1L); assertEquals(3, listener1.created.get()); assertEquals(3, listener1.updated.get());
@Test public void testTerminationThenContainsKey() throws Exception { CacheManagerBuilder<PersistentCacheManager> clusteredCacheManagerBuilder = CacheManagerBuilder.newCacheManagerBuilder() .with(ClusteringServiceConfigurationBuilder.cluster(cluster.getConnectionURI().resolve("/MyCacheManagerName")) .timeouts(TimeoutsBuilder.timeouts().read(Duration.of(1, ChronoUnit.SECONDS)).build()) .autoCreate() .defaultServerResource("primary-server-resource")) .withCache("simple-cache", CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class, ResourcePoolsBuilder.newResourcePoolsBuilder() .with(ClusteredResourcePoolBuilder.clusteredDedicated(4, MemoryUnit.MB)))); PersistentCacheManager cacheManager = clusteredCacheManagerBuilder.build(false); cacheManager.init(); Cache<Long, String> cache = cacheManager.getCache("simple-cache", Long.class, String.class); cache.put(1L, "un"); cache.put(2L, "deux"); cache.put(3L, "trois"); assertThat(cache.containsKey(2L)).isTrue(); cluster.getClusterControl().terminateAllServers(); boolean value = new TimeLimitedTask<Boolean>(5, TimeUnit.SECONDS) { @Override Boolean runTask() throws Exception { return cache.containsKey(2L); } }.run(); assertThat(value).isFalse(); }
public boolean containsKey(K key) { Cache cache = this.cacheManager.getCache(cacheName); if (cache == null) { return false; } return cache.containsKey(key); }
@Override public boolean contains(Sha3Hash key) { return pendingPool.containsKey(key) || db.get(key.getBytes()) != null; }