}

  @GwtIncompatible // java.util.BitSet
  private void doTestSetBits(CharMatcher matcher) {
    BitSet bitset = new BitSet();
    matcher.setBits(bitset);
    for (int i = Character.MIN_VALUE; i <= Character.MAX_VALUE; i++) {
      assertEquals(matcher.matches((char) i), bitset.get(i));
    }
  }

  public void testEmpty() throws Exception {
    doTestEmpty(CharMatcher.any());

  /**
   * Returns a hash code for {@code value}; obsolete alternative to {@link Long#hashCode(long)}.
   *
   * @param value a primitive {@code long} value
   * @return a hash code for the value
   */
  @InlineMe(replacement = "Long.hashCode(value)")
  public static int hashCode(long value) {
    return Long.hashCode(value);
  }

  /**

                    final Object value = e.getValue();
                    if (value instanceof Map) {
                        @SuppressWarnings("unchecked")
                        final Map<String, Object> mapValue = (Map<String, Object>) value;
                        return toLowerHyphen(mapValue);
                    }
                    return e.getValue();
                }));

  /**
   * Returns a {@code MapJoiner} using the given key-value separator, and the same configuration as
   * this {@code Joiner} otherwise.
   *
   * @since 20.0
   */
  public MapJoiner withKeyValueSeparator(char keyValueSeparator) {
    return withKeyValueSeparator(String.valueOf(keyValueSeparator));
  }

  /**
   * Returns a {@code MapJoiner} using the given key-value separator, and the same configuration as

    static final int DEFAULT_INITIAL_CAPACITY = 4;

    static int expandedCapacity(int oldCapacity, int minCapacity) {
      if (minCapacity < 0) {
        throw new IllegalArgumentException("cannot store more than Integer.MAX_VALUE elements");
      } else if (minCapacity <= oldCapacity) {
        return oldCapacity;
      }
      // careful of overflow!
      int newCapacity = oldCapacity + (oldCapacity >> 1) + 1;

      return count(element);
    }
    int index = element.ordinal();
    int oldCount = counts[index];
    long newCount = (long) oldCount + occurrences;
    checkArgument(newCount <= Integer.MAX_VALUE, "too many occurrences: %s", newCount);
    counts[index] = (int) newCount;
    if (oldCount == 0) {
      distinctElements++;
    }
    size += occurrences;
    return oldCount;
  }

  public void testIndexOf_specialValues() {
    ImmutableDoubleArray iia =
        ImmutableDoubleArray.of(-0.0, 0.0, Double.MAX_VALUE, Double.POSITIVE_INFINITY, Double.NaN);
    assertThat(iia.indexOf(-0.0)).isEqualTo(0);
    assertThat(iia.indexOf(0.0)).isEqualTo(1);
    assertThat(iia.indexOf(Double.MAX_VALUE)).isEqualTo(2);
    assertThat(iia.indexOf(Double.POSITIVE_INFINITY)).isEqualTo(3);
    assertThat(iia.indexOf(Double.NaN)).isEqualTo(4);

    out.reset();
  }

  public void testReset() throws Exception {
    byte[] data = newPreFilledByteArray(100);
    FileBackedOutputStream out = new FileBackedOutputStream(Integer.MAX_VALUE);
    ByteSource source = out.asByteSource();

    out.write(data);
    assertTrue(Arrays.equals(data, source.read()));

    out.reset();
    assertTrue(Arrays.equals(new byte[0], source.read()));

    IllegalArgumentException expected =
        assertThrows(
            IllegalArgumentException.class,
            () -> builder.addAll(nCopies(Integer.MAX_VALUE - 50, "a")));
    assertThat(expected)
        .hasMessageThat()
        .contains("cannot store more than Integer.MAX_VALUE elements");
  }

    // don't check cache.size() until we know the get("b") call is complete
    computationComplete.await();

    // At this point, the listener should be holding the seed value (a -> a), and the map should
    // contain the computed value (b -> b), since the clear() happened before the computation
    // completed.
    assertEquals(1, listener.size());
    RemovalNotification<String, String> notification = listener.remove();