if (hasColon) {
      if (hasDot) {
        ipString = convertDottedQuadToHex(ipString);
        if (ipString == null) {
          return null;
        }
      }
      if (percentIndex != -1) {
        if (scope != null) {
          scope.scope = ipString.substring(percentIndex + 1);
        }
        ipString = ipString.substring(0, percentIndex);
      }

		desc            string
		ipString        []string
		wantIPv6        bool
		expectCorrect   []string
		expectIncorrect []string
	}{
		{
			desc:            "empty input IPv4",
			ipString:        []string{},
			wantIPv6:        false,
			expectCorrect:   nil,
			expectIncorrect: nil,
		},
		{
			desc:            "empty input IPv6",
			ipString:        []string{},
			wantIPv6:        true,

    if (hasColon) {
      if (hasDot) {
        ipString = convertDottedQuadToHex(ipString);
        if (ipString == null) {
          return null;
        }
      }
      if (percentIndex != -1) {
        if (scope != null) {
          scope.scope = ipString.substring(percentIndex + 1);
        }
        ipString = ipString.substring(0, percentIndex);
      }

    ImmutableSet<String> ipStrings =
        ImmutableSet.of("7::0.128.0.127", "7::0.128.0.128", "7::128.128.0.127", "7::0.128.128.127");

    for (String ipString : ipStrings) {
      // Shouldn't hit DNS, because it's an IP string literal.
      InetAddress ipv6Addr = InetAddress.getByName(ipString);
      assertEquals(ipv6Addr, InetAddresses.forString(ipString));
      assertTrue(InetAddresses.isInetAddress(ipString));
    }
  }

)

func TestGetClientIP(t *testing.T) {
	ipString := "10.0.0.1"
	ip := netutils.ParseIPSloppy(ipString)
	invalidIPString := "invalidIPString"
	testCases := []struct {
		Request    http.Request
		ExpectedIP net.IP
	}{
		{
			Request: http.Request{},
		},
		{
			Request: http.Request{
				Header: map[string][]string{
					"X-Real-Ip": {ipString},
				},
			},
			ExpectedIP: ip,
		},
		{

	}
	h.localAddresses[dev] = make([]string, 0)
	h.localAddresses[dev] = append(h.localAddresses[dev], ips...)
	return nil
}

func (h *FakeNetlinkHandle) isValidForSet(ipString string) bool {
	ip := net.ParseIPSloppy(ipString)
	if h.IsIPv6 != (ip.To4() == nil) {
		return false
	}
	if h.IsIPv6 && ip.IsLinkLocalUnicast() {
		return false
	}
	if ip.IsLoopback() {
		return false
	}
	return true

            appProtocol: HTTP
`
	cases := []struct {
		name        string
		iopString   string
		expectValue string
		expectExist bool
	}{
		{
			name:        "without appProtocol",
			iopString:   iopString,
			expectExist: false,
		},
		{
			name:        "with appProtocol",
			iopString:   iopString2,
			expectExist: true,
			expectValue: "HTTP",
		},
	}

	isSlice(*&slice)

	asString(str)
	isString(str)
	asString(str + "a")
	isString(str + "a")
	asString("a" + str)
	isString("a" + str)
	asString(str + str)
	isString(str + str)
	str += "a"
	str += str
	asString(String('a'))
	isString(String('a'))
	asString(String([]byte(slice)))
	isString(String([]byte(slice)))
	asString(String([]byte(nil)))
	isString(String([]byte(nil)))
	asString("hello")

// Properties of basic types.
const (
	IsBoolean BasicInfo = 1 << iota
	IsInteger
	IsUnsigned
	IsFloat
	IsComplex
	IsString
	IsUntyped

	IsOrdered   = IsInteger | IsFloat | IsString
	IsNumeric   = IsInteger | IsFloat | IsComplex
	IsConstType = IsBoolean | IsNumeric | IsString
)

// A Basic represents a basic type.
type Basic struct {
	kind BasicKind
	info BasicInfo
	name string
}

                return read();
            }
        }

        if (ch == '"' && !quoted) {
            inString = !inString;
            quoted = false;
        } else if (ch == '\\') {
            quoted = !quoted;
        } else {
            quoted = false;
            if (!inString) {
                if (ch == '/') {
                    ch = next();
                    if (ch == '/') {