assertEquals("NEXT", next, "nextCalledName should delegate to NbtAddress when called");
    }

    @Test
    void nextCalledNameWithInetAddressReturnsSMBSERVERFirstIfNotDefault() {
        // Arrange
        InetAddress addr = mock(InetAddress.class);
        when(addr.getHostName()).thenReturn("mycomputer.foo.com");
        UniAddress ua = new UniAddress(addr);
        // Act: first call should set to SMBSERVER_NAME

    }

    @Test
    @DisplayName("DCE/RPC flags should be set correctly")
    void testDcerpcFlags() {
        // Test individual flag checking
        assertTrue(dfsRootEnum.isFlagSet(DcerpcConstants.DCERPC_FIRST_FRAG));
        assertTrue(dfsRootEnum.isFlagSet(DcerpcConstants.DCERPC_LAST_FRAG));

        // Combined flags should equal FIRST_FRAG | LAST_FRAG

                assertEquals((byte) 0xFF, buffer[startIndex + SOURCE_KEY_SIZE + 4 + i],
                        "Reserved byte at position " + i + " should remain unchanged");
            }
        }

        @Test
        @DisplayName("Should encode single chunk data correctly")
        void testEncodeSingleChunk() {
            // Given
            SrvCopychunk chunk = new SrvCopychunk(1024, 2048, 4096);

        assertNotNull("Encoded result should not be null", encoded);
        final byte[] decoded = Base64Util.decode(encoded);
        assertEquals("Decoded should have same length", 2, decoded.length);
        assertEquals("First byte should match", twoBytes[0], decoded[0]);
        assertEquals("Second byte should match", twoBytes[1], decoded[1]);
    }

    /**

        // Then
        assertNotNull(result);
        assertTrue(result.length > 0, "HMAC-T64 should produce non-empty result");
    }

    @Test
    @DisplayName("Should perform RC4 encryption/decryption")
    void testRC4() throws Exception {
        // Given
        byte[] key = "testkey123456789".getBytes(); // 16 bytes
        byte[] plaintext = "This is a test message for RC4".getBytes();

        // When

            request.writeBytesWireFormat(buffer, i * 10);
        }

        // Then - all should have same structure size
        for (int i = 0; i < 10; i++) {
            assertEquals(4, SMBUtil.readInt2(buffer, i * 10));
        }
    }

    @Test
    @DisplayName("Should handle null configuration gracefully in response creation")
    void testCreateResponseWithNullConfig() {
        // Given

        assertTrue(config.isUseUnicode(), "Unicode should be enabled");
        assertTrue(config.isUseBatching(), "Batching should be enabled");

        // When both are enabled, batch limits should be available
        int limit = config.getBatchLimit("TreeConnectAndX.QueryInformation");
        assertTrue(limit >= 0, "Batch limit should be non-negative when Unicode and batching enabled");
    }

    /**

            // key3 should definitely exist (just created)
            assertNotNull(limitedManager.getLease(key3));

            // key1 should have been evicted (oldest)
            assertNull(limitedManager.getLease(key1));

            // key2 should still exist (not the oldest)
            assertNotNull(limitedManager.getLease(key2));
        } finally {

    }

    @Test
    @DisplayName("Constructor with Configuration only should create empty Name instances")
    void testConstructorWithConfigOnly() {
        SessionRequestPacket packet = new SessionRequestPacket(mockConfig);

        assertNotNull(packet);
        // The packet should have calledName and callingName initialized but empty
        byte[] dst = new byte[256];

    class ConstructorTests {

        @Test
        @DisplayName("Should create handler with default constructor")
        void testDefaultConstructor() {
            // When
            Handler testHandler = new Handler();

            // Then
            assertNotNull(testHandler);
        }

        @Test
        @DisplayName("Should extend jcifs.smb1.http.Handler")
        void testInheritance() {