Java FakeTicker类代码示例

import com.google.common.testing.FakeTicker; //导入依赖的package包/类
private void checkExpiration(LoadingCache<String, Integer> cache, WatchedCreatorLoader loader,
    FakeTicker ticker, CountingRemovalListener<String, Integer> removalListener) {

  for (int i = 0; i < 10; i++) {
    assertEquals(Integer.valueOf(VALUE_PREFIX + i), cache.getUnchecked(KEY_PREFIX + i));
  }

  for (int i = 0; i < 10; i++) {
    loader.reset();
    assertEquals(Integer.valueOf(VALUE_PREFIX + i), cache.getUnchecked(KEY_PREFIX + i));
    assertFalse("Creator should not have been called @#" + i, loader.wasCalled());
  }

  CacheTesting.expireEntries((LoadingCache<?, ?>) cache, EXPIRING_TIME, ticker);

  assertEquals("Map must be empty by now", 0, cache.size());
  assertEquals("Eviction notifications must be received", 10,
      removalListener.getCount());

  CacheTesting.expireEntries((LoadingCache<?, ?>) cache, EXPIRING_TIME, ticker);
  // ensure that no new notifications are sent
  assertEquals("Eviction notifications must be received", 10,
      removalListener.getCount());
}
 

import com.google.common.testing.FakeTicker; //导入依赖的package包/类
@Before
public void setup() {
    MockitoAnnotations.initMocks(this);

    doNothing().when(mockCallback).accept(any(MockFailure.class));

    ticker = new FakeTicker();
    ticker.advance(ThreadLocalRandom.current().nextLong());
    doReturn(ticker).when(mockContext).ticker();

    final ClientActorConfig mockConfig = AccessClientUtil.newMockClientActorConfig();
    doReturn(mockConfig).when(mockContext).config();

    doReturn(mock(MessageSlicer.class)).when(mockContext).messageSlicer();

    mockActor = TestProbe.apply(actorSystem);
    mockBackendInfo = new BackendInfo(mockActor.ref(), 0, ABIVersion.current(), 5);
    mockRequest = new MockRequest(mockIdentifier, mockReplyTo);
    mockRequest2 = new MockRequest(mockIdentifier, mockReplyTo);
    mockResponse = mockRequest.toRequestFailure(mockCause);
    mockResponseEnvelope = new FailureEnvelope(mockResponse, 0, 0, 0);
    mockCookie = ThreadLocalRandom.current().nextLong();

    queue = new ConnectingClientConnection<>(mockContext, mockCookie);
}
 

import com.google.common.testing.FakeTicker; //导入依赖的package包/类
@Test
public void testDelegate() throws Exception {
    FakeTicker ticker = new FakeTicker();
    CircuitBreaker circuitBreaker = new CircuitBreakerBuilder(remoteServiceName)
            .ticker(ticker)
            .build();

    @SuppressWarnings("unchecked")
    Client<RpcRequest, RpcResponse> delegate = mock(Client.class);
    when(delegate.execute(any(), any())).thenReturn(successRes);

    CircuitBreakerMapping mapping = (ctx, req) -> circuitBreaker;
    CircuitBreakerClient<RpcRequest, RpcResponse> stub = new CircuitBreakerClient<>(delegate, mapping);

    stub.execute(ctx, req);

    verify(delegate, times(1)).execute(eq(ctx), eq(req));
}
 

import com.google.common.testing.FakeTicker; //导入依赖的package包/类
private void checkExpiration(
    LoadingCache<String, Integer> cache,
    WatchedCreatorLoader loader,
    FakeTicker ticker,
    CountingRemovalListener<String, Integer> removalListener) {

  for (int i = 0; i < 10; i++) {
    assertEquals(Integer.valueOf(VALUE_PREFIX + i), cache.getUnchecked(KEY_PREFIX + i));
  }

  for (int i = 0; i < 10; i++) {
    loader.reset();
    assertEquals(Integer.valueOf(VALUE_PREFIX + i), cache.getUnchecked(KEY_PREFIX + i));
    assertFalse("Creator should not have been called @#" + i, loader.wasCalled());
  }

  CacheTesting.expireEntries((LoadingCache<?, ?>) cache, EXPIRING_TIME, ticker);

  assertEquals("Map must be empty by now", 0, cache.size());
  assertEquals("Eviction notifications must be received", 10, removalListener.getCount());

  CacheTesting.expireEntries((LoadingCache<?, ?>) cache, EXPIRING_TIME, ticker);
  // ensure that no new notifications are sent
  assertEquals("Eviction notifications must be received", 10, removalListener.getCount());
}
 

import com.google.common.testing.FakeTicker; //导入依赖的package包/类
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);
}
 

import com.google.common.testing.FakeTicker; //导入依赖的package包/类
public void testRemovalListener_expired() {
  FakeTicker ticker = new FakeTicker();
  QueuingRemovalListener<Object, Object> listener = queuingRemovalListener();
  LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder()
      .concurrencyLevel(1)
      .expireAfterWrite(3, TimeUnit.NANOSECONDS)
      .ticker(ticker)
      .removalListener(listener));
  assertTrue(listener.isEmpty());

  Object one = new Object();
  Object two = new Object();
  Object three = new Object();
  Object four = new Object();
  Object five = new Object();

  map.put(one, two);
  ticker.advance(1);
  map.put(two, three);
  ticker.advance(1);
  map.put(three, four);
  assertTrue(listener.isEmpty());
  ticker.advance(1);
  map.put(four, five);
  assertNotified(listener, one, two, RemovalCause.EXPIRED);

  assertTrue(listener.isEmpty());
}
 

