// Then
            assertNotNull(chunk);
        }
    }

    @Nested
    @DisplayName("Size Method Tests")
    class SizeTests {

        @Test
        @DisplayName("Should return correct size of 24 bytes")
        void testSize() {
            // Given
            SrvCopychunk chunk = new SrvCopychunk(0, 0, 0);

            // When
            int size = chunk.size();

            // Then

        int bytesRead = response.readDataWireFormat(buffer, 0, buffer.length);

        assertTrue(bytesRead > 0);
        assertNotNull(response.getInfo());

        // Verify the correct type was created
        if (infoLevel == FileInformation.FILE_BASIC_INFO) {
            assertTrue(response.getInfo() instanceof FileBasicInfo);
        } else if (infoLevel == FileInformation.FILE_STANDARD_INFO) {

        int written = trans2QueryPathInfo.writeParametersWireFormat(buffer, 0);

        // Should write the entire path
        assertTrue(written > longPath.length());

        // Check information level is still correct
        int actualInfoLevel = SMBUtil.readInt2(buffer, 0);
        assertEquals(0x0101, actualInfoLevel);
    }

    @Test
    void testWriteParametersWithSpecialCharacters() {

    }

    @Test
    @DisplayName("ensureDFSResolved forwards to tree connection with locator")
    void ensureDFSResolvedDelegates() throws Exception {
        // Confirms DFS resolution is delegated with the correct locator
        // Act
        handle.ensureDFSResolved();
        // Assert & interaction verify
        verify(treeConnection).ensureDFSResolved(resourceLoc);
    }

    @Test

        assertEquals(testDialect, response.getDialect(), "Dialect should match");
    }

    @Test
    @DisplayName("Test decode returns correct bytes consumed")
    void testDecodeBytesConsumed() throws SMBProtocolDecodingException {
        // Prepare minimal buffer
        byte[] buffer = new byte[24];

        // Test with offset 0

 * </pre>
 * the access check would fail because the direct ACE has an access mask
 * of <code>0x001200A9</code> which doesn't have the
 * <code>FILE_WRITE_DATA</code> bit on (bit <code>0x00000002</code>). Actually, this isn't quite correct. If
 * <code>WNET\alice</code> is in the local <code>Administrators</code> group the access check
 * will succeed because the inherited ACE allows local <code>Administrators</code>

            populatedArray.s[i] = entry;
        }

        // Replace the info.e field with our populated array
        setDfsEnumArray(dfsRootEnum, populatedArray);

        // Test getEntries returns correct SmbShareInfo objects
        FileEntry[] entries = dfsRootEnum.getEntries();
        assertNotNull(entries);
        assertEquals(3, entries.length);

        // Verify each entry
        for (int i = 0; i < 3; i++) {

        String id = "test-id";
        SuggestSettings settings = builder.build(client, id);

        assertNotNull(settings);
        // Verify that the settings object was created with the correct parameters
        // Note: We can't directly verify internal state of SuggestSettings without getters,
        // but we can verify it was created successfully
    }

    @Test

            // Assert
            verify(signingDigest).sign(largeData, offset, 10, request, response);
        }

        // Verify method was called correct number of times
        verify(signingDigest, times(offsets.length)).sign(any(byte[].class), anyInt(), anyInt(), any(CommonServerMessageBlock.class),
                any(CommonServerMessageBlock.class));
    }

    @Test

    @ValueSource(ints = { -1, 0, 13, 15, 99 })
    @DisplayName("seq ctor: invalid msgType values throw")
    void sequenceConstructor_invalidMsgType_throws(int badType) throws Exception {
        // Arrange: correct version, wrong msg type
        ASN1EncodableVector v = new ASN1EncodableVector();
        v.add(new DERTaggedObject(true, 0, new ASN1Integer(Integer.parseInt(KerberosConstants.KERBEROS_VERSION))));