}

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

    }

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

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

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

  }

  public void testImmutableTable() {
    assertFreshInstance(new TypeToken<ImmutableTable<String, Integer, ImmutableList<String>>>() {});
  }

  public void testList() {
    assertFreshInstance(new TypeToken<List<String>>() {});
    assertNotInstantiable(new TypeToken<List<EmptyEnum>>() {});
  }

  public void testArrayList() {

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

## Sobrepondo dependências durante os testes { #overriding-dependencies-during-testing }

Existem alguns cenários onde você deseje sobrepor uma dependência durante os testes.

Você não quer que a dependência original execute (e nenhuma das subdependências que você possa ter).