}

  public static void assertEmpty(Iterable<?> iterable) {
    if (!isEmpty(iterable)) {
      fail("Not true that " + iterable + " is empty");
    }
  }

  public static void assertEmpty(Map<?, ?> map) {
    if (!map.isEmpty()) {
      fail("Not true that " + map + " is empty");
    }
  }

  public static void assertEqualInOrder(Iterable<?> expected, Iterable<?> actual) {

  /**
   * Returns the value the specified class is mapped to, or {@code null} if no entry for this class
   * is present. This will only return a value that was bound to this specific class, not a value
   * that may have been bound to a subtype.
   *
   * <p>{@code getInstance(Foo.class)} is equivalent to {@code
   * getInstance(TypeToken.of(Foo.class))}.
   */

    attributes:
      label: "Proposal"
      description: "What is the proposed change? Who does this proposal help, and why? Please describe as precisely as possible the change to the language."
    validations:
      required: true

  - type: textarea
    id: language-spec-changes
    attributes:
      label: "Language Spec Changes"
      description: "What would change in the language spec?"
    validations:

@GwtIncompatible
public final class TestingExecutors {
  private TestingExecutors() {}

  /**
   * Returns a {@link ScheduledExecutorService} that never executes anything.
   *
   * <p>The {@code shutdownNow} method of the returned executor always returns an empty list despite
   * the fact that everything is still technically awaiting execution. The {@code getDelay} method

    void testGetDefaultPort() {
        // This test verifies that the handler returns the correct default HTTP port.
        assertEquals(Handler.DEFAULT_HTTP_PORT, handler.getDefaultPort(), "Default port should be 80 for HTTP.");
    }

    @Test
    void testOpenConnection_HttpProtocol_ReturnsNtlmHttpURLConnection() throws Exception {
        // This test ensures that for a standard HTTP URL, openConnection wraps the connection

/**
 * A type of {@link RestTestTransform} that finds the transformation by a given key that has a value that is an {@link ArrayNode}.
 */
public interface RestTestTransformByParentArray extends RestTestTransform<ArrayNode> {

    /**
     * Arrays are always the value in a key/value pair. Find a key with this name that has an array as the value to identify which Array(s)
     * to transform.

 * @since 15.0
 */
@GwtCompatible
public final class Escapers {
  private Escapers() {}

  /**
   * Returns an {@link Escaper} that does no escaping, passing all character data through unchanged.
   */
  public static Escaper nullEscaper() {
    return NULL_ESCAPER;
  }

  // An Escaper that efficiently performs no escaping.
  // Extending CharEscaper (instead of Escaper) makes Escapers.compose() easier.

        CHILD_URL,
        /** Indicates that multiple child URLs were discovered. */
        CHILD_URLS,
        /** Indicates that a URL was evaluated for crawling eligibility. */
        EVALUATED,
        /** Indicates that a general exception occurred during processing. */
        EXCEPTION,
        /** Indicates that processing of a URL has finished. */
        FINISHED,

/**
 * Represents a single character mapping rule that defines how input characters are mapped to output characters
 * for text analysis and search processing. This class is used in character mapping dictionaries to transform
 * text during indexing and search operations.
 *
 * <p>Each mapping item consists of one or more input character sequences that are mapped to a single output

    This defines the name of the query parameter that should be provided in the request
    with the API key and integrates that into the OpenAPI documentation. It extracts
    the key value sent in the query parameter automatically and provides it as the
    dependency result. But it doesn't define how to send that API key to the client.

    ## Usage

    Create an instance object and use that object as the dependency in `Depends()`.