IdentityLoader<Object> loader = identityLoader();
    for (int i = 1; i < 1000; i++) {
      LoadingCache<Object, Object> cache = CacheBuilder.newBuilder().maximumSize(i).build(loader);
      assertThat(CacheTesting.getTotalSegmentSize(cache)).isEqualTo(i);
    }
  }

  public void testEviction_setMaxSegmentWeight() {
    IdentityLoader<Object> loader = identityLoader();
    for (int i = 1; i < 1000; i++) {

  public void testBulkLoad_loadAll() throws ExecutionException {
    IdentityLoader<Integer> backingLoader = identityLoader();
    CacheLoader<Integer, Integer> loader = bulkLoader(backingLoader);
    LoadingCache<Integer, Integer> cache = CacheBuilder.newBuilder().recordStats().build(loader);
    CacheStats stats = cache.stats();
    assertThat(stats.missCount()).isEqualTo(0);
    assertThat(stats.loadSuccessCount()).isEqualTo(0);

  public void testBulkLoad_loadAll() throws ExecutionException {
    IdentityLoader<Integer> backingLoader = identityLoader();
    CacheLoader<Integer, Integer> loader = bulkLoader(backingLoader);
    LoadingCache<Integer, Integer> cache = CacheBuilder.newBuilder().recordStats().build(loader);
    CacheStats stats = cache.stats();
    assertThat(stats.missCount()).isEqualTo(0);
    assertThat(stats.loadSuccessCount()).isEqualTo(0);

   *
   * If the library is loaded in an application class loader, we try to break the cycle by loading
   * Finalizer in its own independent class loader:
   *
   * System class loader -> Application class loader -> ReferenceMap -> FinalizableReferenceQueue ->
   * etc. -> Decoupled class loader -> Finalizer
   *
   * Now, Finalizer no longer keeps an indirect strong reference to the static

        };

    cache.put(0, 10);

    assertThat(cache.get(0, loader)).isEqualTo(10);
    assertThat(cache.get(20, loader)).isEqualTo(1);
    assertThat(cache.get(34, loader)).isEqualTo(2);

    cache.invalidate(0);
    assertThat(cache.get(0, loader)).isEqualTo(3);

    cache.put(0, 10);
    cache.invalidateAll();
    assertThat(cache.get(0, loader)).isEqualTo(4);
  }

  @Test
  public void sizeConstraint() {

    CountingLoader loader = new CountingLoader();
    LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder());
    assertThat(loader.getCount()).isEqualTo(0);

    Object key = new Object();
    Object value = map.get(key, loader);
    assertThat(loader.getCount()).isEqualTo(1);
    assertThat(map.get(key, loader)).isEqualTo(value);
    assertThat(loader.getCount()).isEqualTo(1);
  }

    CountingLoader loader = new CountingLoader();
    LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder());
    assertThat(loader.getCount()).isEqualTo(0);

    Object key = new Object();
    Object value = map.get(key, loader);
    assertThat(loader.getCount()).isEqualTo(1);
    assertThat(map.get(key, loader)).isEqualTo(value);
    assertThat(loader.getCount()).isEqualTo(1);
  }

          ImmutableSet.of(
              new ResourceInfo(FILE, "left/some.txt", loader),
              new ResourceInfo(FILE, "left/sibling/another.txt", loader),
              new ResourceInfo(FILE, "right/another.txt", loader),
              new ResourceInfo(FILE, "right/sibling/some.txt", loader)),
          new ClassPath.LocationInfo(root.toFile(), loader).scanResources());
    } finally {
      deleteRecursivelyOrLog(root);
    }

    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);
  }

    assertThat(cache.localCache.defaultLoader).isSameInstanceAs(loader);
  }

  // null parameters test

  public void testNullParameters() throws Exception {
    NullPointerTester tester = new NullPointerTester();
    CacheLoader<Object, Object> loader = identityLoader();
    tester.testAllPublicInstanceMethods(makeCache(createCacheBuilder(), loader));
  }

  // stats tests