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)

        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)

				t.Fatalf("Test %d: error: expected = <nil>, got = %v", i+1, err)
			}
		}

		addrs := listener.Addrs()
		addrSet := set.NewStringSet()
		for _, addr := range addrs {
			addrSet.Add(addr.String())
		}

		if !addrSet.Equals(testCase.expectedAddrs) {
			t.Fatalf("Test %d: addr: expected = %v, got = %v", i+1, testCase.expectedAddrs, addrs)
		}

		listener.Close()
	}

        } 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());

		haddrs, err := globalDNSCache.LookupHost(ctx, host)
		if err == nil {
			for _, addr := range haddrs {
				addrs.Add(net.JoinHostPort(addr, globalMinioPort))
			}
		} else {
			// Unable to lookup host in 2-secs, let it fail later anyways.
			addrs.Add(globalMinioAddr)
		}
	} else {
		addrs.Add(globalMinioAddr)
	}
	return addrs.ToSlice()
}

var globalLoggerOutput io.WriteCloser

            file.delete();
            file.mkdirs();
            file.deleteOnExit();
            fileTransformer.setPath(file.getAbsolutePath());
            crawler.addUrl(url);
            crawler.crawlerContext.setMaxAccessCount(maxCount);
            crawler.crawlerContext.setNumOfThread(numOfThread);
            crawler.urlFilter.addInclude(url + ".*");

			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)