protected void assertEventuallyExpires(final String key) throws Exception { eventually(() -> cl.load(key) == null); }
public void testWriteAndDeleteBatch() throws Exception { // Number of entries is randomized to even numbers between 80 and 120 int numberOfEntries = 2 * ThreadLocalRandom.current().nextInt(WRITE_DELETE_BATCH_MIN_ENTRIES / 2, WRITE_DELETE_BATCH_MAX_ENTRIES / 2 + 1); assertIsEmpty(); assertNull("should not be present in the store", cl.load(0)); List<MarshalledEntry<?, ?>> entries = IntStream.range(0, numberOfEntries).boxed() .map(i -> marshalledEntry(i.toString(), "Val" + i, null)) .collect(Collectors.toList()); cl.writeBatch(entries); Set<MarshalledEntry<Object, Object>> set = TestingUtil.allEntries(cl); assertSize(set, numberOfEntries); assertNotNull(cl.load("56")); int batchSize = numberOfEntries / 2; List<Object> keys = IntStream.range(0, batchSize).mapToObj(Integer::toString).collect(Collectors.toList()); cl.deleteBatch(keys); set = TestingUtil.allEntries(cl); assertSize(set, batchSize); assertNull(cl.load("20")); }
private void assertInStoreNotInCache(Object key, Object value, long lifespanMillis) throws PersistenceException { MarshalledEntry se = store.load(key); testStoredEntry(se, value, lifespanMillis, "Store", key); assert !cache.getAdvancedCache().getDataContainer().containsKey(key) : "Key " + key + " should not be in cache!"; }
@Override public void testReplaceExpiredEntry() throws Exception { cl.write(marshalledEntry(internalCacheEntry("k1", "v1", 100l))); timeService.advance(1101); assertNull(cl.load("k1")); long start = System.currentTimeMillis(); cl.write(marshalledEntry(internalCacheEntry("k1", "v2", 100l))); assertTrue(cl.load("k1").getValue().equals("v2") || TestingUtil.moreThanDurationElapsed(start, 100)); } }
@Override public void testReplaceExpiredEntry() throws Exception { cl.write(marshalledEntry(internalCacheEntry("k1", "v1", 100l))); // Hot Rod does not support milliseconds, so 100ms is rounded to the nearest second, // and so data is stored for 1 second here. Adjust waiting time accordingly. timeService.advance(1101); assertNull(cl.load("k1")); long start = System.currentTimeMillis(); cl.write(marshalledEntry(internalCacheEntry("k1", "v2", 100l))); assertTrue(cl.load("k1").getValue().equals("v2") || TestingUtil.moreThanDurationElapsed(start, 100)); } }
@Override public void testReplaceExpiredEntry() throws Exception { cl.write(marshalledEntry(internalCacheEntry("k1", "v1", 100))); // Hot Rod does not support milliseconds, so 100ms is rounded to the nearest second, // and so data is stored for 1 second here. Adjust waiting time accordingly. timeService.advance(1101); assertNull(cl.load("k1")); long start = System.currentTimeMillis(); cl.write(marshalledEntry(internalCacheEntry("k1", "v2", 100))); assertTrue(cl.load("k1").getValue().equals("v2") || TestingUtil.moreThanDurationElapsed(start, 100)); }
public void testStoreLoadRemove() throws Exception { assertRowCount(0); assertNull("should not be present in the store", cacheStore.load(MIRCEA)); String value = "adsdsadsa"; cacheStore.write(new MarshalledEntryImpl(MIRCEA, value, null, marshaller)); assertRowCount(1); assertEquals(value, cacheStore.load(MIRCEA).getValue()); assertFalse(cacheStore.delete(MANIK)); assertEquals(value, cacheStore.load(MIRCEA).getValue()); assertRowCount(1); assertTrue(cacheStore.delete(MIRCEA)); assertRowCount(0); }
@Override public void testReplaceExpiredEntry() throws Exception { InternalCacheEntry ice = internalCacheEntry("k1", "v1", 100); cl.write(marshalledEntry(ice)); // Hot Rod does not support milliseconds, so 100ms is rounded to the nearest second, // and so data is stored for 1 second here. Adjust waiting time accordingly. timeService.advance(1101); assertNull(cl.load("k1")); InternalCacheEntry ice2 = internalCacheEntry("k1", "v2", 100); cl.write(marshalledEntry(ice2)); assertEquals("v2", cl.load("k1").getValue()); }
public void testReplaceExpiredEntry() throws Exception { assertIsEmpty(); final long lifespan = 3000; InternalCacheEntry ice = internalCacheEntry("k1", "v1", lifespan); assertExpired(ice, false); cl.write(marshalledEntry(ice)); assertEquals("v1", unwrap(cl.load("k1").getValue())); timeService.advance(lifespan + 1); assertExpired(ice, true); assertNull(cl.load("k1")); InternalCacheEntry ice2 = internalCacheEntry("k1", "v2", lifespan); assertExpired(ice2, false); cl.write(marshalledEntry(ice2)); assertEquals("v2", unwrap(cl.load("k1").getValue())); timeService.advance(lifespan + 1); assertExpired(ice2, true); assertNull(cl.load("k1")); }
public void testReplaceEntry() { assertIsEmpty(); InternalCacheEntry ice = internalCacheEntry("k1", "v1", -1); cl.write(marshalledEntry(ice)); assertEquals("v1", unwrap(cl.load("k1").getValue())); InternalCacheEntry ice2 = internalCacheEntry("k1", "v2", -1); cl.write(marshalledEntry(ice2)); assertEquals("v2", unwrap(cl.load("k1").getValue())); }
public void testPutKeyValue() throws Exception { assertStoreAccess(0, 0, 0); cache.put("key", "value"); assertStoreAccess(0, 1, 1); cache.put("key", "value2"); assertStoreAccess(0, 1, 2); store.write(new MarshalledEntryImpl("a", "b", null, marshaller())); cache.put("a", "c"); assertStoreAccess(1, 1, 3); assert store.load("a").getValue().equals("c"); }
public void testPurgeExpired() throws Exception { InternalCacheEntry first = TestInternalCacheEntryFactory.create(MIRCEA, "val", 1000); InternalCacheEntry second = TestInternalCacheEntryFactory.create(MANIK, "val2"); cacheStore.write(marshalledEntry(first, marshaller)); cacheStore.write(marshalledEntry(second, marshaller)); assertRowCount(2); Thread.sleep(1100); cacheStore.purge(new WithinThreadExecutor(), null); assertRowCount(1); assertEquals("val2", cacheStore.load(MANIK).getValue()); }
public void testLoadAndStoreWithLifespan() throws Exception { assertIsEmpty(); long lifespan = 120000; InternalCacheEntry se = internalCacheEntry("k", "v", lifespan); assertExpired(se, false); cl.write(marshalledEntry(se)); assertContains("k", true); assertCorrectExpiry(cl.load("k"), "v", lifespan, -1, false); assertCorrectExpiry(TestingUtil.allEntries(cl).iterator().next(), "v", lifespan, -1, false); lifespan = 2000; se = internalCacheEntry("k", "v", lifespan); assertExpired(se, false); cl.write(marshalledEntry(se)); timeService.advance(lifespan + 1); purgeExpired("k"); assertExpired(se, true); assertEventuallyExpires("k"); assertContains("k", false); assertIsEmpty(); }
cl.start(); assertExpired(se1, true); assertNull(cl.load("k1")); assertContains("k1", false); assertExpired(se2, false); assertNotNull(cl.load("k2")); assertContains("k2", true); assertEquals("v2", unwrap(cl.load("k2").getValue())); assertExpired(se3, true); assertNull(cl.load("k3")); assertContains("k3", false); assertExpired(se4, true); assertNull(cl.load("k4")); assertContains("k4", false);
public void testLoadAndStoreWithIdle() throws Exception { assertIsEmpty(); long idle = 120000; InternalCacheEntry se = internalCacheEntry("k", "v", -1, idle); assertExpired(se, false); cl.write(marshalledEntry(se)); assertContains("k", true); assertCorrectExpiry(cl.load("k"), "v", -1, idle, false); assertCorrectExpiry(TestingUtil.allEntries(cl).iterator().next(), "v", -1, idle, false); idle = 1000; se = internalCacheEntry("k", "v", -1, idle); assertExpired(se, false); cl.write(marshalledEntry(se)); timeService.advance(idle + 1); purgeExpired("k"); assertExpired(se, true); assertEventuallyExpires("k"); assertContains("k", false); assertIsEmpty(); }
public void testLoadAndStoreImmortal() throws PersistenceException { assertIsEmpty(); cl.write(marshalledEntry("k", "v", null)); MarshalledEntry entry = cl.load("k"); assertEquals("v", unwrap(entry.getValue())); assertTrue("Expected an immortalEntry", entry.getMetadata() == null || entry.getMetadata().expiryTime() == -1 || entry.getMetadata().maxIdle() == -1); assertContains("k", true); assertFalse(cl.delete("k2")); }
public void testLoadAndStoreWithLifespanAndIdle2() throws Exception { assertContains("k", false); long lifespan = 2000; long idle = 2000; InternalCacheEntry se = internalCacheEntry("k", "v", lifespan, idle); InternalCacheValue icv = se.toInternalCacheValue(); assertEquals(se.getCreated(), icv.getCreated()); assertEquals(se.getLastUsed(), icv.getLastUsed()); assertExpired(se, false); cl.write(marshalledEntry(se)); assertContains("k", true); assertCorrectExpiry(cl.load("k"), "v", lifespan, idle, false); assertCorrectExpiry(TestingUtil.allEntries(cl).iterator().next(), "v", lifespan, idle, false); idle = 4000; lifespan = 2000; se = internalCacheEntry("k", "v", lifespan, idle); assertExpired(se, false); cl.write(marshalledEntry(se)); timeService.advance(lifespan + 1); assertExpired(se, true); //expired by lifespan purgeExpired("k"); assertEventuallyExpires("k"); assertContains("k", false); assertIsEmpty(); }
public void testLoadAndStoreWithLifespanAndIdle() throws Exception { assertIsEmpty(); long lifespan = 200000; long idle = 120000; InternalCacheEntry se = internalCacheEntry("k", "v", lifespan, idle); InternalCacheValue icv = se.toInternalCacheValue(); assertEquals(se.getCreated(), icv.getCreated()); assertEquals(se.getLastUsed(), icv.getLastUsed()); assertExpired(se, false); cl.write(marshalledEntry(se)); assertContains("k", true); assertCorrectExpiry(cl.load("k"), "v", lifespan, idle, false); assertCorrectExpiry(TestingUtil.allEntries(cl).iterator().next(), "v", lifespan, idle, false); idle = 1000; lifespan = 4000; se = internalCacheEntry("k", "v", lifespan, idle); assertExpired(se, false); cl.write(marshalledEntry(se)); timeService.advance(idle + 1); purgeExpired("k"); assertExpired(se, true); //expired by idle assertEventuallyExpires("k"); assertContains("k", false); assertIsEmpty(); }
public void testLoadAndStoreBytesValues() throws PersistenceException, IOException, InterruptedException { assertIsEmpty(); WrappedBytes key = new WrappedByteArray(getMarshaller().objectToByteBuffer(new Pojo().role("key"))); WrappedBytes key2 = new WrappedByteArray(getMarshaller().objectToByteBuffer(new Pojo().role("key2"))); WrappedBytes value = new WrappedByteArray(getMarshaller().objectToByteBuffer(new Pojo().role("value"))); assertFalse(cl.contains(key)); cl.write(new MarshalledEntryImpl<Object, Object>(key, value, null, getMarshaller())); assertEquals(value, cl.load(key).getValue()); MarshalledEntry entry = cl.load(key); assertTrue("Expected an immortalEntry", entry.getMetadata() == null || entry.getMetadata().expiryTime() == -1 || entry.getMetadata().maxIdle() == -1); assertContains(key, true); assertFalse(cl.delete(key2)); assertTrue(cl.delete(key)); }