loadbalance
        kubernetes cluster.local in-addr.arpa ip6.arpa {
           pods insecure
           upstream
           fallthrough in-addr.arpa ip6.arpa
           ttl 30
        }
        health
    }
`,
			expectedCorefileData: `.:53 {
    errors
    health {
       lameduck 5s
    }
    ready
    kubernetes cluster.local in-addr.arpa ip6.arpa {
       pods insecure

// Test escape analysis for sync/atomic.

package escape

import (
	"sync/atomic"
	"unsafe"
)

// BAD: should be "leaking param: addr to result ~r1 level=1$".
func LoadPointer(addr *unsafe.Pointer) unsafe.Pointer { // ERROR "leaking param: addr$"
	return atomic.LoadPointer(addr)
}

var ptr unsafe.Pointer

func StorePointer() {
	var x int // ERROR "moved to heap: x"
	atomic.StorePointer(&ptr, unsafe.Pointer(&x))
}

	r0, _, _ := syscall.Syscall9(procRegLoadMUIStringW.Addr(), 7, uintptr(key), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(buf)), uintptr(buflen), uintptr(unsafe.Pointer(buflenCopied)), uintptr(flags), uintptr(unsafe.Pointer(dir)), 0, 0)
	if r0 != 0 {
		regerrno = syscall.Errno(r0)
	}
	return
}

		}

		var sloc []*Location
		for _, addr := range addrs {
			// Addresses from stack traces point to the next instruction after
			// each call. Adjust by -1 to land somewhere on the actual call.
			addr--
			loc := locs[addr]
			if locs[addr] == nil {
				loc = &Location{
					Address: addr,
				}
				p.Location = append(p.Location, loc)
				locs[addr] = loc
			}
			sloc = append(sloc, loc)
		}

		return secs[i].Addr < secs[j].Addr
	})

	// Check to make sure we don't have any overlaps.
	foundOverlap := false
	for i := 0; i < len(secs)-1; i++ {
		for j := i + 1; j < len(secs); j++ {
			s := secs[i]
			sn := secs[j]
			if secOverlaps(s, sn) {
				t.Errorf("unexpected: section %d:%q (addr=%x size=%x) overlaps section %d:%q (addr=%x size=%x)", i, s.Name, s.Addr, s.Size, i+1, sn.Name, sn.Addr, sn.Size)

			}
		})
	}

}

func createListener(network, addr string) (net.Listener, int, error) {
	if len(network) == 0 {
		network = "tcp"
	}
	ln, err := net.Listen(network, addr)
	if err != nil {
		return nil, 0, fmt.Errorf("failed to listen on %v: %v", addr, err)
	}

	// get port
	tcpAddr, ok := ln.Addr().(*net.TCPAddr)
	if !ok {
		ln.Close()

	prefix := os.Args[2]
	for _, port := range ports {
		addr := fmt.Sprintf(":%s", port)
		go serve(addr, prefix)
	}
	ch := make(chan struct{})
	<-ch
}

// serve starts serving on a given address
func serve(addr, prefix string) {
	// create a tcp listener on the given port
	listener, err := net.Listen("tcp", addr)
	if err != nil {
		fmt.Println("failed to create listener, err:", err)
		os.Exit(1)

			}
		}
	}
}

func TestModeSocket(t *testing.T) {
	if !windows.SupportUnixSocket() {
		t.Skip("unix test")
	}

	addr := testUnixAddr(t)

	l, err := Listen("unix", addr)
	if err != nil {
		t.Fatal(err)
	}
	defer l.Close()

	stat, err := os.Stat(addr)
	if err != nil {
		t.Fatal(err)
	}

	mode := stat.Mode()
	if mode&os.ModeSocket == 0 {
		t.Fatalf("%v should have ModeSocket", mode)

		for ; result != nil; result = result.Next {
			addr := unsafe.Pointer(result.Addr)
			switch result.Family {
			case syscall.AF_INET:
				a := (*syscall.RawSockaddrInet4)(addr).Addr
				addrs = append(addrs, IPAddr{IP: copyIP(a[:])})
			case syscall.AF_INET6:
				a := (*syscall.RawSockaddrInet6)(addr).Addr
				zone := zoneCache.name(int((*syscall.RawSockaddrInet6)(addr).Scope_id))

// overflow by returning true in the second return value.
func adjust(addr uint64, offset int64) (uint64, bool) {
	adj := uint64(int64(addr) + offset)
	if offset < 0 {
		if adj >= addr {
			return 0, true
		}
	} else {
		if adj < addr {
			return 0, true
		}
	}
	return adj, false