}
        writeInt2(writeMode, dst, dstIndex);
        dstIndex += 2;
        writeInt2(remaining, dst, dstIndex);
        dstIndex += 2;
        dst[dstIndex] = (byte) 0x00;
        dstIndex++;
        dst[dstIndex++] = (byte) 0x00;
        writeInt2(dataLength, dst, dstIndex);
        dstIndex += 2;
        writeInt2(dataOffset, dst, dstIndex);
        dstIndex += 2;
        writeInt4(offset >> 32, dst, dstIndex);

  </properties>

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>com.squareup.okhttp3</groupId>
        <artifactId>okhttp-bom</artifactId>
        <version>[5.2.0-SNAPSHOT,6.0.0-SNAPSHOT)</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>

    assertEscaping(e, "%7F", '\u007f'); // del
    assertEscaping(e, "%C2%80", '\u0080'); // xx-00010,x-000000
    assertEscaping(e, "%DF%BF", '\u07ff'); // xx-11111,x-111111
    assertEscaping(e, "%E0%A0%80", '\u0800'); // xxx-0000,x-100000,x-00,0000
    assertEscaping(e, "%EF%BF%BF", '\uffff'); // xxx-1111,x-111111,x-11,1111
    assertUnicodeEscaping(e, "%F0%90%80%80", '\uD800', '\uDC00');
    assertUnicodeEscaping(e, "%F4%8F%BF%BF", '\uDBFF', '\uDFFF');

        message[58] = 0;
        message[59] = 0;

        // Flags (NTLMSSP_NEGOTIATE_UNICODE)
        message[60] = 0x01; // NTLMSSP_NEGOTIATE_UNICODE
        message[61] = 0x00;
        message[62] = 0x00;
        message[63] = 0x00;

        // Add dummy LM response (24 zeros at offset 64)
        for (int i = 0; i < 24; i++) {
            message[64 + i] = 0;
        }

     */
    int DCERPC_OBJECT_UUID = 0x80; /* if true, a non-nil object UUID */

    // Packet Types (ptype)
    /**
     * Request packet type
     */
    int RPC_PT_REQUEST = 0x00;
    /**
     * Ping packet type
     */
    int RPC_PT_PING = 0x01;
    /**
     * Response packet type
     */
    int RPC_PT_RESPONSE = 0x02;
    /**
     * Fault packet type - indicates an error

        int nameType = mockNetbiosName.getNameType();

        // Then
        assertEquals(testType, nameType);
        verify(mockNetbiosName).getNameType();
    }

    @ParameterizedTest
    @ValueSource(ints = { 0x00, 0x03, 0x06, 0x1B, 0x1C, 0x1D, 0x1E, 0x20 })
    @DisplayName("Should handle various NetBIOS name types")
    void testVariousNameTypes(int nameType) {
        // Given

        byte[] buffer = new byte[100];
        int result = response.readSetupWireFormat(buffer, 0, 100);
        assertEquals(0, result);
    }

    @Test
    void testReadParametersWireFormat() {
        byte[] buffer = new byte[100];
        int result = response.readParametersWireFormat(buffer, 0, 100);
        assertEquals(0, result);
    }

    @Test

        return SCOPE_OFFSET + readScopeWireFormat(src, srcIndex + SCOPE_OFFSET);
    }

    int writeScopeWireFormat(final byte[] dst, int dstIndex) {
        if (scope == null) {
            dst[dstIndex] = (byte) 0x00;
            return 1;
        }

        // copy new scope in
        dst[dstIndex] = (byte) '.';
        dstIndex++;
        try {

      deflatedBytes.readAndWriteUnsafe().use { cursor ->
        cursor.resizeBuffer(newSize)
      }
    } else {
      // Same as adding EMPTY_DEFLATE_BLOCK and then removing 4 bytes.
      deflatedBytes.writeByte(0x00)
    }

    buffer.write(deflatedBytes, deflatedBytes.size)
  }

  @Throws(IOException::class)
  override fun close() = deflaterSink.close()

    byte[] expectedBytes = buf.clone();
    System.arraycopy(testBytes, 0, expectedBytes, 0, testBytes.length);

    HashingInputStream in = new HashingInputStream(hashFunction, buffer);

    int numOfByteRead = in.read(buf, 0, 100);
    assertEquals(4, numOfByteRead);
    for (int i = 0; i < numOfByteRead; i++) {
      assertEquals(testBytes[i], buf[i]);
    }

    verify(hasher).putBytes(expectedBytes, 0, 4);