func TestVendorTest2(t *testing.T) { testenv.MustHaveExternalNetwork(t) tg := testgo(t) defer tg.cleanup() tg.makeTempdir() tg.setenv("GOPATH", tg.path(".")) tg.setenv("GO15VENDOREXPERIMENT", "1") tg.run("get", "github.com/rsc/go-get-issue-11864") // build -i should work tg.run("build", "-i", "github.com/rsc/go-get-issue-11864") tg.run("build", "-i", "github.com/rsc/go-get-issue-11864/t") // test -i should work like build -i (golang.org/issue/11988) tg.run("test", "-i", "github.com/rsc/go-get-issue-11864") tg.run("test", "-i", "github.com/rsc/go-get-issue-11864/t") // test should work too tg.run("test", "github.com/rsc/go-get-issue-11864") tg.run("test", "github.com/rsc/go-get-issue-11864/t") // external tests should observe internal test exports (golang.org/issue/11977) tg.run("test", "github.com/rsc/go-get-issue-11864/vendor/vendor.org/tx2") }
func TestLookupNS(t *testing.T) { testenv.MustHaveExternalNetwork(t) for _, server := range nslookupTestServers { ns, err := LookupNS(server) if err != nil { t.Errorf("failed %s: %s", server, err) continue } if len(ns) == 0 { t.Errorf("no results") continue } expected, err := nslookupNS(server) if err != nil { t.Logf("skipping failed nslookup %s test: %s", server, err) continue } sort.Sort(byHost(expected)) sort.Sort(byHost(ns)) if !reflect.DeepEqual(expected, ns) { t.Errorf("different results %s:\texp:%v\tgot:%v", toJson(server), toJson(expected), ns) } } }
func TestVerifyHostname(t *testing.T) { testenv.MustHaveExternalNetwork(t) c, err := Dial("tcp", "www.google.com:https", nil) if err != nil { t.Fatal(err) } if err := c.VerifyHostname("www.google.com"); err != nil { t.Fatalf("verify www.google.com: %v", err) } if err := c.VerifyHostname("www.yahoo.com"); err == nil { t.Fatalf("verify www.yahoo.com succeeded") } c, err = Dial("tcp", "www.google.com:https", &Config{InsecureSkipVerify: true}) if err != nil { t.Fatal(err) } if err := c.VerifyHostname("www.google.com"); err == nil { t.Fatalf("verify www.google.com succeeded with InsecureSkipVerify=true") } if err := c.VerifyHostname("www.yahoo.com"); err == nil { t.Fatalf("verify www.google.com succeeded with InsecureSkipVerify=true") } }
func TestLookupTXT(t *testing.T) { testenv.MustHaveExternalNetwork(t) for _, server := range nslookupTestServers { txt, err := LookupTXT(server) if err != nil { t.Errorf("failed %s: %s", server, err) continue } if len(txt) == 0 { t.Errorf("no results") continue } expected, err := nslookupTXT(server) if err != nil { t.Logf("skipping failed nslookup %s test: %s", server, err) continue } sort.Strings(expected) sort.Strings(txt) if !reflect.DeepEqual(expected, txt) { t.Errorf("different results %s:\texp:%v\tgot:%v", server, toJson(expected), toJson(txt)) } } }
func TestVendorTest3(t *testing.T) { testenv.MustHaveExternalNetwork(t) tg := testgo(t) defer tg.cleanup() tg.makeTempdir() tg.setenv("GOPATH", tg.path(".")) tg.run("get", "github.com/clsung/go-vendor-issue-14613") tg.run("build", "-i", "github.com/clsung/go-vendor-issue-14613") // test folder should work tg.run("test", "-i", "github.com/clsung/go-vendor-issue-14613") tg.run("test", "github.com/clsung/go-vendor-issue-14613") // test with specified _test.go should work too tg.cd(filepath.Join(tg.path("."), "src")) tg.run("test", "-i", "github.com/clsung/go-vendor-issue-14613/vendor_test.go") tg.run("test", "github.com/clsung/go-vendor-issue-14613/vendor_test.go") // test with imported and not used tg.run("test", "-i", "github.com/clsung/go-vendor-issue-14613/vendor/mylibtesttest/myapp/myapp_test.go") tg.runFail("test", "github.com/clsung/go-vendor-issue-14613/vendor/mylibtesttest/myapp/myapp_test.go") tg.grepStderr("imported and not used:", `should say "imported and not used"`) }
func TestLookupGmailNS(t *testing.T) { if testenv.Builder() == "" { testenv.MustHaveExternalNetwork(t) } if !supportsIPv4 || !*testIPv4 { t.Skip("IPv4 is required") } for _, tt := range lookupGmailNSTests { nss, err := LookupNS(tt.name) if err != nil { testenv.SkipFlakyNet(t) t.Fatal(err) } if len(nss) == 0 { t.Error("got no record") } for _, ns := range nss { if !strings.HasSuffix(ns.Host, tt.host) { t.Errorf("got %v; want a record containing %s", ns, tt.host) } } } }
func TestLookupGoogleSRV(t *testing.T) { if testenv.Builder() == "" { testenv.MustHaveExternalNetwork(t) } if !supportsIPv4 || !*testIPv4 { t.Skip("IPv4 is required") } for _, tt := range lookupGoogleSRVTests { cname, srvs, err := LookupSRV(tt.service, tt.proto, tt.name) if err != nil { testenv.SkipFlakyNet(t) t.Fatal(err) } if len(srvs) == 0 { t.Error("got no record") } if !strings.HasSuffix(cname, tt.cname) { t.Errorf("got %s; want %s", cname, tt.cname) } for _, srv := range srvs { if !strings.HasSuffix(srv.Target, tt.target) { t.Errorf("got %v; want a record containing %s", srv, tt.target) } } } }
func TestProhibitionaryDialArg(t *testing.T) { testenv.MustHaveExternalNetwork(t) switch runtime.GOOS { case "plan9": t.Skipf("not supported on %s", runtime.GOOS) } if !supportsIPv4map { t.Skip("mapping ipv4 address inside ipv6 address not supported") } ln, err := Listen("tcp", "[::]:0") if err != nil { t.Fatal(err) } defer ln.Close() _, port, err := SplitHostPort(ln.Addr().String()) if err != nil { t.Fatal(err) } for i, tt := range prohibitionaryDialArgTests { c, err := Dial(tt.network, JoinHostPort(tt.address, port)) if err == nil { c.Close() t.Errorf("#%d: %v", i, err) } } }
func TestWildWildcardListener(t *testing.T) { testenv.MustHaveExternalNetwork(t) switch runtime.GOOS { case "plan9": t.Skipf("not supported on %s", runtime.GOOS) } defer func() { if p := recover(); p != nil { t.Fatalf("panicked: %v", p) } }() if ln, err := Listen("tcp", ""); err == nil { ln.Close() } if ln, err := ListenPacket("udp", ""); err == nil { ln.Close() } if ln, err := ListenTCP("tcp", nil); err == nil { ln.Close() } if ln, err := ListenUDP("udp", nil); err == nil { ln.Close() } if ln, err := ListenIP("ip:icmp", nil); err == nil { ln.Close() } }
func TestListenMulticastUDP(t *testing.T) { testenv.MustHaveExternalNetwork(t) ifcs, err := Interfaces() if err != nil { t.Skip(err.Error()) } if len(ifcs) == 0 { t.Skip("no network interfaces found") } var mifc *Interface for _, ifc := range ifcs { if ifc.Flags&FlagUp|FlagMulticast != FlagUp|FlagMulticast { continue } mifc = &ifc break } if mifc == nil { t.Skipf("no multicast interfaces found") } c1, err := ListenMulticastUDP("udp4", mifc, &UDPAddr{IP: ParseIP("224.0.0.254")}) if err != nil { t.Fatalf("multicast not working on %s", runtime.GOOS) } c1addr := c1.LocalAddr().(*UDPAddr) if err != nil { t.Fatal(err) } defer c1.Close() c2, err := ListenUDP("udp4", &UDPAddr{IP: IPv4zero, Port: 0}) c2addr := c2.LocalAddr().(*UDPAddr) if err != nil { t.Fatal(err) } defer c2.Close() n, err := c2.WriteToUDP([]byte("data"), c1addr) if err != nil { t.Fatal(err) } if n != 4 { t.Fatalf("got %d; want 4", n) } n, err = c1.WriteToUDP([]byte("data"), c2addr) if err != nil { t.Fatal(err) } if n != 4 { t.Fatalf("got %d; want 4", n) } }
func TestGetSubmodules(t *testing.T) { testenv.MustHaveExternalNetwork(t) tg := testgo(t) defer tg.cleanup() tg.makeTempdir() tg.setenv("GOPATH", tg.path(".")) tg.run("get", "-d", "github.com/rsc/go-get-issue-12612") tg.run("get", "-u", "-d", "github.com/rsc/go-get-issue-12612") }
func TestVendorGetUpdate(t *testing.T) { testenv.MustHaveExternalNetwork(t) tg := testgo(t) defer tg.cleanup() tg.makeTempdir() tg.setenv("GOPATH", tg.path(".")) tg.run("get", "github.com/rsc/go-get-issue-11864") tg.run("get", "-u", "github.com/rsc/go-get-issue-11864") }
// TestIPv6MulticastListener tests both single and double listen to a // test listener with same address family, same group address and same // port. func TestIPv6MulticastListener(t *testing.T) { testenv.MustHaveExternalNetwork(t) switch runtime.GOOS { case "plan9": t.Skipf("not supported on %s", runtime.GOOS) case "solaris": t.Skipf("not supported on solaris, see issue 7399") } if !supportsIPv6 { t.Skip("IPv6 is not supported") } if os.Getuid() != 0 { t.Skip("must be root") } closer := func(cs []*UDPConn) { for _, c := range cs { if c != nil { c.Close() } } } for _, ifi := range []*Interface{loopbackInterface(), nil} { // Note that multicast interface assignment by system // is not recommended because it usually relies on // routing stuff for finding out an appropriate // nexthop containing both network and link layer // adjacencies. if ifi == nil && !*testIPv6 { continue } for _, tt := range ipv6MulticastListenerTests { var err error cs := make([]*UDPConn, 2) if cs[0], err = ListenMulticastUDP(tt.net, ifi, tt.gaddr); err != nil { t.Fatal(err) } if err := checkMulticastListener(cs[0], tt.gaddr.IP); err != nil { closer(cs) t.Fatal(err) } if cs[1], err = ListenMulticastUDP(tt.net, ifi, tt.gaddr); err != nil { closer(cs) t.Fatal(err) } if err := checkMulticastListener(cs[1], tt.gaddr.IP); err != nil { closer(cs) t.Fatal(err) } closer(cs) } } }
func TestGetSubmodules(t *testing.T) { testenv.MustHaveExternalNetwork(t) tg := testgo(t) defer tg.cleanup() tg.makeTempdir() tg.setenv("GOPATH", tg.path(".")) tg.run("get", "-d", "github.com/rsc/go-get-issue-12612") tg.run("get", "-u", "-d", "github.com/rsc/go-get-issue-12612") tg.mustExist(tg.path("src/github.com/rsc/go-get-issue-12612/vendor/golang.org/x/crypto/.git")) }
func TestIPv6LinkLocalUnicastTCP(t *testing.T) { testenv.MustHaveExternalNetwork(t) if !supportsIPv6 { t.Skip("IPv6 is not supported") } for i, tt := range ipv6LinkLocalUnicastTCPTests { ln, err := Listen(tt.network, tt.address) if err != nil { // It might return "LookupHost returned no // suitable address" error on some platforms. t.Log(err) continue } ls, err := (&streamListener{Listener: ln}).newLocalServer() if err != nil { t.Fatal(err) } defer ls.teardown() ch := make(chan error, 1) handler := func(ls *localServer, ln Listener) { transponder(ln, ch) } if err := ls.buildup(handler); err != nil { t.Fatal(err) } if la, ok := ln.Addr().(*TCPAddr); !ok || !tt.nameLookup && la.Zone == "" { t.Fatalf("got %v; expected a proper address with zone identifier", la) } c, err := Dial(tt.network, ls.Listener.Addr().String()) if err != nil { t.Fatal(err) } defer c.Close() if la, ok := c.LocalAddr().(*TCPAddr); !ok || !tt.nameLookup && la.Zone == "" { t.Fatalf("got %v; expected a proper address with zone identifier", la) } if ra, ok := c.RemoteAddr().(*TCPAddr); !ok || !tt.nameLookup && ra.Zone == "" { t.Fatalf("got %v; expected a proper address with zone identifier", ra) } if _, err := c.Write([]byte("TCP OVER IPV6 LINKLOCAL TEST")); err != nil { t.Fatal(err) } b := make([]byte, 32) if _, err := c.Read(b); err != nil { t.Fatal(err) } for err := range ch { t.Errorf("#%d: %v", i, err) } } }
func TestTCPListenerName(t *testing.T) { testenv.MustHaveExternalNetwork(t) for _, tt := range tcpListenerNameTests { ln, err := ListenTCP(tt.net, tt.laddr) if err != nil { t.Fatal(err) } defer ln.Close() la := ln.Addr() if a, ok := la.(*TCPAddr); !ok || a.Port == 0 { t.Fatalf("got %v; expected a proper address with non-zero port number", la) } } }
func TestUDPConnLocalName(t *testing.T) { testenv.MustHaveExternalNetwork(t) for _, tt := range udpConnLocalNameTests { c, err := ListenUDP(tt.net, tt.laddr) if err != nil { t.Fatal(err) } defer c.Close() la := c.LocalAddr() if a, ok := la.(*UDPAddr); !ok || a.Port == 0 { t.Fatalf("got %v; expected a proper address with non-zero port number", la) } } }
func TestLookupDotsWithRemoteSource(t *testing.T) { if testenv.Builder() == "" { testenv.MustHaveExternalNetwork(t) } if !supportsIPv4 || !*testIPv4 { t.Skip("IPv4 is required") } if fixup := forceGoDNS(); fixup != nil { testDots(t, "go") fixup() } if fixup := forceCgoDNS(); fixup != nil { testDots(t, "cgo") fixup() } }
func TestLookupDotsWithLocalSource(t *testing.T) { if !supportsIPv4 || !*testIPv4 { t.Skip("IPv4 is required") } if testenv.Builder() == "" { testenv.MustHaveExternalNetwork(t) } for i, fn := range []func() func(){forceGoDNS, forceCgoDNS} { fixup := fn() if fixup == nil { continue } names, err := LookupAddr("127.0.0.1") fixup() if err != nil { t.Logf("#%d: %v", i, err) continue } mode := "netgo" if i == 1 { mode = "netcgo" } loop: for i, name := range names { if strings.Index(name, ".") == len(name)-1 { // "localhost" not "localhost." for j := range names { if j == i { continue } if names[j] == name[:len(name)-1] { // It's OK if we find the name without the dot, // as some systems say 127.0.0.1 localhost localhost. continue loop } } t.Errorf("%s: got %s; want %s", mode, name, name[:len(name)-1]) } else if strings.Contains(name, ".") && !strings.HasSuffix(name, ".") { // "localhost.localdomain." not "localhost.localdomain" t.Errorf("%s: got %s; want name ending with trailing dot", mode, name) } } } }
func TestDNSTransportFallback(t *testing.T) { testenv.MustHaveExternalNetwork(t) for _, tt := range dnsTransportFallbackTests { ctx, cancel := context.WithTimeout(context.Background(), time.Duration(tt.timeout)*time.Second) defer cancel() msg, err := exchange(ctx, tt.server, tt.name, tt.qtype) if err != nil { t.Error(err) continue } switch msg.rcode { case tt.rcode, dnsRcodeServerFailure: default: t.Errorf("got %v from %v; want %v", msg.rcode, tt.server, tt.rcode) continue } } }
func TestGoLookupIPWithResolverConfig(t *testing.T) { testenv.MustHaveExternalNetwork(t) conf, err := newResolvConfTest() if err != nil { t.Fatal(err) } defer conf.teardown() for _, tt := range goLookupIPWithResolverConfigTests { if err := conf.writeAndUpdate(tt.lines); err != nil { t.Error(err) continue } addrs, err := goLookupIP(context.Background(), tt.name) if err != nil { // This test uses external network connectivity. // We need to take care with errors on both // DNS message exchange layer and DNS // transport layer because goLookupIP may fail // when the IP connectivty on node under test // gets lost during its run. if err, ok := err.(*DNSError); !ok || tt.error != nil && (err.Name != tt.error.(*DNSError).Name || err.Server != tt.error.(*DNSError).Server || err.IsTimeout != tt.error.(*DNSError).IsTimeout) { t.Errorf("got %v; want %v", err, tt.error) } continue } if len(addrs) == 0 { t.Errorf("no records for %s", tt.name) } if !tt.a && !tt.aaaa && len(addrs) > 0 { t.Errorf("unexpected %v for %s", addrs, tt.name) } for _, addr := range addrs { if !tt.a && addr.IP.To4() != nil { t.Errorf("got %v; must not be IPv4 address", addr) } if !tt.aaaa && addr.IP.To16() != nil && addr.IP.To4() == nil { t.Errorf("got %v; must not be IPv6 address", addr) } } } }
func TestLookupIANACNAME(t *testing.T) { if testenv.Builder() == "" { testenv.MustHaveExternalNetwork(t) } if !supportsIPv4 || !*testIPv4 { t.Skip("IPv4 is required") } for _, tt := range lookupIANACNAMETests { cname, err := LookupCNAME(tt.name) if err != nil { t.Fatal(err) } if !strings.HasSuffix(cname, tt.cname) { t.Errorf("got %s; want a record containing %s", cname, tt.cname) } } }
func TestSpecialDomainName(t *testing.T) { testenv.MustHaveExternalNetwork(t) server := "8.8.8.8:53" for _, tt := range specialDomainNameTests { ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) defer cancel() msg, err := exchange(ctx, server, tt.name, tt.qtype) if err != nil { t.Error(err) continue } switch msg.rcode { case tt.rcode, dnsRcodeServerFailure: default: t.Errorf("got %v from %v; want %v", msg.rcode, server, tt.rcode) continue } } }
func TestUpdateResolvConf(t *testing.T) { testenv.MustHaveExternalNetwork(t) conf, err := newResolvConfTest() if err != nil { t.Fatal(err) } defer conf.teardown() for i, tt := range updateResolvConfTests { if err := conf.writeAndUpdate(tt.lines); err != nil { t.Error(err) continue } if tt.name != "" { var wg sync.WaitGroup const N = 10 wg.Add(N) for j := 0; j < N; j++ { go func(name string) { defer wg.Done() ips, err := goLookupIP(context.Background(), name) if err != nil { t.Error(err) return } if len(ips) == 0 { t.Errorf("no records for %s", name) return } }(tt.name) } wg.Wait() } servers := conf.servers() if !reflect.DeepEqual(servers, tt.servers) { t.Errorf("#%d: got %v; want %v", i, servers, tt.servers) continue } } }
// Test that goLookupIPOrder falls back to the host file when no DNS servers are available. func TestGoLookupIPOrderFallbackToFile(t *testing.T) { testenv.MustHaveExternalNetwork(t) // Add a config that simulates no dns servers being available. conf, err := newResolvConfTest() if err != nil { t.Fatal(err) } if err := conf.writeAndUpdate([]string{}); err != nil { t.Fatal(err) } // Redirect host file lookups. defer func(orig string) { testHookHostsPath = orig }(testHookHostsPath) testHookHostsPath = "testdata/hosts" for _, order := range []hostLookupOrder{hostLookupFilesDNS, hostLookupDNSFiles} { name := fmt.Sprintf("order %v", order) // First ensure that we get an error when contacting a non-existent host. _, err := goLookupIPOrder(context.Background(), "notarealhost", order) if err == nil { t.Errorf("%s: expected error while looking up name not in hosts file", name) continue } // Now check that we get an address when the name appears in the hosts file. addrs, err := goLookupIPOrder(context.Background(), "thor", order) // entry is in "testdata/hosts" if err != nil { t.Errorf("%s: expected to successfully lookup host entry", name) continue } if len(addrs) != 1 { t.Errorf("%s: expected exactly one result, but got %v", name, addrs) continue } if got, want := addrs[0].String(), "127.1.1.1"; got != want { t.Errorf("%s: address doesn't match expectation. got %v, want %v", name, got, want) } } defer conf.teardown() }
func TestVendorList(t *testing.T) { testenv.MustHaveExternalNetwork(t) tg := testgo(t) defer tg.cleanup() tg.makeTempdir() tg.setenv("GOPATH", tg.path(".")) tg.run("get", "github.com/rsc/go-get-issue-11864") tg.run("list", "-f", `{{join .TestImports "\n"}}`, "github.com/rsc/go-get-issue-11864/t") tg.grepStdout("go-get-issue-11864/vendor/vendor.org/p", "did not find vendor-expanded p") tg.run("list", "-f", `{{join .XTestImports "\n"}}`, "github.com/rsc/go-get-issue-11864/tx") tg.grepStdout("go-get-issue-11864/vendor/vendor.org/p", "did not find vendor-expanded p") tg.run("list", "-f", `{{join .XTestImports "\n"}}`, "github.com/rsc/go-get-issue-11864/vendor/vendor.org/tx2") tg.grepStdout("go-get-issue-11864/vendor/vendor.org/tx2", "did not find vendor-expanded tx2") tg.run("list", "-f", `{{join .XTestImports "\n"}}`, "github.com/rsc/go-get-issue-11864/vendor/vendor.org/tx3") tg.grepStdout("go-get-issue-11864/vendor/vendor.org/tx3", "did not find vendor-expanded tx3") }
func TestLookupCNAME(t *testing.T) { testenv.MustHaveExternalNetwork(t) for _, server := range nslookupTestServers { cname, err := LookupCNAME(server) if err != nil { t.Errorf("failed %s: %s", server, err) continue } if cname == "" { t.Errorf("no result %s", server) } expected, err := nslookupCNAME(server) if err != nil { t.Logf("skipping failed nslookup %s test: %s", server, err) continue } if expected != cname { t.Errorf("different results %s:\texp:%v\tgot:%v", server, expected, cname) } } }
func TestResolveGoogle(t *testing.T) { testenv.MustHaveExternalNetwork(t) if !supportsIPv4 || !supportsIPv6 || !*testIPv4 || !*testIPv6 { t.Skip("both IPv4 and IPv6 are required") } for _, network := range []string{"tcp", "tcp4", "tcp6"} { addr, err := ResolveTCPAddr(network, "www.google.com:http") if err != nil { t.Error(err) continue } switch { case network == "tcp" && addr.IP.To4() == nil: fallthrough case network == "tcp4" && addr.IP.To4() == nil: t.Errorf("got %v; want an IPv4 address on %s", addr, network) case network == "tcp6" && (addr.IP.To16() == nil || addr.IP.To4() != nil): t.Errorf("got %v; want an IPv6 address on %s", addr, network) } } }
func TestDialGoogle(t *testing.T) { testenv.MustHaveExternalNetwork(t) if !supportsIPv4 || !supportsIPv6 || !*testIPv4 || !*testIPv6 { t.Skip("both IPv4 and IPv6 are required") } var err error dialGoogleTests[1].addrs, dialGoogleTests[2].addrs, err = googleLiteralAddrs() if err != nil { t.Error(err) } for _, tt := range dialGoogleTests { for _, network := range tt.networks { disableSocketConnect(tt.unreachableNetwork) for _, addr := range tt.addrs { if err := fetchGoogle(tt.dial, network, addr); err != nil { t.Error(err) } } enableSocketConnect() } } }
func TestVerifyHostnameResumed(t *testing.T) { testenv.MustHaveExternalNetwork(t) config := &Config{ ClientSessionCache: NewLRUClientSessionCache(32), } for i := 0; i < 2; i++ { c, err := Dial("tcp", "www.google.com:https", config) if err != nil { t.Fatalf("Dial #%d: %v", i, err) } cs := c.ConnectionState() if i > 0 && !cs.DidResume { t.Fatalf("Subsequent connection unexpectedly didn't resume") } if cs.VerifiedChains == nil { t.Fatalf("Dial #%d: cs.VerifiedChains == nil", i) } if err := c.VerifyHostname("www.google.com"); err != nil { t.Fatalf("verify www.google.com #%d: %v", i, err) } c.Close() } }