How to use

load

method

in

org.infinispan.persistence.spi.CacheLoader

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);
}

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 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 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());
}

  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");
  }
}

private void assertPassivated(DataContainer dc, CacheLoader cl, String key, String expected) {
 MarshalledEntry se;
 assertFalse(dc.containsKey(key));
 se = cl.load(key);
 assertNotNull(se);
 assertEquals(expected, se.getValue());
}

  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 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());
}

  @SuppressWarnings("unchecked")
  @Override
  protected void assertNotInMemory(Object key, Object value) {
   DataContainer container = cache.getAdvancedCache().getDataContainer();
   InternalCacheEntry entry = container.get(key);
   CacheLoader<Object, Object> loader = TestingUtil.getFirstLoader(cache);
   assertNull("Key " + key + " exists in data container", entry);
   MarshalledEntry<Object, Object> entryLoaded = loader.load(key);
   assertNotNull("Key " + key + " does not exist in cache loader", entryLoaded);
   assertEquals("Wrong value for key " + key + " in cache loader", value, entryLoaded.getValue());
  }
}

@SuppressWarnings("unchecked")
@Override
protected void assertInMemory(Object key, Object value) {
 DataContainer container = cache.getAdvancedCache().getDataContainer();
 InternalCacheEntry entry = container.get(key);
 CacheLoader<Object, Object> loader = TestingUtil.getFirstLoader(cache);
 assertNotNull("Key " + key + " does not exist in data container", entry);
 assertEquals("Wrong value for key " + key + " in data container", value, entry.getValue());
 MarshalledEntry<Object, Object> entryLoaded = loader.load(key);
 assertNull("Key " + key + " exists in cache loader.", entryLoaded);
}

  @SuppressWarnings("unchecked")
  @Override
  protected void assertNotInMemory(Object key, Object value) {
   DataContainer container = cache.getAdvancedCache().getDataContainer();
   InternalCacheEntry entry = container.get(key);
   CacheLoader<Object, Object> loader = TestingUtil.getFirstLoader(cache);
   assertNull("Key " + key + " exists in data container", entry);
   MarshalledEntry<Object, Object> entryLoaded = loader.load(key);
   assertNotNull("Key " + key + " does not exist in cache loader", entryLoaded);
   assertEquals("Wrong value for key " + key + " in cache loader", value, entryLoaded.getValue());
  }
}

@SuppressWarnings("unchecked")
@Override
protected void assertNotInMemory(Object key, Object value) {
 DataContainer container = cache.getAdvancedCache().getDataContainer();
 InternalCacheEntry entry = container.get(key);
 CacheLoader<Object, Object> loader = TestingUtil.getFirstLoader(cache);
 assertNull("Key " + key + " exists in data container", entry);
 MarshalledEntry<Object, Object> entryLoaded = loader.load(key);
 assertNotNull("Key " + key + " does not exist in cache loader", entryLoaded);
 assertEquals("Wrong value for key " + key + " in cache loader", value, entryLoaded.getValue());
}

@SuppressWarnings("unchecked")
@Override
protected void assertInMemory(Object key, Object value) {
 DataContainer container = cache.getAdvancedCache().getDataContainer();
 InternalCacheEntry entry = container.get(key);
 CacheLoader<Object, Object> loader = TestingUtil.getFirstLoader(cache);
 assertNotNull("Key " + key + " does not exist in data container", entry);
 assertEquals("Wrong value for key " + key + " in data container", value, entry.getValue());
 MarshalledEntry<Object, Object> entryLoaded = loader.load(key);
 assertNull("Key " + key + " exists in cache loader", entryLoaded);
}

