* Copyright (C) 2011 The Guava Authors

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

* @author Charles Fry

*/

  public static Test suite() {

    TestSuite suite = new TestSuite();

    suite.addTestSuite(LocalCacheTest.class);

    suite.addTest(MapTestSuiteBuilder.using(new TestStringMapGenerator() {

          @Override public Map<String, String> create(

              Entry<String, String>[] entries) {

            LocalCache<String, String> map = makeLocalCache(createCacheBuilder());

            for (Entry<String, String> entry : entries) {

              map.put(entry.getKey(), entry.getValue());

            }

            return map;

          }

        }).named("LocalCache with defaults")

        .withFeatures(CollectionSize.ANY, MapFeature.GENERAL_PURPOSE,

            CollectionFeature.SUPPORTS_ITERATOR_REMOVE)

        .createTestSuite());

    return suite;

  }

  static final int SMALL_MAX_SIZE = DRAIN_THRESHOLD * 5;

  TestLogHandler logHandler;

  @Override

  public void setUp() throws Exception {

    super.setUp();

    logHandler = new TestLogHandler();

    LocalCache.logger.addHandler(logHandler);

  }

  @Override

  public void tearDown() throws Exception {

    super.tearDown();

    LocalCache.logger.removeHandler(logHandler);

  }

  private Throwable popLoggedThrowable() {

    List<LogRecord> logRecords = logHandler.getStoredLogRecords();

    assertSame(1, logRecords.size());

    LogRecord logRecord = logRecords.get(0);

    logHandler.clear();

    return logRecord.getThrown();

  }

  private void checkNothingLogged() {

    assertTrue(logHandler.getStoredLogRecords().isEmpty());

  }

  private void checkLogged(Throwable t) {

    assertSame(t, popLoggedThrowable());

  }

  private static <K, V> LocalCache<K, V> makeLocalCache(

      CacheBuilder<? super K, ? super V> builder) {

    return new LocalCache<K, V>(builder, null);

  }

  private static CacheBuilder<Object, Object> createCacheBuilder() {

    return new CacheBuilder<Object, Object>();

  }

  // constructor tests

  public void testDefaults() {

    LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder());

    assertSame(Strength.STRONG, map.keyStrength);

    assertSame(Strength.STRONG, map.valueStrength);

    assertSame(map.keyStrength.defaultEquivalence(), map.keyEquivalence);

    assertSame(map.valueStrength.defaultEquivalence(), map.valueEquivalence);

    assertEquals(0, map.expireAfterAccessNanos);

    assertEquals(0, map.expireAfterWriteNanos);

    assertEquals(0, map.refreshNanos);

    assertEquals(CacheBuilder.UNSET_INT, map.maxWeight);

    assertSame(EntryFactory.STRONG, map.entryFactory);

    assertSame(CacheBuilder.NullListener.INSTANCE, map.removalListener);

    assertSame(DISCARDING_QUEUE, map.removalNotificationQueue);

    assertSame(NULL_TICKER, map.ticker);

    assertEquals(4, map.concurrencyLevel);

    // concurrency level

    assertEquals(4, map.segments.length);

    // initial capacity / concurrency level

    assertEquals(16 / map.segments.length, map.segments[0].table.length());

    assertFalse(map.evictsBySize());

    assertFalse(map.expires());

    assertFalse(map.expiresAfterWrite());

    assertFalse(map.expiresAfterAccess());

    assertFalse(map.refreshes());

  }

  public void testSetKeyEquivalence() {

    Equivalence<Object> testEquivalence = new Equivalence<Object>() {

      @Override

      protected boolean doEquivalent(Object a, Object b) {

        return false;

      }

      @Override

      protected int doHash(Object t) {

        return 0;

      }

    };

    LocalCache<Object, Object> map =

        makeLocalCache(createCacheBuilder().keyEquivalence(testEquivalence));

    assertSame(testEquivalence, map.keyEquivalence);

    assertSame(map.valueStrength.defaultEquivalence(), map.valueEquivalence);

  }

  public void testSetValueEquivalence() {

    Equivalence<Object> testEquivalence = new Equivalence<Object>() {

      @Override

      protected boolean doEquivalent(Object a, Object b) {

        return false;

      }

      @Override

      protected int doHash(Object t) {

        return 0;

      }

    };

    LocalCache<Object, Object> map =

        makeLocalCache(createCacheBuilder().valueEquivalence(testEquivalence));

    assertSame(testEquivalence, map.valueEquivalence);

    assertSame(map.keyStrength.defaultEquivalence(), map.keyEquivalence);

  }

  public void testSetConcurrencyLevel() {

    // round up to nearest power of two

    checkConcurrencyLevel(1, 1);

    checkConcurrencyLevel(2, 2);

    checkConcurrencyLevel(3, 4);

    checkConcurrencyLevel(4, 4);

    checkConcurrencyLevel(5, 8);

    checkConcurrencyLevel(6, 8);

    checkConcurrencyLevel(7, 8);

    checkConcurrencyLevel(8, 8);

  }

  private static void checkConcurrencyLevel(int concurrencyLevel, int segmentCount) {

    LocalCache<Object, Object> map =

        makeLocalCache(createCacheBuilder().concurrencyLevel(concurrencyLevel));

    assertEquals(segmentCount, map.segments.length);

  }

  public void testSetInitialCapacity() {

    // share capacity over each segment, then round up to nearest power of two

    checkInitialCapacity(1, 0, 1);

    checkInitialCapacity(1, 1, 1);

    checkInitialCapacity(1, 2, 2);

    checkInitialCapacity(1, 3, 4);

    checkInitialCapacity(1, 4, 4);

    checkInitialCapacity(1, 5, 8);

    checkInitialCapacity(1, 6, 8);

    checkInitialCapacity(1, 7, 8);

    checkInitialCapacity(1, 8, 8);

    checkInitialCapacity(2, 0, 1);

    checkInitialCapacity(2, 1, 1);

    checkInitialCapacity(2, 2, 1);

    checkInitialCapacity(2, 3, 2);

    checkInitialCapacity(2, 4, 2);

    checkInitialCapacity(2, 5, 4);

    checkInitialCapacity(2, 6, 4);

    checkInitialCapacity(2, 7, 4);

    checkInitialCapacity(2, 8, 4);

    checkInitialCapacity(4, 0, 1);

    checkInitialCapacity(4, 1, 1);

    checkInitialCapacity(4, 2, 1);

    checkInitialCapacity(4, 3, 1);

    checkInitialCapacity(4, 4, 1);

    checkInitialCapacity(4, 5, 2);

    checkInitialCapacity(4, 6, 2);

    checkInitialCapacity(4, 7, 2);

    checkInitialCapacity(4, 8, 2);

  }

  private static void checkInitialCapacity(

      int concurrencyLevel, int initialCapacity, int segmentSize) {

    LocalCache<Object, Object> map = makeLocalCache(

        createCacheBuilder().concurrencyLevel(concurrencyLevel).initialCapacity(initialCapacity));

    for (int i = 0; i < map.segments.length; i++) {

      assertEquals(segmentSize, map.segments[i].table.length());

    }

  }

  public void testSetMaximumSize() {

    // vary maximumSize wrt concurrencyLevel

    for (int maxSize = 1; maxSize < 100; maxSize++) {

      checkMaximumSize(1, 8, maxSize);

      checkMaximumSize(2, 8, maxSize);

      checkMaximumSize(4, 8, maxSize);

      checkMaximumSize(8, 8, maxSize);

    }

    checkMaximumSize(1, 8, Long.MAX_VALUE);

    checkMaximumSize(2, 8, Long.MAX_VALUE);

    checkMaximumSize(4, 8, Long.MAX_VALUE);

    checkMaximumSize(8, 8, Long.MAX_VALUE);

    // vary initial capacity wrt maximumSize

    for (int capacity = 0; capacity < 8; capacity++) {

      checkMaximumSize(1, capacity, 4);

      checkMaximumSize(2, capacity, 4);

      checkMaximumSize(4, capacity, 4);

      checkMaximumSize(8, capacity, 4);

    }

  }

  private static void checkMaximumSize(int concurrencyLevel, int initialCapacity, long maxSize) {

    LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder()

        .concurrencyLevel(concurrencyLevel)

        .initialCapacity(initialCapacity)

        .maximumSize(maxSize));

    long totalCapacity = 0;

    assertTrue("segments=" + map.segments.length + ", maxSize=" + maxSize,

        map.segments.length <= Math.max(1, maxSize / 10));

    for (int i = 0; i < map.segments.length; i++) {

      totalCapacity += map.segments[i].maxSegmentWeight;

    }

    assertTrue("totalCapacity=" + totalCapacity + ", maxSize=" + maxSize, totalCapacity == maxSize);

    map = makeLocalCache(createCacheBuilder()

        .concurrencyLevel(concurrencyLevel)

        .initialCapacity(initialCapacity)

        .maximumWeight(maxSize)

        .weigher(constantWeigher(1)));

    assertTrue("segments=" + map.segments.length + ", maxSize=" + maxSize,

        map.segments.length <= Math.max(1, maxSize / 10));

    totalCapacity = 0;

    for (int i = 0; i < map.segments.length; i++) {

      totalCapacity += map.segments[i].maxSegmentWeight;

    }

    assertTrue("totalCapacity=" + totalCapacity + ", maxSize=" + maxSize, totalCapacity == maxSize);

  }

  public void testSetWeigher() {

    Weigher<Object, Object> testWeigher = new Weigher<Object, Object>() {

      @Override

      public int weigh(Object key, Object value) {

        return 42;

      }

    };

    LocalCache<Object, Object> map =

        makeLocalCache(createCacheBuilder().maximumWeight(1).weigher(testWeigher));

    assertSame(testWeigher, map.weigher);

  }

  public void testSetWeakKeys() {

    LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder().weakKeys());

    checkStrength(map, Strength.WEAK, Strength.STRONG);

    assertSame(EntryFactory.WEAK, map.entryFactory);

  }

  public void testSetWeakValues() {

    LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder().weakValues());

    checkStrength(map, Strength.STRONG, Strength.WEAK);

    assertSame(EntryFactory.STRONG, map.entryFactory);

  }

  public void testSetSoftValues() {

    LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder().softValues());

    checkStrength(map, Strength.STRONG, Strength.SOFT);

    assertSame(EntryFactory.STRONG, map.entryFactory);

  }

  private static void checkStrength(

      LocalCache<Object, Object> map, Strength keyStrength, Strength valueStrength) {

    assertSame(keyStrength, map.keyStrength);

    assertSame(valueStrength, map.valueStrength);

    assertSame(keyStrength.defaultEquivalence(), map.keyEquivalence);

    assertSame(valueStrength.defaultEquivalence(), map.valueEquivalence);

  }

  public void testSetExpireAfterWrite() {

    long duration = 42;

    TimeUnit unit = TimeUnit.SECONDS;

    LocalCache<Object, Object> map =

        makeLocalCache(createCacheBuilder().expireAfterWrite(duration, unit));

    assertEquals(unit.toNanos(duration), map.expireAfterWriteNanos);

  }

  public void testSetExpireAfterAccess() {

    long duration = 42;

    TimeUnit unit = TimeUnit.SECONDS;

    LocalCache<Object, Object> map =

        makeLocalCache(createCacheBuilder().expireAfterAccess(duration, unit));

    assertEquals(unit.toNanos(duration), map.expireAfterAccessNanos);

  }

  public void testSetRefresh() {

    long duration = 42;

    TimeUnit unit = TimeUnit.SECONDS;

    LocalCache<Object, Object> map =

        makeLocalCache(createCacheBuilder().refreshAfterWrite(duration, unit));

    assertEquals(unit.toNanos(duration), map.refreshNanos);

  }

  public void testSetRemovalListener() {

    RemovalListener<Object, Object> testListener = TestingRemovalListeners.nullRemovalListener();

    LocalCache<Object, Object> map =

        makeLocalCache(createCacheBuilder().removalListener(testListener));

    assertSame(testListener, map.removalListener);

  }

  public void testSetTicker() {

    Ticker testTicker = new Ticker() {

      @Override

      public long read() {

        return 0;

      }

    };

    LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder().ticker(testTicker));

    assertSame(testTicker, map.ticker);

  }

  public void testEntryFactory() {

    assertSame(EntryFactory.STRONG,

        EntryFactory.getFactory(Strength.STRONG, false, false));

    assertSame(EntryFactory.STRONG_ACCESS,

        EntryFactory.getFactory(Strength.STRONG, true, false));

    assertSame(EntryFactory.STRONG_WRITE,

        EntryFactory.getFactory(Strength.STRONG, false, true));

    assertSame(EntryFactory.STRONG_ACCESS_WRITE,

        EntryFactory.getFactory(Strength.STRONG, true, true));

    assertSame(EntryFactory.WEAK,

        EntryFactory.getFactory(Strength.WEAK, false, false));

    assertSame(EntryFactory.WEAK_ACCESS,

        EntryFactory.getFactory(Strength.WEAK, true, false));

    assertSame(EntryFactory.WEAK_WRITE,

        EntryFactory.getFactory(Strength.WEAK, false, true));

    assertSame(EntryFactory.WEAK_ACCESS_WRITE,

        EntryFactory.getFactory(Strength.WEAK, true, true));

  }

  // computation tests

  public void testCompute() throws ExecutionException {

    CountingLoader loader = new CountingLoader();

    LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder());

    assertEquals(0, loader.getCount());

    Object key = new Object();

    Object value = map.get(key, loader);

    assertEquals(1, loader.getCount());

    assertEquals(value, map.get(key, loader));

    assertEquals(1, loader.getCount());

  }

  public void testRecordReadOnCompute() throws ExecutionException {

    CountingLoader loader = new CountingLoader();

    for (CacheBuilder<Object, Object> builder : allEvictingMakers()) {

      LocalCache<Object, Object> map =

          makeLocalCache(builder.concurrencyLevel(1));

      Segment<Object, Object> segment = map.segments[0];

      List<ReferenceEntry<Object, Object>> writeOrder = Lists.newLinkedList();

      List<ReferenceEntry<Object, Object>> readOrder = Lists.newLinkedList();

      for (int i = 0; i < SMALL_MAX_SIZE; i++) {

        Object key = new Object();

        int hash = map.hash(key);

        map.get(key, loader);

        ReferenceEntry<Object, Object> entry = segment.getEntry(key, hash);

        writeOrder.add(entry);

        readOrder.add(entry);

      }

      checkEvictionQueues(map, segment, readOrder, writeOrder);

      checkExpirationTimes(map);

      assertTrue(segment.recencyQueue.isEmpty());

      // access some of the elements

      Random random = new Random();

      List<ReferenceEntry<Object, Object>> reads = Lists.newArrayList();

      Iterator<ReferenceEntry<Object, Object>> i = readOrder.iterator();

      while (i.hasNext()) {

        ReferenceEntry<Object, Object> entry = i.next();

        if (random.nextBoolean()) {

          map.get(entry.getKey(), loader);

          reads.add(entry);

          i.remove();

          assertTrue(segment.recencyQueue.size() <= DRAIN_THRESHOLD);

        }

      }

      int undrainedIndex = reads.size() - segment.recencyQueue.size();

      checkAndDrainRecencyQueue(map, segment, reads.subList(undrainedIndex, reads.size()));

      readOrder.addAll(reads);

      checkEvictionQueues(map, segment, readOrder, writeOrder);

      checkExpirationTimes(map);

    }

  }

  public void testComputeExistingEntry() throws ExecutionException {

    CountingLoader loader = new CountingLoader();

    LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder());

    assertEquals(0, loader.getCount());

    Object key = new Object();

    Object value = new Object();

    map.put(key, value);

    assertEquals(value, map.get(key, loader));

    assertEquals(0, loader.getCount());

  }

  public void testComputePartiallyCollectedKey() throws ExecutionException {

    CacheBuilder<Object, Object> builder = createCacheBuilder().concurrencyLevel(1);

    CountingLoader loader = new CountingLoader();

    LocalCache<Object, Object> map = makeLocalCache(builder);

    Segment<Object, Object> segment = map.segments[0];

    AtomicReferenceArray<ReferenceEntry<Object, Object>> table = segment.table;

    assertEquals(0, loader.getCount());

    Object key = new Object();

    int hash = map.hash(key);

    Object value = new Object();

    int index = hash & (table.length() - 1);

    DummyEntry<Object, Object> entry = DummyEntry.create(key, hash, null);

    DummyValueReference<Object, Object> valueRef = DummyValueReference.create(value);

    entry.setValueReference(valueRef);

    table.set(index, entry);

    segment.count++;

    assertSame(value, map.get(key, loader));

    assertEquals(0, loader.getCount());

    assertEquals(1, segment.count);

    entry.clearKey();

    assertNotSame(value, map.get(key, loader));