@Test(dataProvider = "writeMethods") public void testWriteLoadLocal(WriteMethod method) { Integer key = 1; method.eval(key, lwo, lrw, view -> { assertFalse(view.find().isPresent()); return null; }, (view, nil) -> view.set("value"), getClass()); assertInvocations(1); assertEquals(cacheManagers.get(0).getCache().get(key), "value"); method.eval(key, lwo, lrw, view -> { assertTrue(view.find().isPresent()); assertEquals(view.get(), "value"); return null; }, (view, nil) -> {}, getClass()); assertInvocations(2); }
@Test(dataProvider = "owningModeAndWriteMethod") public void testWrite(boolean isOwner, WriteMethod method) { Object key = getKey(isOwner, SCATTERED); method.eval(key, swo, srw, view -> { assertFalse(view.find().isPresent()); return null; }, (view, nil) -> view.set("value"), getClass()); assertInvocations(1); caches(SCATTERED).forEach(cache -> assertEquals(cache.get(key), "value", getAddress(cache).toString())); Utils.assertOwnershipAndNonOwnership(caches(SCATTERED), key); method.eval(key, swo, srw, view -> { assertTrue(view.find().isPresent()); assertEquals(view.get(), "value"); return null; }, (view, nil) -> {}, getClass()); assertInvocations(2); }
(view, nil) -> view.set("value"), getClass());
(view, nil) -> view.set("value"), getClass());
@Test(dataProvider = "owningModeAndWriteMethod") public void testEntryInvalidated(boolean isOwner, WriteMethod method) { Cache<Object, String> primary = cache(isOwner ? 0 : 2, DIST); Cache<Object, String> backup = cache(1, DIST); Cache<Object, String> reader = cache(3, DIST); Cache<Object, String> nonOwner = cache(isOwner ? 2 : 0, DIST); Object KEY = getKeyForCache(primary, backup); primary.put(KEY, "value"); assertNoEntry(reader, KEY); assertEquals("value", reader.get(KEY)); assertEntry(primary, KEY, "value", false); assertEntry(backup, KEY, "value", false); assertEntry(reader, KEY, "value", true); assertNoEntry(nonOwner, KEY); FunctionalMapImpl<Object, String> functionalMap = FunctionalMapImpl.create(this.<Object, String>cache(0, DIST).getAdvancedCache()); FunctionalMap.WriteOnlyMap<Object, String> wo = WriteOnlyMapImpl.create(functionalMap); FunctionalMap.ReadWriteMap<Object, String> rw = ReadWriteMapImpl.create(functionalMap); Function<ReadEntryView<Object, String>, String> readFunc = MarshallableFunctions.returnReadOnlyFindOrNull(); method.eval(KEY, wo, rw, readFunc, (view, nil) -> view.set("value2"), FunctionalL1Test.class); assertEntry(primary, KEY, "value2", false); assertEntry(backup, KEY, "value2", false); assertNoEntry(reader, KEY); assertNoEntry(nonOwner, KEY); }
@Test(dataProvider = "writeMethods") public void testWriteLoadLocal(WriteMethod method) { Integer key = 1; method.eval(key, lwo, lrw, view -> { assertFalse(view.find().isPresent()); return null; }, (view, nil) -> view.set("value"), getClass()); assertInvocations(1); Cache<Integer, String> cache = cacheManagers.get(0).getCache(); assertEquals(cache.get(key), "value"); cache.evict(key); assertFalse(cache.getAdvancedCache().getDataContainer().containsKey(key)); DummyInMemoryStore store = getStore(cache); assertTrue(store.contains(key)); method.eval(key, lwo, lrw, view -> { assertTrue(view.find().isPresent()); assertEquals(view.get(), "value"); return null; }, (view, nil) -> {}, getClass()); assertInvocations(2); }
@Override public void accept(WriteEntryView<K, String> wo) { wo.set(constant); }
@Test(dataProvider = "owningModeAndReadWrites") public void testWriteModsInTxContext(boolean isOwner, WriteMethod method) throws Exception { Object KEY = getKey(isOwner, DIST); cache(0, DIST).put(KEY, "a"); tm.begin(); assertEquals("a", cache(0, DIST).put(KEY, "b")); // read-write operation should execute locally instead assertEquals("b", method.eval(KEY, null, rw, EntryView.ReadEntryView::get, (e, prev) -> e.set(prev + "c"), getClass())); // make sure that the operation was executed in context assertEquals("bc", ro.eval(KEY, MarshallableFunctions.returnReadOnlyFindOrNull()).join()); tm.commit(); }
@Override public void accept(WriteEntryView<K, String> wo) { wo.set("one"); }
@Override public void accept(V v, WriteEntryView<K, V> wo) { wo.set(v, new MetaLifespan(100000)); }
<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()))); }
public void testPrimaryOwnerChangingDuringReplaceBasedOnMeta() throws Exception { // TODO: Move initial set and replace with meta logic to TestWriteOperation WriteOnlyMap<String, String> wo0 = wo(0); wo0.eval("testkey", wo -> wo.set("v0", new MetaEntryVersion(new NumericVersion(1)))); doTest(TestWriteOperation.REPLACE_META_FUNCTIONAL); }