Helpers.testComparator(comparator, ordered);
  }

  public void testSort() {
    testSort(new int[] {}, new int[] {});
    testSort(new int[] {2}, new int[] {2});
    testSort(new int[] {2, 1, 0}, new int[] {0, 1, 2});
    testSort(new int[] {2, GREATEST, 1, LEAST}, new int[] {LEAST, 1, 2, GREATEST});
  }

  static void testSort(int[] input, int[] expected) {
    input = Arrays.copyOf(input, input.length);

    assertThat(comparator2.compare(a0, b0)).isLessThan(0);
  }

  public void testSort() {
    testSort(new byte[] {}, new byte[] {});
    testSort(new byte[] {2}, new byte[] {2});
    testSort(new byte[] {2, 1, 0}, new byte[] {0, 1, 2});
    testSort(new byte[] {2, GREATEST, 1, LEAST}, new byte[] {LEAST, 1, 2, GREATEST});
  }

  static void testSort(byte[] input, byte[] expected) {
    input = Arrays.copyOf(input, input.length);

    }

    @Test
    void testGetNbtAllByAddress_StringIntString() throws UnknownHostException {
        // Arrange
        String host = "testHost";
        int type = 0x20;
        String scope = "testScope";
        NetbiosAddress[] expectedAddresses = { mock(NetbiosAddress.class) };

            writer.write("192.168.1.100 TESTHOST\n");
            writer.write("10.0.0.1      SERVER01\n");
        }

        when(mockConfig.getLmHostsFileName()).thenReturn(lmhostsFile.getAbsolutePath());

        // Test first host
        NbtAddress result = lmhosts.getByName("TESTHOST", mockContext);
        assertNotNull(result);
        assertEquals("TESTHOST", result.getHostName());

        // Test second host

     */
    @Test
    public void testConcurrentTreeOperationsThreadSafe() throws Exception {
        // Given
        SmbSessionImpl session = new SmbSessionImpl(mockContext, "testhost", "testdomain", mockTransport);

        int threadCount = 10;
        int opsPerThread = 100;
        ExecutorService executor = Executors.newFixedThreadPool(threadCount);

        assertFalse(robotsTxt.allows("/valid1/", "TestBot"));
        assertFalse(robotsTxt.allows("/valid2/", "TestBot"));
        assertTrue(robotsTxt.allows("/valid3/", "TestBot"));
        assertFalse(robotsTxt.allows("/valid4/", "TestBot"));
    }

    public void testParse_emptyValues() {
        String robotsTxtContent = "User-agent: TestBot\n" + "Disallow:\n" + "Allow:\n" + "Crawl-delay:\n";

    /**
     * Test basic session lifecycle management
     */
    @Test
    @Timeout(5)
    public void testSessionLifecycle() throws Exception {
        SmbSessionImpl session = new SmbSessionImpl(mockContext, "testhost", "testdomain", mockTransport);

        // Test initial state - session starts with usage count > 0 due to transport.acquire()
        assertTrue(session.isInUse(), "New session should be in use due to transport acquisition");

        // Test the constructor with minimal parameters
        mockName = new Name(mockConfig, "TESTHOST", 0x20, null);
        NbtAddress nbtAddress = new NbtAddress(mockName, testAddressInt, false, NbtAddress.H_NODE);

        assertNotNull(nbtAddress);
        assertEquals("TESTHOST", nbtAddress.getHostName());
        assertArrayEquals(new byte[] { (byte) 192, (byte) 168, (byte) 1, (byte) 1 }, nbtAddress.getAddress());

    private SmbTransport transport;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        // Setup transport fields that are accessed directly
        transport.tconHostName = "testHost";
        // Setup session.transport field (accessed directly in SmbTree)
        session.transport = transport;
        // Setup session to return transport via method call

 */
public class RdmaIntegrationTest {

    private String testServer;
    private int testPort;
    private CIFSContext testContext;

    @BeforeEach
    public void setUp() throws Exception {
        testServer = System.getProperty("rdma.test.server");
        String portStr = System.getProperty("rdma.test.port", "445");
        testPort = Integer.parseInt(portStr);

        // Create RDMA-enabled context