assertWithMessage("keyEquivalence")
        .that(actual.keyEquivalence)
        .isEqualTo(expected.keyEquivalence);
    assertWithMessage("keyStrength").that(actual.keyStrength).isEqualTo(expected.keyStrength);
    assertWithMessage("removalListener")
        .that(actual.removalListener)
        .isEqualTo(expected.removalListener);

        Interners.newBuilder().strong().concurrencyLevel(concurrencyLevel).build();
    InternerImpl<Object> internerImpl = (InternerImpl<Object>) interner;
    assertEquals(Strength.STRONG, internerImpl.map.keyStrength());
  }

  public void testWeak_simplistic() {
    String canonical = "a";
    String not = new String("a");

    Interner<String> pool = Interners.newWeakInterner();

    this.refreshes = new LinkedHashSet<>(durations);
    return this;
  }

  @CanIgnoreReturnValue
  CacheBuilderFactory withKeyStrengths(Set<Strength> keyStrengths) {
    this.keyStrengths = new LinkedHashSet<>(keyStrengths);
    Preconditions.checkArgument(!this.keyStrengths.contains(Strength.SOFT));
    return this;
  }

  @CanIgnoreReturnValue
  CacheBuilderFactory withValueStrengths(Set<Strength> valueStrengths) {

  }

  private static void checkStrength(
      LocalCache<Object, Object> map, Strength keyStrength, Strength valueStrength) {
    assertThat(map.keyStrength).isEqualTo(keyStrength);
    assertThat(map.valueStrength).isEqualTo(valueStrength);
    assertThat(map.keyEquivalence).isSameInstanceAs(keyStrength.defaultEquivalence());
    assertThat(map.valueEquivalence).isSameInstanceAs(valueStrength.defaultEquivalence());
  }

  }

  private static void checkStrength(
      LocalCache<Object, Object> map, Strength keyStrength, Strength valueStrength) {
    assertThat(map.keyStrength).isEqualTo(keyStrength);
    assertThat(map.valueStrength).isEqualTo(valueStrength);
    assertThat(map.keyEquivalence).isSameInstanceAs(keyStrength.defaultEquivalence());
    assertThat(map.valueEquivalence).isSameInstanceAs(valueStrength.defaultEquivalence());
  }

        Interners.newBuilder().strong().concurrencyLevel(concurrencyLevel).build();
    InternerImpl<Object> internerImpl = (InternerImpl<Object>) interner;
    assertEquals(Strength.STRONG, internerImpl.map.keyStrength());
  }

  public void testWeak_simplistic() {
    String canonical = "a";
    String not = new String("a");

    Interner<String> pool = Interners.newWeakInterner();

  public void testIdentityKeyEquality_weakKeys() {
    testIdentityKeyEquality(WEAK);
  }

  private void testIdentityKeyEquality(MapMakerInternalMap.Strength keyStrength) {

    ConcurrentMap<String, AtomicInteger> map =
        new MapMaker().setKeyStrength(keyStrength).keyEquivalence(Equivalence.identity()).makeMap();

    ConcurrentHashMultiset<String> multiset = ConcurrentHashMultiset.create(map);

      }

      for (Segment<?, ?, ?, ?> segment : map.segments) {
        segment.runCleanup();
      }
    }
  }

  @VisibleForTesting
  Strength keyStrength() {
    return entryHelper.keyStrength();
  }

  @VisibleForTesting
  Strength valueStrength() {
    return entryHelper.valueStrength();
  }

  @VisibleForTesting
  Equivalence<Object> valueEquivalence() {

  }

  @CanIgnoreReturnValue
  CacheBuilder<K, V> setKeyStrength(Strength strength) {
    checkState(keyStrength == null, "Key strength was already set to %s", keyStrength);
    keyStrength = checkNotNull(strength);
    return this;
  }

  Strength getKeyStrength() {
    return MoreObjects.firstNonNull(keyStrength, Strength.STRONG);
  }

  /**

  }

  private static void checkStrength(
      MapMakerInternalMap<Object, Object, ?, ?> map, Strength keyStrength, Strength valueStrength) {
    assertThat(map.keyStrength()).isEqualTo(keyStrength);
    assertThat(map.valueStrength()).isEqualTo(valueStrength);
    assertSame(keyStrength.defaultEquivalence(), map.keyEquivalence);
    assertSame(valueStrength.defaultEquivalence(), map.valueEquivalence());
  }