/** Advances the ticker value by {@code time} in {@code timeUnit}. */ @SuppressWarnings("GoodTime") // should accept a java.time.Duration public FakeTicker advance(long time, TimeUnit timeUnit) { return advance(timeUnit.toNanos(time)); }
public void testExpiration_invalidateAll() { FakeTicker ticker = new FakeTicker(); QueuingRemovalListener<Integer, Integer> listener = TestingRemovalListeners.queuingRemovalListener(); Cache<Integer, Integer> cache = CacheBuilder.newBuilder() .expireAfterAccess(1, TimeUnit.MINUTES) .removalListener(listener) .ticker(ticker) .build(); cache.put(1, 1); ticker.advance(10, TimeUnit.MINUTES); cache.invalidateAll(); assertThat(listener.poll().getCause()).isEqualTo(RemovalCause.EXPIRED); }
public void testAutoIncrement_negative() { FakeTicker ticker = new FakeTicker(); try { ticker.setAutoIncrementStep(-1, TimeUnit.NANOSECONDS); fail("Expected IllegalArgumentException"); } catch (IllegalArgumentException expected) { } }
public void testAutoIncrementStep_millis() { FakeTicker ticker = new FakeTicker().setAutoIncrementStep(1, TimeUnit.MILLISECONDS); assertEquals(0, ticker.read()); assertEquals(1000000, ticker.read()); assertEquals(2000000, ticker.read()); }
@Override protected void setUp() throws Exception { super.setUp(); fakeTicker = new FakeTicker(); }
static void expireEntries(LocalCache<?, ?> cchm, long expiringTime, FakeTicker ticker) { for (Segment<?, ?> segment : cchm.segments) { drainRecencyQueue(segment); } ticker.advance(2 * expiringTime, TimeUnit.MILLISECONDS); long now = ticker.read(); for (Segment<?, ?> segment : cchm.segments) { expireEntries(segment, now); assertEquals("Expiration queue must be empty by now", 0, writeQueueSize(segment)); assertEquals("Expiration queue must be empty by now", 0, accessQueueSize(segment)); assertEquals("Segments must be empty by now", 0, segmentSize(segment)); } cchm.processPendingNotifications(); }
@GwtIncompatible // concurrency public void testConcurrentAdvance() throws Exception { final FakeTicker ticker = new FakeTicker(); int numberOfThreads = 64; runConcurrentTest( numberOfThreads, new Callable<Void>() { @Override public Void call() throws Exception { // adds two nanoseconds to the ticker ticker.advance(1L); Thread.sleep(10); ticker.advance(1L); return null; } }); assertEquals(numberOfThreads * 2, ticker.read()); }
@Override public Void call() throws Exception { ticker.read(); return null; } });
@Override protected void setUp() throws Exception { super.setUp(); fakeTicker = new FakeTicker(); }
public void testAutoIncrementStep_seconds() { FakeTicker ticker = new FakeTicker().setAutoIncrementStep(3, TimeUnit.SECONDS); assertEquals(0, ticker.read()); assertEquals(3000000000L, ticker.read()); assertEquals(6000000000L, ticker.read()); }
public void testAutoIncrementStep_returnsSameInstance() { FakeTicker ticker = new FakeTicker(); assertSame(ticker, ticker.setAutoIncrementStep(10, TimeUnit.NANOSECONDS)); }
/** @return the current time in milliseconds */ protected final long currentTimeMillis() { return TimeUnit.NANOSECONDS.toMillis(ticker.read()); }
public void testRemovalListener_expireAfterWrite() { FakeTicker ticker = new FakeTicker(); final AtomicInteger evictionCount = new AtomicInteger(); final AtomicInteger applyCount = new AtomicInteger(); ticker.advance(1, MILLISECONDS);
public void testExpireAfterWrite() { FakeTicker ticker = new FakeTicker(); LocalCache<Object, Object> map = makeLocalCache( map.put(key, value); ReferenceEntry<Object, Object> entry = map.getEntry(key); assertTrue(map.isLive(entry, ticker.read())); assertEquals(1, segment.writeQueue.size()); segment.recordRead(entry, ticker.read()); segment.expireEntries(ticker.read()); assertSame(value, map.get(key)); assertSame(entry, segment.writeQueue.peek()); assertEquals(1, segment.writeQueue.size()); ticker.advance(1); segment.recordRead(entry, ticker.read()); segment.expireEntries(ticker.read()); assertSame(value, map.get(key)); assertSame(entry, segment.writeQueue.peek()); assertEquals(1, segment.writeQueue.size()); ticker.advance(1); assertNull(map.get(key)); segment.expireEntries(ticker.read()); assertNull(map.get(key)); assertTrue(segment.writeQueue.isEmpty());
public void testExpiration_expireAfterAccess() { FakeTicker ticker = new FakeTicker(); CountingRemovalListener<String, Integer> removalListener = countingRemovalListener(); WatchedCreatorLoader loader = new WatchedCreatorLoader(); LoadingCache<String, Integer> cache = CacheBuilder.newBuilder() .expireAfterAccess(EXPIRING_TIME, MILLISECONDS) .removalListener(removalListener) .ticker(ticker) .build(loader); checkExpiration(cache, loader, ticker, removalListener); }
public void testAutoIncrementStep_nanos() { FakeTicker ticker = new FakeTicker().setAutoIncrementStep(10, TimeUnit.NANOSECONDS); assertEquals(0, ticker.read()); assertEquals(10, ticker.read()); assertEquals(20, ticker.read()); }
public void testExpirationOrder_write() throws ExecutionException { FakeTicker ticker = new FakeTicker(); IdentityLoader<Integer> loader = identityLoader(); LoadingCache<Integer, Integer> cache = for (int i = 0; i < 10; i++) { cache.getUnchecked(i); ticker.advance(1, MILLISECONDS); ticker.advance(1, MILLISECONDS); assertThat(keySet).containsExactly(1, 2, 3, 4, 5, 6, 7, 8, 9); ticker.advance(1, MILLISECONDS); assertThat(keySet).containsExactly(2, 3, 4, 5, 6, 7, 8, 9, 0); ticker.advance(1, MILLISECONDS); assertThat(keySet).containsExactly(3, 4, 5, 6, 7, 8, 9, 0); ticker.advance(1, MILLISECONDS); assertThat(keySet).containsExactly(4, 5, 6, 7, 8, 9, 0, 3); ticker.advance(1, MILLISECONDS); assertThat(keySet).containsExactly(5, 6, 7, 8, 9, 0, 3, 4); ticker.advance(1, MILLISECONDS); assertThat(keySet).containsExactly(6, 7, 8, 9, 0, 3, 4);