TransportException exception = new TransportException("Test exception");

        // Test inheritance chain
        assertTrue(exception instanceof TransportException);
        assertTrue(exception instanceof CIFSException);
        assertTrue(exception instanceof Exception);
        assertTrue(exception instanceof Throwable);

        // Test that it can be caught as CIFSException
        boolean caughtAsCIFSException = false;

        startLatch.countDown();

        // Wait for completion
        assertTrue(endLatch.await(10, TimeUnit.SECONDS), "All threads should complete");
        executor.shutdown();

        // Then - Session should be in consistent state
        // The double-check pattern should prevent inconsistent cleanup
        assertTrue(releaseCount.get() > 0 || acquireCount.get() > 0, "Release and acquire counts should be processed");

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.io.IOException;

import javax.security.auth.kerberos.KerberosKey;

import org.bouncycastle.asn1.ASN1Encodable;
import org.bouncycastle.asn1.ASN1EncodableVector;

        byte[] b = new byte[] { 1, 2, 3 };
        SecurityBlob left = new SecurityBlob(a);
        SecurityBlob right = new SecurityBlob(b);

        // Act & Assert
        assertTrue(left.equals(right), "Blobs with equal content should be equal");
        assertTrue(right.equals(left), "Equality should be symmetric for identical content");
    }

    // Demonstrates observed equals() asymmetry when this is shorter than argument
    @Test

            // Assert message indicates which validation failed
            if (expectDirSlashMsg) {
                assertTrue(ex.getMessage().contains("directory must end with '/'"),
                        "Expected trailing slash message, was: " + ex.getMessage());
            } else {
                assertTrue(ex.getMessage().contains("invalid") || ex.getMessage().contains("invalid:"),

        data.setResponseBody(content);

        assertTrue(data.hasResponseBody());
        assertNotNull(data.getResponseBody());

        try (InputStream is = data.getResponseBody()) {
            byte[] buffer = new byte[content.length];
            int bytesRead = is.read(buffer);
            assertEquals(content.length, bytesRead);
            assertTrue(Arrays.equals(content, buffer));
        } catch (IOException e) {

            SID sid = new SID(buildSidT((byte) 1, ident, 7, 8), jcifs.SID.SID_TYPE_USE_NONE, null, null, false);
            String s = sid.toString();
            assertTrue(s.startsWith("S-1-0x010203040506"));
            assertTrue(s.endsWith("-7-8"));
        }

        @Test
        @DisplayName("equals and hashCode for equal and non-equal SIDs")
        void testEqualsAndHashCode() throws Exception {

        assertEquals("test-channel", state.getChannelId());
        assertEquals(0, state.getRetryCount());
        assertTrue(state.shouldRetry());
        assertTrue(state.getFailureTime() > 0);
        assertTrue(state.getNextRetryTime() > state.getFailureTime());
    }

    @Test
    void testFailoverStateRetryLogic() {

import static org.junit.jupiter.api.Assertions.assertTrue;

/**
 * Unit tests for the Features class.
 */
class FeaturesTest {

    @Test
    void testDeployBuildPomDefaultValue() {
        // Test that deployBuildPom returns true by default (when property is not set)
        Map<String, Object> emptyProperties = Map.of();
        assertTrue(Features.deployBuildPom(emptyProperties));

    assertTrue(table.containsRow("foo"));
    assertTrue(table.containsRow("bar"));
    assertFalse(table.containsRow("cat"));
    assertFalse(table.containsRow(null));
  }

  public void testContainsColumn() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    assertTrue(table.containsColumn(1));
    assertTrue(table.containsColumn(3));