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

     */
    public void setHeartbeatInterval(long heartbeatInterval) {
        this.heartbeatInterval = heartbeatInterval;
    }

    /**
     * Validates that the heartbeat response is correct.
     * The response sequence number should match the request sequence number.
     *
     * @return true if the response is valid
     */
    public boolean isValidResponse() {

        decoded.decode(buf);
        assertEquals(expected, decoded.value, "decoded value should match original after masking");
    }

    /**
     * Verify that encode writes the correct little-endian sequence
     * to the buffer and that alignment is respected.
     */
    @Test
    void encodeWritesCorrectBytesAndAlignment() throws NdrException {

        }
    }

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

        @ParameterizedTest
        @DisplayName("Should calculate correct size for various path lengths")
        @CsvSource({ "'', 4", "'a', 6", "'\\\\', 8", "'\\\\server', 20", "'\\\\server\\share', 32", "'\\\\server\\share\\path', 42",

            int terminationPos = Strings.findUNITermination(bufferWithTermination, 0, bufferWithTermination.length);

            // Then
            assertEquals(stringBytes.length, terminationPos, "Should find termination at correct position");
        }

        @Test
        @DisplayName("findUNITermination should throw exception when termination not found")
        void testFindUNITerminationNotFound() {
            // Given

        assertTrue(ex.getMessage().contains("failed"));
        verify(session).treeConnectLogon();
    }

    // Happy path: getSmbTree returns a tree and receives correct args
    @Test
    @DisplayName("getSmbTree returns tree and captures arguments")
    void getSmbTree_happy() {
        when(session.getSmbTree(anyString(), anyString())).thenReturn(tree);

      return super.toString();
    }

    private static final long serialVersionUID = 0;
  }

  /*
   * This is somewhat of a weak test; we verify that all of the methods are
   * correct, but not that they're actually forwarding correctly. We also rely
   * on the other tests (e.g., SynchronizedSetTest) to verify that the
   * collection views are synchronized correctly.
   */

  public void testSize() {

    }

    @Test
    @DisplayName("Should return correct cipher ID")
    void testGetCipherId() {
        // When
        int cipherId = encryptionContext.getCipherId();

        // Then
        assertEquals(1, cipherId, "Should return the cipher ID set in constructor");
    }

    @Test
    @DisplayName("Should return correct dialect version")
    void testGetDialect() {
        // When

            int offset = 64;
            Arrays.fill(largeData, (byte) 0x00);

            digest.sign(largeData, offset, 128, request, response);

            // Verify signature is placed at correct location
            byte[] signature = Arrays.copyOfRange(largeData, offset + SIGNATURE_OFFSET, offset + SIGNATURE_OFFSET + SIGNATURE_LENGTH);
            boolean hasNonZero = false;
            for (byte b : signature) {