public static void putValuesOnMultimapCache(MultimapCache<String, Person> multimapCache, String key, Person... values) { for (int i = 0; i < values.length; i++) { await(multimapCache.put(key, values[i])); } }
protected void assertKeyValueNotFoundInAllCaches(String key, Person value) { for (Map.Entry<Address, MultimapCache<String, Person>> entry : multimapCacheCluster.entrySet()) { await(entry.getValue().get(key).thenAccept(v -> { assertNotNull(format("values on the key %s must be not null", key), v); assertFalse(format("values on the key '%s' must not contain '%s' on node '%s'", key, value, entry.getKey()), v.contains(value)); }) ); } }
protected void assertOnAllCaches(Object key, Person value) { for (Map.Entry<Address, MultimapCache<String, Person>> entry : multimapCacheCluster.entrySet()) { await(entry.getValue().get((String) key).thenAccept(v -> { assertNotNull(format("values on the key %s must be not null", key), v); assertTrue(format("values on the key '%s' must contain '%s' on node '%s'", key, value, entry.getKey()), v.contains(value)); }) ); } } }
/** * Read-write allows to retrieve an empty cache entry. */ <K> void doReadWriteGetsEmpty(Supplier<K> keySupplier, ReadWriteMap<K, String> map) { K key = keySupplier.get(); await(map.eval(key, returnReadWriteFind()).thenAccept(v -> assertEquals(Optional.empty(), v))); }
<K> void doReadWriteToRemoveAllAndReturnPrevs(Supplier<K> keySupplier, WriteOnlyMap<K, String> map1, ReadWriteMap<K, String> map2) { K key1 = keySupplier.get(), key2 = keySupplier.get(), key3 = keySupplier.get(); Map<K, String> data = new HashMap<>(); data.put(key1, "one"); data.put(key2, "two"); data.put(key3, "three"); await(map1.evalMany(data, setValueConsumer())); Traversable<String> prevTraversable = map2.evalAll(removeReturnPrevOrNull()); Set<String> prevValues = prevTraversable.collect(HashSet::new, HashSet::add, HashSet::addAll); assertEquals(new HashSet<>(data.values()), prevValues); }
public static void assertMultimapCacheSize(MultimapCache<String, Person> multimapCache, int expectedSize) { assertEquals(expectedSize, await(multimapCache.size()).intValue()); }
private <K> void replaceWithVersion(Supplier<K> keySupplier, ReadWriteMap<K, String> map1, ReadWriteMap<K, String> map2, long version, Consumer<ReadWriteEntryView<K, String>> asserts) { K key = keySupplier.get(); await( map1.eval(key, SetStringAndVersionConstant.getInstance()).thenCompose(r -> map2.eval(key, new VersionBasedConditionalReplace<>(version)).thenAccept(rw -> { assertNull(r); asserts.accept(rw); } ) ) ); }
public void testGet() { initAndTest(); MultimapCache<String, Person> multimapCache = getMultimapCacheMember(); await(multimapCache.get(NAMES_KEY).thenAccept(v -> { assertTrue(v.contains(OIHANA)); })); await(multimapCache.getEntry(NAMES_KEY).thenAccept(v -> { assertTrue(v.isPresent() && v.get().getKey().equals(NAMES_KEY) && v.get().getValue().contains(OIHANA)); })); await(multimapCache.put(EMPTY_KEY, RAMON).thenCompose(r3 -> multimapCache.get(EMPTY_KEY)).thenAccept(v -> { assertTrue(v.contains(RAMON)); })); }
public static void assertContaisKeyValue(MultimapCache<String, Person> multimapCache, String key, Person value) { Address address = ((EmbeddedMultimapCache) multimapCache).getCache().getCacheManager().getAddress(); await(multimapCache.get(key).thenAccept(v -> { assertTrue(format("get method call : multimap '%s' must contain key '%s' value '%s' pair", address, key, value), v.contains(value)); })); await(multimapCache.containsEntry(key, value).thenAccept(v -> { assertTrue(format("containsEntry method call : multimap '%s' must contain key '%s' value '%s' pair", address, key, value), v); })); }
public void testContainsKey() { await( multimapCache.containsKey(NAMES_KEY) .thenAccept(containsKey -> assertFalse(containsKey)) ); await( multimapCache.put(NAMES_KEY, OIHANA) .thenCompose(r -> multimapCache.containsKey(NAMES_KEY)) .thenAccept(containsKey -> assertTrue(containsKey)) ); await( multimapCache.put(EMPTY_KEY, KOLDO) .thenCompose(r -> multimapCache.containsKey(EMPTY_KEY)) .thenAccept(containsKey -> assertTrue(containsKey)) ); }
<K> void doReturnViewFromReadOnlyEval(Supplier<K> keySupplier, ReadOnlyMap<K, String> ro, WriteOnlyMap<K, String> wo) { K k = keySupplier.get(); assertReadOnlyViewEmpty(k, await(ro.eval(k, identity()))); await(wo.eval(k, wv -> wv.set("one"))); assertReadOnlyViewEquals(k, "one", await(ro.eval(k, identity()))); }
<K> void doReturnViewFromReadWriteEval(Supplier<K> keySupplier, ReadWriteMap<K, String> readMap, ReadWriteMap<K, String> writeMap) { K k = keySupplier.get(); assertReadWriteViewEmpty(k, await(readMap.eval(k, returnReadWriteView()))); assertReadWriteViewEquals(k, "one", await(writeMap.eval(k, setOneReadWrite()))); assertReadWriteViewEquals(k, "one", await(readMap.eval(k, returnReadWriteView()))); assertReadWriteViewEquals(k, "uno", await(writeMap.eval(k, "uno", setValueReturnView()))); assertReadWriteViewEquals(k, "uno", await(readMap.eval(k, returnReadWriteView()))); }
/** * Read-write allows for constant, non-capturing, values to be written, * returns previous value, and also allows values to be retrieved. */ private <K> void doReadWriteConstantReturnPrev(Supplier<K> keySupplier, ReadWriteMap<K, String> map1, ReadWriteMap<K, String> map2) { K key = keySupplier.get(); await( map2.eval(key, SetStringConstantReturnPrevious.getInstance()).thenCompose(r -> map1.eval(key, returnReadWriteGet()).thenAccept(v -> { assertFalse(r.isPresent()); assertEquals("one", v); } ) ) ); }
public void testGetAndModifyResults() { initAndTest(); MultimapCache<String, Person> multimapCache = getMultimapCacheMember(NAMES_KEY); Person pepe = new Person("Pepe"); await( multimapCache.get(NAMES_KEY) .thenAccept(v -> { List<Person> modifiedList = new ArrayList<>(v); modifiedList.add(pepe); } ) ); assertKeyValueNotFoundInAllCaches(NAMES_KEY, pepe); }
protected void assertKeyValueFoundInOwners(String key, Person value) { Cache<String, Collection<Person>> firstOwner = getFirstOwner(key); Cache<String, Collection<Person>> secondNonOwner = getSecondNonOwner(key); MultimapCache<String, Person> mcFirstOwner = multimapCacheCluster.get(firstOwner.getCacheManager().getAddress()); MultimapCache<String, Person> mcSecondOwner = multimapCacheCluster.get(secondNonOwner.getCacheManager().getAddress()); await(mcFirstOwner.get(key).thenAccept(v -> { assertTrue(format("firstOwner '%s' must contain key '%s' value '%s' pair", firstOwner.getCacheManager().getAddress(), key, value), v.contains(value)); }) ); await(mcSecondOwner.get(key).thenAccept(v -> { assertTrue(format("secondOwner '%s' must contain key '%s' value '%s' pair", secondNonOwner.getCacheManager().getAddress(), key, value), v.contains(value)); }) ); }
public void testRemoveKey() { initAndTest(); MultimapCache<String, Person> multimapCache = getMultimapCacheMember(NAMES_KEY); await( multimapCache.remove(NAMES_KEY, OIHANA).thenCompose(r1 -> { assertTrue(r1); return multimapCache.get(NAMES_KEY).thenAccept(v -> assertTrue(v.isEmpty())); }) ); assertRemovedOnAllCaches(NAMES_KEY); putValuesOnMultimapCache(multimapCache, EMPTY_KEY, RAMON); await(multimapCache.remove(EMPTY_KEY).thenCompose(r1 -> { assertTrue(r1); return multimapCache.get(EMPTY_KEY).thenAccept(v -> assertTrue(v.isEmpty())); })); }
public void testSizeInExplicitTxWithRemoveKeyValue() throws SystemException, NotSupportedException { assertMultimapCacheSize(multimapCache, 0); putValuesOnMultimapCache(multimapCache, NAMES_KEY, JULIEN, OIHANA); assertMultimapCacheSize(multimapCache, 2); TransactionManager tm1 = getTransactionManager(multimapCache); tm1.begin(); try { await(multimapCache.remove(MultimapTestUtils.NAMES_KEY, JULIEN)); assertMultimapCacheSize(multimapCache, 1); } finally { tm1.rollback(); } assertMultimapCacheSize(multimapCache, 2); }
/** * Write-only allows for non-capturing values to be written along with metadata, * and read-only allows for both values and metadata to be retrieved. */ private <K> void doWriteValueAndReadValueAndMetadata(Supplier<K> keySupplier, ReadOnlyMap<K, String> map1, WriteOnlyMap<K, String> map2) { K key = keySupplier.get(); await( map2.eval(key, "one", SetValueAndConstantLifespan.getInstance()).thenCompose(r -> map1.eval(key, identity()).thenAccept(ro -> { assertNull(r); assertEquals(Optional.of("one"), ro.find()); assertEquals("one", ro.get()); assertEquals(Optional.of(new MetaLifespan(100000)), ro.findMetaParam(MetaLifespan.class)); } ) ) ); }
public void testSizeInExplicitTxWithRemoveNonExistentAndPut() throws SystemException, NotSupportedException { assertMultimapCacheSize(multimapCache, 0); putValuesOnMultimapCache(multimapCache, NAMES_KEY, JULIEN); assertMultimapCacheSize(multimapCache, 1); TransactionManager tm1 = getTransactionManager(multimapCache); tm1.begin(); try { await(multimapCache.remove("firstnames")); assertMultimapCacheSize(multimapCache, 1); putValuesOnMultimapCache(multimapCache, "firstnames", JULIEN, OIHANA, RAMON); assertMultimapCacheSize(multimapCache, 4); } finally { tm1.rollback(); } assertMultimapCacheSize(multimapCache, 1); }