Address addr1 = mock(Address.class);
        when(addr1.getHostAddress()).thenReturn("10.0.0.1");

        Address addr2 = mock(Address.class);
        when(addr2.getHostAddress()).thenReturn("10.0.0.2");

        when(nameSvc.getAllByName(eq("test.server"), eq(true))).thenReturn(new Address[] { addr1, addr2 });

        // Set fail counts (addr1 has more failures, addr2 has fewer)

        InetAddress addr1 = InetAddress.getByName("192.168.1.100");
        InetAddress addr2 = InetAddress.getByName("192.168.1.101");
        NetworkInterfaceInfo local = new NetworkInterfaceInfo(addr1, 1000);
        NetworkInterfaceInfo remote1 = new NetworkInterfaceInfo(addr1, 1000);
        NetworkInterfaceInfo remote2 = new NetworkInterfaceInfo(addr2, 10000); // Faster interface

			}
		}
	}
}

func TestSameLocalAddrs(t *testing.T) {
	testCases := []struct {
		addr1       string
		addr2       string
		sameAddr    bool
		expectedErr error
	}{
		{"", "", false, errors.New("unable to process empty address")},
		{":9000", ":9000", true, nil},
		{"localhost:9000", ":9000", true, nil},

        Object addr;
        int i;

        if (hostname == null || hostname.length() == 0) {
            throw new UnknownHostException();
        }

        if (isDotQuadIP(hostname)) {
            final UniAddress[] addrs = new UniAddress[1];
            addrs[0] = new UniAddress(NbtAddress.getByName(hostname));
            return addrs;
        }

        try {
            final NbtAddress[] addrs = getNodeStatus(addr);
            cacheAddressArray(addrs);
            return addrs;
        } catch (final UnknownHostException uhe) {
            throw new UnknownHostException("no name with type 0x" + Hexdump.toHexString(addr.getNameType(), 2)

        WitnessNotification.WitnessIPAddress addr4 = new WitnessNotification.WitnessIPAddress(ipv4);
        WitnessNotification.WitnessIPAddress addr6 = new WitnessNotification.WitnessIPAddress(ipv6);

        // IPv4 tests
        assertTrue(addr4.isIPv4());
        assertFalse(addr4.isIPv6());
        assertEquals(WitnessNotification.WitnessIPAddress.IPV4, addr4.getFlags());

        // IPv6 tests

        } else if (calledName == SMBSERVER_NAME) {
            NbtAddress[] addrs;

            try {
                addrs = CLIENT.getNodeStatus(this);
                if (hostName.hexCode == 0x1D) {
                    for (final NbtAddress addr : addrs) {
                        if (addr.hostName.hexCode == 0x20) {
                            return addr.hostName.name;
                        }
                    }

            NetbiosAddress[] addrs;

            try {
                addrs = tc.getNameServiceClient().getNodeStatus(this);
                if (this.getNameType() == 0x1D) {
                    for (final NetbiosAddress addr : addrs) {
                        if (addr.getNameType() == 0x20) {
                            return addr.getHostName();
                        }
                    }

            final boolean forceSigning) throws IOException {

        final Address[] addrs = tf.getNameServiceClient().getAllByName(name, true);

        if (addrs == null || addrs.length == 0) {
            throw new UnknownHostException(name);
        }

        Arrays.sort(addrs, (o1, o2) -> {
            Integer fail1 = SmbTransportPoolImpl.this.failCounts.get(o1.getHostAddress());

			if net.ParseIP(endpoint) == nil {
				// Checking if the IP is a DNS entry.
				addrs, err := globalDNSCache.LookupHost(GlobalContext, endpoint)
				if err != nil {
					logger.FatalIf(err, "Unable to initialize MinIO server with [%s] invalid entry found in MINIO_PUBLIC_IPS", endpoint)
				}
				for _, addr := range addrs {
					domainIPs.Add(addr)
				}
			}
			domainIPs.Add(endpoint)
		}
		updateDomainIPs(domainIPs)