From 2385f692e861d3eebb6487353d62c9d6d38d424a Mon Sep 17 00:00:00 2001 From: Mikio Hara Date: Tue, 28 Apr 2015 19:59:07 +0900 Subject: [PATCH] net: consolidate listener test files This change merges unicast_posix_test.go and multicast_test.go into listen_test.go before deflaking tests for Listen functions. No code changes. Change-Id: Ic4cd6531b95dfb5b6e6e254241692eca61a71e94 Reviewed-on: https://go-review.googlesource.com/9460 Reviewed-by: Ian Lance Taylor --- .../{unicast_posix_test.go => listen_test.go} | 178 +++++++++++++++++ src/net/multicast_test.go | 188 ------------------ 2 files changed, 178 insertions(+), 188 deletions(-) rename src/net/{unicast_posix_test.go => listen_test.go} (74%) delete mode 100644 src/net/multicast_test.go diff --git a/src/net/unicast_posix_test.go b/src/net/listen_test.go similarity index 74% rename from src/net/unicast_posix_test.go rename to src/net/listen_test.go index ab7ef40a75..9e29375851 100644 --- a/src/net/unicast_posix_test.go +++ b/src/net/listen_test.go @@ -7,6 +7,8 @@ package net import ( + "fmt" + "os" "runtime" "syscall" "testing" @@ -467,3 +469,179 @@ func TestWildWildcardListener(t *testing.T) { ln.Close() } } + +var ipv4MulticastListenerTests = []struct { + net string + gaddr *UDPAddr // see RFC 4727 +}{ + {"udp", &UDPAddr{IP: IPv4(224, 0, 0, 254), Port: 12345}}, + + {"udp4", &UDPAddr{IP: IPv4(224, 0, 0, 254), Port: 12345}}, +} + +// TestIPv4MulticastListener tests both single and double listen to a +// test listener with same address family, same group address and same +// port. +func TestIPv4MulticastListener(t *testing.T) { + switch runtime.GOOS { + case "android", "nacl", "plan9": + t.Skipf("skipping test on %q", runtime.GOOS) + case "solaris": + t.Skipf("skipping test on solaris, see issue 7399") + } + + 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 && !*testExternal { + continue + } + for _, tt := range ipv4MulticastListenerTests { + var err error + cs := make([]*UDPConn, 2) + if cs[0], err = ListenMulticastUDP(tt.net, ifi, tt.gaddr); err != nil { + t.Fatalf("First ListenMulticastUDP on %v failed: %v", ifi, 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.Fatalf("Second ListenMulticastUDP on %v failed: %v", ifi, err) + } + if err := checkMulticastListener(cs[1], tt.gaddr.IP); err != nil { + closer(cs) + t.Fatal(err) + } + closer(cs) + } + } +} + +var ipv6MulticastListenerTests = []struct { + net string + gaddr *UDPAddr // see RFC 4727 +}{ + {"udp", &UDPAddr{IP: ParseIP("ff01::114"), Port: 12345}}, + {"udp", &UDPAddr{IP: ParseIP("ff02::114"), Port: 12345}}, + {"udp", &UDPAddr{IP: ParseIP("ff04::114"), Port: 12345}}, + {"udp", &UDPAddr{IP: ParseIP("ff05::114"), Port: 12345}}, + {"udp", &UDPAddr{IP: ParseIP("ff08::114"), Port: 12345}}, + {"udp", &UDPAddr{IP: ParseIP("ff0e::114"), Port: 12345}}, + + {"udp6", &UDPAddr{IP: ParseIP("ff01::114"), Port: 12345}}, + {"udp6", &UDPAddr{IP: ParseIP("ff02::114"), Port: 12345}}, + {"udp6", &UDPAddr{IP: ParseIP("ff04::114"), Port: 12345}}, + {"udp6", &UDPAddr{IP: ParseIP("ff05::114"), Port: 12345}}, + {"udp6", &UDPAddr{IP: ParseIP("ff08::114"), Port: 12345}}, + {"udp6", &UDPAddr{IP: ParseIP("ff0e::114"), Port: 12345}}, +} + +// 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) { + switch runtime.GOOS { + case "plan9": + t.Skipf("skipping test on %q", runtime.GOOS) + case "solaris": + t.Skipf("skipping test on solaris, see issue 7399") + } + if !supportsIPv6 { + t.Skip("ipv6 is not supported") + } + if os.Getuid() != 0 { + t.Skip("skipping test; 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 && (!*testExternal || !*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.Fatalf("First ListenMulticastUDP on %v failed: %v", ifi, 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.Fatalf("Second ListenMulticastUDP on %v failed: %v", ifi, err) + } + if err := checkMulticastListener(cs[1], tt.gaddr.IP); err != nil { + closer(cs) + t.Fatal(err) + } + closer(cs) + } + } +} + +func checkMulticastListener(c *UDPConn, ip IP) error { + if ok, err := multicastRIBContains(ip); err != nil { + return err + } else if !ok { + return fmt.Errorf("%q not found in multicast RIB", ip.String()) + } + la := c.LocalAddr() + if la, ok := la.(*UDPAddr); !ok || la.Port == 0 { + return fmt.Errorf("got %v; expected a proper address with non-zero port number", la) + } + return nil +} + +func multicastRIBContains(ip IP) (bool, error) { + switch runtime.GOOS { + case "dragonfly", "netbsd", "openbsd", "plan9", "solaris", "windows": + return true, nil // not implemented yet + case "linux": + if runtime.GOARCH == "arm" || runtime.GOARCH == "alpha" { + return true, nil // not implemented yet + } + } + ift, err := Interfaces() + if err != nil { + return false, err + } + for _, ifi := range ift { + ifmat, err := ifi.MulticastAddrs() + if err != nil { + return false, err + } + for _, ifma := range ifmat { + if ifma.(*IPAddr).IP.Equal(ip) { + return true, nil + } + } + } + return false, nil +} diff --git a/src/net/multicast_test.go b/src/net/multicast_test.go deleted file mode 100644 index 5f253f44a4..0000000000 --- a/src/net/multicast_test.go +++ /dev/null @@ -1,188 +0,0 @@ -// Copyright 2011 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package net - -import ( - "fmt" - "os" - "runtime" - "testing" -) - -var ipv4MulticastListenerTests = []struct { - net string - gaddr *UDPAddr // see RFC 4727 -}{ - {"udp", &UDPAddr{IP: IPv4(224, 0, 0, 254), Port: 12345}}, - - {"udp4", &UDPAddr{IP: IPv4(224, 0, 0, 254), Port: 12345}}, -} - -// TestIPv4MulticastListener tests both single and double listen to a -// test listener with same address family, same group address and same -// port. -func TestIPv4MulticastListener(t *testing.T) { - switch runtime.GOOS { - case "android", "nacl", "plan9": - t.Skipf("skipping test on %q", runtime.GOOS) - case "solaris": - t.Skipf("skipping test on solaris, see issue 7399") - } - - 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 && !*testExternal { - continue - } - for _, tt := range ipv4MulticastListenerTests { - var err error - cs := make([]*UDPConn, 2) - if cs[0], err = ListenMulticastUDP(tt.net, ifi, tt.gaddr); err != nil { - t.Fatalf("First ListenMulticastUDP on %v failed: %v", ifi, 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.Fatalf("Second ListenMulticastUDP on %v failed: %v", ifi, err) - } - if err := checkMulticastListener(cs[1], tt.gaddr.IP); err != nil { - closer(cs) - t.Fatal(err) - } - closer(cs) - } - } -} - -var ipv6MulticastListenerTests = []struct { - net string - gaddr *UDPAddr // see RFC 4727 -}{ - {"udp", &UDPAddr{IP: ParseIP("ff01::114"), Port: 12345}}, - {"udp", &UDPAddr{IP: ParseIP("ff02::114"), Port: 12345}}, - {"udp", &UDPAddr{IP: ParseIP("ff04::114"), Port: 12345}}, - {"udp", &UDPAddr{IP: ParseIP("ff05::114"), Port: 12345}}, - {"udp", &UDPAddr{IP: ParseIP("ff08::114"), Port: 12345}}, - {"udp", &UDPAddr{IP: ParseIP("ff0e::114"), Port: 12345}}, - - {"udp6", &UDPAddr{IP: ParseIP("ff01::114"), Port: 12345}}, - {"udp6", &UDPAddr{IP: ParseIP("ff02::114"), Port: 12345}}, - {"udp6", &UDPAddr{IP: ParseIP("ff04::114"), Port: 12345}}, - {"udp6", &UDPAddr{IP: ParseIP("ff05::114"), Port: 12345}}, - {"udp6", &UDPAddr{IP: ParseIP("ff08::114"), Port: 12345}}, - {"udp6", &UDPAddr{IP: ParseIP("ff0e::114"), Port: 12345}}, -} - -// 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) { - switch runtime.GOOS { - case "plan9": - t.Skipf("skipping test on %q", runtime.GOOS) - case "solaris": - t.Skipf("skipping test on solaris, see issue 7399") - } - if !supportsIPv6 { - t.Skip("ipv6 is not supported") - } - if os.Getuid() != 0 { - t.Skip("skipping test; 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 && (!*testExternal || !*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.Fatalf("First ListenMulticastUDP on %v failed: %v", ifi, 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.Fatalf("Second ListenMulticastUDP on %v failed: %v", ifi, err) - } - if err := checkMulticastListener(cs[1], tt.gaddr.IP); err != nil { - closer(cs) - t.Fatal(err) - } - closer(cs) - } - } -} - -func checkMulticastListener(c *UDPConn, ip IP) error { - if ok, err := multicastRIBContains(ip); err != nil { - return err - } else if !ok { - return fmt.Errorf("%q not found in multicast RIB", ip.String()) - } - la := c.LocalAddr() - if la, ok := la.(*UDPAddr); !ok || la.Port == 0 { - return fmt.Errorf("got %v; expected a proper address with non-zero port number", la) - } - return nil -} - -func multicastRIBContains(ip IP) (bool, error) { - switch runtime.GOOS { - case "dragonfly", "netbsd", "openbsd", "plan9", "solaris", "windows": - return true, nil // not implemented yet - case "linux": - if runtime.GOARCH == "arm" || runtime.GOARCH == "alpha" { - return true, nil // not implemented yet - } - } - ift, err := Interfaces() - if err != nil { - return false, err - } - for _, ifi := range ift { - ifmat, err := ifi.MulticastAddrs() - if err != nil { - return false, err - } - for _, ifma := range ifmat { - if ifma.(*IPAddr).IP.Equal(ip) { - return true, nil - } - } - } - return false, nil -} -- 2.50.0