}

  // Helper to assert common expected behaviour of uri escapers.
  static void assertBasicUrlEscaper(UnicodeEscaper e) {
    assertBasicUrlEscaperExceptPercent(e);
    // The escape character must always be escaped
    assertEscaping(e, "%25", '%');
  }

  static void assertPathEscaper(UnicodeEscaper e) {
    assertBasicUrlEscaper(e);

    assertUnescaped(e, '!');
    assertUnescaped(e, '\'');

 * href="https://developers.google.com/closure/templates/">Closure Templates</a>.
 *
 * <p>HTML escaping is particularly tricky: For example, <a
 * href="https://www.w3.org/TR/html4/types.html#h-6.2">some elements' text contents must not be HTML
 * escaped</a>. As a result, it is impossible to escape an HTML document correctly without
 * domain-specific knowledge beyond what {@code HtmlEscapers} provides. We strongly encourage the

    /**
     * Tries to resolve the specified artifact from the artifacts of the given project.
     *
     * @param project The project to try to resolve the artifact from, must not be <code>null</code>.
     * @param requestedArtifact The artifact to resolve, must not be <code>null</code>.
     * @return The matching artifact from the project or <code>null</code> if not found. Note that this
     */

      if (rule[0][0] == EXCEPTION_MARKER) {
        // Exception rules hold the effective TLD plus one.
        domainLabels.size - rule.size
      } else {
        // Otherwise the rule is for a public suffix, so we must take one more label.
        domainLabels.size - (rule.size + 1)
      }

    return splitDomain(domain).asSequence().drop(firstLabelOffset).joinToString(".")
  }

        apply {
          parts += part
        }

      /** Assemble the specified parts into a request body. */
      fun build(): MultipartBody {
        check(parts.isNotEmpty()) { "Multipart body must have at least one part." }
        return MultipartBody(boundary, type, parts.toImmutableList())
      }
    }

  companion object {
    /**

  // expectedHashCodes must contain at least one hash code with 4 bytes
  public void testFromInt() {
    for (ExpectedHashCode expected : expectedHashCodes) {
      if (expected.bytes.length == 4) {
        HashCode fromInt = HashCode.fromInt(expected.asInt);
        assertExpectedHashCode(expected, fromInt);
      }
    }
  }

  // expectedHashCodes must contain at least one hash code with 8 bytes

 * to a BloomFilter of M bits and k hash functions. These strategies are part of the serialized form
 * of the Bloom filters that use them, thus they must be preserved as is (no updates allowed, only
 * introduction of new versions).
 *
 * <p>Important: the order of the constants cannot change, and they cannot be deleted - we depend on
 * their ordinal for BloomFilter serialization.

  // +optional
  repeated Subject subjects = 2;

  // RoleRef can only reference a ClusterRole in the global namespace.
  // If the RoleRef cannot be resolved, the Authorizer must return an error.
  optional RoleRef roleRef = 3;
}

// ClusterRoleBindingList is a collection of ClusterRoleBindings.

                || FAIL_NEVER.equals(failureBehavior)) {
            this.failureBehavior = failureBehavior;
        } else {
            throw new IllegalArgumentException("Invalid failure behavior (must be one of: '" + FAIL_FAST + "', '"
                    + FAIL_AT_END + "', '" + FAIL_NEVER + "').");
        }
    }

    public String getFailureBehavior() {
        return failureBehavior;
    }

    }
    return result;
  }

  private static int checkNoOverflow(long result) {
    checkArgument(
        result == (int) result,
        "the total number of elements (%s) in the arrays must fit in an int",
        result);
    return (int) result;
  }

  /**
   * Returns an array containing the same values as {@code array}, but guaranteed to be of a