final int start = dstIndex;

        SMBUtil.writeInt2(this.fid, dst, dstIndex);
        dstIndex += 2;
        dst[dstIndex] = (byte) 0x00; // Reserved
        dstIndex++;
        dst[dstIndex++] = (byte) 0x00; // Reserved
        SMBUtil.writeInt4(this.securityInformation, dst, dstIndex);
        dstIndex += 4;
        return dstIndex - start;
    }

    @Override

            // Test with various wildcard patterns and attribute masks
            String[] wildcards = { "*.txt", "test*", null };
            int[] attributes = { 0x10, 0x20, 0x07 };

            for (int i = 0; i < wildcards.length; i++) {
                DosFileFilter dos = new DosFileFilter(wildcards[i], attributes[i]);

                // negative fid wraps around, lastWriteTime = 1000 -> 1 second -> int value 1
                Arguments.of(-1, 1000L, new byte[] { (byte) 0xFF, (byte) 0xFF, 0x01, 0x00, 0x00, 0x00 }));
    }

    /**
     * When lastWriteTime is zero the encoded unsigned time must be all 1s.
     */
    @Test
    @DisplayName("edge: writeParameterWordsWireFormat with lastWriteTime=0")

    }

    @Test
    void testGetNbtAllByAddress_StringIntString() throws UnknownHostException {
        // Arrange
        String host = "testHost";
        int type = 0x20;
        String scope = "testScope";
        NetbiosAddress[] expectedAddresses = { mock(NetbiosAddress.class) };
        when(nameServiceClient.getNbtAllByAddress(host, type, scope)).thenReturn(expectedAddresses);

        // Then
        assertEquals(4, bytesWritten);
        assertEquals(SmbComTransaction.TRANS_CALL_NAMED_PIPE, dst[0]);
        assertEquals((byte) 0x00, dst[1]);
        assertEquals((byte) 0x00, dst[2]);
        assertEquals((byte) 0x00, dst[3]);
    }

    @Test
    @DisplayName("Test writeSetupWireFormat with offset")
    void testWriteSetupWireFormatWithOffset() {
        // Given

				Name:     "small.txt",
				Size:     5,
				Mode:     0640,
				Uid:      73025,
				Gid:      5000,
				Uname:    "dsymonds",
				Gname:    "eng",
				ModTime:  time.Unix(1246508266, 0),
			}, nil},
			testWrite{"Kilts", 5, nil},

			testHeader{Header{
				Typeflag: TypeReg,
				Name:     "small2.txt",
				Size:     11,
				Mode:     0640,
				Uid:      73025,
				Uname:    "dsymonds",

     */
    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);

	s_IFSOCK = 0xc000
	s_IFLNK  = 0xa000
	s_IFREG  = 0x8000
	s_IFBLK  = 0x6000
	s_IFDIR  = 0x4000
	s_IFCHR  = 0x2000
	s_IFIFO  = 0x1000
	s_ISUID  = 0x800
	s_ISGID  = 0x400
	s_ISVTX  = 0x200

	msdosDir      = 0x10
	msdosReadOnly = 0x01
)

// Mode returns the permission and mode bits for the [FileHeader].
func (h *FileHeader) Mode() (mode fs.FileMode) {
	switch h.CreatorVersion >> 8 {

        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

    @Override
    protected int writeBytesWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;

        dst[dstIndex] = (byte) 0x04;
        dstIndex++;
        dstIndex += writeString(this.oldFileName, dst, dstIndex);
        dst[dstIndex++] = (byte) 0x04;
        if (this.isUseUnicode()) {
            dst[dstIndex++] = (byte) '\0';
        }
        dstIndex += writeString(this.newFileName, dst, dstIndex);