protected void verifyNoDataOnLoader(Cache<Object, Object> c) throws Exception { CacheLoader l = TestingUtil.getFirstLoader(c); assert !l.contains(A_B_AGE); assert !l.contains(A_B_NAME); assert !l.contains(A_C_AGE); assert !l.contains(A_C_NAME); assert !l.contains(A_D_AGE); assert !l.contains(A_D_NAME); }
public static void verifyNoDataOnLoader(Cache<Object, Object> c) throws Exception { CacheLoader l = TestingUtil.getFirstLoader(c); assert !l.contains(A_B_AGE); assert !l.contains(A_B_NAME); assert !l.contains(A_C_AGE); assert !l.contains(A_C_NAME); assert !l.contains(A_D_AGE); assert !l.contains(A_D_NAME); }
public static void verifyInitialDataOnLoader(Cache<Object, Object> c) throws Exception { CacheLoader l = TestingUtil.getFirstLoader(c); assert l.contains(A_B_AGE); assert l.contains(A_B_NAME); assert l.contains(A_C_AGE); assert l.contains(A_C_NAME); assert l.load(A_B_AGE).getValue().equals(TWENTY); assert l.load(A_B_NAME).getValue().equals(JOE); assert l.load(A_C_AGE).getValue().equals(FORTY); assert l.load(A_C_NAME).getValue().equals(BOB); }
protected void verifyInitialDataOnLoader(Cache<Object, Object> c) throws Exception { CacheLoader l = TestingUtil.getFirstLoader(c); assert l.contains(A_B_AGE); assert l.contains(A_B_NAME); assert l.contains(A_C_AGE); assert l.contains(A_C_NAME); assert l.load(A_B_AGE).getValue().equals(TWENTY); assert l.load(A_B_NAME).getValue().equals(JOE); assert l.load(A_C_AGE).getValue().equals(FORTY); assert l.load(A_C_NAME).getValue().equals(BOB); }
private void assertNoOverlapingState(Cache first, Cache second, CacheLoader firstCs, CacheLoader secondCs) throws PersistenceException { first.put("k", "v"); assert firstCs.contains("k"); assert !secondCs.contains("k"); assert first.get("k").equals("v"); assert second.get("k") == null; second.put("k2", "v2"); assert second.get("k2").equals("v2"); assert first.get("k2") == null; } }
private static <K> void assertInCacheAndNotInStore(Cache<? super K, ?> cache, CacheLoader<? super K, ?> store, K... keys) throws PersistenceException { for (K key : keys) { assert cache.getAdvancedCache().getDataContainer().containsKey(key) : "Cache should not contain key " + key; assertFalse("Store should contain key " + key, store.contains(key)); } }
private void initStore(Cache<String, String> cache) { writeToStore(cache, key, value1); assertTrue(TestingUtil.getFirstLoader(cache).contains(key)); cacheLoaderInterceptor(cache).resetStatistics(); }
public void testSkipSharedCacheStoreFlagUsage() throws PersistenceException { cache(0).getAdvancedCache().withFlags(Flag.SKIP_SHARED_CACHE_STORE).put("key", "value"); assert cache(0).get("key").equals("value"); List<CacheLoader<Object, Object>> cachestores = TestingUtil.cachestores(caches()); for (CacheLoader cs : cachestores) { assert !cs.contains("key"); DummyInMemoryStore dimcs = (DummyInMemoryStore) cs; assert dimcs.stats().get("write") == 0 : "Cache store should NOT contain any entry. Put was with SKIP_SHARED_CACHE_STORE flag."; } }
protected void verifyInitialDataOnLoader(Cache<Object, Object> c) { CacheLoader l = TestingUtil.getFirstLoader(c); for (int i = 0; i < INSERTION_COUNT; ++i) { assertTrue("Didn't contain key " + i, l.contains("key " + i)); } for (int i = 0; i < INSERTION_COUNT; ++i) { assertEquals("value " + i, l.load("key " + i).getValue()); } } }
private <T> void assertNotInCacheAndStore(Cache cache, CacheLoader store, T... keys) throws PersistenceException { for (Object key : keys) { assertFalse("Cache should not contain key " + key, cache.getAdvancedCache().getDataContainer().containsKey(key)); assertFalse("Store should not contain key " + key, store.contains(key)); } }
private <T> void assertNotInCacheAndStore(Cache cache, CacheLoader store, T... keys) throws PersistenceException { for (Object key : keys) { assertFalse("Cache should not contain key " + key, cache.getAdvancedCache().getDataContainer().containsKey(key)); assertFalse("Store should not contain key " + key, store.contains(key)); } }
private void assertInCacheNotInStore(Object key) throws PersistenceException { InternalCacheValue ice = cache.getAdvancedCache().getDataContainer().get(key).toInternalCacheValue(); testStoredEntry(ice, key, "Cache"); assert !loader.contains(key) : "Key " + key + " should not be in store!"; }
private static <K> void assertNotInCacheAndStore(Cache<? super K, ?> cache, CacheLoader<? super K, ?> store, K... keys) throws PersistenceException { for (K key : keys) { assertFalse("Cache should not contain key " + key, cache.getAdvancedCache().getDataContainer().containsKey(key)); assertFalse("Store should not contain key " + key, store.contains(key)); } }
private static <K> void assertInStoreNotInCache(Cache<? super K, ?> cache, CacheLoader<? super K, ?> store, K... keys) throws PersistenceException { for (K key : keys) { assertFalse("Cache should not contain key " + key, cache.getAdvancedCache().getDataContainer().containsKey(key)); assertTrue("Store should contain key " + key, store.contains(key)); } }
public void testPutFromNonOwner(Method m) throws Exception { String key = k(m), value = "value2"; Cache<Object, String> nonOwner = getFirstNonOwner(key); Cache<Object, String> owner = getFirstOwner(key); CacheLoader nonOwnerLoader = TestingUtil.getFirstLoader(nonOwner); CacheLoader ownerLoader = TestingUtil.getFirstLoader(owner); assertFalse(nonOwnerLoader.contains(key)); assertFalse(ownerLoader.contains(key)); Object retval = nonOwner.put(key, value); assertInStores(key, value, true); if (testRetVals) assert retval == null; assertOnAllCachesAndOwnership(key, value); }
public void testRemoveFromNonOwnerWithFlags() throws Exception { String key = "k1", value = "value"; initAndTest(); Object retval = getFirstNonOwner(key).getAdvancedCache().withFlags(Flag.SKIP_CACHE_STORE).remove(key); if (testRetVals) assert value.equals(retval); for (Cache<Object, String> c : caches) { if (isOwner(c, key)) { CacheLoader store = TestingUtil.getFirstLoader(c); assertTrue(store.contains(key)); } } }
private boolean isEntryInStore(String key) throws Exception { Cache<String, String> testCache = cacheManager.getCache(CACHE_NAME); CacheLoader<String, String> loader = TestingUtil.getFirstLoader(testCache); Object loaderKey = key; if (storage == StorageType.OFF_HEAP) { GlobalMarshaller gm = TestingUtil.extractGlobalMarshaller(testCache.getCacheManager()); loaderKey = new WrappedByteArray(gm.objectToByteBuffer(key)); } return loader.contains(loaderKey); }
public void testPutAllWithFlags() throws Exception { Map<String, String> data = makePutAllTestData(); c1.getAdvancedCache().withFlags(Flag.SKIP_CACHE_STORE).putAll(data); for (Cache<Object, String> c : caches) { CacheLoader store = TestingUtil.getFirstLoader(c); for (String key : keys) { assertFalse(store.contains(key)); if (isOwner(c, key)) { assertIsInContainerImmortal(c, key); } } } }
public void testPutForStateTransfer() throws Exception { MagicKey k1 = getMagicKey(); CacheLoader store2 = TestingUtil.getFirstLoader(c2); c2.put(k1, v1); assertTrue(store2.contains(k1)); assertEquals(v1, store2.load(k1).getValue()); c2.getAdvancedCache().withFlags(Flag.CACHE_MODE_LOCAL).put(k1, v2); assertEquals(v2, store2.load(k1).getValue()); }
public void testAtomicPutIfAbsentFromNonOwnerWithFlag(Method m) throws Exception { String key = k(m), value = "value"; String replaced = getFirstNonOwner(key).getAdvancedCache().withFlags(Flag.SKIP_CACHE_STORE).putIfAbsent(key, value); assertNull(replaced); //interesting case: fails to put as value exists, put actually missing in Store replaced = getFirstNonOwner(key).putIfAbsent(key, value); assertEquals(replaced, value); for (Cache<Object, String> c : caches) { assertEquals(replaced, c.get(key)); CacheLoader store = TestingUtil.getFirstLoader(c); assertFalse(store.contains(key)); } }