} else {
                            postcard.addTo(fessConfig.getMailFromAddress());
                            postcard.dryrun();
                        }
                        postcard.setHostname(systemHelper.getHostname());
                        postcard.setClustername(ping.getClusterName());
                        postcard.setClusterstatus(ping.getClusterStatus());
                    });

                (et, vl) -> ((FileAuthentication) et).setFileConfigId(DfTypeUtil.toString(vl)), "fileConfigId");
        setupEpg(_epgMap, et -> ((FileAuthentication) et).getHostname(),
                (et, vl) -> ((FileAuthentication) et).setHostname(DfTypeUtil.toString(vl)), "hostname");
        setupEpg(_epgMap, et -> ((FileAuthentication) et).getParameters(),

                    connector.setProperty("SSLEnabled", "true");
                    final SSLHostConfig sslHostConfig = new SSLHostConfig();
                    sslHostConfig.setHostName("_default_");
                    final SSLHostConfigCertificate certificate =
                            new SSLHostConfigCertificate(sslHostConfig, SSLHostConfigCertificate.Type.UNDEFINED);

            }

            String hostname = fessConfig.getMailHostname();
            if (StringUtil.isBlank(hostname)) {
                hostname = ComponentUtil.getSystemHelper().getHostname();
            }
            dataMap.put("hostname", hostname);

            logger.debug("\ninfoMap: {}\ndataMap: {}", infoMap, dataMap);

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

            @Override
            public boolean isChangedClusterState(int status) {
                // State has changed
                return true;
            }

            @Override
            public String getHostname() {
                return "test-hostname";
            }
        };

        FessConfig fessConfig = createTestFessConfig();

        // Register components

    }

    @Test
    @DisplayName("getHostName should return valid hostname or address")
    void testGetHostNameContract() {
        // Given
        String expectedHostName = "server.example.com";
        when(mockAddress.getHostName()).thenReturn(expectedHostName);

        // When
        String hostName = mockAddress.getHostName();

        // Then

     *
     * @return the hostname associated with the address
     */
    @Override
    public String getHostName() {
        if (this.addr instanceof NbtAddress) {
            return ((NbtAddress) this.addr).getHostName();
        }
        return ((InetAddress) this.addr).getHostName();
    }

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

    }

    @Test
    void getHostNameDelegatesToWrappedInetAddress() {
        InetAddress dummy = mock(InetAddress.class);
        when(dummy.getHostName()).thenReturn("host.example.com");
        UniAddress ua = new UniAddress(dummy);
        assertEquals("host.example.com", ua.getHostName(), "should forward hostName to underlying InetAddress");
    }

    @Test
    void getHostAddressDelegatesToWrappedInetAddress() {

        verify(nameServiceClient, times(1)).getNodeStatus(nbtAddress);
    }

    @Test
    void testGetAllByName() throws UnknownHostException {
        // Arrange
        String hostname = "testHostname";
        boolean possibleNTDomainOrWorkgroup = true;
        Address[] expectedAddresses = { mock(Address.class) };