}
    if (expireAfterAccess != null) {
      builder.expireAfterAccess(expireAfterAccess.duration, expireAfterAccess.unit);
    }
    if (refresh != null) {
      builder.refreshAfterWrite(refresh.duration, refresh.unit);
    }
    if (keyStrength != null) {
      builder.setKeyStrength(keyStrength);
    }
    if (valueStrength != null) {
      builder.setValueStrength(valueStrength);

    }
    if (expireAfterAccess != null) {
      builder.expireAfterAccess(expireAfterAccess.duration, expireAfterAccess.unit);
    }
    if (refresh != null) {
      builder.refreshAfterWrite(refresh.duration, refresh.unit);
    }
    if (keyStrength != null) {
      builder.setKeyStrength(keyStrength);
    }
    if (valueStrength != null) {
      builder.setValueStrength(valueStrength);

     * Returns the newly refreshed value associated with {@code key} if it was refreshed inline, or
     * {@code null} if another thread is performing the refresh or if an error occurs during
     * refresh.
     */
    @CanIgnoreReturnValue
    @CheckForNull
    V refresh(K key, int hash, CacheLoader<? super K, V> loader, boolean checkTime) {
      final LoadingValueReference<K, V> loadingValueReference =

        : expireAfterAccessNanos;
  }

  /**
   * Specifies that active entries are eligible for automatic refresh once a fixed duration has
   * elapsed after the entry's creation, or the most recent replacement of its value. The semantics
   * of refreshes are specified in {@link LoadingCache#refresh}, and are performed by calling {@link
   * CacheLoader#reload}.
   *

        : expireAfterAccessNanos;
  }

  /**
   * Specifies that active entries are eligible for automatic refresh once a fixed duration has
   * elapsed after the entry's creation, or the most recent replacement of its value. The semantics
   * of refreshes are specified in {@link LoadingCache#refresh}, and are performed by calling {@link
   * CacheLoader#reload}.
   *

      Map<K, V> map = new HashMap<K, V>();
      for (K key : keys) {
        map.put(key, localCache.getOrLoad(key));
      }
      return ImmutableMap.copyOf(map);
    }

    @Override
    public void refresh(K key) {
      throw new UnsupportedOperationException();
    }
  }

  /**
   * LinkedHashMap that enforces it's maximum size and logs events in a StatsCounter object and an
   * optional RemovalListener.

     * Returns the newly refreshed value associated with {@code key} if it was refreshed inline, or
     * {@code null} if another thread is performing the refresh or if an error occurs during
     * refresh.
     */
    @CanIgnoreReturnValue
    @CheckForNull
    V refresh(K key, int hash, CacheLoader<? super K, V> loader, boolean checkTime) {
      final LoadingValueReference<K, V> loadingValueReference =

      return perms;
    }

    @Override
    public boolean implies(ProtectionDomain pd, Permission p) {
      return perms.implies(p);
    }

    @Override
    public void refresh() {}
  }

  /** Returns a policy containing all the permissions we ever need. */
  public static Policy permissivePolicy() {
    return new AdjustablePolicy
    // Permissions j.u.c. needs directly
    (

      return perms;
    }

    public boolean implies(ProtectionDomain pd, Permission p) {
      return perms.implies(p);
    }

    public void refresh() {}
  }

  /** Returns a policy containing all the permissions we ever need. */
  public static Policy permissivePolicy() {
    return new AdjustablePolicy
    // Permissions j.u.c. needs directly
    (

      LocalCache<String, String> cache = makeLocalCache(builder, loader);

      assertThat(cache.getOrLoad("test")).isEqualTo("testLoad");

      ticker.advance(10, MILLISECONDS); // so that the next call will trigger refresh
      assertThat(cache.getOrLoad("test")).isEqualTo("testLoad");
      reloadStarted.await();
      ticker.advance(500, MILLISECONDS); // so that the entry expires during the reload