when(mockInetAddress.getHostName()).thenReturn("h.ostname");
            UniAddress uniAddress = new UniAddress(mockInetAddress);
            // Dot at position 1, which is NOT > 1, so it doesn't substring, just uppercase
            assertEquals("H.OSTNAME", uniAddress.firstCalledName());
        }
    }

    @Nested
    @DisplayName("nextCalledName method tests")

    }
  }

  /** Returns true if [certificate] matches [hostname]. */
  private fun verifyHostname(
    hostname: String,
    certificate: X509Certificate,
  ): Boolean {
    val hostname = hostname.asciiToLowercase()
    return getSubjectAltNames(certificate, ALT_DNS_NAME).any {
      verifyHostname(hostname, it)
    }
  }

  /**

			sortedIPList: []string{"hostname", "192.168.1.106", "127.0.0.1"},
		},
		// Non parsable ip is assumed to be hostname, with a mixed input of ip and hostname.
		// gets preserved and moved into left most elements, regardless of
		// IP based sorting.
		{
			ipList:       []string{"hostname1", "10.0.0.13", "hostname2", "127.0.0.1", "192.168.1.106"},

     * a literal IP address, or a hostname pattern. If no subject alternative names are added that
     * extension will be omitted.
     */
    fun addSubjectAlternativeName(altName: String) =
      apply {
        altNames += altName
      }

    /**
     * Set this certificate's common name (CN). Historically this held the hostname of TLS

        }
    }

    // Test with different hostnames
    @Test
    public void test_differentHostnames() {
        String[] hostnames = { "smtp.gmail.com", "mail.example.com", "localhost", "192.168.1.1" };

        for (String hostname : hostnames) {
            ComponentUtil.setFessConfig(new FessConfig.SimpleImpl() {

        // Verify all values are set correctly
        assertEquals(TEST_NET_NAME, info.getName());
        assertEquals(SmbConstants.TYPE_SHARE, info.getType());
        assertNotNull(info.toString());
        assertTrue(info.toString().contains(TEST_NET_NAME));
        assertTrue(info.toString().contains(TEST_REMARK));
    }

    @Test
    @DisplayName("Test getName method")
    void testGetName() {
        // Default constructor

        String netName = "SHARE";
        int type = 1;
        String remark = "remark";
        instance = new SmbShareInfo(netName, type, remark);
        assertEquals(netName, instance.getName());
        // Note: getType() transforms the raw type
        assertEquals(SmbFile.TYPE_PRINTER, instance.getType());
    }

    /**
     * Test of getName method, of class SmbShareInfo.
     */
    @Test

    private static boolean isAllDigits(final String hostname) {
        for (int i = 0; i < hostname.length(); i++) {
            if (!Character.isDigit(hostname.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    @Override
    public UniAddress getByName(final String hostname) throws UnknownHostException {
        return getByName(hostname, false);
    }

    @Override

 * crawling from duplicate hostnames to the regular canonical hostname.
 */
public class CreateForm {

    /**
     * Creates a new CreateForm instance.
     */
    public CreateForm() {
    }

    /** The CRUD operation mode for form processing */
    @ValidateTypeFailure
    public Integer crudMode;

    /** The regular canonical hostname that should be used */
    @Required

        assertEquals("DiskShare", entries[0].getName());
        assertEquals(8, entries[0].getType()); // TYPE_SHARE

        // Verify printer share
        assertEquals("PrinterShare", entries[1].getName());
        assertEquals(32, entries[1].getType()); // TYPE_PRINTER (0x20)

        // Verify named pipe
        assertEquals("PipeShare", entries[2].getName());