go.net/ipv4: add missing per interface multicast listener tests

Also removes unnecessary build tag.

R=dave
CC=golang-dev
https://golang.org/cl/21270043

ipv4/multicastlistener_test.go

@@ -2,41 +2,41 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build darwin freebsd linux netbsd openbsd
-
 package ipv4_test
 
 import (
 	"code.google.com/p/go.net/ipv4"
 	"net"
 	"os"
+	"runtime"
 	"testing"
 )
 
-var udpMultipleGroupListenerTests = []struct {
-	gaddr *net.UDPAddr
-}{
-	{&net.UDPAddr{IP: net.IPv4(224, 0, 0, 249)}}, // see RFC 4727
-	{&net.UDPAddr{IP: net.IPv4(224, 0, 0, 250)}}, // see RFC 4727
-	{&net.UDPAddr{IP: net.IPv4(224, 0, 0, 254)}}, // see RFC 4727
+var udpMultipleGroupListenerTests = []net.Addr{
+	&net.UDPAddr{IP: net.IPv4(224, 0, 0, 249)}, // see RFC 4727
+	&net.UDPAddr{IP: net.IPv4(224, 0, 0, 250)},
+	&net.UDPAddr{IP: net.IPv4(224, 0, 0, 254)},
 }
 
-func TestUDPSingleConnWithMultipleGroupListeners(t *testing.T) {
+func TestUDPSinglePacketConnWithMultipleGroupListeners(t *testing.T) {
+	switch runtime.GOOS {
+	case "plan9", "windows":
+		t.Skipf("not supported on %q", runtime.GOOS)
+	}
 	if testing.Short() || !*testExternal {
 		t.Skip("to avoid external network")
 	}
 
-	for _, tt := range udpMultipleGroupListenerTests {
-		// listen to a wildcard address with no reusable port
-		c, err := net.ListenPacket("udp4", "0.0.0.0:0")
+	for _, gaddr := range udpMultipleGroupListenerTests {
+		c, err := net.ListenPacket("udp4", "0.0.0.0:0") // wildcard address with no reusable port
 		if err != nil {
 			t.Fatalf("net.ListenPacket failed: %v", err)
 		}
 		defer c.Close()
 
 		p := ipv4.NewPacketConn(c)
-
 		var mift []*net.Interface
+
 		ift, err := net.Interfaces()
 		if err != nil {
 			t.Fatalf("net.Interfaces failed: %v", err)
@@ -45,34 +45,36 @@ func TestUDPSingleConnWithMultipleGroupListeners(t *testing.T) {
 			if _, ok := isMulticastAvailable(&ifi); !ok {
 				continue
 			}
-			if err := p.JoinGroup(&ifi, tt.gaddr); err != nil {
-				t.Fatalf("ipv4.PacketConn.JoinGroup %v on %v failed: %v", tt.gaddr, ifi, err)
+			if err := p.JoinGroup(&ifi, gaddr); err != nil {
+				t.Fatalf("ipv4.PacketConn.JoinGroup %v on %v failed: %v", gaddr, ifi, err)
 			}
 			mift = append(mift, &ift[i])
 		}
 		for _, ifi := range mift {
-			if err := p.LeaveGroup(ifi, tt.gaddr); err != nil {
-				t.Fatalf("ipv4.PacketConn.LeaveGroup %v on %v failed: %v", tt.gaddr, ifi, err)
+			if err := p.LeaveGroup(ifi, gaddr); err != nil {
+				t.Fatalf("ipv4.PacketConn.LeaveGroup %v on %v failed: %v", gaddr, ifi, err)
 			}
 		}
 	}
 }
 
-func TestUDPMultipleConnWithMultipleGroupListeners(t *testing.T) {
+func TestUDPMultiplePacketConnWithMultipleGroupListeners(t *testing.T) {
+	switch runtime.GOOS {
+	case "plan9", "windows":
+		t.Skipf("not supported on %q", runtime.GOOS)
+	}
 	if testing.Short() || !*testExternal {
 		t.Skip("to avoid external network")
 	}
 
-	for _, tt := range udpMultipleGroupListenerTests {
-		// listen to a group address, actually a wildcard address
-		// with reusable port
-		c1, err := net.ListenPacket("udp4", "224.0.0.0:1024") // see RFC 4727
+	for _, gaddr := range udpMultipleGroupListenerTests {
+		c1, err := net.ListenPacket("udp4", "224.0.0.0:1024") // wildcard address with reusable port
 		if err != nil {
 			t.Fatalf("net.ListenPacket failed: %v", err)
 		}
 		defer c1.Close()
 
-		c2, err := net.ListenPacket("udp4", "224.0.0.0:1024") // see RFC 4727
+		c2, err := net.ListenPacket("udp4", "224.0.0.0:1024") // wildcard address with reusable port
 		if err != nil {
 			t.Fatalf("net.ListenPacket failed: %v", err)
 		}
@@ -81,8 +83,8 @@ func TestUDPMultipleConnWithMultipleGroupListeners(t *testing.T) {
 		var ps [2]*ipv4.PacketConn
 		ps[0] = ipv4.NewPacketConn(c1)
 		ps[1] = ipv4.NewPacketConn(c2)
-
 		var mift []*net.Interface
+
 		ift, err := net.Interfaces()
 		if err != nil {
 			t.Fatalf("net.Interfaces failed: %v", err)
@@ -92,105 +94,115 @@ func TestUDPMultipleConnWithMultipleGroupListeners(t *testing.T) {
 				continue
 			}
 			for _, p := range ps {
-				if err := p.JoinGroup(&ifi, tt.gaddr); err != nil {
-					t.Fatalf("ipv4.PacketConn.JoinGroup %v on %v failed: %v", tt.gaddr, ifi, err)
+				if err := p.JoinGroup(&ifi, gaddr); err != nil {
+					t.Fatalf("ipv4.PacketConn.JoinGroup %v on %v failed: %v", gaddr, ifi, err)
 				}
 			}
 			mift = append(mift, &ift[i])
 		}
 		for _, ifi := range mift {
 			for _, p := range ps {
-				if err := p.LeaveGroup(ifi, tt.gaddr); err != nil {
-					t.Fatalf("ipv4.PacketConn.LeaveGroup %v on %v failed: %v", tt.gaddr, ifi, err)
+				if err := p.LeaveGroup(ifi, gaddr); err != nil {
+					t.Fatalf("ipv4.PacketConn.LeaveGroup %v on %v failed: %v", gaddr, ifi, err)
 				}
 			}
 		}
 	}
 }
 
-func TestIPSingleConnWithSingleGroupListener(t *testing.T) {
+func TestUDPPerInterfaceSinglePacketConnWithSingleGroupListener(t *testing.T) {
+	switch runtime.GOOS {
+	case "plan9", "windows":
+		t.Skipf("not supported on %q", runtime.GOOS)
+	}
 	if testing.Short() || !*testExternal {
 		t.Skip("to avoid external network")
 	}
-	if os.Getuid() != 0 {
-		t.Skip("must be root")
-	}
 
-	// listen to a wildcard address
-	c, err := net.ListenPacket("ip4:icmp", "0.0.0.0")
-	if err != nil {
-		t.Fatalf("net.ListenPacket failed: %v", err)
-	}
-	defer c.Close()
-
-	r, err := ipv4.NewRawConn(c)
-	if err != nil {
-		t.Fatalf("ipv4.RawConn failed: %v", err)
+	gaddr := net.IPAddr{IP: net.IPv4(224, 0, 0, 254)} // see RFC 4727
+	type ml struct {
+		c   *ipv4.PacketConn
+		ifi *net.Interface
 	}
+	var mlt []*ml
 
-	gaddr := &net.IPAddr{IP: net.IPv4(224, 0, 0, 254)} // see RFC 4727
-	var mift []*net.Interface
 	ift, err := net.Interfaces()
 	if err != nil {
 		t.Fatalf("net.Interfaces failed: %v", err)
 	}
 	for i, ifi := range ift {
-		if _, ok := isMulticastAvailable(&ifi); !ok {
+		ip, ok := isMulticastAvailable(&ifi)
+		if !ok {
 			continue
 		}
-		if err := r.JoinGroup(&ifi, gaddr); err != nil {
-			t.Fatalf("ipv4.RawConn.JoinGroup on %v failed: %v", ifi, err)
+		c, err := net.ListenPacket("udp4", ip.String()+":"+"1024") // unicast address with non-reusable port
+		if err != nil {
+			t.Fatalf("net.ListenPacket with %v failed: %v", ip, err)
 		}
-		mift = append(mift, &ift[i])
+		defer c.Close()
+		p := ipv4.NewPacketConn(c)
+		if err := p.JoinGroup(&ifi, &gaddr); err != nil {
+			t.Fatalf("ipv4.PacketConn.JoinGroup on %v failed: %v", ifi, err)
+		}
+		mlt = append(mlt, &ml{p, &ift[i]})
 	}
-	for _, ifi := range mift {
-		if err := r.LeaveGroup(ifi, gaddr); err != nil {
-			t.Fatalf("ipv4.RawConn.LeaveGroup on %v failed: %v", ifi, err)
+	for _, m := range mlt {
+		if err := m.c.LeaveGroup(m.ifi, &gaddr); err != nil {
+			t.Fatalf("ipv4.PacketConn.LeaveGroup on %v failed: %v", m.ifi, err)
 		}
 	}
 }
 
-func TestUDPPerInterfaceSingleConnWithSingleGroupListener(t *testing.T) {
+func TestIPSingleRawConnWithSingleGroupListener(t *testing.T) {
+	switch runtime.GOOS {
+	case "plan9", "windows":
+		t.Skipf("not supported on %q", runtime.GOOS)
+	}
 	if testing.Short() || !*testExternal {
 		t.Skip("to avoid external network")
 	}
+	if os.Getuid() != 0 {
+		t.Skip("must be root")
+	}
 
-	gaddr := &net.IPAddr{IP: net.IPv4(224, 0, 0, 254)} // see RFC 4727
-	type ml struct {
-		c   *ipv4.PacketConn
-		ifi *net.Interface
+	c, err := net.ListenPacket("ip4:icmp", "0.0.0.0") // wildcard address
+	if err != nil {
+		t.Fatalf("net.ListenPacket failed: %v", err)
 	}
-	var mlt []*ml
+	defer c.Close()
+
+	r, err := ipv4.NewRawConn(c)
+	if err != nil {
+		t.Fatalf("ipv4.RawConn failed: %v", err)
+	}
+	gaddr := net.IPAddr{IP: net.IPv4(224, 0, 0, 254)} // see RFC 4727
+	var mift []*net.Interface
 
 	ift, err := net.Interfaces()
 	if err != nil {
 		t.Fatalf("net.Interfaces failed: %v", err)
 	}
 	for i, ifi := range ift {
-		ip, ok := isMulticastAvailable(&ifi)
-		if !ok {
+		if _, ok := isMulticastAvailable(&ifi); !ok {
 			continue
 		}
-		// listen to a unicast interface address
-		c, err := net.ListenPacket("udp4", ip.String()+":"+"1024") // see RFC 4727
-		if err != nil {
-			t.Fatalf("net.ListenPacket with %v failed: %v", ip, err)
-		}
-		defer c.Close()
-		p := ipv4.NewPacketConn(c)
-		if err := p.JoinGroup(&ifi, gaddr); err != nil {
-			t.Fatalf("ipv4.PacketConn.JoinGroup on %v failed: %v", ifi, err)
+		if err := r.JoinGroup(&ifi, &gaddr); err != nil {
+			t.Fatalf("ipv4.RawConn.JoinGroup on %v failed: %v", ifi, err)
 		}
-		mlt = append(mlt, &ml{p, &ift[i]})
+		mift = append(mift, &ift[i])
 	}
-	for _, m := range mlt {
-		if err := m.c.LeaveGroup(m.ifi, gaddr); err != nil {
-			t.Fatalf("ipv4.PacketConn.LeaveGroup on %v failed: %v", m.ifi, err)
+	for _, ifi := range mift {
+		if err := r.LeaveGroup(ifi, &gaddr); err != nil {
+			t.Fatalf("ipv4.RawConn.LeaveGroup on %v failed: %v", ifi, err)
 		}
 	}
 }
 
-func TestIPPerInterfaceSingleConnWithSingleGroupListener(t *testing.T) {
+func TestIPPerInterfaceSingleRawConnWithSingleGroupListener(t *testing.T) {
+	switch runtime.GOOS {
+	case "plan9", "windows":
+		t.Skipf("not supported on %q", runtime.GOOS)
+	}
 	if testing.Short() || !*testExternal {
 		t.Skip("to avoid external network")
 	}
@@ -198,7 +210,7 @@ func TestIPPerInterfaceSingleConnWithSingleGroupListener(t *testing.T) {
 		t.Skip("must be root")
 	}
 
-	gaddr := &net.IPAddr{IP: net.IPv4(224, 0, 0, 254)} // see RFC 4727
+	gaddr := net.IPAddr{IP: net.IPv4(224, 0, 0, 254)} // see RFC 4727
 	type ml struct {
 		c   *ipv4.RawConn
 		ifi *net.Interface
@@ -214,8 +226,7 @@ func TestIPPerInterfaceSingleConnWithSingleGroupListener(t *testing.T) {
 		if !ok {
 			continue
 		}
-		// listen to a unicast interface address
-		c, err := net.ListenPacket("ip4:253", ip.String()) // see RFC 4727
+		c, err := net.ListenPacket("ip4:253", ip.String()) // unicast address
 		if err != nil {
 			t.Fatalf("net.ListenPacket with %v failed: %v", ip, err)
 		}
@@ -224,13 +235,13 @@ func TestIPPerInterfaceSingleConnWithSingleGroupListener(t *testing.T) {
 		if err != nil {
 			t.Fatalf("ipv4.NewRawConn failed: %v", err)
 		}
-		if err := r.JoinGroup(&ifi, gaddr); err != nil {
+		if err := r.JoinGroup(&ifi, &gaddr); err != nil {
 			t.Fatalf("ipv4.RawConn.JoinGroup on %v failed: %v", ifi, err)
 		}
 		mlt = append(mlt, &ml{r, &ift[i]})
 	}
 	for _, m := range mlt {
-		if err := m.c.LeaveGroup(m.ifi, gaddr); err != nil {
+		if err := m.c.LeaveGroup(m.ifi, &gaddr); err != nil {
 			t.Fatalf("ipv4.RawConn.LeaveGroup on %v failed: %v", m.ifi, err)
 		}
 	}