}
		}
		addr := l.Addr()
		hosts = append(hosts, "http://"+addr.String())
		listeners = append(listeners, l)
	}
	return hosts, listeners, err
}

func startHTTPServer(listener net.Listener, handler http.Handler) (server *httptest.Server) {
	server = httptest.NewUnstartedServer(handler)
	server.Config.Addr = listener.Addr().String()
	server.Listener = listener
	server.Start()

        final String addr = prp.getProperty(key);
        if (addr != null) {
            try {
                def = InetAddress.getByName(addr);
            } catch (final UnknownHostException uhe) {
                if (LogStream.level > 0) {
                    log.println(addr);
                    uhe.printStackTrace(log);
                }
            }

        final String addr = props.getProperty(key);
        if (addr != null) {
            try {
                def = InetAddress.getByName(addr);
            } catch (final UnknownHostException uhe) {
                log.error("Unknown host " + addr, uhe);
            }
        }
        return def;
    }

    /**

                addr = new NbtAddress(name, ip, false, NbtAddress.B_NODE, false, false, true, true, NbtAddress.UNKNOWN_MAC_ADDRESS);
                if (log.isDebugEnabled()) {
                    log.debug("Adding " + name + " with addr " + addr);
                }
                this.table.put(name, addr);
            }
        }
    }

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

		addr := listener.Addr()
		if addr.String() != testCase.expectedAddr {
			t.Fatalf("Test %d: addr: expected = %v, got = %v", i+1, testCase.expectedAddr, addr)
		}

		listener.Close()
	}
}

func TestHTTPListenerAddrs(t *testing.T) {
	if runtime.GOOS == "windows" {
		t.Skip()

        assertEquals(SmbConstants.TYPE_WORKGROUP, locator("smb:///").getType());

        // Server vs Workgroup depends on NetBIOS name type
        Address addr = mock(Address.class);
        NetbiosAddress nb = mock(NetbiosAddress.class);
        when(addr.unwrap(NetbiosAddress.class)).thenReturn(nb);
        when(nb.getNameType()).thenReturn(0x1d); // workgroup code

  public static InetAddress decrement(InetAddress address) {
    byte[] addr = address.getAddress();
    int i = addr.length - 1;
    while (i >= 0 && addr[i] == (byte) 0x00) {
      addr[i] = (byte) 0xff;
      i--;
    }

    checkArgument(i >= 0, "Decrementing %s would wrap.", address);

    addr[i]--;
    return bytesToInetAddress(addr, null);
  }

  /**

//	}
	MOVB	R8, R9		// 00084e0000094e03
	MOVBU	R12, R17	// 319100ff

//	LMOVV addr ',' rreg
//	{
//		outcode(int($1), &$2, 0, &$4);
//	}
	MOVV	foo<>+3(SB), R2
	MOVV	(R5), R18	// dcb20000
	MOVV	8(R16), R4	// de040008
	MOVV	-32(R14), R1	// ddc1ffe0
	LLV	(R1), R2	// d0220000

//	LMOVW addr ',' rreg
//	{
//		outcode(int($1), &$2, 0, &$4);
//	}
	MOVW	foo<>+3(SB), R2

            _domains = null;
        }
        if (_domains != null) {
            return _domains.map;
        }
        try {
            final UniAddress addr = UniAddress.getByName(auth.domain, true);
            final SmbTransport trans = SmbTransport.getSmbTransport(addr, 0);
            final CacheEntry entry = new CacheEntry(Dfs.TTL * 10L);

            DfsReferral dr = trans.getDfsReferrals(auth, "", 0);
            if (dr != null) {

				if value := reflect.Indirect(db.Statement.ReflectValue.Index(i)); value.CanAddr() {
					fc(value.Addr().Interface(), tx)
				} else {
					db.AddError(gorm.ErrInvalidValue)
					return
				}
				db.Statement.CurDestIndex++
			}
		case reflect.Struct:
			if db.Statement.ReflectValue.CanAddr() {
				fc(db.Statement.ReflectValue.Addr().Interface(), tx)
			} else {
				db.AddError(gorm.ErrInvalidValue)
			}
		}
	}