@SuppressWarnings("unchecked")
protected void assertNotInMemory(Object key, Object value) {
 DataContainer container = cache.getAdvancedCache().getDataContainer();
 InternalCacheEntry entry = container.get(key);
 CacheLoader<Object, Object> loader = TestingUtil.getFirstLoader(cache);
 assertNull("Key " + key + " exists in data container", entry);
 MarshalledEntry<Object, Object> entryLoaded = loader.load(key);
 assertNotNull("Key " + key + " does not exist in cache loader", entryLoaded);
 assertEquals("Wrong value for key " + key + " in cache loader", value, entryLoaded.getValue());
}

@SuppressWarnings("unchecked")
@Override
protected void assertInMemory(Object key, Object value) {
 DataContainer container = cache.getAdvancedCache().getDataContainer();
 InternalCacheEntry entry = container.get(key);
 CacheLoader<Object, Object> loader = TestingUtil.getFirstLoader(cache);
 assertNotNull("Key " + key + " does not exist in data container", entry);
 assertEquals("Wrong value for key " + key + " in data container", value, entry.getValue());
 MarshalledEntry<Object, Object> entryLoaded = loader.load(key);
 assertNull("Key " + key + " exists in cache loader.", entryLoaded);
}

@SuppressWarnings("unchecked")
protected void assertInMemory(Object key, Object value) {
 DataContainer container = cache.getAdvancedCache().getDataContainer();
 InternalCacheEntry entry = container.get(key);
 CacheLoader<Object, Object> loader = TestingUtil.getFirstLoader(cache);
 assertNotNull("Key " + key + " does not exist in data container", entry);
 assertEquals("Wrong value for key " + key + " in data container", value, entry.getValue());
 MarshalledEntry<Object, Object> entryLoaded = loader.load(key);
 assertNotNull("Key " + key + " does not exist in cache loader", entryLoaded);
 assertEquals("Wrong value for key " + key + " in cache loader", value, entryLoaded.getValue());
}

@SuppressWarnings("unchecked")
@Override
protected void initializeKeyAndCheckData(Object key, Object value) {
 assertTrue("A cache store should be configured!", cache.getCacheConfiguration().persistence().usingStores());
 cache.put(key, value);
 DataContainer container = cache.getAdvancedCache().getDataContainer();
 InternalCacheEntry entry = container.get(key);
 CacheLoader<Object, Object> loader = TestingUtil.getFirstLoader(cache);
 assertNotNull("Key " + key + " does not exist in data container.", entry);
 assertEquals("Wrong value for key " + key + " in data container.", value, entry.getValue());
 MarshalledEntry<Object, Object> entryLoaded = loader.load(key);
 assertNull("Key " + key + " exists in cache loader.", entryLoaded);
}

@SuppressWarnings("unchecked")
@Override
protected void initializeKeyAndCheckData(Object key, Object value) {
 assertTrue("A cache store should be configured!", cache.getCacheConfiguration().persistence().usingStores());
 cache.put(key, value);
 DataContainer container = cache.getAdvancedCache().getDataContainer();
 InternalCacheEntry entry = container.get(key);
 CacheLoader<Object, Object> loader = TestingUtil.getFirstLoader(cache);
 assertNotNull("Key " + key + " does not exist in data container.", entry);
 assertEquals("Wrong value for key " + key + " in data container.", value, entry.getValue());
 MarshalledEntry<Object, Object> entryLoaded = loader.load(key);
 assertNull("Key " + key + " exists in cache loader.", entryLoaded);
}

private void assertInCacheAndStore(Cache cache, CacheLoader store, Object key, Object value, long lifespanMillis) throws PersistenceException {
 InternalCacheValue icv = cache.getAdvancedCache().getDataContainer().get(key).toInternalCacheValue();
 assertStoredEntry(icv.getValue(), value, icv.getLifespan(), lifespanMillis, "Cache", key);
 assertNotNull("For :" + icv, icv.getMetadata().version());
 MarshalledEntry load = store.load(key);
 assertStoredEntry(load.getValue(), value, load.getMetadata().lifespan(), lifespanMillis, "Store", key);
 assertNotNull("For :" + load, load.getMetadata().version());
}