buffer[offset + 2] = 0x00;
        buffer[offset + 3] = 0x00;
        buffer[offset + 4] = 0x00;
        buffer[offset + 5] = 0x00;
        buffer[offset + 6] = 0x00;
        buffer[offset + 7] = 0x01;
        // Sub-authority
        SMBUtil.writeInt4(0, buffer, offset + 8);
    }

    private void prepareDaclHeader(byte[] buffer, int offset, int aceCount) {
        buffer[offset] = 0x02; // revision

    private static Stream<Arguments> provideNamesForWriteTest() {
        return Stream.of(Arguments.of("SERVER", 0x20, "CLIENT", 0x00), Arguments.of("WORKSTATION", 0x00, "USER", 0x03),
                Arguments.of("DOMAIN", 0x1B, "BROWSER", 0x1D), Arguments.of("A", 0x20, "B", 0x00),
                Arguments.of("VERYLONGNAMETEST", 0x20, "ANOTHERLONGNAME", 0x00));
    }

    @Test

     */

    public static final int H_NODE = 3;

    /**
     * Unknown MAC Address
     */
    public static final byte[] UNKNOWN_MAC_ADDRESS = { (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00 };

    Name hostName;
    int address, nodeType;
    boolean groupName, isBeingDeleted, isInConflict, isActive, isPermanent, isDataFromNodeStatus;
    byte[] macAddress;

        assertEquals((byte) 0x04, dst[4]);
        assertEquals((byte) 0x01, dst[5]);

        // resumeKey (4 bytes, LE)
        assertEquals((byte) 0xEF, dst[6]);
        assertEquals((byte) 0xCD, dst[7]);
        assertEquals((byte) 0xAB, dst[8]);
        assertEquals((byte) 0x89, dst[9]);

        // flags (2 bytes, LE) -> 0x0000
        assertEquals((byte) 0x00, dst[10]);

        byte[] src = { (byte) 0x00, (byte) 0x01, (byte) 0xFF, (byte) 0xFF };
        int length = SessionServicePacket.readLength(src, 0);

        assertEquals(0x01FFFF, length);
    }

    @Test
    @DisplayName("readLength should handle zero length")
    void testReadLengthZero() {
        byte[] src = { (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00 };

        assertEquals((byte) 0x00, dst[8]);
        assertEquals((byte) 0x00, dst[9]);
        assertEquals((byte) 0x00, dst[10]);
        assertEquals((byte) 0x00, dst[11]);
    }

    @Test
    void testReadInt2() {
        byte[] src = new byte[] { (byte) 0x34, (byte) 0x12, // 0x1234
                (byte) 0xFF, (byte) 0xFF, // 0xFFFF
                (byte) 0x00, (byte) 0x00, // 0x0000

        SMBUtil.writeInt2(mapInformationLevel(this.informationLevel), dst, dstIndex);
        dstIndex += 2;
        dst[dstIndex] = (byte) 0x00;
        dstIndex++;
        dst[dstIndex++] = (byte) 0x00;
        dst[dstIndex++] = (byte) 0x00;
        dst[dstIndex++] = (byte) 0x00;
        dstIndex += writeString(this.path, dst, dstIndex);

        return dstIndex - start;
    }

    /**
     * @param informationLevel2

        assertEquals(2, trans.maxParameterCount, "The maxParameterCount should be 2.");
        assertEquals(40, trans.maxDataCount, "The maxDataCount should be 40.");
        assertEquals((byte) 0x00, trans.maxSetupCount, "The maxSetupCount should be 0.");
    }

    /**
     * Tests the writeSetupWireFormat method.
     */
    @Test
    void testWriteSetupWireFormat() {
        // Given

     */
    public static int findUNITermination(final byte[] buffer, final int bufferIndex, final int maxLen) {
        int len = 0;
        while (buffer[bufferIndex + len] != (byte) 0x00 || buffer[bufferIndex + len + 1] != (byte) 0x00) {
            len += 2;
            if (len > maxLen) {
                if (log.isDebugEnabled()) {
                    log.warn("Failed to find string termination with max length " + maxLen);

        int bufferIndex = 0;

        // Reserved bytes
        buffer[bufferIndex++] = 0x00;
        buffer[bufferIndex++] = 0x00;
        buffer[bufferIndex++] = 0x00;

        // totalParameterCount = 10
        writeInt4(10, buffer, bufferIndex);
        bufferIndex += 4;
        // totalDataCount = 20