private <K> void doUpdateSubsetAndReturnPrevs(Supplier<K> keySupplier, ReadOnlyMap<K, String> map1, WriteOnlyMap<K, String> map2, ReadWriteMap<K, String> map3) { 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(map2.evalMany(data, setValueConsumer())); Traversable<String> currentValues = map1.evalMany(data.keySet(), returnReadOnlyFindOrNull()); List<String> collectedValues = currentValues.collect(ArrayList::new, ArrayList::add, ArrayList::addAll); Collections.sort(collectedValues); List<String> dataValues = new ArrayList<>(data.values()); Collections.sort(dataValues); assertEquals(collectedValues, dataValues); Map<K, String> newData = new HashMap<>(); newData.put(key1, "bat"); newData.put(key2, "bi"); newData.put(key3, "hiru"); Traversable<String> prevTraversable = map3.evalMany(newData, setValueReturnPrevOrNull()); List<String> collectedPrev = prevTraversable.collect(ArrayList::new, ArrayList::add, ArrayList::addAll); Collections.sort(collectedPrev); assertEquals(dataValues, collectedPrev); Traversable<String> updatedValues = map1.evalMany(data.keySet(), returnReadOnlyFindOrNull()); List<String> collectedUpdates = updatedValues.collect(ArrayList::new, ArrayList::add, ArrayList::addAll); Collections.sort(collectedUpdates); List<String> newDataValues = new ArrayList<>(newData.values()); Collections.sort(newDataValues); assertEquals(newDataValues, collectedUpdates); }
private <K> void doLambdaWriteListeners(Supplier<K> keySupplier, WriteOnlyMap<K, String> wo, boolean isOwner) throws Exception { K key1 = keySupplier.get(), key2 = keySupplier.get(); List<CountDownLatch> latches = launderLatches(new ArrayList<>(), 1); AutoCloseable onWrite = wo.listeners().onWrite(read -> { assertEquals("write", read.get()); latches.get(0).countDown(); }); awaitEventIfOwnerAndLaunderLatch(isOwner, wo.eval(key1, new SetConstantOnWriteOnly("write")), latches); awaitEventIfOwnerAndLaunderLatch(isOwner, wo.eval(key1, new SetConstantOnWriteOnly("write")), latches); onWrite.close(); awaitNoEvent(wo.eval(key2, new SetConstantOnWriteOnly("write")), latches.get(0)); awaitNoEvent(wo.eval(key2, new SetConstantOnWriteOnly("write")), latches.get(0)); // TODO: Test other eval methods :) AutoCloseable onWriteRemove = wo.listeners().onWrite(read -> { assertFalse(read.find().isPresent()); latches.get(0).countDown(); }); awaitEventIfOwnerAndLaunderLatch(isOwner, wo.eval(key1, removeConsumer()), latches); onWriteRemove.close(); awaitNoEvent(wo.eval(key2, removeConsumer()), latches.get(0)); }
}; for (Object key : keys) { wo.eval(key, "v0", MarshallableFunctions.setValueConsumer()).join(); assertEquals("v0", backup.get(key)); wo.eval(key, MarshallableFunctions.removeConsumer()).join(); assertEquals(null, backup.get(key)); wo.evalMany(map(keys, "v1"), MarshallableFunctions.setValueConsumer()).join(); for (Object key : keys) { assertEquals("v1", backup.get(key)); wo.evalMany(Util.asSet(keys), MarshallableFunctions.removeConsumer()).join(); for (Object key : keys) { assertEquals(null, backup.get(key));
}); awaitNoEvent(woMap.eval(key1, "created", setValueConsumer()), latches.get(0)); awaitNoEvent(woMap.eval(key1, "modified", setValueConsumer()), latches.get(1)); awaitNoEvent(woMap.eval(key1, removeConsumer()), latches.get(2)); awaitNoEvent(woMap.eval(key4, "tres", setValueConsumer()), latches.get(0)); awaitNoEvent(woMap.eval(key4, "three", setValueConsumer()), latches.get(1)); awaitNoEvent(woMap.eval(key4, removeConsumer()), latches.get(2));
wo.eval(KEY, "x", MarshallableFunctions.setValueConsumer()).join(); assertEquals("x", cache.putIfAbsent(KEY, "otherValue")); tm.commit(); wo.eval(KEY, MarshallableFunctions.removeConsumer()).join(); assertNull(cache.putIfAbsent(KEY, "y")); assertEquals("y", ro.eval(KEY, MarshallableFunctions.returnReadOnlyFindOrNull()).join());
/** * 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)); } ) ) ); }
/** * Write-only allows for constant, non-capturing, values to be written, * and read-only allows for those values to be retrieved. */ private <K> void doWriteConstantAndReadGetsValue(Supplier<K> keySupplier, ReadOnlyMap<K, String> map1, WriteOnlyMap<K, String> map2) { K key = keySupplier.get(); await( map2.eval(key, SetStringConstant.INSTANCE).thenCompose(r -> map1.eval(key, returnReadOnlyFindOrNull()).thenAccept(v -> { assertNull(r); assertEquals("one", v); } ) ) ); }
@Override public void putAll(Map<? extends K, ? extends V> m) { await(writeOnly.evalMany(m, setValueConsumer())); }
@Override public void removeAll(Set<? extends K> keys) { await(writeOnly.evalMany(keys, removeConsumer())); }
@Override public void removeAll() { await(writeOnly.evalAll(removeConsumer())); }
@Override public WriteListeners<K, V> writeOnlyListeners() { return writeOnly.listeners(); }
@Override public void put(K key, V value) { await(writeOnly.eval(key, value, setValueConsumer())); }
@Override public void putAll(Map<? extends K, ? extends V> map) { await(writeOnly.evalMany(map, setValueConsumer())); }
@Override public void clear() { await(writeOnly.truncate()); }
@Override public void putAll(Map<? extends K, ? extends V> map, long lifespan, TimeUnit unit) { final MetaLifespan metaLifespan = createMetaLifespan(lifespan, unit); await(wo.evalMany(map, setValueMetasConsumer(metaLifespan))); }
@Test(dataProvider = "ownerAndExistence", enabled = false, description = "ISPN-8676") public void testWriteOnlyManyCommand(boolean onOwner, boolean withExisting) { WriteOnlyMap<Object, Object> wo = onOwner ? wo0 : wo1; test(() -> wo.evalMany(Collections.singleton(key), view -> { }), onOwner, withExisting); }
@Test(dataProvider = "ownerAndExistence") public void testWriteOnlyKeyValueCommand(boolean onOwner, boolean withExisting) { WriteOnlyMap<Object, Object> wo = onOwner ? wo0 : wo1; test(() -> wo.eval(key, "bar", (bar, view) -> { }), onOwner, withExisting); }
@Override public void clear() { await(writeOnly.truncate()); }