fileSystem.source(this@asRequestBody).use { source -> sink.writeAll(source) }
        }
      }

    @JvmStatic
    @Deprecated(
      message = "Moved to extension function. Put the 'content' argument first to fix Java",
      replaceWith =
        ReplaceWith(
          expression = "content.toRequestBody(contentType)",
          imports = ["okhttp3.RequestBody.Companion.toRequestBody"],
        ),

        String password15 = "ABCDEFGHIJKLMNO"; // 15 chars, same first 14
        byte[] challenge = hex("0102030405060708");

        // Act
        byte[] r14 = NtlmUtil.getPreNTLMResponse(cifsContext, password14, challenge);
        byte[] r15 = NtlmUtil.getPreNTLMResponse(cifsContext, password15, challenge);

        // Assert: equal because only first 14 OEM bytes are used

        void testEmptyExtensions() throws IOException {
            // Empty extension seems to match first entry in mime.map
            String result = mimeMap.getMimeType("");
            assertNotNull(result);
            // With custom default, empty still returns the first match
            String customResult = mimeMap.getMimeType("", "custom/default");
            assertNotNull(customResult);
        }

        byte[] actualMachineId = new byte[32];
        System.arraycopy(value, 16, actualMachineId, 0, 32);
        assertArrayEquals(expectedMachineId, actualMachineId);

        // Verify the size field (first 4 bytes)
        assertEquals(48, (value[0] & 0xFF) | ((value[1] & 0xFF) << 8) | ((value[2] & 0xFF) << 16) | ((value[3] & 0xFF) << 24));
    }

    /**
     * Test constructor AvSingleHost(byte[] customData, byte[] machineId).

@SuppressWarnings("serial") // uses writeReplace(), not default serialization
final class RegularImmutableList<E> extends ImmutableList<E> {
  static final ImmutableList<Object> EMPTY = new RegularImmutableList<>(new Object[0], 0);

  // The first `size` elements are non-null.
  @VisibleForTesting final transient @Nullable Object[] array;
  private final transient int size;

  RegularImmutableList(@Nullable Object[] array, int size) {
    this.array = array;

        ImmutableMap.of(
            'a', "first",
            'z', "last");
    ArrayBasedEscaperMap fem = ArrayBasedEscaperMap.create(map);
    // Array length is highest character value + 1
    assertThat(fem.getReplacementArray()).hasLength('z' + 1);
  }

  public void testMapping() {
    Map<Character, String> map =
        ImmutableMap.of(
            '\0', "zero",
            'a', "first",
            'b', "second",

  public void testPoll_size1() {
    assertEquals("size1Queue.poll() should return first element", e0(), getQueue().poll());
    expectMissing(e0());
  }

  @CollectionFeature.Require({KNOWN_ORDER, SUPPORTS_REMOVE})
  @CollectionSize.Require(SEVERAL)
  public void testPoll_sizeMany() {
    assertEquals("sizeManyQueue.poll() should return first element", e0(), getQueue().poll());
    expectMissing(e0());
  }

        originalBuffer[offset++] = (byte) 1; // directory = true

        // Decode into first instance
        FileStandardInfo firstInstance = new FileStandardInfo();
        firstInstance.decode(originalBuffer, 0, originalBuffer.length);

        // Encode from first instance
        byte[] encodedBuffer = new byte[22];
        firstInstance.encode(encodedBuffer, 0);

        // First decode
        byte[] buffer1 = new byte[50];
        SMBUtil.writeInt4(0x11111111, buffer1, 0);
        SMBUtil.writeInt2(0x1111, buffer1, 20);
        SMBUtil.writeInt2(0x0210, buffer1, 22);

        response.decode(buffer1, 0, 24);
        assertEquals(0x11111111, response.getCapabilities(), "First decode capabilities");

        // hasNext/next sequence over two elements
        assertTrue(it.hasNext(), "Expected first element available");
        SmbResource r1 = it.next();
        assertNotNull(r1);
        assertEquals("foo/", r1.getName(), "First child name should match with trailing slash");

        assertTrue(it.hasNext(), "Expected second element available");
        SmbResource r2 = it.next();