when(mockInetAddress.getHostName()).thenReturn("inet-host");
            UniAddress uniAddress = new UniAddress(mockInetAddress);
            assertEquals("inet-host", uniAddress.getHostName());
        }

        @Test
        void shouldReturnNbtAddressHostnameWhenWrappedIsNbtAddress() {
            when(mockNbtAddress.getHostName()).thenReturn("nbt-host");

        // Test getHostName when hostname is known
        mockName = new Name(mockConfig, "KNOWNHOST", 0x20, null);
        NbtAddress nbtAddress = new NbtAddress(mockName, testAddressInt, false, NbtAddress.H_NODE);
        assertEquals("KNOWNHOST", nbtAddress.getHostName());
    }

    @Test
    void testGetHostName_UnknownHost() {
        // Test getHostName when hostname is unknown, should return IP address

        for (final FileAuthentication fileAuth : fileAuthList) {
            if (logger.isDebugEnabled()) {
                logger.debug("FileAuthentication: " + fileAuth.getProtocolScheme() + " " + fileAuth.getHostname() + ":" + fileAuth.getPort()
                        + " " + fileAuth.getUsername());
            }
            if (Constants.SAMBA.equals(fileAuth.getProtocolScheme())) {

        when(mockContext.getNameServiceClient()).thenReturn(mockNameServiceClient);
        when(mockNameServiceClient.getLocalHost()).thenReturn(mockHost);
        when(mockHost.getHostName()).thenReturn(TEST_HOSTNAME);
        when(mockConfig.getDefaultDomain()).thenReturn(TEST_DOMAIN);
        when(mockConfig.isUseUnicode()).thenReturn(true);

        return mockContext;
    }

    @Nested

     *
     * @return the hostname of this address
     */

    public String getHostName() {
        if (addr instanceof NbtAddress) {
            return ((NbtAddress) addr).getHostName();
        }
        return ((InetAddress) addr).getHostName();
    }

    /**
     * Return the IP address as text such as "192.168.1.15".
     *

        assertNotNull(result);
        assertEquals("TESTHOST", result.getHostName());

        // Test second host
        result = lmhosts.getByName("SERVER01", mockContext);
        assertNotNull(result);
        assertEquals("SERVER01", result.getHostName());
    }

    @Test
    void testGetByNameCaching() throws IOException {
        // Create a temporary lmhosts file

                if (this.getNameType() == 0x1D) {
                    for (final NetbiosAddress addr : addrs) {
                        if (addr.getNameType() == 0x20) {
                            return addr.getHostName();
                        }
                    }
                    return null;
                }
                if (this.isDataFromNodeStatus) {
                    /*

        when(config.isIpcSigningEnforced()).thenReturn(true);
        when(config.getLogonShare()).thenReturn("IPC$");

        // Default address values
        when(address.getHostName()).thenReturn("test.host");
        when(address.getHostAddress()).thenReturn("192.168.1.100");
    }

    @Test
    @DisplayName("Should distinguish between pooled and non-pooled connections")

        lenient().when(mockCtx.getNameServiceClient()).thenReturn(mockNameServiceClient);
        lenient().when(mockNameServiceClient.getLocalHost()).thenReturn(mockHost);
        lenient().when(mockHost.getHostName()).thenReturn("TEST_HOSTNAME");

        return mockCtx;
    }

    @Test
    @DisplayName("Should create Type 3 message with authentication data")
    void testType3MessageCreation() throws Exception {

                (et, vl) -> ((WebAuthentication) et).setCreatedTime(DfTypeUtil.toLong(vl)), "createdTime");
        setupEpg(_epgMap, et -> ((WebAuthentication) et).getHostname(),
                (et, vl) -> ((WebAuthentication) et).setHostname(DfTypeUtil.toString(vl)), "hostname");
        setupEpg(_epgMap, et -> ((WebAuthentication) et).getParameters(),