}

        @Test
        @DisplayName("Test read string length without termination throws exception")
        void testReadStringLengthNoTermination() {
            byte[] buffer = "TestTest".getBytes();

            assertThrows(RuntimeCIFSException.class, () -> {
                testBlock.readStringLength(buffer, 0, 3);
            });
        }
    }

    @Nested

        List<DuplicateHost> testList = new ArrayList<>();

        DuplicateHost testHost = new DuplicateHost();
        testHost.setRegularName("www.test.com");
        testHost.setDuplicateHostName("test.com");
        testList.add(testHost);

        helper.setDuplicateHostList(testList);

        assertEquals(testList, helper.duplicateHostList);

    /** */
    public static final int INT_DATA = 987654321;

    /** */
    public static final String STRING_DATA = "Hello World!";

    /**
     * @throws Exception
     */
    @Test
    public void testGet() throws Exception {
        final Field field = getClass().getField("objectField");
        final Integer testData = Integer.valueOf(123);
        FieldUtil.set(field, this, testData);

        assertThat(GenericsUtil.getGenericParameter(t2, 0), is(sameClass(String.class)));
    }

    /**
     * @throws Exception
     */
    public void testList() throws Exception {
        final Method m1 = ListType.class.getMethod("listOfString");
        final Type t1 = m1.getGenericReturnType();
        assertThat(GenericsUtil.isTypeOf(t1, List.class), is(true));

        } catch (final ClIndexOutOfBoundsException ex) {
            System.out.println(ex);
        }
    }

    /**
     * @throws Exception
     */
    @Test
    public void testGet() throws Exception {
        list.addLast("1");
        list.addLast("2");
        list.addLast("3");
        assertThat(list.get(0), is("1"));
        assertThat(list.get(1), is("2"));

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

    }

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