} else {
		t.Fatal("expected result must not be nil")
	}
}

func TestIP(t *testing.T) {
	ipv4Addr, _ := netip.ParseAddr("192.168.0.1")
	int4 := types.Int(4)

	ipv6Addr, _ := netip.ParseAddr("2001:db8::68")
	int6 := types.Int(6)

	trueVal := types.Bool(true)
	falseVal := types.Bool(false)

	cases := []struct {
		name              string

// are valid IPv6 address, for all other cases it returns false.
func AllIPv6(ipAddrs []string) bool {
	for i := 0; i < len(ipAddrs); i++ {
		addr, err := netip.ParseAddr(ipAddrs[i])
		if err != nil {
			// Should not happen, invalid IP in proxy's IPAddresses slice should have been caught earlier,
			// skip it to prevent a panic.
			continue
		}
		if addr.Is4() {

				`global.proxy.excludeIPRanges netip.ParsePrefix("4.4.0.0/34"): prefix length out of range`,
				`global.proxy.includeIPRanges netip.ParsePrefix("1.1.0.256/16"): ParseAddr("1.1.0.256"): IPv4 field has value >255`,
				`global.proxy.includeIPRanges netip.ParsePrefix("2.2.0.257/16"): ParseAddr("2.2.0.257"): IPv4 field has value >255`,
			}),
		},
		{
			desc: "BadIPMalformed",
			yamlStr: `
global:
  proxy:

				t.Fatal(err)
			}
			if got != got2 {
				t.Errorf("ParseAddr(%q) got 2 different results: %#v, %#v", test.in, got, got2)
			}

			// Check that ParseAddr(ip.String()) is the identity function.
			s := got.String()
			got3, err := ParseAddr(s)
			if err != nil {
				t.Fatal(err)
			}
			if got != got3 {
				t.Errorf("ParseAddr(%q) != ParseAddr(ParseIP(%q).String()). Got %#v, want %#v", test.in, test.in, got3, got)

				nodePort = svcPort.NodePort
				break
			}
		}
		if nodePort == 0 {
			return nil, false, fmt.Errorf("no port %d found in service: %s/%s", port, ns, svcName)
		}

		ipAddr, err := netip.ParseAddr(ip)
		if err != nil {
			return nil, false, err
		}
		return []any{netip.AddrPortFrom(ipAddr, uint16(nodePort))}, true, nil
	}

	// Otherwise, get the load balancer IP.

			yamlStr: `
values:
  global:
    proxy:
      includeIPRanges: "1.1.0.300/16,2.2.0.0/16"
`,
			wantErrs: makeErrors([]string{`global.proxy.includeIPRanges netip.ParsePrefix("1.1.0.300/16"): ParseAddr("1.1.0.300"): IPv4 field has value >255`}),
		},
		{
			desc: "EmptyValuesIP",
			yamlStr: `
values:
  global:
    proxy:
      includeIPRanges: ""
`,
		},
		{

			// TODO: look up the HBONE port instead of hardcoding it
			HboneMtlsPort: 15008,
		}
	}
	return nil
}

func (a *index) toNetworkAddress(vip string) (*workloadapi.NetworkAddress, error) {
	ip, err := netip.ParseAddr(vip)
	if err != nil {
		return nil, fmt.Errorf("parse %v: %v", vip, err)
	}
	return &workloadapi.NetworkAddress{
		Network: a.Network(vip, make(labels.Instance, 0)).String(),
		Address: ip.AsSlice(),
	}, nil

		f.Add(seed)
	}

	f.Fuzz(func(t *testing.T, s string) {
		ip, _ := ParseAddr(s)
		checkStringParseRoundTrip(t, ip, ParseAddr)
		checkEncoding(t, ip)

		// Check that we match the net's IP parser, modulo zones.
		if !strings.Contains(s, "%") {
			stdip := net.ParseIP(s)
			if !ip.IsValid() != (stdip == nil) {
				t.Errorf("ParseAddr zero != net.ParseIP nil: ip=%q stdip=%q", ip, stdip)
			}

		t.Fatal("expected result must not be nil")
	}
}

func TestCIDR(t *testing.T) {
	ipv4CIDR, _ := netip.ParsePrefix("192.168.0.0/24")
	ipv4Addr, _ := netip.ParseAddr("192.168.0.0")

	ipv6CIDR, _ := netip.ParsePrefix("2001:db8::/32")
	ipv6Addr, _ := netip.ParseAddr("2001:db8::")

	trueVal := types.Bool(true)
	falseVal := types.Bool(false)

	cases := []struct {
		name              string
		expr              string

}

// MustParseAddr calls [ParseAddr](s) and panics on error.
// It is intended for use in tests with hard-coded strings.
func MustParseAddr(s string) Addr {
	ip, err := ParseAddr(s)
	if err != nil {
		panic(err)
	}
	return ip
}

type parseAddrError struct {
	in  string // the string given to ParseAddr
	msg string // an explanation of the parse failure