// Act
        int bytesWritten = write.writeBytesWireFormat(dst, 0);

        // Assert
        assertEquals(6, bytesWritten, "Should write 6 bytes (1 type + 2 length + 3 data)");
        assertEquals(0x01, dst[0], "Data block type");
        assertEquals(3, dst[1] & 0xFF, "Data length low byte");
        assertEquals(0, dst[2] & 0xFF, "Data length high byte");
        assertEquals(2, dst[3], "First data byte");

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

    /**
     * {@inheritDoc}
     *

            // Share type (DISK)
            buffer[2] = Smb2TreeConnectResponse.SMB2_SHARE_TYPE_DISK;
            // Reserved
            buffer[3] = 0;
            // Share flags (DFS)
            buffer[4] = 0x01;
            buffer[5] = 0x00;
            buffer[6] = 0x00;
            buffer[7] = 0x00;
            // Capabilities (DFS)
            buffer[8] = 0x08;
            buffer[9] = 0x00;

            }
        } else {
            // no password in tree connect
            this.passwordLength = 1;
        }

        dst[dstIndex] = this.disconnectTid ? (byte) 0x01 : (byte) 0x00;
        dstIndex++;
        dst[dstIndex++] = (byte) 0x00;
        SMBUtil.writeInt2(this.passwordLength, dst, dstIndex);
        return 4;
    }

    @SuppressWarnings("deprecation")

        // Then
        assertEquals(serverType, type);
    }

    @Test
    @DisplayName("Should handle browser service type")
    void testBrowserServiceType() {
        // Given
        int browserType = 0x01;
        when(mockNetbiosName.getNameType()).thenReturn(browserType);

        // When
        int type = mockNetbiosName.getNameType();

        // Then
        assertEquals(browserType, type);
    }

    // relative to headerStart
    static final int SETUP_OFFSET = 61;

    static final int DISCONNECT_TID = 0x01;
    static final int ONE_WAY_TRANSACTION = 0x02;

    private int pad;
    private int pad1;
    private boolean parametersDone, dataDone;

    /** Total number of parameter bytes the server is returning */

							<goal>report</goal>
						</goals>
					</execution>
				</executions>
			</plugin>
			<plugin>
				<groupId>org.apache.rat</groupId>
				<artifactId>apache-rat-plugin</artifactId>
				<version>0.16.1</version>
				<executions>
					<execution>
						<phase>verify</phase>
						<goals>
							<goal>check</goal>
						</goals>
					</execution>
				</executions>
				<configuration>

        case 0x0B:
            return "Subfolders and files only";
        case 0x02:
            return "This folder and subfolders";
        case 0x0A:
            return "Subfolders only";
        case 0x01:
            return "This folder and files";
        case 0x09:
            return "Files only";
        }
        return "Invalid";
    }

    @Override
    public int getAccessMask() {

    }

    /**
     * Test constructor with a malformed token.
     */
    @Test
    void testConstructorMalformed() {
        byte[] malformedToken = new byte[] { 0x01, 0x02, 0x03, 0x04 };
        assertThrows(PACDecodingException.class, () -> new KerberosEncData(malformedToken, Collections.emptyMap()));
    }

    /**
     * Test constructor with an unknown field.
     *

UTF-8-encoded bytes may represent a single integer value.  For
instance, the literal <code>'a'</code> holds a single byte representing
a literal <code>a</code>, Unicode U+0061, value <code>0x61</code>, while
<code>'ä'</code> holds two bytes (<code>0xc3</code> <code>0xa4</code>) representing
a literal <code>a</code>-dieresis, U+00E4, value <code>0xe4</code>.
</p>

<p>