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() {

@ExtendWith(MockitoExtension.class)
public class SmbCopyUtilTest {

    // --- Tests for openCopyTargetFile ---

    @ParameterizedTest
    @ValueSource(booleans = { true, false })
    @DisplayName("openCopyTargetFile sets correct access flags depending on alsoRead")
    void openCopyTargetFile_accessMask_respectsAlsoRead(boolean alsoRead) throws Exception {
        // Arrange
        SmbFile dest = mock(SmbFile.class);

        verify(transport).ensureConnected();
    }

    // Happy path: getDfsReferrals returns referral, verify arguments captured
    @Test
    @DisplayName("getDfsReferrals returns data and receives correct args")
    void getDfsReferrals_happy() throws Exception {
        when(transport.getDfsReferrals(any(), any(), any(), any(), anyInt())).thenReturn(referral);

Vamos imaginar que o carregamento do modelo pode **demorar bastante tempo**, porque ele precisa ler muitos **dados do disco**. Então você não quer fazer isso a cada requisição.

 *
 * 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>

        // Then
        assertNotNull(transCallNamedPipe);
        assertEquals(TEST_PIPE_NAME, transCallNamedPipe.name);
    }

    @Test
    @DisplayName("Test writeSetupWireFormat writes correct bytes")
    void testWriteSetupWireFormat() {
        // Given
        transCallNamedPipe = new TransCallNamedPipe(mockConfig, TEST_PIPE_NAME, TEST_DATA, 0, TEST_DATA.length);
        byte[] dst = new byte[10];

            // Verify correctness
            assertTrue(result.success(), "Result should be successful");
            assertEquals(largePomSet.size(), result.processedCount(), "Should have correct processed count");
        }
    }

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

        void setUp() {
            mockConfig = mock(Configuration.class);
            when(mockConfig.getPid()).thenReturn(12345);
        }

        @Test
        @DisplayName("Should initialize with correct command and MID")
        void testConstructorInitialization() throws Exception {
            // Given
            int testMid = 42;

            // When