// Given
        InetAddress realInetAddress = InetAddress.getByName("127.0.0.1");
        when(mockNetbiosAddress.toInetAddress()).thenReturn(realInetAddress);
        when(mockNetbiosAddress.unwrap(NbtAddress.class)).thenReturn(null);

        // When/Then - This will throw UnknownHostException quickly
        assertThrows(UnknownHostException.class, () -> {

    @Override
    protected Map<String, Map<Integer, Character>> makePopulatedMap() {
      Table<String, Integer, Character> table = makeTable();
      populateTable(table);
      return table.rowMap();
    }

    // `protected` to work around b/320650932 / KT-67447 runtime crash
    protected final void populateTable(Table<String, Integer, Character> table) {
      table.put("foo", 1, 'a');

    assertEquals(TypeToken.of(Primitives.wrap((Class<?>) type.getType())), type.wrap());
  }

  private static void assertNotPrimitive(TypeToken<?> type) {
    assertFalse(type.isPrimitive());
    assertSame(type, type.wrap());
  }

  private static void assertIsWrapper(TypeToken<?> type) {
    assertNotPrimitive(type);
    assertEquals(TypeToken.of(Primitives.unwrap((Class<?>) type.getType())), type.unwrap());
  }

    private final byte[] bytes;
    private final int off;
    private final int len;

    /**
     * Constructs a ByteEncodable object wrapping a byte array segment.
     *
     * @param b the byte array to wrap
     * @param off the offset in the byte array
     * @param len the length of the segment to use
     */
    public ByteEncodable(final byte[] b, final int off, final int len) {
        this.bytes = b;

import java.util.concurrent.TimeUnit;
import org.jspecify.annotations.Nullable;

/**
 * An abstract {@code ScheduledExecutorService} that allows subclasses to {@linkplain
 * #wrapTask(Callable) wrap} tasks before they are submitted to the underlying executor.
 *
 * <p>Note that task wrapping may occur even if the task is never executed.
 *
 * @author Luke Sandberg
 */
@J2ktIncompatible
@GwtIncompatible

    private Credentials creds;

    /**
     * Constructs a CIFS context wrapper with custom credentials.
     *
     * @param delegate the context to wrap
     * @param creds
     *            Credentials to use
     */
    public CIFSContextCredentialWrapper(final AbstractCIFSContext delegate, final Credentials creds) {
        super(delegate);
        this.creds = creds;

        // NETWORK_INTERFACE_INFO structure per MS-SMB2 2.2.32.5.1
        // Total size: 152 bytes
        byte[] buffer = new byte[Smb2ChannelCapabilities.NETWORK_INTERFACE_INFO_SIZE];
        ByteBuffer bb = ByteBuffer.wrap(buffer).order(ByteOrder.LITTLE_ENDIAN);

        // Next field (4 bytes) - offset to next entry (0 for last entry)
        bb.putInt(0);

        // InterfaceIndex (4 bytes)
        bb.putInt(interfaceIndex);

            }
          }
      }

    client =
      client
        .newBuilder()
        .connectionSpecs(listOf(spec))
        .eventListenerFactory(
          clientTestRule.wrap(
            object : EventListener() {
              override fun connectionAcquired(
                call: Call,
                connection: Connection,
              ) {

      return Iterators.pollNext(descendingIterator());
    }

    private NavigableSet<V> wrap(NavigableSet<V> wrapped) {
      return new WrappedNavigableSet(key, wrapped, (getAncestor() == null) ? this : getAncestor());
    }

    @Override
    public NavigableSet<V> descendingSet() {
      return wrap(getSortedSetDelegate().descendingSet());
    }

    @Override

// as an error to be reported.
//
// passes NOATIME flag for reads on Unix systems to avoid atime updates.
func ReadFile(name string) ([]byte, error) {
	// Don't wrap with un-needed buffer.
	// Don't use os.ReadFile, since it doesn't pass NO_ATIME when present.
	f, err := OsOpenFile(name, readMode, 0o666)
	if err != nil {
		return nil, err
	}
	defer f.Close()
	st, err := f.Stat()