private byte[] testResponseBuffer;
    private SmbNegotiation negotiation;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        testRequestBuffer = new byte[] { 0x01, 0x02, 0x03, 0x04 };
        testResponseBuffer = new byte[] { 0x05, 0x06, 0x07, 0x08 };
        negotiation = new SmbNegotiation(mockRequest, mockResponse, testRequestBuffer, testResponseBuffer);
    }

    @Test

		if !ok {
			t.Fatal("Unexpected error expecting 0x91")
		}
	}
	if runtime.GOOS == globalWindowsOSName {
		pathErr = &os.PathError{Err: syscall.Errno(0x03)}
		ok = isSysErrPathNotFound(pathErr)
		if !ok {
			t.Fatal("Unexpected error expecting 0x03")
		}
	}

     * The constructor should only use the first 8/32 bytes.
     */
    @Test
    void testAvSingleHostCustomDataMachineIdConstructor_LongerInputs() {
        byte[] customData = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A }; // Longer than 8
        byte[] machineId = new byte[40]; // Longer than 32
        for (int i = 0; i < 40; i++) {
            machineId[i] = (byte) i;
        }

            if (tempStr != null) {
                tempStr.intern();
            }
        }
    }

    // KGS!@#$%
    static final byte[] S8 = { (byte) 0x4b, (byte) 0x47, (byte) 0x53, (byte) 0x21, (byte) 0x40, (byte) 0x23, (byte) 0x24, (byte) 0x25 };

    /*
     * Accepts key multiple of 7
     * Returns enc multiple of 8
     * Multiple is the same like: 21 byte key gives 24 byte result
     */

class AvPairTest {

    @Test
    void testConstructorAndGetters() {
        // Test with a valid type and raw data
        int type = AvPair.MsvAvTimestamp;
        byte[] raw = new byte[] { 0x01, 0x02, 0x03, 0x04 };
        AvPair avPair = new AvPair(type, raw);

        assertEquals(type, avPair.getType(), "Type should match the constructor argument.");

        byte[] data = new byte[] { 0x01, 0x02, 0x03, 0x04 };

        assertDoesNotThrow(() -> digest.update(data, 0, data.length));
    }

    @Test
    @DisplayName("Test update method with zero length")
    void testUpdateWithZeroLength() {
        SMB1SigningDigest digest = new SMB1SigningDigest(testMacSigningKey);
        byte[] data = new byte[] { 0x01, 0x02, 0x03, 0x04 };

	// write "ReplicaSize"
	err = en.Append(0x83, 0xab, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x69, 0x7a, 0x65)
	if err != nil {
		return
	}
	err = en.WriteInt64(z.ReplicaSize)
	if err != nil {
		err = msgp.WrapError(err, "ReplicaSize")
		return
	}
	// write "ReplicaCount"
	err = en.Append(0xac, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x43, 0x6f, 0x75, 0x6e, 0x74)
	if err != nil {
		return

    assertWellFormed(0x00, 0x61, 0x62, 0x63, 0x7F); // "\u0000abc\u007f"
    // Two-byte characters
    assertWellFormed(0xC2, 0xA2, 0xC2, 0xA2); // "\u00a2\u00a2"
    // Three-byte characters
    assertWellFormed(0xc8, 0x8a, 0x63, 0xc8, 0x8a, 0x63); // "\u020ac\u020ac"
    // Four-byte characters
    // "\u024B62\u024B62"
    assertWellFormed(0xc9, 0x8b, 0x36, 0x32, 0xc9, 0x8b, 0x36, 0x32);
    // Mixed string

        // State 1: Generate Type 1 message
        context.initSecContext(new byte[0], 0, 0);

        // Create a mock Type 2 message (server challenge)
        byte[] serverChallenge = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
        int type2Flags = NtlmFlags.NTLMSSP_NEGOTIATE_NTLM | NtlmFlags.NTLMSSP_REQUEST_TARGET | NtlmFlags.NTLMSSP_NEGOTIATE_KEY_EXCH
                | NtlmFlags.NTLMSSP_NEGOTIATE_SIGN;

        assertEquals(0x03, readOnlyHidden);
    }

    @Test
    @DisplayName("Should validate access mask combinations")
    void testAccessMaskCombinations() {
        // Test common access combinations
        int readWriteAccess = SmbConstants.FILE_READ_DATA | SmbConstants.FILE_WRITE_DATA;
        assertEquals(0x03, readWriteAccess);

        int fullFileAccess =