Source file src/net/lookup_test.go

Documentation: net

		 1  // Copyright 2009 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  //go:build !js
		 6  // +build !js
		 7  
		 8  package net
		 9  
		10  import (
		11  	"bytes"
		12  	"context"
		13  	"fmt"
		14  	"internal/testenv"
		15  	"reflect"
		16  	"runtime"
		17  	"sort"
		18  	"strings"
		19  	"sync"
		20  	"sync/atomic"
		21  	"testing"
		22  	"time"
		23  )
		24  
		25  func hasSuffixFold(s, suffix string) bool {
		26  	return strings.HasSuffix(strings.ToLower(s), strings.ToLower(suffix))
		27  }
		28  
		29  func lookupLocalhost(ctx context.Context, fn func(context.Context, string, string) ([]IPAddr, error), network, host string) ([]IPAddr, error) {
		30  	switch host {
		31  	case "localhost":
		32  		return []IPAddr{
		33  			{IP: IPv4(127, 0, 0, 1)},
		34  			{IP: IPv6loopback},
		35  		}, nil
		36  	default:
		37  		return fn(ctx, network, host)
		38  	}
		39  }
		40  
		41  // The Lookup APIs use various sources such as local database, DNS or
		42  // mDNS, and may use platform-dependent DNS stub resolver if possible.
		43  // The APIs accept any of forms for a query; host name in various
		44  // encodings, UTF-8 encoded net name, domain name, FQDN or absolute
		45  // FQDN, but the result would be one of the forms and it depends on
		46  // the circumstances.
		47  
		48  var lookupGoogleSRVTests = []struct {
		49  	service, proto, name string
		50  	cname, target				string
		51  }{
		52  	{
		53  		"xmpp-server", "tcp", "google.com",
		54  		"google.com.", "google.com.",
		55  	},
		56  	{
		57  		"xmpp-server", "tcp", "google.com.",
		58  		"google.com.", "google.com.",
		59  	},
		60  
		61  	// non-standard back door
		62  	{
		63  		"", "", "_xmpp-server._tcp.google.com",
		64  		"google.com.", "google.com.",
		65  	},
		66  	{
		67  		"", "", "_xmpp-server._tcp.google.com.",
		68  		"google.com.", "google.com.",
		69  	},
		70  }
		71  
		72  var backoffDuration = [...]time.Duration{time.Second, 5 * time.Second, 30 * time.Second}
		73  
		74  func TestLookupGoogleSRV(t *testing.T) {
		75  	t.Parallel()
		76  	mustHaveExternalNetwork(t)
		77  
		78  	if iOS() {
		79  		t.Skip("no resolv.conf on iOS")
		80  	}
		81  
		82  	if !supportsIPv4() || !*testIPv4 {
		83  		t.Skip("IPv4 is required")
		84  	}
		85  
		86  	attempts := 0
		87  	for i := 0; i < len(lookupGoogleSRVTests); i++ {
		88  		tt := lookupGoogleSRVTests[i]
		89  		cname, srvs, err := LookupSRV(tt.service, tt.proto, tt.name)
		90  		if err != nil {
		91  			testenv.SkipFlakyNet(t)
		92  			if attempts < len(backoffDuration) {
		93  				dur := backoffDuration[attempts]
		94  				t.Logf("backoff %v after failure %v\n", dur, err)
		95  				time.Sleep(dur)
		96  				attempts++
		97  				i--
		98  				continue
		99  			}
	 100  			t.Fatal(err)
	 101  		}
	 102  		if len(srvs) == 0 {
	 103  			t.Error("got no record")
	 104  		}
	 105  		if !hasSuffixFold(cname, tt.cname) {
	 106  			t.Errorf("got %s; want %s", cname, tt.cname)
	 107  		}
	 108  		for _, srv := range srvs {
	 109  			if !hasSuffixFold(srv.Target, tt.target) {
	 110  				t.Errorf("got %v; want a record containing %s", srv, tt.target)
	 111  			}
	 112  		}
	 113  	}
	 114  }
	 115  
	 116  var lookupGmailMXTests = []struct {
	 117  	name, host string
	 118  }{
	 119  	{"gmail.com", "google.com."},
	 120  	{"gmail.com.", "google.com."},
	 121  }
	 122  
	 123  func TestLookupGmailMX(t *testing.T) {
	 124  	t.Parallel()
	 125  	mustHaveExternalNetwork(t)
	 126  
	 127  	if iOS() {
	 128  		t.Skip("no resolv.conf on iOS")
	 129  	}
	 130  
	 131  	if !supportsIPv4() || !*testIPv4 {
	 132  		t.Skip("IPv4 is required")
	 133  	}
	 134  
	 135  	attempts := 0
	 136  	for i := 0; i < len(lookupGmailMXTests); i++ {
	 137  		tt := lookupGmailMXTests[i]
	 138  		mxs, err := LookupMX(tt.name)
	 139  		if err != nil {
	 140  			testenv.SkipFlakyNet(t)
	 141  			if attempts < len(backoffDuration) {
	 142  				dur := backoffDuration[attempts]
	 143  				t.Logf("backoff %v after failure %v\n", dur, err)
	 144  				time.Sleep(dur)
	 145  				attempts++
	 146  				i--
	 147  				continue
	 148  			}
	 149  			t.Fatal(err)
	 150  		}
	 151  		if len(mxs) == 0 {
	 152  			t.Error("got no record")
	 153  		}
	 154  		for _, mx := range mxs {
	 155  			if !hasSuffixFold(mx.Host, tt.host) {
	 156  				t.Errorf("got %v; want a record containing %s", mx, tt.host)
	 157  			}
	 158  		}
	 159  	}
	 160  }
	 161  
	 162  var lookupGmailNSTests = []struct {
	 163  	name, host string
	 164  }{
	 165  	{"gmail.com", "google.com."},
	 166  	{"gmail.com.", "google.com."},
	 167  }
	 168  
	 169  func TestLookupGmailNS(t *testing.T) {
	 170  	t.Parallel()
	 171  	mustHaveExternalNetwork(t)
	 172  
	 173  	if iOS() {
	 174  		t.Skip("no resolv.conf on iOS")
	 175  	}
	 176  
	 177  	if !supportsIPv4() || !*testIPv4 {
	 178  		t.Skip("IPv4 is required")
	 179  	}
	 180  
	 181  	attempts := 0
	 182  	for i := 0; i < len(lookupGmailNSTests); i++ {
	 183  		tt := lookupGmailNSTests[i]
	 184  		nss, err := LookupNS(tt.name)
	 185  		if err != nil {
	 186  			testenv.SkipFlakyNet(t)
	 187  			if attempts < len(backoffDuration) {
	 188  				dur := backoffDuration[attempts]
	 189  				t.Logf("backoff %v after failure %v\n", dur, err)
	 190  				time.Sleep(dur)
	 191  				attempts++
	 192  				i--
	 193  				continue
	 194  			}
	 195  			t.Fatal(err)
	 196  		}
	 197  		if len(nss) == 0 {
	 198  			t.Error("got no record")
	 199  		}
	 200  		for _, ns := range nss {
	 201  			if !hasSuffixFold(ns.Host, tt.host) {
	 202  				t.Errorf("got %v; want a record containing %s", ns, tt.host)
	 203  			}
	 204  		}
	 205  	}
	 206  }
	 207  
	 208  var lookupGmailTXTTests = []struct {
	 209  	name, txt, host string
	 210  }{
	 211  	{"gmail.com", "spf", "google.com"},
	 212  	{"gmail.com.", "spf", "google.com"},
	 213  }
	 214  
	 215  func TestLookupGmailTXT(t *testing.T) {
	 216  	if runtime.GOOS == "plan9" {
	 217  		t.Skip("skipping on plan9; see https://golang.org/issue/29722")
	 218  	}
	 219  	t.Parallel()
	 220  	mustHaveExternalNetwork(t)
	 221  
	 222  	if iOS() {
	 223  		t.Skip("no resolv.conf on iOS")
	 224  	}
	 225  
	 226  	if !supportsIPv4() || !*testIPv4 {
	 227  		t.Skip("IPv4 is required")
	 228  	}
	 229  
	 230  	attempts := 0
	 231  	for i := 0; i < len(lookupGmailTXTTests); i++ {
	 232  		tt := lookupGmailTXTTests[i]
	 233  		txts, err := LookupTXT(tt.name)
	 234  		if err != nil {
	 235  			testenv.SkipFlakyNet(t)
	 236  			if attempts < len(backoffDuration) {
	 237  				dur := backoffDuration[attempts]
	 238  				t.Logf("backoff %v after failure %v\n", dur, err)
	 239  				time.Sleep(dur)
	 240  				attempts++
	 241  				i--
	 242  				continue
	 243  			}
	 244  			t.Fatal(err)
	 245  		}
	 246  		if len(txts) == 0 {
	 247  			t.Error("got no record")
	 248  		}
	 249  		found := false
	 250  		for _, txt := range txts {
	 251  			if strings.Contains(txt, tt.txt) && (strings.HasSuffix(txt, tt.host) || strings.HasSuffix(txt, tt.host+".")) {
	 252  				found = true
	 253  				break
	 254  			}
	 255  		}
	 256  		if !found {
	 257  			t.Errorf("got %v; want a record containing %s, %s", txts, tt.txt, tt.host)
	 258  		}
	 259  	}
	 260  }
	 261  
	 262  var lookupGooglePublicDNSAddrTests = []string{
	 263  	"8.8.8.8",
	 264  	"8.8.4.4",
	 265  	"2001:4860:4860::8888",
	 266  	"2001:4860:4860::8844",
	 267  }
	 268  
	 269  func TestLookupGooglePublicDNSAddr(t *testing.T) {
	 270  	mustHaveExternalNetwork(t)
	 271  
	 272  	if !supportsIPv4() || !supportsIPv6() || !*testIPv4 || !*testIPv6 {
	 273  		t.Skip("both IPv4 and IPv6 are required")
	 274  	}
	 275  
	 276  	defer dnsWaitGroup.Wait()
	 277  
	 278  	for _, ip := range lookupGooglePublicDNSAddrTests {
	 279  		names, err := LookupAddr(ip)
	 280  		if err != nil {
	 281  			t.Fatal(err)
	 282  		}
	 283  		if len(names) == 0 {
	 284  			t.Error("got no record")
	 285  		}
	 286  		for _, name := range names {
	 287  			if !hasSuffixFold(name, ".google.com.") && !hasSuffixFold(name, ".google.") {
	 288  				t.Errorf("got %q; want a record ending in .google.com. or .google.", name)
	 289  			}
	 290  		}
	 291  	}
	 292  }
	 293  
	 294  func TestLookupIPv6LinkLocalAddr(t *testing.T) {
	 295  	if !supportsIPv6() || !*testIPv6 {
	 296  		t.Skip("IPv6 is required")
	 297  	}
	 298  
	 299  	defer dnsWaitGroup.Wait()
	 300  
	 301  	addrs, err := LookupHost("localhost")
	 302  	if err != nil {
	 303  		t.Fatal(err)
	 304  	}
	 305  	found := false
	 306  	for _, addr := range addrs {
	 307  		if addr == "fe80::1%lo0" {
	 308  			found = true
	 309  			break
	 310  		}
	 311  	}
	 312  	if !found {
	 313  		t.Skipf("not supported on %s", runtime.GOOS)
	 314  	}
	 315  	if _, err := LookupAddr("fe80::1%lo0"); err != nil {
	 316  		t.Error(err)
	 317  	}
	 318  }
	 319  
	 320  func TestLookupIPv6LinkLocalAddrWithZone(t *testing.T) {
	 321  	if !supportsIPv6() || !*testIPv6 {
	 322  		t.Skip("IPv6 is required")
	 323  	}
	 324  
	 325  	ipaddrs, err := DefaultResolver.LookupIPAddr(context.Background(), "fe80::1%lo0")
	 326  	if err != nil {
	 327  		t.Error(err)
	 328  	}
	 329  	for _, addr := range ipaddrs {
	 330  		if e, a := "lo0", addr.Zone; e != a {
	 331  			t.Errorf("wrong zone: want %q, got %q", e, a)
	 332  		}
	 333  	}
	 334  
	 335  	addrs, err := DefaultResolver.LookupHost(context.Background(), "fe80::1%lo0")
	 336  	if err != nil {
	 337  		t.Error(err)
	 338  	}
	 339  	for _, addr := range addrs {
	 340  		if e, a := "fe80::1%lo0", addr; e != a {
	 341  			t.Errorf("wrong host: want %q got %q", e, a)
	 342  		}
	 343  	}
	 344  }
	 345  
	 346  var lookupCNAMETests = []struct {
	 347  	name, cname string
	 348  }{
	 349  	{"www.iana.org", "icann.org."},
	 350  	{"www.iana.org.", "icann.org."},
	 351  	{"www.google.com", "google.com."},
	 352  }
	 353  
	 354  func TestLookupCNAME(t *testing.T) {
	 355  	mustHaveExternalNetwork(t)
	 356  
	 357  	if !supportsIPv4() || !*testIPv4 {
	 358  		t.Skip("IPv4 is required")
	 359  	}
	 360  
	 361  	defer dnsWaitGroup.Wait()
	 362  
	 363  	attempts := 0
	 364  	for i := 0; i < len(lookupCNAMETests); i++ {
	 365  		tt := lookupCNAMETests[i]
	 366  		cname, err := LookupCNAME(tt.name)
	 367  		if err != nil {
	 368  			testenv.SkipFlakyNet(t)
	 369  			if attempts < len(backoffDuration) {
	 370  				dur := backoffDuration[attempts]
	 371  				t.Logf("backoff %v after failure %v\n", dur, err)
	 372  				time.Sleep(dur)
	 373  				attempts++
	 374  				i--
	 375  				continue
	 376  			}
	 377  			t.Fatal(err)
	 378  		}
	 379  		if !hasSuffixFold(cname, tt.cname) {
	 380  			t.Errorf("got %s; want a record containing %s", cname, tt.cname)
	 381  		}
	 382  	}
	 383  }
	 384  
	 385  var lookupGoogleHostTests = []struct {
	 386  	name string
	 387  }{
	 388  	{"google.com"},
	 389  	{"google.com."},
	 390  }
	 391  
	 392  func TestLookupGoogleHost(t *testing.T) {
	 393  	mustHaveExternalNetwork(t)
	 394  
	 395  	if !supportsIPv4() || !*testIPv4 {
	 396  		t.Skip("IPv4 is required")
	 397  	}
	 398  
	 399  	defer dnsWaitGroup.Wait()
	 400  
	 401  	for _, tt := range lookupGoogleHostTests {
	 402  		addrs, err := LookupHost(tt.name)
	 403  		if err != nil {
	 404  			t.Fatal(err)
	 405  		}
	 406  		if len(addrs) == 0 {
	 407  			t.Error("got no record")
	 408  		}
	 409  		for _, addr := range addrs {
	 410  			if ParseIP(addr) == nil {
	 411  				t.Errorf("got %q; want a literal IP address", addr)
	 412  			}
	 413  		}
	 414  	}
	 415  }
	 416  
	 417  func TestLookupLongTXT(t *testing.T) {
	 418  	testenv.SkipFlaky(t, 22857)
	 419  	mustHaveExternalNetwork(t)
	 420  
	 421  	defer dnsWaitGroup.Wait()
	 422  
	 423  	txts, err := LookupTXT("golang.rsc.io")
	 424  	if err != nil {
	 425  		t.Fatal(err)
	 426  	}
	 427  	sort.Strings(txts)
	 428  	want := []string{
	 429  		strings.Repeat("abcdefghijklmnopqrstuvwxyABCDEFGHJIKLMNOPQRSTUVWXY", 10),
	 430  		"gophers rule",
	 431  	}
	 432  	if !reflect.DeepEqual(txts, want) {
	 433  		t.Fatalf("LookupTXT golang.rsc.io incorrect\nhave %q\nwant %q", txts, want)
	 434  	}
	 435  }
	 436  
	 437  var lookupGoogleIPTests = []struct {
	 438  	name string
	 439  }{
	 440  	{"google.com"},
	 441  	{"google.com."},
	 442  }
	 443  
	 444  func TestLookupGoogleIP(t *testing.T) {
	 445  	mustHaveExternalNetwork(t)
	 446  
	 447  	if !supportsIPv4() || !*testIPv4 {
	 448  		t.Skip("IPv4 is required")
	 449  	}
	 450  
	 451  	defer dnsWaitGroup.Wait()
	 452  
	 453  	for _, tt := range lookupGoogleIPTests {
	 454  		ips, err := LookupIP(tt.name)
	 455  		if err != nil {
	 456  			t.Fatal(err)
	 457  		}
	 458  		if len(ips) == 0 {
	 459  			t.Error("got no record")
	 460  		}
	 461  		for _, ip := range ips {
	 462  			if ip.To4() == nil && ip.To16() == nil {
	 463  				t.Errorf("got %v; want an IP address", ip)
	 464  			}
	 465  		}
	 466  	}
	 467  }
	 468  
	 469  var revAddrTests = []struct {
	 470  	Addr			string
	 471  	Reverse	 string
	 472  	ErrPrefix string
	 473  }{
	 474  	{"1.2.3.4", "4.3.2.1.in-addr.arpa.", ""},
	 475  	{"245.110.36.114", "114.36.110.245.in-addr.arpa.", ""},
	 476  	{"::ffff:12.34.56.78", "78.56.34.12.in-addr.arpa.", ""},
	 477  	{"::1", "1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa.", ""},
	 478  	{"1::", "0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.1.0.0.0.ip6.arpa.", ""},
	 479  	{"1234:567::89a:bcde", "e.d.c.b.a.9.8.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.7.6.5.0.4.3.2.1.ip6.arpa.", ""},
	 480  	{"1234:567:fefe:bcbc:adad:9e4a:89a:bcde", "e.d.c.b.a.9.8.0.a.4.e.9.d.a.d.a.c.b.c.b.e.f.e.f.7.6.5.0.4.3.2.1.ip6.arpa.", ""},
	 481  	{"1.2.3", "", "unrecognized address"},
	 482  	{"1.2.3.4.5", "", "unrecognized address"},
	 483  	{"1234:567:bcbca::89a:bcde", "", "unrecognized address"},
	 484  	{"1234:567::bcbc:adad::89a:bcde", "", "unrecognized address"},
	 485  }
	 486  
	 487  func TestReverseAddress(t *testing.T) {
	 488  	defer dnsWaitGroup.Wait()
	 489  	for i, tt := range revAddrTests {
	 490  		a, err := reverseaddr(tt.Addr)
	 491  		if len(tt.ErrPrefix) > 0 && err == nil {
	 492  			t.Errorf("#%d: expected %q, got <nil> (error)", i, tt.ErrPrefix)
	 493  			continue
	 494  		}
	 495  		if len(tt.ErrPrefix) == 0 && err != nil {
	 496  			t.Errorf("#%d: expected <nil>, got %q (error)", i, err)
	 497  		}
	 498  		if err != nil && err.(*DNSError).Err != tt.ErrPrefix {
	 499  			t.Errorf("#%d: expected %q, got %q (mismatched error)", i, tt.ErrPrefix, err.(*DNSError).Err)
	 500  		}
	 501  		if a != tt.Reverse {
	 502  			t.Errorf("#%d: expected %q, got %q (reverse address)", i, tt.Reverse, a)
	 503  		}
	 504  	}
	 505  }
	 506  
	 507  func TestDNSFlood(t *testing.T) {
	 508  	if !*testDNSFlood {
	 509  		t.Skip("test disabled; use -dnsflood to enable")
	 510  	}
	 511  
	 512  	defer dnsWaitGroup.Wait()
	 513  
	 514  	var N = 5000
	 515  	if runtime.GOOS == "darwin" || runtime.GOOS == "ios" {
	 516  		// On Darwin this test consumes kernel threads much
	 517  		// than other platforms for some reason.
	 518  		// When we monitor the number of allocated Ms by
	 519  		// observing on runtime.newm calls, we can see that it
	 520  		// easily reaches the per process ceiling
	 521  		// kern.num_threads when CGO_ENABLED=1 and
	 522  		// GODEBUG=netdns=go.
	 523  		N = 500
	 524  	}
	 525  
	 526  	const timeout = 3 * time.Second
	 527  	ctxHalfTimeout, cancel := context.WithTimeout(context.Background(), timeout/2)
	 528  	defer cancel()
	 529  	ctxTimeout, cancel := context.WithTimeout(context.Background(), timeout)
	 530  	defer cancel()
	 531  
	 532  	c := make(chan error, 2*N)
	 533  	for i := 0; i < N; i++ {
	 534  		name := fmt.Sprintf("%d.net-test.golang.org", i)
	 535  		go func() {
	 536  			_, err := DefaultResolver.LookupIPAddr(ctxHalfTimeout, name)
	 537  			c <- err
	 538  		}()
	 539  		go func() {
	 540  			_, err := DefaultResolver.LookupIPAddr(ctxTimeout, name)
	 541  			c <- err
	 542  		}()
	 543  	}
	 544  	qstats := struct {
	 545  		succeeded, failed				 int
	 546  		timeout, temporary, other int
	 547  		unknown									 int
	 548  	}{}
	 549  	deadline := time.After(timeout + time.Second)
	 550  	for i := 0; i < 2*N; i++ {
	 551  		select {
	 552  		case <-deadline:
	 553  			t.Fatal("deadline exceeded")
	 554  		case err := <-c:
	 555  			switch err := err.(type) {
	 556  			case nil:
	 557  				qstats.succeeded++
	 558  			case Error:
	 559  				qstats.failed++
	 560  				if err.Timeout() {
	 561  					qstats.timeout++
	 562  				}
	 563  				if err.Temporary() {
	 564  					qstats.temporary++
	 565  				}
	 566  				if !err.Timeout() && !err.Temporary() {
	 567  					qstats.other++
	 568  				}
	 569  			default:
	 570  				qstats.failed++
	 571  				qstats.unknown++
	 572  			}
	 573  		}
	 574  	}
	 575  
	 576  	// A high volume of DNS queries for sub-domain of golang.org
	 577  	// would be coordinated by authoritative or recursive server,
	 578  	// or stub resolver which implements query-response rate
	 579  	// limitation, so we can expect some query successes and more
	 580  	// failures including timeout, temporary and other here.
	 581  	// As a rule, unknown must not be shown but it might possibly
	 582  	// happen due to issue 4856 for now.
	 583  	t.Logf("%v succeeded, %v failed (%v timeout, %v temporary, %v other, %v unknown)", qstats.succeeded, qstats.failed, qstats.timeout, qstats.temporary, qstats.other, qstats.unknown)
	 584  }
	 585  
	 586  func TestLookupDotsWithLocalSource(t *testing.T) {
	 587  	if !supportsIPv4() || !*testIPv4 {
	 588  		t.Skip("IPv4 is required")
	 589  	}
	 590  
	 591  	mustHaveExternalNetwork(t)
	 592  
	 593  	defer dnsWaitGroup.Wait()
	 594  
	 595  	for i, fn := range []func() func(){forceGoDNS, forceCgoDNS} {
	 596  		fixup := fn()
	 597  		if fixup == nil {
	 598  			continue
	 599  		}
	 600  		names, err := LookupAddr("127.0.0.1")
	 601  		fixup()
	 602  		if err != nil {
	 603  			t.Logf("#%d: %v", i, err)
	 604  			continue
	 605  		}
	 606  		mode := "netgo"
	 607  		if i == 1 {
	 608  			mode = "netcgo"
	 609  		}
	 610  	loop:
	 611  		for i, name := range names {
	 612  			if strings.Index(name, ".") == len(name)-1 { // "localhost" not "localhost."
	 613  				for j := range names {
	 614  					if j == i {
	 615  						continue
	 616  					}
	 617  					if names[j] == name[:len(name)-1] {
	 618  						// It's OK if we find the name without the dot,
	 619  						// as some systems say 127.0.0.1 localhost localhost.
	 620  						continue loop
	 621  					}
	 622  				}
	 623  				t.Errorf("%s: got %s; want %s", mode, name, name[:len(name)-1])
	 624  			} else if strings.Contains(name, ".") && !strings.HasSuffix(name, ".") { // "localhost.localdomain." not "localhost.localdomain"
	 625  				t.Errorf("%s: got %s; want name ending with trailing dot", mode, name)
	 626  			}
	 627  		}
	 628  	}
	 629  }
	 630  
	 631  func TestLookupDotsWithRemoteSource(t *testing.T) {
	 632  	if runtime.GOOS == "darwin" || runtime.GOOS == "ios" {
	 633  		testenv.SkipFlaky(t, 27992)
	 634  	}
	 635  	mustHaveExternalNetwork(t)
	 636  
	 637  	if !supportsIPv4() || !*testIPv4 {
	 638  		t.Skip("IPv4 is required")
	 639  	}
	 640  
	 641  	if iOS() {
	 642  		t.Skip("no resolv.conf on iOS")
	 643  	}
	 644  
	 645  	defer dnsWaitGroup.Wait()
	 646  
	 647  	if fixup := forceGoDNS(); fixup != nil {
	 648  		testDots(t, "go")
	 649  		fixup()
	 650  	}
	 651  	if fixup := forceCgoDNS(); fixup != nil {
	 652  		testDots(t, "cgo")
	 653  		fixup()
	 654  	}
	 655  }
	 656  
	 657  func testDots(t *testing.T, mode string) {
	 658  	names, err := LookupAddr("8.8.8.8") // Google dns server
	 659  	if err != nil {
	 660  		testenv.SkipFlakyNet(t)
	 661  		t.Errorf("LookupAddr(8.8.8.8): %v (mode=%v)", err, mode)
	 662  	} else {
	 663  		for _, name := range names {
	 664  			if !hasSuffixFold(name, ".google.com.") && !hasSuffixFold(name, ".google.") {
	 665  				t.Errorf("LookupAddr(8.8.8.8) = %v, want names ending in .google.com or .google with trailing dot (mode=%v)", names, mode)
	 666  				break
	 667  			}
	 668  		}
	 669  	}
	 670  
	 671  	cname, err := LookupCNAME("www.mit.edu")
	 672  	if err != nil {
	 673  		testenv.SkipFlakyNet(t)
	 674  		t.Errorf("LookupCNAME(www.mit.edu, mode=%v): %v", mode, err)
	 675  	} else if !strings.HasSuffix(cname, ".") {
	 676  		t.Errorf("LookupCNAME(www.mit.edu) = %v, want cname ending in . with trailing dot (mode=%v)", cname, mode)
	 677  	}
	 678  
	 679  	mxs, err := LookupMX("google.com")
	 680  	if err != nil {
	 681  		testenv.SkipFlakyNet(t)
	 682  		t.Errorf("LookupMX(google.com): %v (mode=%v)", err, mode)
	 683  	} else {
	 684  		for _, mx := range mxs {
	 685  			if !hasSuffixFold(mx.Host, ".google.com.") {
	 686  				t.Errorf("LookupMX(google.com) = %v, want names ending in .google.com. with trailing dot (mode=%v)", mxString(mxs), mode)
	 687  				break
	 688  			}
	 689  		}
	 690  	}
	 691  
	 692  	nss, err := LookupNS("google.com")
	 693  	if err != nil {
	 694  		testenv.SkipFlakyNet(t)
	 695  		t.Errorf("LookupNS(google.com): %v (mode=%v)", err, mode)
	 696  	} else {
	 697  		for _, ns := range nss {
	 698  			if !hasSuffixFold(ns.Host, ".google.com.") {
	 699  				t.Errorf("LookupNS(google.com) = %v, want names ending in .google.com. with trailing dot (mode=%v)", nsString(nss), mode)
	 700  				break
	 701  			}
	 702  		}
	 703  	}
	 704  
	 705  	cname, srvs, err := LookupSRV("xmpp-server", "tcp", "google.com")
	 706  	if err != nil {
	 707  		testenv.SkipFlakyNet(t)
	 708  		t.Errorf("LookupSRV(xmpp-server, tcp, google.com): %v (mode=%v)", err, mode)
	 709  	} else {
	 710  		if !hasSuffixFold(cname, ".google.com.") {
	 711  			t.Errorf("LookupSRV(xmpp-server, tcp, google.com) returned cname=%v, want name ending in .google.com. with trailing dot (mode=%v)", cname, mode)
	 712  		}
	 713  		for _, srv := range srvs {
	 714  			if !hasSuffixFold(srv.Target, ".google.com.") {
	 715  				t.Errorf("LookupSRV(xmpp-server, tcp, google.com) returned addrs=%v, want names ending in .google.com. with trailing dot (mode=%v)", srvString(srvs), mode)
	 716  				break
	 717  			}
	 718  		}
	 719  	}
	 720  }
	 721  
	 722  func mxString(mxs []*MX) string {
	 723  	var buf bytes.Buffer
	 724  	sep := ""
	 725  	fmt.Fprintf(&buf, "[")
	 726  	for _, mx := range mxs {
	 727  		fmt.Fprintf(&buf, "%s%s:%d", sep, mx.Host, mx.Pref)
	 728  		sep = " "
	 729  	}
	 730  	fmt.Fprintf(&buf, "]")
	 731  	return buf.String()
	 732  }
	 733  
	 734  func nsString(nss []*NS) string {
	 735  	var buf bytes.Buffer
	 736  	sep := ""
	 737  	fmt.Fprintf(&buf, "[")
	 738  	for _, ns := range nss {
	 739  		fmt.Fprintf(&buf, "%s%s", sep, ns.Host)
	 740  		sep = " "
	 741  	}
	 742  	fmt.Fprintf(&buf, "]")
	 743  	return buf.String()
	 744  }
	 745  
	 746  func srvString(srvs []*SRV) string {
	 747  	var buf bytes.Buffer
	 748  	sep := ""
	 749  	fmt.Fprintf(&buf, "[")
	 750  	for _, srv := range srvs {
	 751  		fmt.Fprintf(&buf, "%s%s:%d:%d:%d", sep, srv.Target, srv.Port, srv.Priority, srv.Weight)
	 752  		sep = " "
	 753  	}
	 754  	fmt.Fprintf(&buf, "]")
	 755  	return buf.String()
	 756  }
	 757  
	 758  func TestLookupPort(t *testing.T) {
	 759  	// See https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml
	 760  	//
	 761  	// Please be careful about adding new test cases.
	 762  	// There are platforms which have incomplete mappings for
	 763  	// restricted resource access and security reasons.
	 764  	type test struct {
	 765  		network string
	 766  		name		string
	 767  		port		int
	 768  		ok			bool
	 769  	}
	 770  	var tests = []test{
	 771  		{"tcp", "0", 0, true},
	 772  		{"udp", "0", 0, true},
	 773  		{"udp", "domain", 53, true},
	 774  
	 775  		{"--badnet--", "zzz", 0, false},
	 776  		{"tcp", "--badport--", 0, false},
	 777  		{"tcp", "-1", 0, false},
	 778  		{"tcp", "65536", 0, false},
	 779  		{"udp", "-1", 0, false},
	 780  		{"udp", "65536", 0, false},
	 781  		{"tcp", "123456789", 0, false},
	 782  
	 783  		// Issue 13610: LookupPort("tcp", "")
	 784  		{"tcp", "", 0, true},
	 785  		{"tcp4", "", 0, true},
	 786  		{"tcp6", "", 0, true},
	 787  		{"udp", "", 0, true},
	 788  		{"udp4", "", 0, true},
	 789  		{"udp6", "", 0, true},
	 790  	}
	 791  
	 792  	switch runtime.GOOS {
	 793  	case "android":
	 794  		if netGo {
	 795  			t.Skipf("not supported on %s without cgo; see golang.org/issues/14576", runtime.GOOS)
	 796  		}
	 797  	default:
	 798  		tests = append(tests, test{"tcp", "http", 80, true})
	 799  	}
	 800  
	 801  	for _, tt := range tests {
	 802  		port, err := LookupPort(tt.network, tt.name)
	 803  		if port != tt.port || (err == nil) != tt.ok {
	 804  			t.Errorf("LookupPort(%q, %q) = %d, %v; want %d, error=%t", tt.network, tt.name, port, err, tt.port, !tt.ok)
	 805  		}
	 806  		if err != nil {
	 807  			if perr := parseLookupPortError(err); perr != nil {
	 808  				t.Error(perr)
	 809  			}
	 810  		}
	 811  	}
	 812  }
	 813  
	 814  // Like TestLookupPort but with minimal tests that should always pass
	 815  // because the answers are baked-in to the net package.
	 816  func TestLookupPort_Minimal(t *testing.T) {
	 817  	type test struct {
	 818  		network string
	 819  		name		string
	 820  		port		int
	 821  	}
	 822  	var tests = []test{
	 823  		{"tcp", "http", 80},
	 824  		{"tcp", "HTTP", 80}, // case shouldn't matter
	 825  		{"tcp", "https", 443},
	 826  		{"tcp", "ssh", 22},
	 827  		{"tcp", "gopher", 70},
	 828  		{"tcp4", "http", 80},
	 829  		{"tcp6", "http", 80},
	 830  	}
	 831  
	 832  	for _, tt := range tests {
	 833  		port, err := LookupPort(tt.network, tt.name)
	 834  		if port != tt.port || err != nil {
	 835  			t.Errorf("LookupPort(%q, %q) = %d, %v; want %d, error=nil", tt.network, tt.name, port, err, tt.port)
	 836  		}
	 837  	}
	 838  }
	 839  
	 840  func TestLookupProtocol_Minimal(t *testing.T) {
	 841  	type test struct {
	 842  		name string
	 843  		want int
	 844  	}
	 845  	var tests = []test{
	 846  		{"tcp", 6},
	 847  		{"TcP", 6}, // case shouldn't matter
	 848  		{"icmp", 1},
	 849  		{"igmp", 2},
	 850  		{"udp", 17},
	 851  		{"ipv6-icmp", 58},
	 852  	}
	 853  
	 854  	for _, tt := range tests {
	 855  		got, err := lookupProtocol(context.Background(), tt.name)
	 856  		if got != tt.want || err != nil {
	 857  			t.Errorf("LookupProtocol(%q) = %d, %v; want %d, error=nil", tt.name, got, err, tt.want)
	 858  		}
	 859  	}
	 860  
	 861  }
	 862  
	 863  func TestLookupNonLDH(t *testing.T) {
	 864  	defer dnsWaitGroup.Wait()
	 865  
	 866  	if fixup := forceGoDNS(); fixup != nil {
	 867  		defer fixup()
	 868  	}
	 869  
	 870  	// "LDH" stands for letters, digits, and hyphens and is the usual
	 871  	// description of standard DNS names.
	 872  	// This test is checking that other kinds of names are reported
	 873  	// as not found, not reported as invalid names.
	 874  	addrs, err := LookupHost("!!!.###.bogus..domain.")
	 875  	if err == nil {
	 876  		t.Fatalf("lookup succeeded: %v", addrs)
	 877  	}
	 878  	if !strings.HasSuffix(err.Error(), errNoSuchHost.Error()) {
	 879  		t.Fatalf("lookup error = %v, want %v", err, errNoSuchHost)
	 880  	}
	 881  	if !err.(*DNSError).IsNotFound {
	 882  		t.Fatalf("lookup error = %v, want true", err.(*DNSError).IsNotFound)
	 883  	}
	 884  }
	 885  
	 886  func TestLookupContextCancel(t *testing.T) {
	 887  	mustHaveExternalNetwork(t)
	 888  	defer dnsWaitGroup.Wait()
	 889  
	 890  	ctx, ctxCancel := context.WithCancel(context.Background())
	 891  	ctxCancel()
	 892  	_, err := DefaultResolver.LookupIPAddr(ctx, "google.com")
	 893  	if err != errCanceled {
	 894  		testenv.SkipFlakyNet(t)
	 895  		t.Fatal(err)
	 896  	}
	 897  	ctx = context.Background()
	 898  	_, err = DefaultResolver.LookupIPAddr(ctx, "google.com")
	 899  	if err != nil {
	 900  		testenv.SkipFlakyNet(t)
	 901  		t.Fatal(err)
	 902  	}
	 903  }
	 904  
	 905  // Issue 24330: treat the nil *Resolver like a zero value. Verify nothing
	 906  // crashes if nil is used.
	 907  func TestNilResolverLookup(t *testing.T) {
	 908  	mustHaveExternalNetwork(t)
	 909  	var r *Resolver = nil
	 910  	ctx := context.Background()
	 911  
	 912  	// Don't care about the results, just that nothing panics:
	 913  	r.LookupAddr(ctx, "8.8.8.8")
	 914  	r.LookupCNAME(ctx, "google.com")
	 915  	r.LookupHost(ctx, "google.com")
	 916  	r.LookupIPAddr(ctx, "google.com")
	 917  	r.LookupIP(ctx, "ip", "google.com")
	 918  	r.LookupMX(ctx, "gmail.com")
	 919  	r.LookupNS(ctx, "google.com")
	 920  	r.LookupPort(ctx, "tcp", "smtp")
	 921  	r.LookupSRV(ctx, "service", "proto", "name")
	 922  	r.LookupTXT(ctx, "gmail.com")
	 923  }
	 924  
	 925  // TestLookupHostCancel verifies that lookup works even after many
	 926  // canceled lookups (see golang.org/issue/24178 for details).
	 927  func TestLookupHostCancel(t *testing.T) {
	 928  	mustHaveExternalNetwork(t)
	 929  	const (
	 930  		google				= "www.google.com"
	 931  		invalidDomain = "invalid.invalid" // RFC 2606 reserves .invalid
	 932  		n						 = 600							 // this needs to be larger than threadLimit size
	 933  	)
	 934  
	 935  	_, err := LookupHost(google)
	 936  	if err != nil {
	 937  		t.Fatal(err)
	 938  	}
	 939  
	 940  	ctx, cancel := context.WithCancel(context.Background())
	 941  	cancel()
	 942  	for i := 0; i < n; i++ {
	 943  		addr, err := DefaultResolver.LookupHost(ctx, invalidDomain)
	 944  		if err == nil {
	 945  			t.Fatalf("LookupHost(%q): returns %v, but should fail", invalidDomain, addr)
	 946  		}
	 947  		if !strings.Contains(err.Error(), "canceled") {
	 948  			t.Fatalf("LookupHost(%q): failed with unexpected error: %v", invalidDomain, err)
	 949  		}
	 950  		time.Sleep(time.Millisecond * 1)
	 951  	}
	 952  
	 953  	_, err = LookupHost(google)
	 954  	if err != nil {
	 955  		t.Fatal(err)
	 956  	}
	 957  }
	 958  
	 959  type lookupCustomResolver struct {
	 960  	*Resolver
	 961  	mu		 sync.RWMutex
	 962  	dialed bool
	 963  }
	 964  
	 965  func (lcr *lookupCustomResolver) dial() func(ctx context.Context, network, address string) (Conn, error) {
	 966  	return func(ctx context.Context, network, address string) (Conn, error) {
	 967  		lcr.mu.Lock()
	 968  		lcr.dialed = true
	 969  		lcr.mu.Unlock()
	 970  		return Dial(network, address)
	 971  	}
	 972  }
	 973  
	 974  // TestConcurrentPreferGoResolversDial tests that multiple resolvers with the
	 975  // PreferGo option used concurrently are all dialed properly.
	 976  func TestConcurrentPreferGoResolversDial(t *testing.T) {
	 977  	// The windows and plan9 implementation of the resolver does not use
	 978  	// the Dial function.
	 979  	switch runtime.GOOS {
	 980  	case "windows", "plan9":
	 981  		t.Skipf("skip on %v", runtime.GOOS)
	 982  	}
	 983  
	 984  	testenv.MustHaveExternalNetwork(t)
	 985  	testenv.SkipFlakyNet(t)
	 986  
	 987  	defer dnsWaitGroup.Wait()
	 988  
	 989  	resolvers := make([]*lookupCustomResolver, 2)
	 990  	for i := range resolvers {
	 991  		cs := lookupCustomResolver{Resolver: &Resolver{PreferGo: true}}
	 992  		cs.Dial = cs.dial()
	 993  		resolvers[i] = &cs
	 994  	}
	 995  
	 996  	var wg sync.WaitGroup
	 997  	wg.Add(len(resolvers))
	 998  	for i, resolver := range resolvers {
	 999  		go func(r *Resolver, index int) {
	1000  			defer wg.Done()
	1001  			_, err := r.LookupIPAddr(context.Background(), "google.com")
	1002  			if err != nil {
	1003  				t.Errorf("lookup failed for resolver %d: %q", index, err)
	1004  			}
	1005  		}(resolver.Resolver, i)
	1006  	}
	1007  	wg.Wait()
	1008  
	1009  	if t.Failed() {
	1010  		t.FailNow()
	1011  	}
	1012  
	1013  	for i, resolver := range resolvers {
	1014  		if !resolver.dialed {
	1015  			t.Errorf("custom resolver %d not dialed during lookup", i)
	1016  		}
	1017  	}
	1018  }
	1019  
	1020  var ipVersionTests = []struct {
	1021  	network string
	1022  	version byte
	1023  }{
	1024  	{"tcp", 0},
	1025  	{"tcp4", '4'},
	1026  	{"tcp6", '6'},
	1027  	{"udp", 0},
	1028  	{"udp4", '4'},
	1029  	{"udp6", '6'},
	1030  	{"ip", 0},
	1031  	{"ip4", '4'},
	1032  	{"ip6", '6'},
	1033  	{"ip7", 0},
	1034  	{"", 0},
	1035  }
	1036  
	1037  func TestIPVersion(t *testing.T) {
	1038  	for _, tt := range ipVersionTests {
	1039  		if version := ipVersion(tt.network); version != tt.version {
	1040  			t.Errorf("Family for: %s. Expected: %s, Got: %s", tt.network,
	1041  				string(tt.version), string(version))
	1042  		}
	1043  	}
	1044  }
	1045  
	1046  // Issue 28600: The context that is used to lookup ips should always
	1047  // preserve the values from the context that was passed into LookupIPAddr.
	1048  func TestLookupIPAddrPreservesContextValues(t *testing.T) {
	1049  	origTestHookLookupIP := testHookLookupIP
	1050  	defer func() { testHookLookupIP = origTestHookLookupIP }()
	1051  
	1052  	keyValues := []struct {
	1053  		key, value interface{}
	1054  	}{
	1055  		{"key-1", 12},
	1056  		{384, "value2"},
	1057  		{new(float64), 137},
	1058  	}
	1059  	ctx := context.Background()
	1060  	for _, kv := range keyValues {
	1061  		ctx = context.WithValue(ctx, kv.key, kv.value)
	1062  	}
	1063  
	1064  	wantIPs := []IPAddr{
	1065  		{IP: IPv4(127, 0, 0, 1)},
	1066  		{IP: IPv6loopback},
	1067  	}
	1068  
	1069  	checkCtxValues := func(ctx_ context.Context, fn func(context.Context, string, string) ([]IPAddr, error), network, host string) ([]IPAddr, error) {
	1070  		for _, kv := range keyValues {
	1071  			g, w := ctx_.Value(kv.key), kv.value
	1072  			if !reflect.DeepEqual(g, w) {
	1073  				t.Errorf("Value lookup:\n\tGot:	%v\n\tWant: %v", g, w)
	1074  			}
	1075  		}
	1076  		return wantIPs, nil
	1077  	}
	1078  	testHookLookupIP = checkCtxValues
	1079  
	1080  	resolvers := []*Resolver{
	1081  		nil,
	1082  		new(Resolver),
	1083  	}
	1084  
	1085  	for i, resolver := range resolvers {
	1086  		gotIPs, err := resolver.LookupIPAddr(ctx, "golang.org")
	1087  		if err != nil {
	1088  			t.Errorf("Resolver #%d: unexpected error: %v", i, err)
	1089  		}
	1090  		if !reflect.DeepEqual(gotIPs, wantIPs) {
	1091  			t.Errorf("#%d: mismatched IPAddr results\n\tGot: %v\n\tWant: %v", i, gotIPs, wantIPs)
	1092  		}
	1093  	}
	1094  }
	1095  
	1096  // Issue 30521: The lookup group should call the resolver for each network.
	1097  func TestLookupIPAddrConcurrentCallsForNetworks(t *testing.T) {
	1098  	origTestHookLookupIP := testHookLookupIP
	1099  	defer func() { testHookLookupIP = origTestHookLookupIP }()
	1100  
	1101  	queries := [][]string{
	1102  		{"udp", "golang.org"},
	1103  		{"udp4", "golang.org"},
	1104  		{"udp6", "golang.org"},
	1105  		{"udp", "golang.org"},
	1106  		{"udp", "golang.org"},
	1107  	}
	1108  	results := map[[2]string][]IPAddr{
	1109  		{"udp", "golang.org"}: {
	1110  			{IP: IPv4(127, 0, 0, 1)},
	1111  			{IP: IPv6loopback},
	1112  		},
	1113  		{"udp4", "golang.org"}: {
	1114  			{IP: IPv4(127, 0, 0, 1)},
	1115  		},
	1116  		{"udp6", "golang.org"}: {
	1117  			{IP: IPv6loopback},
	1118  		},
	1119  	}
	1120  	calls := int32(0)
	1121  	waitCh := make(chan struct{})
	1122  	testHookLookupIP = func(ctx context.Context, fn func(context.Context, string, string) ([]IPAddr, error), network, host string) ([]IPAddr, error) {
	1123  		// We'll block until this is called one time for each different
	1124  		// expected result. This will ensure that the lookup group would wait
	1125  		// for the existing call if it was to be reused.
	1126  		if atomic.AddInt32(&calls, 1) == int32(len(results)) {
	1127  			close(waitCh)
	1128  		}
	1129  		select {
	1130  		case <-waitCh:
	1131  		case <-ctx.Done():
	1132  			return nil, ctx.Err()
	1133  		}
	1134  		return results[[2]string{network, host}], nil
	1135  	}
	1136  
	1137  	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	1138  	defer cancel()
	1139  	wg := sync.WaitGroup{}
	1140  	for _, q := range queries {
	1141  		network := q[0]
	1142  		host := q[1]
	1143  		wg.Add(1)
	1144  		go func() {
	1145  			defer wg.Done()
	1146  			gotIPs, err := DefaultResolver.lookupIPAddr(ctx, network, host)
	1147  			if err != nil {
	1148  				t.Errorf("lookupIPAddr(%v, %v): unexpected error: %v", network, host, err)
	1149  			}
	1150  			wantIPs := results[[2]string{network, host}]
	1151  			if !reflect.DeepEqual(gotIPs, wantIPs) {
	1152  				t.Errorf("lookupIPAddr(%v, %v): mismatched IPAddr results\n\tGot: %v\n\tWant: %v", network, host, gotIPs, wantIPs)
	1153  			}
	1154  		}()
	1155  	}
	1156  	wg.Wait()
	1157  }
	1158  
	1159  func TestWithUnexpiredValuesPreserved(t *testing.T) {
	1160  	ctx, cancel := context.WithCancel(context.Background())
	1161  
	1162  	// Insert a value into it.
	1163  	key, value := "key-1", 2
	1164  	ctx = context.WithValue(ctx, key, value)
	1165  
	1166  	// Now use the "values preserving context" like
	1167  	// we would for LookupIPAddr. See Issue 28600.
	1168  	ctx = withUnexpiredValuesPreserved(ctx)
	1169  
	1170  	// Lookup before expiry.
	1171  	if g, w := ctx.Value(key), value; g != w {
	1172  		t.Errorf("Lookup before expiry: Got %v Want %v", g, w)
	1173  	}
	1174  
	1175  	// Cancel the context.
	1176  	cancel()
	1177  
	1178  	// Lookup after expiry should return nil
	1179  	if g := ctx.Value(key); g != nil {
	1180  		t.Errorf("Lookup after expiry: Got %v want nil", g)
	1181  	}
	1182  }
	1183  
	1184  // Issue 31597: don't panic on null byte in name
	1185  func TestLookupNullByte(t *testing.T) {
	1186  	testenv.MustHaveExternalNetwork(t)
	1187  	testenv.SkipFlakyNet(t)
	1188  	LookupHost("foo\x00bar") // check that it doesn't panic; it used to on Windows
	1189  }
	1190  
	1191  func TestResolverLookupIP(t *testing.T) {
	1192  	testenv.MustHaveExternalNetwork(t)
	1193  
	1194  	v4Ok := supportsIPv4() && *testIPv4
	1195  	v6Ok := supportsIPv6() && *testIPv6
	1196  
	1197  	defer dnsWaitGroup.Wait()
	1198  
	1199  	for _, impl := range []struct {
	1200  		name string
	1201  		fn	 func() func()
	1202  	}{
	1203  		{"go", forceGoDNS},
	1204  		{"cgo", forceCgoDNS},
	1205  	} {
	1206  		t.Run("implementation: "+impl.name, func(t *testing.T) {
	1207  			fixup := impl.fn()
	1208  			if fixup == nil {
	1209  				t.Skip("not supported")
	1210  			}
	1211  			defer fixup()
	1212  
	1213  			for _, network := range []string{"ip", "ip4", "ip6"} {
	1214  				t.Run("network: "+network, func(t *testing.T) {
	1215  					switch {
	1216  					case network == "ip4" && !v4Ok:
	1217  						t.Skip("IPv4 is not supported")
	1218  					case network == "ip6" && !v6Ok:
	1219  						t.Skip("IPv6 is not supported")
	1220  					}
	1221  
	1222  					// google.com has both A and AAAA records.
	1223  					const host = "google.com"
	1224  					ips, err := DefaultResolver.LookupIP(context.Background(), network, host)
	1225  					if err != nil {
	1226  						testenv.SkipFlakyNet(t)
	1227  						t.Fatalf("DefaultResolver.LookupIP(%q, %q): failed with unexpected error: %v", network, host, err)
	1228  					}
	1229  
	1230  					var v4Addrs []IP
	1231  					var v6Addrs []IP
	1232  					for _, ip := range ips {
	1233  						switch {
	1234  						case ip.To4() != nil:
	1235  							// We need to skip the test below because To16 will
	1236  							// convent an IPv4 address to an IPv4-mapped IPv6
	1237  							// address.
	1238  							v4Addrs = append(v4Addrs, ip)
	1239  						case ip.To16() != nil:
	1240  							v6Addrs = append(v6Addrs, ip)
	1241  						default:
	1242  							t.Fatalf("IP=%q is neither IPv4 nor IPv6", ip)
	1243  						}
	1244  					}
	1245  
	1246  					// Check that we got the expected addresses.
	1247  					if network == "ip4" || network == "ip" && v4Ok {
	1248  						if len(v4Addrs) == 0 {
	1249  							t.Errorf("DefaultResolver.LookupIP(%q, %q): no IPv4 addresses", network, host)
	1250  						}
	1251  					}
	1252  					if network == "ip6" || network == "ip" && v6Ok {
	1253  						if len(v6Addrs) == 0 {
	1254  							t.Errorf("DefaultResolver.LookupIP(%q, %q): no IPv6 addresses", network, host)
	1255  						}
	1256  					}
	1257  
	1258  					// Check that we didn't get any unexpected addresses.
	1259  					if network == "ip6" && len(v4Addrs) > 0 {
	1260  						t.Errorf("DefaultResolver.LookupIP(%q, %q): unexpected IPv4 addresses: %v", network, host, v4Addrs)
	1261  					}
	1262  					if network == "ip4" && len(v6Addrs) > 0 {
	1263  						t.Errorf("DefaultResolver.LookupIP(%q, %q): unexpected IPv6 addresses: %v", network, host, v6Addrs)
	1264  					}
	1265  				})
	1266  			}
	1267  		})
	1268  	}
	1269  }
	1270  

View as plain text