@Test(dataProvider = "badArgs", expectedExceptions = IllegalArgumentException.class) public void invalid(int hitCount, int missCount, int loadSuccessCount, int loadFailureCount, int totalLoadTime, int evictionCount, int evictionWeight) { new CacheStats(hitCount, missCount, loadSuccessCount, loadFailureCount, totalLoadTime, evictionCount, evictionWeight); }
/** * Returns a new {@code CacheStats} representing the difference between this {@code CacheStats} * and {@code other}. Negative values, which aren't supported by {@code CacheStats} will be * rounded up to zero. * * @param other the statistics to subtract with * @return the difference between this instance and {@code other} */ @NonNull public CacheStats minus(@NonNull CacheStats other) { return new CacheStats( Math.max(0L, hitCount - other.hitCount), Math.max(0L, missCount - other.missCount), Math.max(0L, loadSuccessCount - other.loadSuccessCount), Math.max(0L, loadFailureCount - other.loadFailureCount), Math.max(0L, totalLoadTime - other.totalLoadTime), Math.max(0L, evictionCount - other.evictionCount), Math.max(0L, evictionWeight - other.evictionWeight)); }
/** * Returns a new {@code CacheStats} representing the sum of this {@code CacheStats} and * {@code other}. * * @param other the statistics to add with * @return the sum of the statistics */ @NonNull public CacheStats plus(@NonNull CacheStats other) { return new CacheStats( hitCount + other.hitCount, missCount + other.missCount, loadSuccessCount + other.loadSuccessCount, loadFailureCount + other.loadFailureCount, totalLoadTime + other.totalLoadTime, evictionCount + other.evictionCount, evictionWeight + other.evictionWeight); }
public void plus() { CacheStats one = new CacheStats(11, 13, 15, 13, 11, 9, 18); CacheStats two = new CacheStats(53, 47, 41, 39, 37, 35, 70); CacheStats sum = two.plus(one); checkStats(sum, 124, 64, 64.0 / 124, 60, 60.0 / 124, 56, 52, 52.0 / 108, 56 + 52, 48, 48.0 / (56 + 52), 44, 88); assertThat(sum, is(one.plus(two))); }
@Test public void minus() { CacheStats one = new CacheStats(11, 13, 17, 19, 23, 27, 54); CacheStats two = new CacheStats(53, 47, 43, 41, 37, 31, 62); CacheStats diff = two.minus(one); checkStats(diff, 76, 42, 42.0 / 76, 34, 34.0 / 76, 26, 22, 22.0 / 48, 26 + 22, 14, 14.0 / (26 + 22), 4, 8); assertThat(one.minus(two), is(CacheStats.empty())); }
@Test public void empty() { CacheStats stats = new CacheStats(0, 0, 0, 0, 0, 0, 0); checkStats(stats, 0, 0, 1.0, 0, 0.0, 0, 0, 0.0, 0, 0, 0.0, 0, 0); assertThat(stats, is(equalTo(CacheStats.empty()))); assertThat(stats, is(not(equalTo(null)))); assertThat(stats, is(not(equalTo(new Object())))); assertThat(stats, is(equalTo(CacheStats.empty()))); assertThat(stats.hashCode(), is(CacheStats.empty().hashCode())); assertThat(stats, hasToString(CacheStats.empty().toString())); }
@CacheSpec @CheckNoWriter @CheckNoStats @Test(dataProvider = "caches") public void stats(Cache<Integer, Integer> cache, CacheContext context) { CacheStats stats = cache.stats() .plus(new CacheStats(1, 2, 3, 4, 5, 6, 7) .minus(new CacheStats(6, 5, 4, 3, 2, 1, 0))); assertThat(stats, is(new CacheStats(0, 0, 0, 1, 3, 5, 7))); assertThat(cache.policy().isRecordingStats(), is(context.isRecordingStats())); }
@Test public void populated() { CacheStats stats = new CacheStats(11, 13, 17, 19, 23, 27, 54); checkStats(stats, 24, 11, 11.0/24, 13, 13.0/24, 17, 19, 19.0/36, 17 + 19, 23, 23.0/(17 + 19), 27, 54); assertThat(stats, is(equalTo(stats))); assertThat(stats, is(not(equalTo(CacheStats.empty())))); assertThat(stats.hashCode(), is(not(CacheStats.empty().hashCode()))); assertThat(stats, hasToString(not(CacheStats.empty().toString()))); CacheStats expected = new CacheStats(11, 13, 17, 19, 23, 27, 54); assertThat(stats, is(equalTo(expected))); assertThat(stats.hashCode(), is(expected.hashCode())); assertThat(stats, hasToString(expected.toString())); }
@Test public void disabled() { StatsCounter counter = DisabledStatsCounter.INSTANCE; counter.recordHits(1); counter.recordMisses(1); counter.recordLoadSuccess(1); counter.recordLoadFailure(1); assertThat(counter.snapshot(), is(new CacheStats(0, 0, 0, 0, 0, 0, 0))); assertThat(counter.toString(), is(new CacheStats(0, 0, 0, 0, 0, 0, 0).toString())); for (DisabledStatsCounter type : DisabledStatsCounter.values()) { assertThat(DisabledStatsCounter.valueOf(type.name()), is(counter)); } }
@Override public CacheStats snapshot() { return new CacheStats( hitCount.sum(), missCount.sum(), loadSuccessCount.sum(), loadFailureCount.sum(), totalLoadTime.sum(), evictionCount.sum(), evictionWeight.sum()); }
@Test public void enabled() { ConcurrentStatsCounter counter = new ConcurrentStatsCounter(); counter.recordHits(1); counter.recordMisses(1); counter.recordEviction(); counter.recordEviction(10); counter.recordLoadSuccess(1); counter.recordLoadFailure(1); CacheStats expected = new CacheStats(1, 1, 1, 1, 2, 2, 10); assertThat(counter.snapshot(), is(expected)); assertThat(counter.toString(), is(expected.toString())); assertThat(counter.snapshot().toString(), is(expected.toString())); counter.incrementBy(counter); assertThat(counter.snapshot(), is(new CacheStats(2, 2, 2, 2, 4, 4, 20))); }
@Test public void guarded() { StatsCounter counter = StatsCounter.guardedStatsCounter(new ConcurrentStatsCounter()); counter.recordHits(1); counter.recordMisses(1); counter.recordEviction(); counter.recordEviction(10); counter.recordLoadSuccess(1); counter.recordLoadFailure(1); CacheStats expected = new CacheStats(1, 1, 1, 1, 2, 2, 10); assertThat(counter.snapshot(), is(expected)); assertThat(counter.toString(), is(expected.toString())); assertThat(counter.snapshot().toString(), is(expected.toString())); }
@Test public void concurrent() { StatsCounter counter = new ConcurrentStatsCounter(); ConcurrentTestHarness.timeTasks(5, () -> { counter.recordHits(1); counter.recordMisses(1); counter.recordEviction(); counter.recordEviction(10); counter.recordLoadSuccess(1); counter.recordLoadFailure(1); }); assertThat(counter.snapshot(), is(new CacheStats(5, 5, 5, 5, 10, 10, 50))); }
@Override public CacheStats stats() { com.google.common.cache.CacheStats stats = statsCounter.snapshot().plus(cache.stats()); return new CacheStats(stats.hitCount(), stats.missCount(), stats.loadSuccessCount(), stats.loadExceptionCount(), stats.totalLoadTime(), stats.evictionCount(), 0L); }
public void testMinus() { CacheStats one = new CacheStats(11, 13, 17, 19, 23, 27, 54); CacheStats two = new CacheStats(53, 47, 43, 41, 37, 31, 62); CacheStats diff = two.minus(one); assertEquals(76, diff.requestCount()); assertEquals(42, diff.hitCount()); assertEquals(42.0/76, diff.hitRate()); assertEquals(34, diff.missCount()); assertEquals(34.0/76, diff.missRate()); assertEquals(26, diff.loadSuccessCount()); assertEquals(22, diff.loadFailureCount()); assertEquals(22.0/48, diff.loadFailureRate()); assertEquals(26 + 22, diff.loadCount()); assertEquals(14, diff.totalLoadTime()); assertEquals(14.0/(26 + 22), diff.averageLoadPenalty()); assertEquals(4, diff.evictionCount()); assertEquals(8, diff.evictionWeight()); assertEquals(new CacheStats(0, 0, 0, 0, 0, 0, 0), one.minus(two)); }
/** * Returns a new {@code CacheStats} representing the difference between this {@code CacheStats} * and {@code other}. Negative values, which aren't supported by {@code CacheStats} will be * rounded up to zero. * * @param other the statistics to subtract with * @return the difference between this instance and {@code other} */ @Nonnull public CacheStats minus(@Nonnull CacheStats other) { return new CacheStats( Math.max(0L, hitCount - other.hitCount), Math.max(0L, missCount - other.missCount), Math.max(0L, loadSuccessCount - other.loadSuccessCount), Math.max(0L, loadFailureCount - other.loadFailureCount), Math.max(0L, totalLoadTime - other.totalLoadTime), Math.max(0L, evictionCount - other.evictionCount), Math.max(0L, evictionWeight - other.evictionWeight)); }
public void testPlus() { CacheStats one = new CacheStats(11, 13, 15, 13, 11, 9, 18); CacheStats two = new CacheStats(53, 47, 41, 39, 37, 35, 70); CacheStats sum = two.plus(one); assertEquals(124, sum.requestCount()); assertEquals(64, sum.hitCount()); assertEquals(64.0/124, sum.hitRate()); assertEquals(60, sum.missCount()); assertEquals(60.0/124, sum.missRate()); assertEquals(56, sum.loadSuccessCount()); assertEquals(52, sum.loadFailureCount()); assertEquals(52.0/108, sum.loadFailureRate()); assertEquals(56 + 52, sum.loadCount()); assertEquals(48, sum.totalLoadTime()); assertEquals(48.0/(56 + 52), sum.averageLoadPenalty()); assertEquals(44, sum.evictionCount()); assertEquals(88, sum.evictionWeight()); assertEquals(sum, one.plus(two)); } }
public void testEmpty() { CacheStats stats = new CacheStats(0, 0, 0, 0, 0, 0, 0); assertEquals(0, stats.requestCount()); assertEquals(0, stats.hitCount()); assertEquals(1.0, stats.hitRate()); assertEquals(0, stats.missCount()); assertEquals(0.0, stats.missRate()); assertEquals(0, stats.loadSuccessCount()); assertEquals(0, stats.loadFailureCount()); assertEquals(0.0, stats.loadFailureRate()); assertEquals(0, stats.loadCount()); assertEquals(0, stats.totalLoadTime()); assertEquals(0.0, stats.averageLoadPenalty()); assertEquals(0, stats.evictionCount()); }
public void testSingle() { CacheStats stats = new CacheStats(11, 13, 17, 19, 23, 27, 54); assertEquals(24, stats.requestCount()); assertEquals(11, stats.hitCount()); assertEquals(11.0/24, stats.hitRate()); assertEquals(13, stats.missCount()); assertEquals(13.0/24, stats.missRate()); assertEquals(17, stats.loadSuccessCount()); assertEquals(19, stats.loadFailureCount()); assertEquals(19.0/36, stats.loadFailureRate()); assertEquals(17 + 19, stats.loadCount()); assertEquals(23, stats.totalLoadTime()); assertEquals(23.0/(17 + 19), stats.averageLoadPenalty()); assertEquals(27, stats.evictionCount()); assertEquals(54, stats.evictionWeight()); }
@Override public CacheStats snapshot() { return new CacheStats( hitCount.sum(), missCount.sum(), loadSuccessCount.sum(), loadFailureCount.sum(), totalLoadTime.sum(), evictionCount.sum(), evictionWeight.sum()); }