checkArgument(type.isEnum());
    this.enumConstants = type.getEnumConstants();
    this.counts = new int[enumConstants.length];
  }

  private boolean isActuallyE(@Nullable Object o) {
    if (o instanceof Enum) {
      Enum<?> e = (Enum<?>) o;
      int index = e.ordinal();
      return index < enumConstants.length && enumConstants[index] == e;
    }
    return false;
  }

  /**

    ): Boolean {
      if (urlHost == domain) {
        return true // As in 'example.com' matching 'example.com'.
      }

      return urlHost.endsWith(domain) &&
        urlHost[urlHost.length - domain.length - 1] == '.' &&
        !urlHost.canParseAsIpAddress()
    }

    private fun pathMatch(
      url: HttpUrl,
      path: String,
    ): Boolean {
      val urlPath = url.encodedPath

            final DateTimeFormatter formatter = DateTimeFormatter.ofPattern(YYYY_MM_DD_HH_MM);
            try {
                if (values.length > 0) {
                    cb.query().setRequestedAt_GreaterEqual(parseDateTime(values[0], formatter));
                }
                if (values.length > 1) {
                    cb.query().setRequestedAt_LessEqual(LocalDateTime.parse(values[1], formatter));
                }

        if (token != null) {
            final String[] values = token.trim().split(" ");
            if (values.length == 2 && BEARER.equals(values[0])) {
                return values[1];
            }
            if (values.length == 1 && !BEARER.equals(values[0])) {
                return values[0];
            }

        final BulkItemResponse[] itemResponses = response.getItems();
        if (itemResponses.length != entityList.size()) {
            throw new IllegalStateException("Invalid response size: " + itemResponses.length + " != " + entityList.size());
        }
        final int[] results = new int[itemResponses.length];
        for (int i = 0; i < itemResponses.length; i++) {
            final BulkItemResponse itemResponse = itemResponses[i];

        if (includedDocUrlPatterns == null || excludedDocUrlPatterns == null) {
            initDocUrlPattern();
        }

        if (includedDocUrlPatterns.length == 0 && excludedDocUrlPatterns.length == 0) {
            return Constants.TRUE;
        }

        for (final Pattern pattern : includedDocUrlPatterns) {
            if (pattern.matcher(input).matches()) {

      for (int i = 0; i < codePoints.length; i++) {
        do {
          codePoints[i] = rng.nextInt(0x800);
        } while (!Character.isValidCodePoint(codePoints[i])
            || (codePoints[i] >= Character.MIN_SURROGATE
                && codePoints[i] <= Character.MAX_SURROGATE));
      }
      StringBuilder builder = new StringBuilder();
      for (int i = 0; i < codePoints.length; i++) {

    assertEquals(-1, matcher.indexIn(s, s.length()));
    assertEquals(s.length() - 1, matcher.lastIndexIn(s));
    assertTrue(matcher.matchesAnyOf(s));
    assertTrue(matcher.matchesAllOf(s));
    assertFalse(matcher.matchesNoneOf(s));
    assertThat(matcher.removeFrom(s)).isEqualTo("");
    assertThat(matcher.replaceFrom(s, 'z')).isEqualTo(Strings.repeat("z", s.length()));

    // Field validation
    // ----------------------------------------------------------------------

    /**
     * Asserts:
     * <p/>
     * <ul>
     * <li><code>string.length != null</code>
     * <li><code>string.length > 0</code>
     * </ul>
     */
    private static boolean validateStringNotEmpty(
            SettingsProblemCollector problems, String fieldName, String string, String sourceHint) {

    extends AbstractTableReadTest<C> {

  protected void populate(Table<String, Integer, C> table, @Nullable Object... data) {
    checkArgument(data.length % 3 == 0);
    for (int i = 0; i < data.length; i += 3) {
      table.put(
          (String) data[i], (Integer) data[i + 1], nullableCellValue((Character) data[i + 2]));
    }
  }

  protected boolean supportsRemove() {
    return true;