import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

        ScriptEngineException exception = new ScriptEngineException(message, cause);

        // Verify stack trace exists
        StackTraceElement[] stackTrace = exception.getStackTrace();
        assertNotNull(stackTrace);
        assertTrue(stackTrace.length > 0);

        // Verify cause's stack trace is also available
        StackTraceElement[] causeStackTrace = exception.getCause().getStackTrace();

        // Act
        transPeekNamedPipe = new TransPeekNamedPipe(mockConfig, TEST_PIPE_NAME, fid);

        // Assert
        assertNotNull(transPeekNamedPipe);
        // FID is written in writeSetupWireFormat, verify it there
    }

    @Test
    @DisplayName("writeSetupWireFormat should write correct bytes")
    void testWriteSetupWireFormat() {
        // Arrange

        assertNotNull(logonInfo.getExtraSids());
        assertNotNull(logonInfo.getResourceGroupSids());

        // Verify mock interactions
        verify(logonInfo).getUserName();
        verify(logonInfo).getDomainName();
        verify(logonInfo).getServerName();
    }

    @Test
    @DisplayName("Test date conversion from FILETIME")
    void testFiletimeConversion() throws Exception {

            int bytesWritten = req.writeBytesWireFormat(buffer, 0);

            // Verify structure
            assertEquals(48, SMBUtil.readInt2(buffer, 0)); // Structure size
            assertEquals(1, SMBUtil.readInt2(buffer, 2)); // Lock count

            // Verify lock sequence (bits 4-7 are sequence number, bits 0-27 are index)
            int lockSequence = SMBUtil.readInt4(buffer, 4);

    public void test_execute_queryBuilderCreation() {
        // Execute the job
        purgeDocJob.execute();

        // Verify the query builder was created correctly
        assertNotNull(deleteQuery);
        assertTrue(deleteQuery instanceof RangeQueryBuilder);

        // Verify the range query parameters
        RangeQueryBuilder rangeQuery = (RangeQueryBuilder) deleteQuery;

import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

        // Create a spy to verify method call
        NetShareEnumResponse spyResponse = spy(new NetShareEnumResponse(mockConfig));

        setNumEntries(spyResponse, 0);
        byte[] buffer = new byte[100];

        spyResponse.readDataWireFormat(buffer, 0, buffer.length);

        // Verify setUseUnicode was called with false
        verify(spyResponse).setUseUnicode(false);
    }

    @Test

  private const val ALT_IPA_NAME = 7

  override fun verify(
    host: String,
    session: SSLSession,
  ): Boolean =
    if (!host.isAscii()) {
      false
    } else {
      try {
        verify(host, session.peerCertificates[0] as X509Certificate)
      } catch (_: SSLException) {
        false
      }
    }

  fun verify(
    host: String,
    certificate: X509Certificate,
  ): Boolean =

        // When & Then
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> {
            response.readBytesWireFormat(buffer, offset);
        });
    }

    @Test
    @DisplayName("Should verify inheritance from ServerMessageBlock2Response")
    void testInheritance() {
        // Then
        assertTrue(response instanceof ServerMessageBlock2Response);
        assertTrue(response instanceof ServerMessageBlock2);