cidr  string
		addrs uint64
	}{
		{
			name:  "supported IPv4 cidr",
			cidr:  "192.168.1.0/24",
			addrs: 254,
		},
		{
			name:  "single IPv4 host",
			cidr:  "192.168.1.0/32",
			addrs: 0,
		},
		{
			name:  "small IPv4 cidr",
			cidr:  "192.168.1.0/31",
			addrs: 0,
		},
		{
			name:  "very large IPv4 cidr",
			cidr:  "0.0.0.0/1",
			addrs: math.MaxInt32 - 1,
		},

		},

		// BAD VALUES WE CURRENTLY CONSIDER GOOD
		{
			name: "ipv4 with leading 0s",
			in:   "1.1.01.0/24",
		},
		{
			name: "ipv4-in-ipv6 with ipv4-sized prefix",
			in:   "::ffff:1.1.1.0/24",
		},
		{
			name: "ipv4-in-ipv6 with ipv6-sized prefix",
			in:   "::ffff:1.1.1.0/120",
		},
		{
			name: "ipv4 with bits past prefix",
			in:   "1.2.3.4/24",
		},
		{

func (_ networkInterface) Interfaces() ([]net.Interface, error) {
	return net.Interfaces()
}

// getAllDefaultRoutes obtains IPv4 and IPv6 default routes on the node. If unable
// to read the IPv4 routing info file, we return an error. If unable to read the IPv6
// routing info file (which is optional), we'll just use the IPv4 route information.
// Using all the routing info, if no default routes are found, an error is returned.

  }
  return result.readUtf8()
}

/**
 * Returns the canonical address for [address]. If [address] is an IPv6 address that is mapped to an
 * IPv4 address, this returns the IPv4-mapped address. Otherwise, this returns [address].
 *
 * https://en.wikipedia.org/wiki/IPv6#IPv4-mapped_IPv6_addresses
 */
internal fun canonicalizeInetAddress(address: ByteArray): ByteArray {
  return when {

		},
		{
			name: "small mask IPv4",
			cidr: "192.168.1.1/28",
			want: 0,
		},
		{
			name: "small mask IPv4",
			cidr: "192.168.1.1/27",
			want: 16,
		},
		{
			name: "small mask IPv6",
			cidr: "fd00::1/124",
			want: 0,
		},
		{
			name: "small mask IPv6",
			cidr: "fd00::1/122",
			want: 16,
		},
		{
			name: "medium mask IPv4",
			cidr: "192.168.1.1/22",

			},
			expectedIPs: []string{"10.0.1.1"},
			actions:     [][]string{{"create", "ipaddresses"}},
			events:      []string{"Warning ClusterIPNotAllocated Cluster IP [IPv4]: 10.0.1.1 is not allocated; repairing"},
		},
		{
			name: "create IPAddresses dual stack",
			svcs: []*v1.Service{newService("test-svc", []string{"10.0.1.1", "2001:db8::10"})},

			cidrs: []*networkingapiv1alpha1.ServiceCIDR{
				deletingServiceCIDR,
			},
			cidrSynced: deletingServiceCIDR.Name,
			actions:    [][]string{},
		},
		{
			name: "service CIDR being deleted with IPv4 addresses should update the status",
			cidrs: []*networkingapiv1alpha1.ServiceCIDR{
				deletedServiceCIDR,
			},
			ips: []*networkingapiv1alpha1.IPAddress{
				makeIPAddress("192.168.0.1"),
			},

		{"udp6", "golang.org"},
		{"udp", "golang.org"},
		{"udp", "golang.org"},
	}
	results := map[[2]string][]IPAddr{
		{"udp", "golang.org"}: {
			{IP: IPv4(127, 0, 0, 1)},
			{IP: IPv6loopback},
		},
		{"udp4", "golang.org"}: {
			{IP: IPv4(127, 0, 0, 1)},
		},
		{"udp6", "golang.org"}: {
			{IP: IPv6loopback},
		},
	}
	calls := int32(0)
	waitCh := make(chan struct{})

		},
		{
			name:         "service cidr is too big",
			expectErrors: true,
			options:      makeOptionsWithCIDRs("10.0.0.0/8", ""),
		},
		{
			name:         "service cidr IPv4 is too big but gate enbled",
			expectErrors: false,
			options:      makeOptionsWithCIDRs("10.0.0.0/8", ""),
			gate:         true,
		},
		{
			name:         "service cidr IPv6 is too big but gate enbled",

		},

		{
			testName: "lightstep address empty",
			key:      "lightstep",
			option:   option.LightstepAddress(""),
			expected: nil,
		},
		{
			testName: "lightstep address ipv4",
			key:      "lightstep",
			option:   option.LightstepAddress("127.0.0.1:80"),
			expected: "{\"address\": \"127.0.0.1\", \"port_value\": 80}",
		},
		{
			testName: "lightstep address ipv6",