import com.google.common.testing.FakeTicker; //导入依赖的package包/类
public void testExpireAfterWrite() {
  FakeTicker ticker = new FakeTicker();
  LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder()
      .concurrencyLevel(1)
      .ticker(ticker)
      .expireAfterWrite(2, TimeUnit.NANOSECONDS));
  Segment<Object, Object> segment = map.segments[0];

  Object key = new Object();
  Object value = new Object();
  map.put(key, value);
  ReferenceEntry<Object, Object> entry = map.getEntry(key);
  assertTrue(map.isLive(entry, ticker.read()));

  segment.writeQueue.add(entry);
  assertSame(value, map.get(key));
  assertSame(entry, segment.writeQueue.peek());
  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());
}
 

import com.google.common.testing.FakeTicker; //导入依赖的package包/类
public void testExpiration_expireAfterWrite() {
  FakeTicker ticker = new FakeTicker();
  CountingRemovalListener<String, Integer> removalListener = countingRemovalListener();
  WatchedCreatorLoader loader = new WatchedCreatorLoader();
  LoadingCache<String, Integer> cache = CacheBuilder.newBuilder()
      .expireAfterWrite(EXPIRING_TIME, MILLISECONDS)
      .removalListener(removalListener)
      .ticker(ticker)
      .build(loader);
  checkExpiration(cache, loader, ticker, removalListener);
}
 

import com.google.common.testing.FakeTicker; //导入依赖的package包/类
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);
}
 

import com.google.common.testing.FakeTicker; //导入依赖的package包/类
public void testExpiringGet_expireAfterWrite() {
  FakeTicker ticker = new FakeTicker();
  CountingRemovalListener<String, Integer> removalListener = countingRemovalListener();
  WatchedCreatorLoader loader = new WatchedCreatorLoader();
  LoadingCache<String, Integer> cache = CacheBuilder.newBuilder()
      .expireAfterWrite(EXPIRING_TIME, MILLISECONDS)
      .removalListener(removalListener)
      .ticker(ticker)
      .build(loader);
  runExpirationTest(cache, loader, ticker, removalListener);
}
 

import com.google.common.testing.FakeTicker; //导入依赖的package包/类
public void testExpiringGet_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);
  runExpirationTest(cache, loader, ticker, removalListener);
}
 

import com.google.common.testing.FakeTicker; //导入依赖的package包/类
public void testRemovalListener_expireAfterWrite() {
  FakeTicker ticker = new FakeTicker();
  final AtomicInteger evictionCount = new AtomicInteger();
  final AtomicInteger applyCount = new AtomicInteger();
  final AtomicInteger totalSum = new AtomicInteger();

  RemovalListener<Integer, AtomicInteger> removalListener =
      new RemovalListener<Integer, AtomicInteger>() {
        @Override
        public void onRemoval(RemovalNotification<Integer, AtomicInteger> notification) {
          if (notification.wasEvicted()) {
            evictionCount.incrementAndGet();
            totalSum.addAndGet(notification.getValue().get());
          }
        }
      };

  CacheLoader<Integer, AtomicInteger> loader = new CacheLoader<Integer, AtomicInteger>() {
    @Override public AtomicInteger load(Integer key) {
      applyCount.incrementAndGet();
      return new AtomicInteger();
    }
  };

  LoadingCache<Integer, AtomicInteger> cache = CacheBuilder.newBuilder()
      .removalListener(removalListener)
      .expireAfterWrite(10, MILLISECONDS)
      .ticker(ticker)
      .build(loader);

  // Increment 100 times
  for (int i = 0; i < 100; ++i) {
    cache.getUnchecked(10).incrementAndGet();
    ticker.advance(1, MILLISECONDS);
  }

  assertEquals(evictionCount.get() + 1, applyCount.get());
  int remaining = cache.getUnchecked(10).get();
  assertEquals(100, totalSum.get() + remaining);
}
 

import com.google.common.testing.FakeTicker; //导入依赖的package包/类
public void testRemovalScheduler_expireAfterWrite() {
  FakeTicker ticker = new FakeTicker();
  CountingRemovalListener<String, Integer> removalListener = countingRemovalListener();
  WatchedCreatorLoader loader = new WatchedCreatorLoader();
  LoadingCache<String, Integer> cache = CacheBuilder.newBuilder()
      .expireAfterWrite(EXPIRING_TIME, MILLISECONDS)
      .removalListener(removalListener)
      .ticker(ticker)
      .build(loader);
  runRemovalScheduler(cache, removalListener, loader, ticker, KEY_PREFIX, EXPIRING_TIME);
}
 

import com.google.common.testing.FakeTicker; //导入依赖的package包/类
public void testRemovalScheduler_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);
  runRemovalScheduler(cache, removalListener, loader, ticker, KEY_PREFIX, EXPIRING_TIME);
}
 

import com.google.common.testing.FakeTicker; //导入依赖的package包/类
public void testRemovalScheduler_expireAfterBoth() {
  FakeTicker ticker = new FakeTicker();
  CountingRemovalListener<String, Integer> removalListener = countingRemovalListener();
  WatchedCreatorLoader loader = new WatchedCreatorLoader();
  LoadingCache<String, Integer> cache = CacheBuilder.newBuilder()
      .expireAfterAccess(EXPIRING_TIME, MILLISECONDS)
      .expireAfterWrite(EXPIRING_TIME, MILLISECONDS)
      .removalListener(removalListener)
      .ticker(ticker)
      .build(loader);
  runRemovalScheduler(cache, removalListener, loader, ticker, KEY_PREFIX, EXPIRING_TIME);
}