}
	return filteredNS, nil
}

// LookupTXT returns the DNS TXT records for the given domain name.
//
// LookupTXT uses [context.Background] internally; to specify the context, use
// [Resolver.LookupTXT].
func LookupTXT(name string) ([]string, error) {
	return DefaultResolver.lookupTXT(context.Background(), name)
}

// LookupTXT returns the DNS TXT records for the given domain name.

				return err
			},
		},
		{
			name: "LookupTXT NXDOMAIN",
			query: func() error {
				_, err := LookupTXT(testNXDOMAIN)
				return err
			},
		},
		{
			name: "LookupTXT NODATA",
			query: func() error {
				_, err := LookupTXT(testNODATA)
				return err
			},
		},
	}

	for _, v := range tests {

	return r.goLookupMX(ctx, name)
}

func (r *Resolver) lookupNS(ctx context.Context, name string) ([]*NS, error) {
	return r.goLookupNS(ctx, name)
}

func (r *Resolver) lookupTXT(ctx context.Context, name string) ([]string, error) {
	return r.goLookupTXT(ctx, name)
}

func (r *Resolver) lookupAddr(ctx context.Context, addr string) ([]string, error) {

	}
	for _, line := range lines {
		f := getFields(line)
		if len(f) < 3 {
			continue
		}
		ns = append(ns, &NS{absDomainName(f[2])})
	}
	return
}

func (r *Resolver) lookupTXT(ctx context.Context, name string) (txt []string, err error) {
	if systemConf().mustUseGoResolver(r) {
		return r.goLookupTXT(ctx, name)
	}
	lines, err := queryDNS(ctx, name, "txt")
	if err != nil {

						},
					},
				},
			}
			return r, nil
		},
	}
	r := Resolver{PreferGo: true, Dial: fake.DialContext}
	txt, err := r.lookupTXT(context.Background(), "golang.org")
	if err != nil {
		t.Fatal("LookupTXT failed:", err)
	}
	if want := 2; len(txt) != want {
		t.Fatalf("len(txt), got %d, want %d", len(txt), want)
	}
	if want := "string1 string2"; txt[0] != want {

		}
	})
}

func TestNSLookupTXT(t *testing.T) {
	testenv.MustHaveExternalNetwork(t)

	testLookup(t, func(t *testing.T, r *Resolver, server string) {
		txt, err := r.LookupTXT(context.Background(), server)
		if err != nil {
			t.Fatalf("failed %s: %s", server, err)
		}
		if len(txt) == 0 {
			t.Fatalf("no results")
		}
		expected, err := nslookupTXT(server)
		if err != nil {

		v := (*syscall.DNSPTRData)(unsafe.Pointer(&p.Data[0]))
		nss = append(nss, &NS{absDomainName(syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(v.Host))[:]))})
	}
	return nss, nil
}

func (r *Resolver) lookupTXT(ctx context.Context, name string) ([]string, error) {
	if systemConf().mustUseGoResolver(r) {
		return r.goLookupTXT(ctx, name)
	}
	// TODO(bradfitz): finish ctx plumbing.
	if err := acquireThread(ctx); err != nil {

pkg net, method (*Resolver) LookupPort(context.Context, string, string) (int, error)
pkg net, method (*Resolver) LookupSRV(context.Context, string, string, string) (string, []*SRV, error)
pkg net, method (*Resolver) LookupTXT(context.Context, string) ([]string, error)
pkg net, method (*UnixListener) SetUnlinkOnClose(bool)
pkg net, type Buffers [][]uint8
pkg net, type Dialer struct, Resolver *Resolver
pkg net, type Resolver struct

		{"(*Resolver).LookupNS", Method, 8},
		{"(*Resolver).LookupNetIP", Method, 18},
		{"(*Resolver).LookupPort", Method, 8},
		{"(*Resolver).LookupSRV", Method, 8},
		{"(*Resolver).LookupTXT", Method, 8},
		{"(*TCPAddr).AddrPort", Method, 18},
		{"(*TCPAddr).Network", Method, 0},
		{"(*TCPAddr).String", Method, 0},
		{"(*TCPConn).Close", Method, 0},
		{"(*TCPConn).CloseRead", Method, 0},

pkg net, func LookupMX(string) ([]*MX, error)
pkg net, func LookupPort(string, string) (int, error)
pkg net, func LookupSRV(string, string, string) (string, []*SRV, error)
pkg net, func LookupTXT(string) ([]string, error)
pkg net, func ParseCIDR(string) (IP, *IPNet, error)
pkg net, func ParseIP(string) IP
pkg net, func ParseMAC(string) (HardwareAddr, error)
pkg net, func Pipe() (Conn, Conn)