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 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 assertRemovedFromStores(String key) { for (Cache<Object, String> c : caches) { CacheLoader store = TestingUtil.getFirstLoader(c); MarshalledEntry me = store.load(key); // handle possible tombstones assert me == null || me.getValue() == null; } }
private Object load(SingletonCacheWriter cs, Object key) throws PersistenceException { MarshalledEntry se = ((CacheLoader)cs.undelegate()).load(key); return se == null ? null : se.getValue(); }
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); }
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); }
@SuppressWarnings("unchecked") private Map<String, String> nodeContentsInCacheStore(CacheLoader cs, Fqn fqn) throws PersistenceException { return (Map<String, String>) cs.load(new NodeKey(fqn, DATA)).getValue(); }
public void testRootNodePersistence() throws PersistenceException { cache.put(ROOT, "key", "value"); assert "value".equals(cache.get(ROOT, "key")); assert store.contains(new NodeKey(ROOT, DATA)); assert "value".equals(nodeContentsInCacheStore(store, ROOT).get("key")); assert store.contains(new NodeKey(ROOT, STRUCTURE)); restartCache(); assert "value".equals(cache.get(ROOT, "key")); assert store.contains(new NodeKey(ROOT, DATA)); assert "value".equals(nodeContentsInCacheStore(store, ROOT).get("key")); assert store.contains(new NodeKey(ROOT, STRUCTURE)); }
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()); } } }
public void testPutFromNonOwner() throws Exception { Cache<Object, String> cacheX = getFirstNonOwner("key1"); CacheLoader storeX = TestingUtil.getFirstLoader(cacheX); cacheX.put("key1", "v1"); assertEquals("v1", cacheX.get("key1")); assertNotNull(storeX.load("key1")); assertEquals("v1", storeX.load("key1").getValue()); }
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; } }
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()); }
private void assertInStoreNotInCache(Object key) throws PersistenceException { MarshalledEntry se = loader.load(key); testStoredEntry(se, key, "Store"); assert !cache.getAdvancedCache().getDataContainer().containsKey(key) : "Key " + key + " should not be in cache!"; }
public void testPersistence() throws PersistenceException { cache.put("/a/b/c", "key", "value"); assert "value".equals(cache.get("/a/b/c", "key")); assert store.contains(new NodeKey(Fqn.fromString("/a/b/c"), DATA)); assert "value".equals(nodeContentsInCacheStore(store, Fqn.fromString("/a/b/c")).get("key")); assert store.contains(new NodeKey(Fqn.fromString("/a/b/c"), STRUCTURE)); restartCache(); assert "value".equals(cache.get("/a/b/c", "key")); assert store.contains(new NodeKey(Fqn.fromString("/a/b/c"), DATA)); assert "value".equals(nodeContentsInCacheStore(store, Fqn.fromString("/a/b/c")).get("key")); assert store.contains(new NodeKey(Fqn.fromString("/a/b/c"), STRUCTURE)); }
protected void assertInStores(String key, String value, boolean allowL1) { for (Cache<Object, String> c : caches) { CacheLoader store = TestingUtil.getFirstLoader(c); if (isOwner(c, key)) { assertIsInContainerImmortal(c, key); assertEquals(value, store.load(key).getValue()); } else { if (!allowL1) { assertIsNotInL1(c, key); } assertFalse(store.contains(key)); } } }
public void testPutAllBatch() throws Exception { int numberOfEntries = 100; String cacheName = "testPutAllBatch"; ConfigurationBuilder cb = new ConfigurationBuilder(); cb.read(cacheManager.getDefaultCacheConfiguration()); createCacheStoreConfig(cb.persistence(), false); cacheManager.defineConfiguration(cacheName, cb.build()); Cache<String, Object> cache = cacheManager.getCache(cacheName); Map<String, Object> entriesMap = IntStream.range(0, numberOfEntries).boxed() .collect(Collectors.toMap(Object::toString, i -> wrap(i.toString(), "Val"+i))); cache.putAll(entriesMap); assertEquals(numberOfEntries, cache.size()); CacheLoader cl = TestingUtil.getCacheLoader(cache); if (cl != null) IntStream.range(0, numberOfEntries).forEach(i -> assertNotNull(cl.load(Integer.toString(i)))); }
private void checkCacheStoresEmpty() throws PersistenceException { for (Cache<Object, Object> cache : caches()) { CacheLoader store = TestingUtil.getFirstLoader(cache); for (Person person : persons) { assert !store.contains(person.getName()); } } }
assert cs.contains("key"); DummyInMemoryStore dimcs = (DummyInMemoryStore) cs; assert dimcs.stats().get("clear") == 0: "Cache store should not be cleared, purgeOnStartup is false"; if (cacheMode.isScattered()) { MarshalledEntry entry = cs.load("key"); assert entry == null || entry.getValue() == null; assertEquals("Entry should have been replaced by tombstone", Integer.valueOf(2), dimcs.stats().get("write")); } else { assert !cs.contains("key"); assertEquals("Entry should have been removed from the cache store just once", Integer.valueOf(1), dimcs.stats().get("delete"));
public void testRemoteLoadFromCacheLoader() throws Exception { Cache<String, String> cache1 = cache(0, "clusteredCl"); Cache<String, String> cache2 = cache(1, "clusteredCl"); CacheWriter writer = TestingUtil.getFirstWriter(cache2); assertNull(cache1.get("key")); assertNull(cache2.get("key")); writer.write(new MarshalledEntryImpl("key", "value", null, cache2.getAdvancedCache().getComponentRegistry().getCacheMarshaller())); assertEquals(((CacheLoader)writer).load("key").getValue(), "value"); assertEquals(cache1.get("key"), "value"); } }
public void testPutFromNonOwnerWithFlags(Method m) throws Exception { String key = k(m), value = "value2"; Cache<Object, String> nonOwner = getFirstNonOwner(key); Cache<Object, String> owner = getFirstOwner(key); CacheLoader nonOwnerStore = TestingUtil.getFirstLoader(nonOwner); CacheLoader ownerStore = TestingUtil.getFirstLoader(owner); assertFalse(nonOwnerStore.contains(key)); assertFalse(ownerStore.contains(key)); Object retval = nonOwner.getAdvancedCache().withFlags(Flag.SKIP_CACHE_STORE).put(key, value); assertFalse(nonOwnerStore.contains(key)); assertFalse(ownerStore.contains(key)); if (testRetVals) assert retval == null; assertOnAllCachesAndOwnership(key, value); }