*/
    public static UniAddress getByName(final String hostname) throws UnknownHostException {
        return getByName(hostname, false);
    }

    static boolean isDotQuadIP(final String hostname) {
        if (hostname != null && hostname.length() > 0 && Character.isDigit(hostname.charAt(0))) {
            int i, len, dots;
            char[] data;

            i = dots = 0; /* quick IP address validation */

      }
    }

    return lookupHttps(hostname)
  }

  @Throws(UnknownHostException::class)
  private fun lookupHttps(hostname: String): List<InetAddress> {
    val networkRequests =
      buildList {
        add(client.newCall(buildRequest(hostname, DnsRecordCodec.TYPE_A)))

        if (includeIPv6) {
          add(client.newCall(buildRequest(hostname, DnsRecordCodec.TYPE_AAAA)))
        }
      }

    }

    @Test
    void testGetByName_String() throws UnknownHostException {
        // Arrange
        String hostname = "testHostname";
        Address expectedAddress = mock(Address.class);
        when(nameServiceClient.getByName(hostname)).thenReturn(expectedAddress);

        // Act
        Address actualAddress = nameServiceClient.getByName(hostname);

    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

    static final class CacheEntry {
        Name hostName;
        NbtAddress address;
        long expiration;

        CacheEntry(final Name hostName, final NbtAddress address, final long expiration) {
            this.hostName = hostName;
            this.address = address;
            this.expiration = expiration;
        }
    }

    /**
     * Lookup addresses for the given <code>hostname</code>.
     *
     * @param hostname the hostname to resolve
     * @param possibleNTDomainOrWorkgroup if true, perform additional master browser lookup
     * @return found addresses
     * @throws UnknownHostException if the hostname cannot be resolved
     */
    Address[] getAllByName(String hostname, boolean possibleNTDomainOrWorkgroup) throws UnknownHostException;

    Name hostName;
    int address, nodeType;
    boolean groupName, isBeingDeleted, isInConflict, isActive, isPermanent, isDataFromNodeStatus;
    byte[] macAddress;
    String calledName;

    NbtAddress(final Name hostName, final int address, final boolean groupName, final int nodeType) {
        this.hostName = hostName;
        this.address = address;

        .serialNumber(2L)
        .commonName(server.hostName)
        .addSubjectAlternativeName(server.hostName)
        .addSubjectAlternativeName("san.com")
        .addSubjectAlternativeName("*.wildcard.com")
        .addSubjectAlternativeName("differentdns.com")
        .build()
    serverIps = Dns.SYSTEM.lookup(server.hostName)
    dns[server.hostName] = serverIps
    dns["san.com"] = serverIps

 */

public class UniAddress implements Address {

    /**
     * Check whether a hostname is actually an ip address
     *
     * @param hostname the hostname to check
     * @return whether this is an IP address
     */
    public static boolean isDotQuadIP(final String hostname) {
        if (Character.isDigit(hostname.charAt(0))) {
            int i, len, dots;
            char[] data;

  val hostname = "local.host"
  private val handshakeCertificates =
    run {
      // Generate a self-signed cert for the server to serve and the client to trust.
      val heldCertificate =
        HeldCertificate
          .Builder()
          .commonName(hostname)
          .addSubjectAlternativeName(hostname)
          .build()
      HandshakeCertificates
        .Builder()