}
	}

	// Test functionality of IPv4 communication using AF_INET6
	// sockets.
	if !supportsIPv4map() && supportsIPv4() && (network == "tcp" || network == "udp" || network == "ip") && wildcard {
		// At this point, we prefer IPv4 when ip is nil.
		// See favoriteAddrFamily for further information.
		if ip.To16() != nil && ip.To4() == nil && cip.To4() != nil { // a pair of IPv6 server and IPv4 client
			return false
		}

		},

		// 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",
		},
		{

	}
	return IPAddrs, nil
}

func TestGetLocalIP(t *testing.T) {
	tests := []struct {
		name     string
		lipas    func() ([]net.Addr, error)
		isDS     bool
		expected bool
	}{
		{
			name: "ipv4 only local ip addresses",
			lipas: func() ([]net.Addr, error) {
				return tesrLocalIPAddrs([]netip.Addr{
					netip.MustParseAddr("127.0.0.1"),
					netip.MustParseAddr("1.2.3.5"),
				})
			},
			isDS:     false,

	if isIpv4 {
		addr, err = unix.GetsockoptIPv6MTUInfo(
			int(fd),
			unix.IPPROTO_IP,
			constants.SoOriginalDst)
		if err != nil {
			log.Errorf("Error ipv4 getsockopt: %v", err)
			return
		}
		// See struct sockaddr_in
		daddr = net.IPv4(
			addr.Addr.Addr[0], addr.Addr.Addr[1], addr.Addr.Addr[2], addr.Addr.Addr[3])
	} else {
		addr, err = unix.GetsockoptIPv6MTUInfo(
			int(fd), unix.IPPROTO_IPV6,

    val allAddresses = mutableListOf<InetAddress>()
    var exception: Exception? = null
    val latch = CountDownLatch(1)

    // assumes an IPv4 address
    AndroidAsyncDns.IPv4.query(
      hostname,
      object : AsyncDns.Callback {
        override fun onResponse(
          hostname: String,
          addresses: List<InetAddress>,
        ) {

)

// Network-related utility functions
const (
	waitInterval = 100 * time.Millisecond
	waitTimeout  = 2 * time.Minute
)

// ip family enum
type IPFamilyType int

const (
	IPv4 = iota
	IPv6
	UNKNOWN
)

type lookupIPAddrType = func(ctx context.Context, addr string) ([]netip.Addr, error)

// ErrResolveNoAddress error occurs when IP address resolution is attempted,

	wildCards = map[model.IPMode][]string{
		model.IPv4: {WildcardAddress},
		model.IPv6: {WildcardIPv6Address},
		model.Dual: {WildcardAddress, WildcardIPv6Address},
	}

	localHosts = map[model.IPMode][]string{
		model.IPv4: {LocalhostAddress},
		model.IPv6: {LocalhostIPv6Address},
		model.Dual: {LocalhostAddress, LocalhostIPv6Address},
	}

	dualstack, _ := netutils.IsDualStackCIDRs(cidrs)

	return cidrs, dualstack, nil
}

// setNodeCIDRMaskSizes returns the IPv4 and IPv6 node cidr mask sizes to the value provided
// for --node-cidr-mask-size-ipv4 and --node-cidr-mask-size-ipv6 respectively. If value not provided,
// then it will return default IPv4 and IPv6 cidr mask sizes.

  }
  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 {

	// When DA and DB belong to the same address family (both are IPv6 or
	// both are IPv4 [but see below]): If CommonPrefixLen(Source(DA), DA) >
	// CommonPrefixLen(Source(DB), DB), then prefer DA.  Similarly, if
	// CommonPrefixLen(Source(DA), DA) < CommonPrefixLen(Source(DB), DB),
	// then prefer DB.
	//
	// However, applying this rule to IPv4 addresses causes
	// problems (see issues 13283 and 18518), so limit to IPv6.