// /etc/resolv.conf are recursive resolvers.
			//
			// We asked for recursion, so it should have included all the
			// answers we need in this one packet.
			//
			// Further, RFC 1034 section 4.3.1 says that "the recursive
			// response to a query will be... The answer to the query,
			// possibly preface by one or more CNAME RRs that specify
			// aliases encountered on the way to an answer."
			//

  // - uri: an URI as parsed by Golang net/url.ParseRequestURI
  // - email: an email address as parsed by Golang net/mail.ParseAddress
  // - hostname: a valid representation for an Internet host name, as defined by RFC 1034, section 3.1 [RFC1034].
  // - ipv4: an IPv4 IP as parsed by Golang net.ParseIP
  // - ipv6: an IPv6 IP as parsed by Golang net.ParseIP
  // - cidr: a CIDR as parsed by Golang net.ParseCIDR

  // - uri: an URI as parsed by Golang net/url.ParseRequestURI
  // - email: an email address as parsed by Golang net/mail.ParseAddress
  // - hostname: a valid representation for an Internet host name, as defined by RFC 1034, section 3.1 [RFC1034].
  // - ipv4: an IPv4 IP as parsed by Golang net.ParseIP
  // - ipv6: an IPv6 IP as parsed by Golang net.ParseIP
  // - cidr: a CIDR as parsed by Golang net.ParseCIDR

	SYS_T_CLOSE                         = 0x40C // 1036
	SYS_T_CONNECT                       = 0x40D // 1037
	SYS_T_ERROR                         = 0x40E // 1038
	SYS_T_FREE                          = 0x40F // 1039
	SYS_T_GETINFO                       = 0x410 // 1040
	SYS_T_GETPROTADDR                   = 0x411 // 1041
	SYS_T_GETSTATE                      = 0x412 // 1042

	defer wg.Wait()

	c1.SetReadDeadline(time.Now().Add(time.Millisecond))
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()

			b1 := make([]byte, 1024)
			b2 := make([]byte, 1024)
			for j := 0; j < 100; j++ {
				_, err := c1.Read(b1)
				copy(b1, b2) // Mutate b1 to trigger potential race
				if err != nil {
					checkForTimeoutError(t, err)

	case AAMOMINW:
		return &inst{0x2f, 0x2, 0x0, -2048, 0x40}
	case AAMOMINUD:
		return &inst{0x2f, 0x3, 0x0, -1024, 0x60}
	case AAMOMINUW:
		return &inst{0x2f, 0x2, 0x0, -1024, 0x60}
	case AAMOORD:
		return &inst{0x2f, 0x3, 0x0, 1024, 0x20}
	case AAMOORW:
		return &inst{0x2f, 0x2, 0x0, 1024, 0x20}
	case AAMOSWAPD:
		return &inst{0x2f, 0x3, 0x0, 128, 0x4}
	case AAMOSWAPW:
		return &inst{0x2f, 0x2, 0x0, 128, 0x4}

package p

// This type and the following one will share the same GC shape and size.
type Pointery struct {
	p *Pointery
	x [1024]int
}

type Pointery2 struct {
	p *Pointery2
	x [1024]int
}

// This type and the following one will have the same size.
type Vanilla struct {
	np uintptr
	x  [1024]int
}

type Vanilla2 struct {
	np uintptr
	x  [1023]int
	y  int
}

type Single struct {
	np uintptr

	}

	var iovecs []syscall.Iovec
	if fd.iovecs != nil {
		iovecs = *fd.iovecs
	}
	// TODO: read from sysconf(_SC_IOV_MAX)? The Linux default is
	// 1024 and this seems conservative enough for now. Darwin's
	// UIO_MAXIOV also seems to be 1024.
	maxVec := 1024
	if runtime.GOOS == "aix" || runtime.GOOS == "solaris" {
		// IOV_MAX is set to XOPEN_IOV_MAX on AIX and Solaris.
		maxVec = 16
	}

	var n int64
	var err error

)

func BenchmarkRingBuffer_Sync(b *testing.B) {
	rb := New(1024)
	data := []byte(strings.Repeat("a", 512))
	buf := make([]byte, 512)

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		rb.Write(data)
		rb.Read(buf)
	}
}

func BenchmarkRingBuffer_AsyncRead(b *testing.B) {
	// Pretty useless benchmark, but it's here for completeness.
	rb := New(1024)
	data := []byte(strings.Repeat("a", 512))
	buf := make([]byte, 512)

		},
		{
			name:    "Dual --node-ips",
			nodeIPs: []net.IP{netutils.ParseIPSloppy("10.1.1.1"), netutils.ParseIPSloppy("fd01::1234")},
			expectedAddresses: []v1.NodeAddress{
				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
				{Type: v1.NodeInternalIP, Address: "fd01::1234"},
				{Type: v1.NodeHostName, Address: testKubeletHostname},
			},
		},
		{