// Verify that SmbShareInfo properly implements FileEntry interface
        SmbShareInfo info = new SmbShareInfo(TEST_NET_NAME, TEST_TYPE, TEST_REMARK);

        // Cast to FileEntry to ensure interface is properly implemented
        jcifs.smb.FileEntry fileEntry = info;

        // Verify all FileEntry methods work
        assertEquals(TEST_NET_NAME, fileEntry.getName());

    peer.sendFrame().windowUpdate(3, 5)
    peer.acceptFrame() // DATA STREAM 3 "fghi"
    peer.play()

    // Play it back.
    val connection = connect(peer)
    connection.writePingAndAwaitPong() // Ensure the SETTINGS have been received.
    val stream = connection.newStream(headerEntries("a", "android"), true)
    val sink = stream.sink.buffer()
    sink.writeUtf8("abcdefghi")
    sink.flush()

   * then we should have {@code 0 ≤ entry ≤ 255}, and if {@code table} is a {@code short[]} then we
   * should have {@code 0 ≤ entry ≤ 65535}. It is the caller's responsibility to ensure this.
   */
  static void tableSet(Object table, int index, int entry) {
    if (table instanceof byte[]) {
      ((byte[]) table)[index] = (byte) entry; // unsigned write
    } else if (table instanceof short[]) {

with other internal or external projects.

## Build guidelines

This is an intentionally small set of guidelines to build users and authors
to ensure we keep the build consistent. We also publish elasticsearch build logic
as `build-tools` to be usuable by thirdparty elasticsearch plugin authors. This is
also used by other elastic teams like `elasticsearch-hadoop`.

  public void runTest() throws Exception {
    /*
     * Note that we do not run this test under Android at the moment. For Android testing, see
     * AggregateFutureStateDefaultAtomicHelperTest.
     */

    // First, ensure that our classloaders are initializing the correct helper versions:

    checkHelperVersion(getClass().getClassLoader(), "SafeAtomicHelper");
    checkHelperVersion(NO_ATOMIC_FIELD_UPDATER, "SynchronizedAtomicHelper");

		if received != "message one\n" {
			cerr = fmt.Errorf(`server: expected: "message one\n", got: %v`, received)
			return
		}

		// Set a deadline in the past to indicate we want the next read to fail.
		// Ensure we don't override it on read.
		deadlineconn.SetReadDeadline(time.Unix(1, 0))

		// Be sure to exceed update interval
		time.Sleep(updateInterval * 2)

		_, terr = deadlineconn.Read(b)
		if terr == nil {

    assertWithMessage("Eviction notifications must be received")
        .that(removalListener.getCount())
        .isEqualTo(10);

    CacheTesting.expireEntries((LoadingCache<?, ?>) cache, EXPIRING_TIME, ticker);
    // ensure that no new notifications are sent
    assertWithMessage("Eviction notifications must be received")
        .that(removalListener.getCount())
        .isEqualTo(10);
  }

   *
   * To avoid leaking resources callers should close the [Response] which in turn will close the
   * underlying [ResponseBody].
   *
   * ```java
   * // ensure the response (and underlying response body) is closed
   * try (Response response = client.newCall(request).execute()) {
   *   ...
   * }
   * ```
   *

   * garbage-collected, even if there are no more instances of FinalizableReferenceQueue itself.
   * The code in FinalizableReferenceQueue goes to considerable trouble to ensure that there are
   * no such references and the tests here check that that trouble has not been in vain.
   *
   * When we reference FinalizableReferenceQueue in this test, we are referencing a class that is

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * Tester to ensure forwarding wrapper works by delegating calls to the corresponding method with
 * the same parameters forwarded and return value forwarded back or exception propagated as is.
 *
 * <p>For example:
 *
 * {@snippet :