stubValidTree(1L, true, true);

        byte[] fidBytes = new byte[] { 0x01, 0x02 };
        SmbFileHandleImpl h1 = new SmbFileHandleImpl(cfg, fidBytes, tree, "//u/one", 0x10, 0x20, 0x30, 0x40, 0L);
        String s1 = h1.toString();
        assertTrue(s1.contains("//u/one"));
        assertTrue(s1.contains("0102"), "Expected hex fileId in string");

            when(mockFileSystemInfo.decode(any(byte[].class), anyInt(), anyInt())).thenReturn(24);

            int result = mockFileSystemInfo.decode(buffer, 0, 100);

            assertEquals(24, result);
            verify(mockFileSystemInfo, times(1)).decode(buffer, 0, 100);
        }

        @Test
        @DisplayName("Should handle decode exception")
        void testDecodeException() throws SMBProtocolDecodingException {

    void testReadSetupWireFormat() {
        // Test that readSetupWireFormat always returns 0
        byte[] buffer = new byte[100];
        int result = response.readSetupWireFormat(buffer, 0, 100);
        assertEquals(0, result);

        // Test with different parameters
        result = response.readSetupWireFormat(buffer, 10, 50);
        assertEquals(0, result);

        // Test with zero length

 *
 * @author mbechler
 */
public class Trans2FindFirst2 extends SmbComTransaction {

    // flags

    static final int FLAGS_CLOSE_AFTER_THIS_REQUEST = 0x01;
    static final int FLAGS_CLOSE_IF_END_REACHED = 0x02;
    static final int FLAGS_RETURN_RESUME_KEYS = 0x04;
    static final int FLAGS_RESUME_FROM_PREVIOUS_END = 0x08;
    static final int FLAGS_FIND_WITH_BACKUP_INTENT = 0x10;

    private final int searchAttributes;

            request.setFileId(testFileId);
            request.setData(data, 512, 1024);
            request.setOffset(4096L);
            request.setRemainingBytes(2048);
            request.setWriteFlags(0x02);

            // Calculate expected size
            int expectedSize = ((Smb2Constants.SMB2_HEADER_LENGTH + 48 + 1024 + 7) / 8) * 8;
            assertEquals(expectedSize, request.size());

@NullUnmarked
public class FileBackedOutputStreamTest extends IoTestCase {


  public void testThreshold() throws Exception {
    testThreshold(0, 100, true, false);
    testThreshold(10, 100, true, false);
    testThreshold(100, 100, true, false);
    testThreshold(1000, 100, true, false);
    testThreshold(0, 100, false, false);
    testThreshold(10, 100, false, false);
    testThreshold(100, 100, false, false);

            response.setDigest(mockDigest);
            when(mockDigest.verify(buffer, 0, 100, 0, response)).thenReturn(false);

            boolean result = response.verifySignature(buffer, 0, 100);

            assertTrue(result);
            assertFalse(response.isVerifyFailed());
        }

        @Test
        @DisplayName("Should handle signature verification failure")

            when(mockConfig.isRequireSecureNegotiate()).thenReturn(true);
            when(mockDigest.verify(buffer, 0, 100, 0, echoResponse)).thenReturn(false);

            boolean result = echoResponse.verifySignature(buffer, 0, 100);

            assertTrue(result);
            assertFalse(echoResponse.isVerifyFailed());
            verify(mockDigest).verify(buffer, 0, 100, 0, echoResponse);
        }

        @Test

        byte[] rawData = new byte[48]; // 8 (size/zero) + 8 (customData) + 32 (machineId)
        // Simulate some data
        rawData[0] = 48; // size
        rawData[16] = 0x01; // machineId start
        rawData[17] = 0x02;

        AvSingleHost avSingleHost = new AvSingleHost(rawData);

        assertNotNull(avSingleHost);
        assertEquals(AvPair.MsvAvSingleHost, avSingleHost.getType());

        assertFalse(key.isZero());
    }

    @Test
    @DisplayName("Should create lease key from byte array")
    void testLeaseKeyFromBytes() {
        byte[] testBytes = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10 };

        Smb2LeaseKey key = new Smb2LeaseKey(testBytes);

        assertArrayEquals(testBytes, key.getKey());