}

  @Test
  fun upgrade() {
    executeAndCheckUpgrade(upgradeRequest())
  }

  @Test
  fun upgradeWithEmptyRequestBody() {
    executeAndCheckUpgrade(upgradeRequest().newBuilder().post(RequestBody.EMPTY).build())
  }

  @Test
  fun upgradeWithNonEmptyRequestBody() {
    executeAndCheckUpgrade(
      upgradeRequest()
        .newBuilder()
        .post("Hello".toRequestBody())
        .build(),

  private static final int REPETITIONS = 3;

  private final List<List<Object>> equalityGroups = new ArrayList<>();
  private final RelationshipTester.ItemReporter itemReporter;

  /** Constructs an empty EqualsTester instance */
  public EqualsTester() {
    this(/* itemReporter= */ Item::toString);
  }

  EqualsTester(RelationshipTester.ItemReporter itemReporter) {
    this.itemReporter = checkNotNull(itemReporter);

   * * If neither a proxy nor proxy selector is configured.
   * * If the proxy is configured explicitly as [Proxy.NO_PROXY].
   * * If the proxy selector returns only [Proxy.NO_PROXY].
   * * If the proxy selector returns an empty list or null.
   *
   * Otherwise it lists the proxies in the order they will be attempted.
   *
   * @param url a URL with only the scheme, hostname, and port specified.
   */
  open fun proxySelectEnd(

  }

  /**
   * Returns the empty bimap.
   *
   * <p><b>Performance note:</b> the instance returned is a singleton.
   */
  // Casting to any type is safe because the set will never hold any elements.
  @SuppressWarnings("unchecked")
  public static <K, V> ImmutableBiMap<K, V> of() {
    return (ImmutableBiMap<K, V>) RegularImmutableBiMap.EMPTY;
  }

    checkSerialization(Predicates.and(TRUE, isOdd(), FALSE));
  }

  public void testAnd_applyIterable() {
    Collection<Predicate<@Nullable Integer>> empty = Arrays.asList();
    assertEvalsToTrue(Predicates.and(empty));
    assertEvalsLikeOdd(Predicates.and(Arrays.asList(isOdd())));
    assertEvalsLikeOdd(Predicates.and(Arrays.asList(TRUE, isOdd())));

    client.send(message2)
    serverListener.assertTextMessage(message2)

    // Empty server to client message.
    val message3 = ""
    server.send(message3)
    clientListener.assertTextMessage(message3)

    // Empty client to server message.
    val message4 = ""
    client.send(message4)
    serverListener.assertTextMessage(message4)

        assertEquals(0x103, Trans2FindFirst2.SMB_FILE_NAMES_INFO);
        assertEquals(0x104, Trans2FindFirst2.SMB_FILE_BOTH_DIRECTORY_INFO);
    }

    @Test
    @DisplayName("Test with empty wildcard")
    void testWithEmptyWildcard() {
        trans2FindFirst2 = new Trans2FindFirst2(mockConfig, "\\test", "", 0x16, 10, 1024);

        byte[] buffer = new byte[256];

        return escapeSlow(string, index);
      }
    }
    return string;
  }

  /**
   * Returns the escaped form of the given character, or {@code null} if this character does not
   * need to be escaped. If an empty array is returned, this effectively strips the input character
   * from the resulting text.
   *
   * <p>If the character does not need to be escaped, this method should return {@code null}, rather

# partition with insufficient storage, we specify the
# 'TFCI_MACOS_BAZEL_TEST_DIR_PATH' environment variable to point to a partition
# with ample storage. When this variable is empty (i.e by default), Bazel will
# use the output base directory to run tests.
if [[ "${TFCI_MACOS_BAZEL_TEST_DIR_ENABLE}" == 1 ]]; then
  mkdir -p "${TFCI_MACOS_BAZEL_TEST_DIR_PATH}"

  /**
   * Returns the value of the edge that connects {@code nodeU} to {@code nodeV} (in the order, if
   * any, specified by {@code endpoints}), if one is present; otherwise, returns {@code
   * Optional.empty()}.
   *
   * @throws IllegalArgumentException if {@code nodeU} or {@code nodeV} is not an element of this
   *     graph
   * @since 23.0 (since 20.0 with return type {@code V})
   */