[infra] Split tcpip/integration test targets to aid investigation.

tcpip integration tests have been flaky lately. They usually run in 20 seconds
and have a 60 seconds timeout. Sometimes they timeout which could be due to
a bug or deadlock. To further investigate it might be helpful to split the
targets and see which test is causing the flake.

Added a new tcpip/tests/utils package to hold all common utilities across all
tests.

PiperOrigin-RevId: 358012936

9 files changed, 651 insertions, 510 deletions

diff --git a/pkg/tcpip/tests/integration/BUILD b/pkg/tcpip/tests/integration/BUILD
index 71695b630..58aabe547 100644
--- a/pkg/tcpip/tests/integration/BUILD
+++ b/pkg/tcpip/tests/integration/BUILD
@@ -3,31 +3,57 @@ load("//tools:defs.bzl", "go_test")
 package(licenses = ["notice"])
 
 go_test(
-    name = "integration_test",
+    name = "forward_test",
     size = "small",
-    srcs = [
-        "forward_test.go",
-        "iptables_test.go",
-        "link_resolution_test.go",
-        "loopback_test.go",
-        "multicast_broadcast_test.go",
-        "route_test.go",
+    srcs = ["forward_test.go"],
+    deps = [
+        "//pkg/tcpip",
+        "//pkg/tcpip/checker",
+        "//pkg/tcpip/network/arp",
+        "//pkg/tcpip/network/ipv4",
+        "//pkg/tcpip/network/ipv6",
+        "//pkg/tcpip/stack",
+        "//pkg/tcpip/tests/utils",
+        "//pkg/tcpip/transport/tcp",
+        "//pkg/tcpip/transport/udp",
+        "//pkg/waiter",
+        "@com_github_google_go_cmp//cmp:go_default_library",
+    ],
+)
+
+go_test(
+    name = "iptables_test",
+    size = "small",
+    srcs = ["iptables_test.go"],
+    deps = [
+        "//pkg/tcpip",
+        "//pkg/tcpip/buffer",
+        "//pkg/tcpip/header",
+        "//pkg/tcpip/link/channel",
+        "//pkg/tcpip/network/ipv4",
+        "//pkg/tcpip/network/ipv6",
+        "//pkg/tcpip/stack",
+        "//pkg/tcpip/tests/utils",
+        "//pkg/tcpip/transport/udp",
     ],
+)
+
+go_test(
+    name = "link_resolution_test",
+    size = "small",
+    srcs = ["link_resolution_test.go"],
     deps = [
         "//pkg/tcpip",
         "//pkg/tcpip/buffer",
         "//pkg/tcpip/checker",
         "//pkg/tcpip/faketime",
         "//pkg/tcpip/header",
-        "//pkg/tcpip/link/channel",
-        "//pkg/tcpip/link/ethernet",
-        "//pkg/tcpip/link/loopback",
-        "//pkg/tcpip/link/nested",
         "//pkg/tcpip/link/pipe",
         "//pkg/tcpip/network/arp",
         "//pkg/tcpip/network/ipv4",
         "//pkg/tcpip/network/ipv6",
         "//pkg/tcpip/stack",
+        "//pkg/tcpip/tests/utils",
         "//pkg/tcpip/transport/icmp",
         "//pkg/tcpip/transport/tcp",
         "//pkg/tcpip/transport/udp",
@@ -36,3 +62,68 @@ go_test(
         "@com_github_google_go_cmp//cmp/cmpopts:go_default_library",
     ],
 )
+
+go_test(
+    name = "loopback_test",
+    size = "small",
+    srcs = ["loopback_test.go"],
+    deps = [
+        "//pkg/tcpip",
+        "//pkg/tcpip/buffer",
+        "//pkg/tcpip/checker",
+        "//pkg/tcpip/header",
+        "//pkg/tcpip/link/loopback",
+        "//pkg/tcpip/network/ipv4",
+        "//pkg/tcpip/network/ipv6",
+        "//pkg/tcpip/stack",
+        "//pkg/tcpip/tests/utils",
+        "//pkg/tcpip/transport/tcp",
+        "//pkg/tcpip/transport/udp",
+        "//pkg/waiter",
+        "@com_github_google_go_cmp//cmp:go_default_library",
+    ],
+)
+
+go_test(
+    name = "multicast_broadcast_test",
+    size = "small",
+    srcs = ["multicast_broadcast_test.go"],
+    deps = [
+        "//pkg/tcpip",
+        "//pkg/tcpip/buffer",
+        "//pkg/tcpip/checker",
+        "//pkg/tcpip/header",
+        "//pkg/tcpip/link/channel",
+        "//pkg/tcpip/link/loopback",
+        "//pkg/tcpip/network/ipv4",
+        "//pkg/tcpip/network/ipv6",
+        "//pkg/tcpip/stack",
+        "//pkg/tcpip/tests/utils",
+        "//pkg/tcpip/transport/icmp",
+        "//pkg/tcpip/transport/udp",
+        "//pkg/waiter",
+        "@com_github_google_go_cmp//cmp:go_default_library",
+    ],
+)
+
+go_test(
+    name = "route_test",
+    size = "small",
+    srcs = ["route_test.go"],
+    deps = [
+        "//pkg/tcpip",
+        "//pkg/tcpip/buffer",
+        "//pkg/tcpip/checker",
+        "//pkg/tcpip/header",
+        "//pkg/tcpip/link/channel",
+        "//pkg/tcpip/link/loopback",
+        "//pkg/tcpip/network/ipv4",
+        "//pkg/tcpip/network/ipv6",
+        "//pkg/tcpip/stack",
+        "//pkg/tcpip/tests/utils",
+        "//pkg/tcpip/transport/icmp",
+        "//pkg/tcpip/transport/udp",
+        "//pkg/waiter",
+        "@com_github_google_go_cmp//cmp:go_default_library",
+    ],
+)
diff --git a/pkg/tcpip/tests/integration/forward_test.go b/pkg/tcpip/tests/integration/forward_test.go
index 38e1881c7..0cb9d034e 100644
--- a/pkg/tcpip/tests/integration/forward_test.go
+++ b/pkg/tcpip/tests/integration/forward_test.go
@@ -12,231 +12,25 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package integration_test
+package forward_test
 
 import (
 	"bytes"
-	"net"
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
 	"gvisor.dev/gvisor/pkg/tcpip"
 	"gvisor.dev/gvisor/pkg/tcpip/checker"
-	"gvisor.dev/gvisor/pkg/tcpip/header"
-	"gvisor.dev/gvisor/pkg/tcpip/link/ethernet"
-	"gvisor.dev/gvisor/pkg/tcpip/link/nested"
-	"gvisor.dev/gvisor/pkg/tcpip/link/pipe"
 	"gvisor.dev/gvisor/pkg/tcpip/network/arp"
 	"gvisor.dev/gvisor/pkg/tcpip/network/ipv4"
 	"gvisor.dev/gvisor/pkg/tcpip/network/ipv6"
 	"gvisor.dev/gvisor/pkg/tcpip/stack"
+	"gvisor.dev/gvisor/pkg/tcpip/tests/utils"
 	"gvisor.dev/gvisor/pkg/tcpip/transport/tcp"
 	"gvisor.dev/gvisor/pkg/tcpip/transport/udp"
 	"gvisor.dev/gvisor/pkg/waiter"
 )
 
-var _ stack.NetworkDispatcher = (*endpointWithDestinationCheck)(nil)
-var _ stack.LinkEndpoint = (*endpointWithDestinationCheck)(nil)
-
-const (
-	host1NICID   = 1
-	routerNICID1 = 2
-	routerNICID2 = 3
-	host2NICID   = 4
-)
-
-var (
-	host1IPv4Addr = tcpip.ProtocolAddress{
-		Protocol: ipv4.ProtocolNumber,
-		AddressWithPrefix: tcpip.AddressWithPrefix{
-			Address:   tcpip.Address(net.ParseIP("192.168.0.2").To4()),
-			PrefixLen: 24,
-		},
-	}
-	routerNIC1IPv4Addr = tcpip.ProtocolAddress{
-		Protocol: ipv4.ProtocolNumber,
-		AddressWithPrefix: tcpip.AddressWithPrefix{
-			Address:   tcpip.Address(net.ParseIP("192.168.0.1").To4()),
-			PrefixLen: 24,
-		},
-	}
-	routerNIC2IPv4Addr = tcpip.ProtocolAddress{
-		Protocol: ipv4.ProtocolNumber,
-		AddressWithPrefix: tcpip.AddressWithPrefix{
-			Address:   tcpip.Address(net.ParseIP("10.0.0.1").To4()),
-			PrefixLen: 8,
-		},
-	}
-	host2IPv4Addr = tcpip.ProtocolAddress{
-		Protocol: ipv4.ProtocolNumber,
-		AddressWithPrefix: tcpip.AddressWithPrefix{
-			Address:   tcpip.Address(net.ParseIP("10.0.0.2").To4()),
-			PrefixLen: 8,
-		},
-	}
-	host1IPv6Addr = tcpip.ProtocolAddress{
-		Protocol: ipv6.ProtocolNumber,
-		AddressWithPrefix: tcpip.AddressWithPrefix{
-			Address:   tcpip.Address(net.ParseIP("a::2").To16()),
-			PrefixLen: 64,
-		},
-	}
-	routerNIC1IPv6Addr = tcpip.ProtocolAddress{
-		Protocol: ipv6.ProtocolNumber,
-		AddressWithPrefix: tcpip.AddressWithPrefix{
-			Address:   tcpip.Address(net.ParseIP("a::1").To16()),
-			PrefixLen: 64,
-		},
-	}
-	routerNIC2IPv6Addr = tcpip.ProtocolAddress{
-		Protocol: ipv6.ProtocolNumber,
-		AddressWithPrefix: tcpip.AddressWithPrefix{
-			Address:   tcpip.Address(net.ParseIP("b::1").To16()),
-			PrefixLen: 64,
-		},
-	}
-	host2IPv6Addr = tcpip.ProtocolAddress{
-		Protocol: ipv6.ProtocolNumber,
-		AddressWithPrefix: tcpip.AddressWithPrefix{
-			Address:   tcpip.Address(net.ParseIP("b::2").To16()),
-			PrefixLen: 64,
-		},
-	}
-)
-
-func setupRoutedStacks(t *testing.T, host1Stack, routerStack, host2Stack *stack.Stack) {
-	host1NIC, routerNIC1 := pipe.New(linkAddr1, linkAddr2)
-	routerNIC2, host2NIC := pipe.New(linkAddr3, linkAddr4)
-
-	if err := host1Stack.CreateNIC(host1NICID, newEthernetEndpoint(host1NIC)); err != nil {
-		t.Fatalf("host1Stack.CreateNIC(%d, _): %s", host1NICID, err)
-	}
-	if err := routerStack.CreateNIC(routerNICID1, newEthernetEndpoint(routerNIC1)); err != nil {
-		t.Fatalf("routerStack.CreateNIC(%d, _): %s", routerNICID1, err)
-	}
-	if err := routerStack.CreateNIC(routerNICID2, newEthernetEndpoint(routerNIC2)); err != nil {
-		t.Fatalf("routerStack.CreateNIC(%d, _): %s", routerNICID2, err)
-	}
-	if err := host2Stack.CreateNIC(host2NICID, newEthernetEndpoint(host2NIC)); err != nil {
-		t.Fatalf("host2Stack.CreateNIC(%d, _): %s", host2NICID, err)
-	}
-
-	if err := routerStack.SetForwarding(ipv4.ProtocolNumber, true); err != nil {
-		t.Fatalf("routerStack.SetForwarding(%d): %s", ipv4.ProtocolNumber, err)
-	}
-	if err := routerStack.SetForwarding(ipv6.ProtocolNumber, true); err != nil {
-		t.Fatalf("routerStack.SetForwarding(%d): %s", ipv6.ProtocolNumber, err)
-	}
-
-	if err := host1Stack.AddProtocolAddress(host1NICID, host1IPv4Addr); err != nil {
-		t.Fatalf("host1Stack.AddProtocolAddress(%d, %#v): %s", host1NICID, host1IPv4Addr, err)
-	}
-	if err := routerStack.AddProtocolAddress(routerNICID1, routerNIC1IPv4Addr); err != nil {
-		t.Fatalf("routerStack.AddProtocolAddress(%d, %#v): %s", routerNICID1, routerNIC1IPv4Addr, err)
-	}
-	if err := routerStack.AddProtocolAddress(routerNICID2, routerNIC2IPv4Addr); err != nil {
-		t.Fatalf("routerStack.AddProtocolAddress(%d, %#v): %s", routerNICID2, routerNIC2IPv4Addr, err)
-	}
-	if err := host2Stack.AddProtocolAddress(host2NICID, host2IPv4Addr); err != nil {
-		t.Fatalf("host2Stack.AddProtocolAddress(%d, %#v): %s", host2NICID, host2IPv4Addr, err)
-	}
-	if err := host1Stack.AddProtocolAddress(host1NICID, host1IPv6Addr); err != nil {
-		t.Fatalf("host1Stack.AddProtocolAddress(%d, %#v): %s", host1NICID, host1IPv6Addr, err)
-	}
-	if err := routerStack.AddProtocolAddress(routerNICID1, routerNIC1IPv6Addr); err != nil {
-		t.Fatalf("routerStack.AddProtocolAddress(%d, %#v): %s", routerNICID1, routerNIC1IPv6Addr, err)
-	}
-	if err := routerStack.AddProtocolAddress(routerNICID2, routerNIC2IPv6Addr); err != nil {
-		t.Fatalf("routerStack.AddProtocolAddress(%d, %#v): %s", routerNICID2, routerNIC2IPv6Addr, err)
-	}
-	if err := host2Stack.AddProtocolAddress(host2NICID, host2IPv6Addr); err != nil {
-		t.Fatalf("host2Stack.AddProtocolAddress(%d, %#v): %s", host2NICID, host2IPv6Addr, err)
-	}
-
-	host1Stack.SetRouteTable([]tcpip.Route{
-		{
-			Destination: host1IPv4Addr.AddressWithPrefix.Subnet(),
-			NIC:         host1NICID,
-		},
-		{
-			Destination: host1IPv6Addr.AddressWithPrefix.Subnet(),
-			NIC:         host1NICID,
-		},
-		{
-			Destination: host2IPv4Addr.AddressWithPrefix.Subnet(),
-			Gateway:     routerNIC1IPv4Addr.AddressWithPrefix.Address,
-			NIC:         host1NICID,
-		},
-		{
-			Destination: host2IPv6Addr.AddressWithPrefix.Subnet(),
-			Gateway:     routerNIC1IPv6Addr.AddressWithPrefix.Address,
-			NIC:         host1NICID,
-		},
-	})
-	routerStack.SetRouteTable([]tcpip.Route{
-		{
-			Destination: routerNIC1IPv4Addr.AddressWithPrefix.Subnet(),
-			NIC:         routerNICID1,
-		},
-		{
-			Destination: routerNIC1IPv6Addr.AddressWithPrefix.Subnet(),
-			NIC:         routerNICID1,
-		},
-		{
-			Destination: routerNIC2IPv4Addr.AddressWithPrefix.Subnet(),
-			NIC:         routerNICID2,
-		},
-		{
-			Destination: routerNIC2IPv6Addr.AddressWithPrefix.Subnet(),
-			NIC:         routerNICID2,
-		},
-	})
-	host2Stack.SetRouteTable([]tcpip.Route{
-		{
-			Destination: host2IPv4Addr.AddressWithPrefix.Subnet(),
-			NIC:         host2NICID,
-		},
-		{
-			Destination: host2IPv6Addr.AddressWithPrefix.Subnet(),
-			NIC:         host2NICID,
-		},
-		{
-			Destination: host1IPv4Addr.AddressWithPrefix.Subnet(),
-			Gateway:     routerNIC2IPv4Addr.AddressWithPrefix.Address,
-			NIC:         host2NICID,
-		},
-		{
-			Destination: host1IPv6Addr.AddressWithPrefix.Subnet(),
-			Gateway:     routerNIC2IPv6Addr.AddressWithPrefix.Address,
-			NIC:         host2NICID,
-		},
-	})
-}
-
-// newEthernetEndpoint returns an ethernet link endpoint that wraps an inner
-// link endpoint and checks the destination link address before delivering
-// network packets to the network dispatcher.
-//
-// See ethernet.Endpoint for more details.
-func newEthernetEndpoint(ep stack.LinkEndpoint) *endpointWithDestinationCheck {
-	var e endpointWithDestinationCheck
-	e.Endpoint.Init(ethernet.New(ep), &e)
-	return &e
-}
-
-// endpointWithDestinationCheck is a link endpoint that checks the destination
-// link address before delivering network packets to the network dispatcher.
-type endpointWithDestinationCheck struct {
-	nested.Endpoint
-}
-
-// DeliverNetworkPacket implements stack.NetworkDispatcher.
-func (e *endpointWithDestinationCheck) DeliverNetworkPacket(src, dst tcpip.LinkAddress, proto tcpip.NetworkProtocolNumber, pkt *stack.PacketBuffer) {
-	if dst == e.Endpoint.LinkAddress() || dst == header.EthernetBroadcastAddress || header.IsMulticastEthernetAddress(dst) {
-		e.Endpoint.DeliverNetworkPacket(src, dst, proto, pkt)
-	}
-}
-
 func TestForwarding(t *testing.T) {
 	const listenPort = 8080
 
@@ -278,11 +72,11 @@ func TestForwarding(t *testing.T) {
 				ep2, ep2WECH := newEP(t, host2Stack, proto, ipv4.ProtocolNumber)
 				return endpointAndAddresses{
 					serverEP:         ep1,
-					serverAddr:       host1IPv4Addr.AddressWithPrefix.Address,
+					serverAddr:       utils.Host1IPv4Addr.AddressWithPrefix.Address,
 					serverReadableCH: ep1WECH,
 
 					clientEP:         ep2,
-					clientAddr:       host2IPv4Addr.AddressWithPrefix.Address,
+					clientAddr:       utils.Host2IPv4Addr.AddressWithPrefix.Address,
 					clientReadableCH: ep2WECH,
 				}
 			},
@@ -294,11 +88,11 @@ func TestForwarding(t *testing.T) {
 				ep2, ep2WECH := newEP(t, host1Stack, proto, ipv6.ProtocolNumber)
 				return endpointAndAddresses{
 					serverEP:         ep1,
-					serverAddr:       host2IPv6Addr.AddressWithPrefix.Address,
+					serverAddr:       utils.Host2IPv6Addr.AddressWithPrefix.Address,
 					serverReadableCH: ep1WECH,
 
 					clientEP:         ep2,
-					clientAddr:       host1IPv6Addr.AddressWithPrefix.Address,
+					clientAddr:       utils.Host1IPv6Addr.AddressWithPrefix.Address,
 					clientReadableCH: ep2WECH,
 				}
 			},
@@ -310,11 +104,11 @@ func TestForwarding(t *testing.T) {
 				ep2, ep2WECH := newEP(t, routerStack, proto, ipv4.ProtocolNumber)
 				return endpointAndAddresses{
 					serverEP:         ep1,
-					serverAddr:       host2IPv4Addr.AddressWithPrefix.Address,
+					serverAddr:       utils.Host2IPv4Addr.AddressWithPrefix.Address,
 					serverReadableCH: ep1WECH,
 
 					clientEP:         ep2,
-					clientAddr:       routerNIC1IPv4Addr.AddressWithPrefix.Address,
+					clientAddr:       utils.RouterNIC1IPv4Addr.AddressWithPrefix.Address,
 					clientReadableCH: ep2WECH,
 				}
 			},
@@ -326,11 +120,11 @@ func TestForwarding(t *testing.T) {
 				ep2, ep2WECH := newEP(t, host1Stack, proto, ipv6.ProtocolNumber)
 				return endpointAndAddresses{
 					serverEP:         ep1,
-					serverAddr:       routerNIC2IPv6Addr.AddressWithPrefix.Address,
+					serverAddr:       utils.RouterNIC2IPv6Addr.AddressWithPrefix.Address,
 					serverReadableCH: ep1WECH,
 
 					clientEP:         ep2,
-					clientAddr:       host1IPv6Addr.AddressWithPrefix.Address,
+					clientAddr:       utils.Host1IPv6Addr.AddressWithPrefix.Address,
 					clientReadableCH: ep2WECH,
 				}
 			},
@@ -405,7 +199,7 @@ func TestForwarding(t *testing.T) {
 					host1Stack := stack.New(stackOpts)
 					routerStack := stack.New(stackOpts)
 					host2Stack := stack.New(stackOpts)
-					setupRoutedStacks(t, host1Stack, routerStack, host2Stack)
+					utils.SetupRoutedStacks(t, host1Stack, routerStack, host2Stack)
 
 					epsAndAddrs := test.epAndAddrs(t, host1Stack, routerStack, host2Stack, subTest.proto)
 					defer epsAndAddrs.serverEP.Close()
diff --git a/pkg/tcpip/tests/integration/iptables_test.go b/pkg/tcpip/tests/integration/iptables_test.go
index b56706357..480174070 100644
--- a/pkg/tcpip/tests/integration/iptables_test.go
+++ b/pkg/tcpip/tests/integration/iptables_test.go
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package integration_test
+package iptables_test
 
 import (
 	"testing"
@@ -24,6 +24,7 @@ import (
 	"gvisor.dev/gvisor/pkg/tcpip/network/ipv4"
 	"gvisor.dev/gvisor/pkg/tcpip/network/ipv6"
 	"gvisor.dev/gvisor/pkg/tcpip/stack"
+	"gvisor.dev/gvisor/pkg/tcpip/tests/utils"
 	"gvisor.dev/gvisor/pkg/tcpip/transport/udp"
 )
 
@@ -375,7 +376,7 @@ func TestIPTableWritePackets(t *testing.T) {
 	const (
 		nicID = 1
 
-		dropLocalPort = localPort - 1
+		dropLocalPort = utils.LocalPort - 1
 		acceptPackets = 2
 		dropPackets   = 3
 	)
@@ -411,7 +412,7 @@ func TestIPTableWritePackets(t *testing.T) {
 					ReserveHeaderBytes: int(r.MaxHeaderLength() + header.UDPMinimumSize),
 				})
 				hdr := pkt.TransportHeader().Push(header.UDPMinimumSize)
-				udpHdr(hdr, r.LocalAddress, r.RemoteAddress, localPort, remotePort)
+				udpHdr(hdr, r.LocalAddress, r.RemoteAddress, utils.LocalPort, utils.RemotePort)
 				pkts.PushFront(pkt)
 
 				return pkts
@@ -473,7 +474,7 @@ func TestIPTableWritePackets(t *testing.T) {
 						ReserveHeaderBytes: int(r.MaxHeaderLength() + header.UDPMinimumSize),
 					})
 					hdr := pkt.TransportHeader().Push(header.UDPMinimumSize)
-					udpHdr(hdr, r.LocalAddress, r.RemoteAddress, localPort, remotePort)
+					udpHdr(hdr, r.LocalAddress, r.RemoteAddress, utils.LocalPort, utils.RemotePort)
 					pkts.PushFront(pkt)
 				}
 				for i := 0; i < dropPackets; i++ {
@@ -481,7 +482,7 @@ func TestIPTableWritePackets(t *testing.T) {
 						ReserveHeaderBytes: int(r.MaxHeaderLength() + header.UDPMinimumSize),
 					})
 					hdr := pkt.TransportHeader().Push(header.UDPMinimumSize)
-					udpHdr(hdr, r.LocalAddress, r.RemoteAddress, dropLocalPort, remotePort)
+					udpHdr(hdr, r.LocalAddress, r.RemoteAddress, dropLocalPort, utils.RemotePort)
 					pkts.PushFront(pkt)
 				}
 
@@ -502,7 +503,7 @@ func TestIPTableWritePackets(t *testing.T) {
 					ReserveHeaderBytes: int(r.MaxHeaderLength() + header.UDPMinimumSize),
 				})
 				hdr := pkt.TransportHeader().Push(header.UDPMinimumSize)
-				udpHdr(hdr, r.LocalAddress, r.RemoteAddress, localPort, remotePort)
+				udpHdr(hdr, r.LocalAddress, r.RemoteAddress, utils.LocalPort, utils.RemotePort)
 				pkts.PushFront(pkt)
 
 				return pkts
@@ -564,7 +565,7 @@ func TestIPTableWritePackets(t *testing.T) {
 						ReserveHeaderBytes: int(r.MaxHeaderLength() + header.UDPMinimumSize),
 					})
 					hdr := pkt.TransportHeader().Push(header.UDPMinimumSize)
-					udpHdr(hdr, r.LocalAddress, r.RemoteAddress, localPort, remotePort)
+					udpHdr(hdr, r.LocalAddress, r.RemoteAddress, utils.LocalPort, utils.RemotePort)
 					pkts.PushFront(pkt)
 				}
 				for i := 0; i < dropPackets; i++ {
@@ -572,7 +573,7 @@ func TestIPTableWritePackets(t *testing.T) {
 						ReserveHeaderBytes: int(r.MaxHeaderLength() + header.UDPMinimumSize),
 					})
 					hdr := pkt.TransportHeader().Push(header.UDPMinimumSize)
-					udpHdr(hdr, r.LocalAddress, r.RemoteAddress, dropLocalPort, remotePort)
+					udpHdr(hdr, r.LocalAddress, r.RemoteAddress, dropLocalPort, utils.RemotePort)
 					pkts.PushFront(pkt)
 				}
 
diff --git a/pkg/tcpip/tests/integration/link_resolution_test.go b/pkg/tcpip/tests/integration/link_resolution_test.go
index 824f81a42..18da67fb1 100644
--- a/pkg/tcpip/tests/integration/link_resolution_test.go
+++ b/pkg/tcpip/tests/integration/link_resolution_test.go
@@ -12,12 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package integration_test
+package link_resolution_test
 
 import (
 	"bytes"
 	"fmt"
-	"net"
 	"testing"
 	"time"
 
@@ -33,107 +32,56 @@ import (
 	"gvisor.dev/gvisor/pkg/tcpip/network/ipv4"
 	"gvisor.dev/gvisor/pkg/tcpip/network/ipv6"
 	"gvisor.dev/gvisor/pkg/tcpip/stack"
+	"gvisor.dev/gvisor/pkg/tcpip/tests/utils"
 	"gvisor.dev/gvisor/pkg/tcpip/transport/icmp"
 	"gvisor.dev/gvisor/pkg/tcpip/transport/tcp"
 	"gvisor.dev/gvisor/pkg/tcpip/transport/udp"
 	"gvisor.dev/gvisor/pkg/waiter"
 )
 
-const (
-	linkAddr1 = tcpip.LinkAddress("\x02\x03\x03\x04\x05\x06")
-	linkAddr2 = tcpip.LinkAddress("\x02\x03\x03\x04\x05\x07")
-	linkAddr3 = tcpip.LinkAddress("\x02\x03\x03\x04\x05\x08")
-	linkAddr4 = tcpip.LinkAddress("\x02\x03\x03\x04\x05\x09")
-)
-
-var (
-	ipv4Addr1 = tcpip.ProtocolAddress{
-		Protocol: ipv4.ProtocolNumber,
-		AddressWithPrefix: tcpip.AddressWithPrefix{
-			Address:   tcpip.Address(net.ParseIP("192.168.0.1").To4()),
-			PrefixLen: 24,
-		},
-	}
-	ipv4Addr2 = tcpip.ProtocolAddress{
-		Protocol: ipv4.ProtocolNumber,
-		AddressWithPrefix: tcpip.AddressWithPrefix{
-			Address:   tcpip.Address(net.ParseIP("192.168.0.2").To4()),
-			PrefixLen: 8,
-		},
-	}
-	ipv4Addr3 = tcpip.ProtocolAddress{
-		Protocol: ipv4.ProtocolNumber,
-		AddressWithPrefix: tcpip.AddressWithPrefix{
-			Address:   tcpip.Address(net.ParseIP("192.168.0.3").To4()),
-			PrefixLen: 8,
-		},
-	}
-	ipv6Addr1 = tcpip.ProtocolAddress{
-		Protocol: ipv6.ProtocolNumber,
-		AddressWithPrefix: tcpip.AddressWithPrefix{
-			Address:   tcpip.Address(net.ParseIP("a::1").To16()),
-			PrefixLen: 64,
-		},
-	}
-	ipv6Addr2 = tcpip.ProtocolAddress{
-		Protocol: ipv6.ProtocolNumber,
-		AddressWithPrefix: tcpip.AddressWithPrefix{
-			Address:   tcpip.Address(net.ParseIP("a::2").To16()),
-			PrefixLen: 64,
-		},
-	}
-	ipv6Addr3 = tcpip.ProtocolAddress{
-		Protocol: ipv6.ProtocolNumber,
-		AddressWithPrefix: tcpip.AddressWithPrefix{
-			Address:   tcpip.Address(net.ParseIP("a::3").To16()),
-			PrefixLen: 64,
-		},
-	}
-)
-
 func setupStack(t *testing.T, stackOpts stack.Options, host1NICID, host2NICID tcpip.NICID) (*stack.Stack, *stack.Stack) {
 	host1Stack := stack.New(stackOpts)
 	host2Stack := stack.New(stackOpts)
 
-	host1NIC, host2NIC := pipe.New(linkAddr1, linkAddr2)
+	host1NIC, host2NIC := pipe.New(utils.LinkAddr1, utils.LinkAddr2)
 
-	if err := host1Stack.CreateNIC(host1NICID, newEthernetEndpoint(host1NIC)); err != nil {
+	if err := host1Stack.CreateNIC(host1NICID, utils.NewEthernetEndpoint(host1NIC)); err != nil {
 		t.Fatalf("host1Stack.CreateNIC(%d, _): %s", host1NICID, err)
 	}
-	if err := host2Stack.CreateNIC(host2NICID, newEthernetEndpoint(host2NIC)); err != nil {
+	if err := host2Stack.CreateNIC(host2NICID, utils.NewEthernetEndpoint(host2NIC)); err != nil {
 		t.Fatalf("host2Stack.CreateNIC(%d, _): %s", host2NICID, err)
 	}
 
-	if err := host1Stack.AddProtocolAddress(host1NICID, ipv4Addr1); err != nil {
-		t.Fatalf("host1Stack.AddProtocolAddress(%d, %#v): %s", host1NICID, ipv4Addr1, err)
+	if err := host1Stack.AddProtocolAddress(host1NICID, utils.Ipv4Addr1); err != nil {
+		t.Fatalf("host1Stack.AddProtocolAddress(%d, %#v): %s", host1NICID, utils.Ipv4Addr1, err)
 	}
-	if err := host2Stack.AddProtocolAddress(host2NICID, ipv4Addr2); err != nil {
-		t.Fatalf("host2Stack.AddProtocolAddress(%d, %#v): %s", host2NICID, ipv4Addr2, err)
+	if err := host2Stack.AddProtocolAddress(host2NICID, utils.Ipv4Addr2); err != nil {
+		t.Fatalf("host2Stack.AddProtocolAddress(%d, %#v): %s", host2NICID, utils.Ipv4Addr2, err)
 	}
-	if err := host1Stack.AddProtocolAddress(host1NICID, ipv6Addr1); err != nil {
-		t.Fatalf("host1Stack.AddProtocolAddress(%d, %#v): %s", host1NICID, ipv6Addr1, err)
+	if err := host1Stack.AddProtocolAddress(host1NICID, utils.Ipv6Addr1); err != nil {
+		t.Fatalf("host1Stack.AddProtocolAddress(%d, %#v): %s", host1NICID, utils.Ipv6Addr1, err)
 	}
-	if err := host2Stack.AddProtocolAddress(host2NICID, ipv6Addr2); err != nil {
-		t.Fatalf("host2Stack.AddProtocolAddress(%d, %#v): %s", host2NICID, ipv6Addr2, err)
+	if err := host2Stack.AddProtocolAddress(host2NICID, utils.Ipv6Addr2); err != nil {
+		t.Fatalf("host2Stack.AddProtocolAddress(%d, %#v): %s", host2NICID, utils.Ipv6Addr2, err)
 	}
 
 	host1Stack.SetRouteTable([]tcpip.Route{
 		{
-			Destination: ipv4Addr1.AddressWithPrefix.Subnet(),
+			Destination: utils.Ipv4Addr1.AddressWithPrefix.Subnet(),
 			NIC:         host1NICID,
 		},
 		{
-			Destination: ipv6Addr1.AddressWithPrefix.Subnet(),
+			Destination: utils.Ipv6Addr1.AddressWithPrefix.Subnet(),
 			NIC:         host1NICID,
 		},
 	})
 	host2Stack.SetRouteTable([]tcpip.Route{
 		{
-			Destination: ipv4Addr2.AddressWithPrefix.Subnet(),
+			Destination: utils.Ipv4Addr2.AddressWithPrefix.Subnet(),
 			NIC:         host2NICID,
 		},
 		{
-			Destination: ipv6Addr2.AddressWithPrefix.Subnet(),
+			Destination: utils.Ipv6Addr2.AddressWithPrefix.Subnet(),
 			NIC:         host2NICID,
 		},
 	})
@@ -164,7 +112,7 @@ func TestPing(t *testing.T) {
 			name:       "IPv4 Ping",
 			transProto: icmp.ProtocolNumber4,
 			netProto:   ipv4.ProtocolNumber,
-			remoteAddr: ipv4Addr2.AddressWithPrefix.Address,
+			remoteAddr: utils.Ipv4Addr2.AddressWithPrefix.Address,
 			icmpBuf: func(t *testing.T) []byte {
 				data := [8]byte{1, 2, 3, 4, 5, 6, 7, 8}
 				hdr := header.ICMPv4(make([]byte, header.ICMPv4MinimumSize+len(data)))
@@ -179,7 +127,7 @@ func TestPing(t *testing.T) {
 			name:       "IPv6 Ping",
 			transProto: icmp.ProtocolNumber6,
 			netProto:   ipv6.ProtocolNumber,
-			remoteAddr: ipv6Addr2.AddressWithPrefix.Address,
+			remoteAddr: utils.Ipv6Addr2.AddressWithPrefix.Address,
 			icmpBuf: func(t *testing.T) []byte {
 				data := [8]byte{1, 2, 3, 4, 5, 6, 7, 8}
 				hdr := header.ICMPv6(make([]byte, header.ICMPv6MinimumSize+len(data)))
@@ -272,30 +220,30 @@ func TestTCPLinkResolutionFailure(t *testing.T) {
 		{
 			name:             "IPv4 with resolvable remote",
 			netProto:         ipv4.ProtocolNumber,
-			remoteAddr:       ipv4Addr2.AddressWithPrefix.Address,
+			remoteAddr:       utils.Ipv4Addr2.AddressWithPrefix.Address,
 			expectedWriteErr: nil,
 		},
 		{
 			name:             "IPv6 with resolvable remote",
 			netProto:         ipv6.ProtocolNumber,
-			remoteAddr:       ipv6Addr2.AddressWithPrefix.Address,
+			remoteAddr:       utils.Ipv6Addr2.AddressWithPrefix.Address,
 			expectedWriteErr: nil,
 		},
 		{
 			name:             "IPv4 without resolvable remote",
 			netProto:         ipv4.ProtocolNumber,
-			remoteAddr:       ipv4Addr3.AddressWithPrefix.Address,
+			remoteAddr:       utils.Ipv4Addr3.AddressWithPrefix.Address,
 			expectedWriteErr: &tcpip.ErrNoRoute{},
 			sockError: tcpip.SockError{
 				Err: &tcpip.ErrNoRoute{},
 				Dst: tcpip.FullAddress{
 					NIC:  host1NICID,
-					Addr: ipv4Addr3.AddressWithPrefix.Address,
+					Addr: utils.Ipv4Addr3.AddressWithPrefix.Address,
 					Port: 1234,
 				},
 				Offender: tcpip.FullAddress{
 					NIC:  host1NICID,
-					Addr: ipv4Addr1.AddressWithPrefix.Address,
+					Addr: utils.Ipv4Addr1.AddressWithPrefix.Address,
 				},
 				NetProto: ipv4.ProtocolNumber,
 			},
@@ -309,18 +257,18 @@ func TestTCPLinkResolutionFailure(t *testing.T) {
 		{
 			name:             "IPv6 without resolvable remote",
 			netProto:         ipv6.ProtocolNumber,
-			remoteAddr:       ipv6Addr3.AddressWithPrefix.Address,
+			remoteAddr:       utils.Ipv6Addr3.AddressWithPrefix.Address,
 			expectedWriteErr: &tcpip.ErrNoRoute{},
 			sockError: tcpip.SockError{
 				Err: &tcpip.ErrNoRoute{},
 				Dst: tcpip.FullAddress{
 					NIC:  host1NICID,
-					Addr: ipv6Addr3.AddressWithPrefix.Address,
+					Addr: utils.Ipv6Addr3.AddressWithPrefix.Address,
 					Port: 1234,
 				},
 				Offender: tcpip.FullAddress{
 					NIC:  host1NICID,
-					Addr: ipv6Addr1.AddressWithPrefix.Address,
+					Addr: utils.Ipv6Addr1.AddressWithPrefix.Address,
 				},
 				NetProto: ipv6.ProtocolNumber,
 			},
@@ -462,25 +410,25 @@ func TestGetLinkAddress(t *testing.T) {
 		{
 			name:       "IPv4 resolvable",
 			netProto:   ipv4.ProtocolNumber,
-			remoteAddr: ipv4Addr2.AddressWithPrefix.Address,
+			remoteAddr: utils.Ipv4Addr2.AddressWithPrefix.Address,
 			expectedOk: true,
 		},
 		{
 			name:       "IPv6 resolvable",
 			netProto:   ipv6.ProtocolNumber,
-			remoteAddr: ipv6Addr2.AddressWithPrefix.Address,
+			remoteAddr: utils.Ipv6Addr2.AddressWithPrefix.Address,
 			expectedOk: true,
 		},
 		{
 			name:       "IPv4 not resolvable",
 			netProto:   ipv4.ProtocolNumber,
-			remoteAddr: ipv4Addr3.AddressWithPrefix.Address,
+			remoteAddr: utils.Ipv4Addr3.AddressWithPrefix.Address,
 			expectedOk: false,
 		},
 		{
 			name:       "IPv6 not resolvable",
 			netProto:   ipv6.ProtocolNumber,
-			remoteAddr: ipv6Addr3.AddressWithPrefix.Address,
+			remoteAddr: utils.Ipv6Addr3.AddressWithPrefix.Address,
 			expectedOk: false,
 		},
 	}
@@ -502,7 +450,7 @@ func TestGetLinkAddress(t *testing.T) {
 			}
 			wantRes := stack.LinkResolutionResult{Success: test.expectedOk}
 			if test.expectedOk {
-				wantRes.LinkAddress = linkAddr2
+				wantRes.LinkAddress = utils.LinkAddr2
 			}
 			if diff := cmp.Diff(wantRes, <-ch); diff != "" {
 				t.Fatalf("link resolution result mismatch (-want +got):\n%s", diff)
@@ -529,7 +477,7 @@ func TestRouteResolvedFields(t *testing.T) {
 		{
 			name:                  "IPv4 immediately resolvable",
 			netProto:              ipv4.ProtocolNumber,
-			localAddr:             ipv4Addr1.AddressWithPrefix.Address,
+			localAddr:             utils.Ipv4Addr1.AddressWithPrefix.Address,
 			remoteAddr:            header.IPv4AllSystems,
 			immediatelyResolvable: true,
 			expectedSuccess:       true,
@@ -538,7 +486,7 @@ func TestRouteResolvedFields(t *testing.T) {
 		{
 			name:                  "IPv6 immediately resolvable",
 			netProto:              ipv6.ProtocolNumber,
-			localAddr:             ipv6Addr1.AddressWithPrefix.Address,
+			localAddr:             utils.Ipv6Addr1.AddressWithPrefix.Address,
 			remoteAddr:            header.IPv6AllNodesMulticastAddress,
 			immediatelyResolvable: true,
 			expectedSuccess:       true,
@@ -547,34 +495,34 @@ func TestRouteResolvedFields(t *testing.T) {
 		{
 			name:                  "IPv4 resolvable",
 			netProto:              ipv4.ProtocolNumber,
-			localAddr:             ipv4Addr1.AddressWithPrefix.Address,
-			remoteAddr:            ipv4Addr2.AddressWithPrefix.Address,
+			localAddr:             utils.Ipv4Addr1.AddressWithPrefix.Address,
+			remoteAddr:            utils.Ipv4Addr2.AddressWithPrefix.Address,
 			immediatelyResolvable: false,
 			expectedSuccess:       true,
-			expectedLinkAddr:      linkAddr2,
+			expectedLinkAddr:      utils.LinkAddr2,
 		},
 		{
 			name:                  "IPv6 resolvable",
 			netProto:              ipv6.ProtocolNumber,
-			localAddr:             ipv6Addr1.AddressWithPrefix.Address,
-			remoteAddr:            ipv6Addr2.AddressWithPrefix.Address,
+			localAddr:             utils.Ipv6Addr1.AddressWithPrefix.Address,
+			remoteAddr:            utils.Ipv6Addr2.AddressWithPrefix.Address,
 			immediatelyResolvable: false,
 			expectedSuccess:       true,
-			expectedLinkAddr:      linkAddr2,
+			expectedLinkAddr:      utils.LinkAddr2,
 		},
 		{
 			name:                  "IPv4 not resolvable",
 			netProto:              ipv4.ProtocolNumber,
-			localAddr:             ipv4Addr1.AddressWithPrefix.Address,
-			remoteAddr:            ipv4Addr3.AddressWithPrefix.Address,
+			localAddr:             utils.Ipv4Addr1.AddressWithPrefix.Address,
+			remoteAddr:            utils.Ipv4Addr3.AddressWithPrefix.Address,
 			immediatelyResolvable: false,
 			expectedSuccess:       false,
 		},
 		{
 			name:                  "IPv6 not resolvable",
 			netProto:              ipv6.ProtocolNumber,
-			localAddr:             ipv6Addr1.AddressWithPrefix.Address,
-			remoteAddr:            ipv6Addr3.AddressWithPrefix.Address,
+			localAddr:             utils.Ipv6Addr1.AddressWithPrefix.Address,
+			remoteAddr:            utils.Ipv6Addr3.AddressWithPrefix.Address,
 			immediatelyResolvable: false,
 			expectedSuccess:       false,
 		},
@@ -594,7 +542,7 @@ func TestRouteResolvedFields(t *testing.T) {
 			defer r.Release()
 
 			var wantRouteInfo stack.RouteInfo
-			wantRouteInfo.LocalLinkAddress = linkAddr1
+			wantRouteInfo.LocalLinkAddress = utils.LinkAddr1
 			wantRouteInfo.LocalAddress = test.localAddr
 			wantRouteInfo.RemoteAddress = test.remoteAddr
 			wantRouteInfo.NetProto = test.netProto
@@ -657,13 +605,13 @@ func TestWritePacketsLinkResolution(t *testing.T) {
 		{
 			name:             "IPv4",
 			netProto:         ipv4.ProtocolNumber,
-			remoteAddr:       ipv4Addr2.AddressWithPrefix.Address,
+			remoteAddr:       utils.Ipv4Addr2.AddressWithPrefix.Address,
 			expectedWriteErr: nil,
 		},
 		{
 			name:             "IPv6",
 			netProto:         ipv6.ProtocolNumber,
-			remoteAddr:       ipv6Addr2.AddressWithPrefix.Address,
+			remoteAddr:       utils.Ipv6Addr2.AddressWithPrefix.Address,
 			expectedWriteErr: nil,
 		},
 	}
@@ -850,8 +798,8 @@ func TestTCPConfirmNeighborReachability(t *testing.T) {
 		{
 			name:         "IPv4 active connection through neighbor",
 			netProto:     ipv4.ProtocolNumber,
-			remoteAddr:   host2IPv4Addr.AddressWithPrefix.Address,
-			neighborAddr: routerNIC1IPv4Addr.AddressWithPrefix.Address,
+			remoteAddr:   utils.Host2IPv4Addr.AddressWithPrefix.Address,
+			neighborAddr: utils.RouterNIC1IPv4Addr.AddressWithPrefix.Address,
 			getEndpoints: func(t *testing.T, host1Stack, _, host2Stack *stack.Stack) (tcpip.Endpoint, tcpip.Endpoint, <-chan struct{}) {
 				var listenerWQ waiter.Queue
 				listenerEP, err := host2Stack.NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &listenerWQ)
@@ -874,8 +822,8 @@ func TestTCPConfirmNeighborReachability(t *testing.T) {
 		{
 			name:         "IPv6 active connection through neighbor",
 			netProto:     ipv6.ProtocolNumber,
-			remoteAddr:   host2IPv6Addr.AddressWithPrefix.Address,
-			neighborAddr: routerNIC1IPv6Addr.AddressWithPrefix.Address,
+			remoteAddr:   utils.Host2IPv6Addr.AddressWithPrefix.Address,
+			neighborAddr: utils.RouterNIC1IPv6Addr.AddressWithPrefix.Address,
 			getEndpoints: func(t *testing.T, host1Stack, _, host2Stack *stack.Stack) (tcpip.Endpoint, tcpip.Endpoint, <-chan struct{}) {
 				var listenerWQ waiter.Queue
 				listenerEP, err := host2Stack.NewEndpoint(tcp.ProtocolNumber, ipv6.ProtocolNumber, &listenerWQ)
@@ -898,8 +846,8 @@ func TestTCPConfirmNeighborReachability(t *testing.T) {
 		{
 			name:         "IPv4 active connection to neighbor",
 			netProto:     ipv4.ProtocolNumber,
-			remoteAddr:   routerNIC1IPv4Addr.AddressWithPrefix.Address,
-			neighborAddr: routerNIC1IPv4Addr.AddressWithPrefix.Address,
+			remoteAddr:   utils.RouterNIC1IPv4Addr.AddressWithPrefix.Address,
+			neighborAddr: utils.RouterNIC1IPv4Addr.AddressWithPrefix.Address,
 			getEndpoints: func(t *testing.T, host1Stack, routerStack, _ *stack.Stack) (tcpip.Endpoint, tcpip.Endpoint, <-chan struct{}) {
 				var listenerWQ waiter.Queue
 				listenerEP, err := routerStack.NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &listenerWQ)
@@ -922,8 +870,8 @@ func TestTCPConfirmNeighborReachability(t *testing.T) {
 		{
 			name:         "IPv6 active connection to neighbor",
 			netProto:     ipv6.ProtocolNumber,
-			remoteAddr:   routerNIC1IPv6Addr.AddressWithPrefix.Address,
-			neighborAddr: routerNIC1IPv6Addr.AddressWithPrefix.Address,
+			remoteAddr:   utils.RouterNIC1IPv6Addr.AddressWithPrefix.Address,
+			neighborAddr: utils.RouterNIC1IPv6Addr.AddressWithPrefix.Address,
 			getEndpoints: func(t *testing.T, host1Stack, routerStack, _ *stack.Stack) (tcpip.Endpoint, tcpip.Endpoint, <-chan struct{}) {
 				var listenerWQ waiter.Queue
 				listenerEP, err := routerStack.NewEndpoint(tcp.ProtocolNumber, ipv6.ProtocolNumber, &listenerWQ)
@@ -946,8 +894,8 @@ func TestTCPConfirmNeighborReachability(t *testing.T) {
 		{
 			name:         "IPv4 passive connection to neighbor",
 			netProto:     ipv4.ProtocolNumber,
-			remoteAddr:   host1IPv4Addr.AddressWithPrefix.Address,
-			neighborAddr: routerNIC1IPv4Addr.AddressWithPrefix.Address,
+			remoteAddr:   utils.Host1IPv4Addr.AddressWithPrefix.Address,
+			neighborAddr: utils.RouterNIC1IPv4Addr.AddressWithPrefix.Address,
 			getEndpoints: func(t *testing.T, host1Stack, routerStack, _ *stack.Stack) (tcpip.Endpoint, tcpip.Endpoint, <-chan struct{}) {
 				var listenerWQ waiter.Queue
 				listenerEP, err := host1Stack.NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &listenerWQ)
@@ -971,8 +919,8 @@ func TestTCPConfirmNeighborReachability(t *testing.T) {
 		{
 			name:         "IPv6 passive connection to neighbor",
 			netProto:     ipv6.ProtocolNumber,
-			remoteAddr:   host1IPv6Addr.AddressWithPrefix.Address,
-			neighborAddr: routerNIC1IPv6Addr.AddressWithPrefix.Address,
+			remoteAddr:   utils.Host1IPv6Addr.AddressWithPrefix.Address,
+			neighborAddr: utils.RouterNIC1IPv6Addr.AddressWithPrefix.Address,
 			getEndpoints: func(t *testing.T, host1Stack, routerStack, _ *stack.Stack) (tcpip.Endpoint, tcpip.Endpoint, <-chan struct{}) {
 				var listenerWQ waiter.Queue
 				listenerEP, err := host1Stack.NewEndpoint(tcp.ProtocolNumber, ipv6.ProtocolNumber, &listenerWQ)
@@ -996,8 +944,8 @@ func TestTCPConfirmNeighborReachability(t *testing.T) {
 		{
 			name:         "IPv4 passive connection through neighbor",
 			netProto:     ipv4.ProtocolNumber,
-			remoteAddr:   host1IPv4Addr.AddressWithPrefix.Address,
-			neighborAddr: routerNIC1IPv4Addr.AddressWithPrefix.Address,
+			remoteAddr:   utils.Host1IPv4Addr.AddressWithPrefix.Address,
+			neighborAddr: utils.RouterNIC1IPv4Addr.AddressWithPrefix.Address,
 			getEndpoints: func(t *testing.T, host1Stack, _, host2Stack *stack.Stack) (tcpip.Endpoint, tcpip.Endpoint, <-chan struct{}) {
 				var listenerWQ waiter.Queue
 				listenerEP, err := host1Stack.NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &listenerWQ)
@@ -1021,8 +969,8 @@ func TestTCPConfirmNeighborReachability(t *testing.T) {
 		{
 			name:         "IPv6 passive connection through neighbor",
 			netProto:     ipv6.ProtocolNumber,
-			remoteAddr:   host1IPv6Addr.AddressWithPrefix.Address,
-			neighborAddr: routerNIC1IPv6Addr.AddressWithPrefix.Address,
+			remoteAddr:   utils.Host1IPv6Addr.AddressWithPrefix.Address,
+			neighborAddr: utils.RouterNIC1IPv6Addr.AddressWithPrefix.Address,
 			getEndpoints: func(t *testing.T, host1Stack, _, host2Stack *stack.Stack) (tcpip.Endpoint, tcpip.Endpoint, <-chan struct{}) {
 				var listenerWQ waiter.Queue
 				listenerEP, err := host1Stack.NewEndpoint(tcp.ProtocolNumber, ipv6.ProtocolNumber, &listenerWQ)
@@ -1062,41 +1010,41 @@ func TestTCPConfirmNeighborReachability(t *testing.T) {
 			host1Stack := stack.New(host1StackOpts)
 			routerStack := stack.New(stackOpts)
 			host2Stack := stack.New(stackOpts)
-			setupRoutedStacks(t, host1Stack, routerStack, host2Stack)
+			utils.SetupRoutedStacks(t, host1Stack, routerStack, host2Stack)
 
 			// Add a reachable dynamic entry to our neighbor table for the remote.
 			{
 				ch := make(chan stack.LinkResolutionResult, 1)
-				err := host1Stack.GetLinkAddress(host1NICID, test.neighborAddr, "", test.netProto, func(r stack.LinkResolutionResult) {
+				err := host1Stack.GetLinkAddress(utils.Host1NICID, test.neighborAddr, "", test.netProto, func(r stack.LinkResolutionResult) {
 					ch <- r
 				})
 				if _, ok := err.(*tcpip.ErrWouldBlock); !ok {
-					t.Fatalf("got host1Stack.GetLinkAddress(%d, %s, '', %d, _) = %s, want = %s", host1NICID, test.neighborAddr, test.netProto, err, &tcpip.ErrWouldBlock{})
+					t.Fatalf("got host1Stack.GetLinkAddress(%d, %s, '', %d, _) = %s, want = %s", utils.Host1NICID, test.neighborAddr, test.netProto, err, &tcpip.ErrWouldBlock{})
 				}
-				if diff := cmp.Diff(stack.LinkResolutionResult{LinkAddress: linkAddr2, Success: true}, <-ch); diff != "" {
+				if diff := cmp.Diff(stack.LinkResolutionResult{LinkAddress: utils.LinkAddr2, Success: true}, <-ch); diff != "" {
 					t.Fatalf("link resolution mismatch (-want +got):\n%s", diff)
 				}
 			}
 			if err := nudDisp.waitForEvent(eventInfo{
 				eventType: entryAdded,
-				nicID:     host1NICID,
+				nicID:     utils.Host1NICID,
 				entry:     stack.NeighborEntry{State: stack.Incomplete, Addr: test.neighborAddr},
 			}); err != nil {
 				t.Fatalf("error waiting for initial NUD event: %s", err)
 			}
 			if err := nudDisp.waitForEvent(eventInfo{
 				eventType: entryChanged,
-				nicID:     host1NICID,
-				entry:     stack.NeighborEntry{State: stack.Reachable, Addr: test.neighborAddr, LinkAddr: linkAddr2},
+				nicID:     utils.Host1NICID,
+				entry:     stack.NeighborEntry{State: stack.Reachable, Addr: test.neighborAddr, LinkAddr: utils.LinkAddr2},
 			}); err != nil {
 				t.Fatalf("error waiting for reachable NUD event: %s", err)
 			}
 
 			// Wait for the remote's neighbor entry to be stale before creating a
 			// TCP connection from host1 to some remote.
-			nudConfigs, err := host1Stack.NUDConfigurations(host1NICID, test.netProto)
+			nudConfigs, err := host1Stack.NUDConfigurations(utils.Host1NICID, test.netProto)
 			if err != nil {
-				t.Fatalf("host1Stack.NUDConfigurations(%d, %d): %s", host1NICID, test.netProto, err)
+				t.Fatalf("host1Stack.NUDConfigurations(%d, %d): %s", utils.Host1NICID, test.netProto, err)
 			}
 			// The maximum reachable time for a neighbor is some maximum random factor
 			// applied to the base reachable time.
@@ -1106,8 +1054,8 @@ func TestTCPConfirmNeighborReachability(t *testing.T) {
 			clock.Advance(maxReachableTime)
 			if err := nudDisp.waitForEvent(eventInfo{
 				eventType: entryChanged,
-				nicID:     host1NICID,
-				entry:     stack.NeighborEntry{State: stack.Stale, Addr: test.neighborAddr, LinkAddr: linkAddr2},
+				nicID:     utils.Host1NICID,
+				entry:     stack.NeighborEntry{State: stack.Stale, Addr: test.neighborAddr, LinkAddr: utils.LinkAddr2},
 			}); err != nil {
 				t.Fatalf("error waiting for stale NUD event: %s", err)
 			}
@@ -1136,15 +1084,15 @@ func TestTCPConfirmNeighborReachability(t *testing.T) {
 			<-clientCH
 			if err := nudDisp.waitForEvent(eventInfo{
 				eventType: entryChanged,
-				nicID:     host1NICID,
-				entry:     stack.NeighborEntry{State: stack.Delay, Addr: test.neighborAddr, LinkAddr: linkAddr2},
+				nicID:     utils.Host1NICID,
+				entry:     stack.NeighborEntry{State: stack.Delay, Addr: test.neighborAddr, LinkAddr: utils.LinkAddr2},
 			}); err != nil {
 				t.Fatalf("error waiting for delay NUD event: %s", err)
 			}
 			if err := nudDisp.waitForEvent(eventInfo{
 				eventType: entryChanged,
-				nicID:     host1NICID,
-				entry:     stack.NeighborEntry{State: stack.Reachable, Addr: test.neighborAddr, LinkAddr: linkAddr2},
+				nicID:     utils.Host1NICID,
+				entry:     stack.NeighborEntry{State: stack.Reachable, Addr: test.neighborAddr, LinkAddr: utils.LinkAddr2},
 			}); err != nil {
 				t.Fatalf("error waiting for reachable NUD event: %s", err)
 			}
@@ -1157,8 +1105,8 @@ func TestTCPConfirmNeighborReachability(t *testing.T) {
 			clock.Advance(maxReachableTime)
 			if err := nudDisp.waitForEvent(eventInfo{
 				eventType: entryChanged,
-				nicID:     host1NICID,
-				entry:     stack.NeighborEntry{State: stack.Stale, Addr: test.neighborAddr, LinkAddr: linkAddr2},
+				nicID:     utils.Host1NICID,
+				entry:     stack.NeighborEntry{State: stack.Stale, Addr: test.neighborAddr, LinkAddr: utils.LinkAddr2},
 			}); err != nil {
 				t.Fatalf("error waiting for stale NUD event: %s", err)
 			}
@@ -1170,8 +1118,8 @@ func TestTCPConfirmNeighborReachability(t *testing.T) {
 			}
 			if err := nudDisp.waitForEvent(eventInfo{
 				eventType: entryChanged,
-				nicID:     host1NICID,
-				entry:     stack.NeighborEntry{State: stack.Delay, Addr: test.neighborAddr, LinkAddr: linkAddr2},
+				nicID:     utils.Host1NICID,
+				entry:     stack.NeighborEntry{State: stack.Delay, Addr: test.neighborAddr, LinkAddr: utils.LinkAddr2},
 			}); err != nil {
 				t.Fatalf("error waiting for delay NUD event: %s", err)
 			}
@@ -1183,16 +1131,16 @@ func TestTCPConfirmNeighborReachability(t *testing.T) {
 				clock.Advance(nudConfigs.DelayFirstProbeTime)
 				if err := nudDisp.waitForEvent(eventInfo{
 					eventType: entryChanged,
-					nicID:     host1NICID,
-					entry:     stack.NeighborEntry{State: stack.Probe, Addr: test.neighborAddr, LinkAddr: linkAddr2},
+					nicID:     utils.Host1NICID,
+					entry:     stack.NeighborEntry{State: stack.Probe, Addr: test.neighborAddr, LinkAddr: utils.LinkAddr2},
 				}); err != nil {
 					t.Fatalf("error waiting for probe NUD event: %s", err)
 				}
 			}
 			if err := nudDisp.waitForEvent(eventInfo{
 				eventType: entryChanged,
-				nicID:     host1NICID,
-				entry:     stack.NeighborEntry{State: stack.Reachable, Addr: test.neighborAddr, LinkAddr: linkAddr2},
+				nicID:     utils.Host1NICID,
+				entry:     stack.NeighborEntry{State: stack.Reachable, Addr: test.neighborAddr, LinkAddr: utils.LinkAddr2},
 			}); err != nil {
 				t.Fatalf("error waiting for reachable NUD event: %s", err)
 			}
@@ -1201,11 +1149,6 @@ func TestTCPConfirmNeighborReachability(t *testing.T) {
 }
 
 func TestDAD(t *testing.T) {
-	const (
-		host1NICID = 1
-		host2NICID = 4
-	)
-
 	dadConfigs := stack.DADConfigurations{
 		DupAddrDetectTransmits: 1,
 		RetransmitTimer:        time.Second,
@@ -1222,42 +1165,42 @@ func TestDAD(t *testing.T) {
 			name:             "IPv4 own address",
 			netProto:         ipv4.ProtocolNumber,
 			dadNetProto:      arp.ProtocolNumber,
-			remoteAddr:       ipv4Addr1.AddressWithPrefix.Address,
+			remoteAddr:       utils.Ipv4Addr1.AddressWithPrefix.Address,
 			expectedResolved: true,
 		},
 		{
 			name:             "IPv6 own address",
 			netProto:         ipv6.ProtocolNumber,
 			dadNetProto:      ipv6.ProtocolNumber,
-			remoteAddr:       ipv6Addr1.AddressWithPrefix.Address,
+			remoteAddr:       utils.Ipv6Addr1.AddressWithPrefix.Address,
 			expectedResolved: true,
 		},
 		{
 			name:             "IPv4 duplicate address",
 			netProto:         ipv4.ProtocolNumber,
 			dadNetProto:      arp.ProtocolNumber,
-			remoteAddr:       ipv4Addr2.AddressWithPrefix.Address,
+			remoteAddr:       utils.Ipv4Addr2.AddressWithPrefix.Address,
 			expectedResolved: false,
 		},
 		{
 			name:             "IPv6 duplicate address",
 			netProto:         ipv6.ProtocolNumber,
 			dadNetProto:      ipv6.ProtocolNumber,
-			remoteAddr:       ipv6Addr2.AddressWithPrefix.Address,
+			remoteAddr:       utils.Ipv6Addr2.AddressWithPrefix.Address,
 			expectedResolved: false,
 		},
 		{
 			name:             "IPv4 no duplicate address",
 			netProto:         ipv4.ProtocolNumber,
 			dadNetProto:      arp.ProtocolNumber,
-			remoteAddr:       ipv4Addr3.AddressWithPrefix.Address,
+			remoteAddr:       utils.Ipv4Addr3.AddressWithPrefix.Address,
 			expectedResolved: true,
 		},
 		{
 			name:             "IPv6 no duplicate address",
 			netProto:         ipv6.ProtocolNumber,
 			dadNetProto:      ipv6.ProtocolNumber,
-			remoteAddr:       ipv6Addr3.AddressWithPrefix.Address,
+			remoteAddr:       utils.Ipv6Addr3.AddressWithPrefix.Address,
 			expectedResolved: true,
 		},
 	}
@@ -1274,21 +1217,21 @@ func TestDAD(t *testing.T) {
 				},
 			}
 
-			host1Stack, _ := setupStack(t, stackOpts, host1NICID, host2NICID)
+			host1Stack, _ := setupStack(t, stackOpts, utils.Host1NICID, utils.Host2NICID)
 
 			// DAD should be disabled by default.
-			if res, err := host1Stack.CheckDuplicateAddress(host1NICID, test.netProto, test.remoteAddr, func(r stack.DADResult) {
+			if res, err := host1Stack.CheckDuplicateAddress(utils.Host1NICID, test.netProto, test.remoteAddr, func(r stack.DADResult) {
 				t.Errorf("unexpectedly called DAD completion handler when DAD was supposed to be disabled")
 			}); err != nil {
-				t.Fatalf("host1Stack.CheckDuplicateAddress(%d, %d, %s, _): %s", host1NICID, test.netProto, test.remoteAddr, err)
+				t.Fatalf("host1Stack.CheckDuplicateAddress(%d, %d, %s, _): %s", utils.Host1NICID, test.netProto, test.remoteAddr, err)
 			} else if res != stack.DADDisabled {
-				t.Errorf("got host1Stack.CheckDuplicateAddress(%d, %d, %s, _) = %d, want = %d", host1NICID, test.netProto, test.remoteAddr, res, stack.DADDisabled)
+				t.Errorf("got host1Stack.CheckDuplicateAddress(%d, %d, %s, _) = %d, want = %d", utils.Host1NICID, test.netProto, test.remoteAddr, res, stack.DADDisabled)
 			}
 
 			// Enable DAD then attempt to check if an address is duplicated.
-			netEP, err := host1Stack.GetNetworkEndpoint(host1NICID, test.dadNetProto)
+			netEP, err := host1Stack.GetNetworkEndpoint(utils.Host1NICID, test.dadNetProto)
 			if err != nil {
-				t.Fatalf("host1Stack.GetNetworkEndpoint(%d, %d): %s", host1NICID, test.dadNetProto, err)
+				t.Fatalf("host1Stack.GetNetworkEndpoint(%d, %d): %s", utils.Host1NICID, test.dadNetProto, err)
 			}
 			dad, ok := netEP.(stack.DuplicateAddressDetector)
 			if !ok {
@@ -1296,12 +1239,12 @@ func TestDAD(t *testing.T) {
 			}
 			dad.SetDADConfigurations(dadConfigs)
 			ch := make(chan stack.DADResult, 3)
-			if res, err := host1Stack.CheckDuplicateAddress(host1NICID, test.netProto, test.remoteAddr, func(r stack.DADResult) {
+			if res, err := host1Stack.CheckDuplicateAddress(utils.Host1NICID, test.netProto, test.remoteAddr, func(r stack.DADResult) {
 				ch <- r
 			}); err != nil {
-				t.Fatalf("host1Stack.CheckDuplicateAddress(%d, %d, %s, _): %s", host1NICID, test.netProto, test.remoteAddr, err)
+				t.Fatalf("host1Stack.CheckDuplicateAddress(%d, %d, %s, _): %s", utils.Host1NICID, test.netProto, test.remoteAddr, err)
 			} else if res != stack.DADStarting {
-				t.Errorf("got host1Stack.CheckDuplicateAddress(%d, %d, %s, _) = %d, want = %d", host1NICID, test.netProto, test.remoteAddr, res, stack.DADStarting)
+				t.Errorf("got host1Stack.CheckDuplicateAddress(%d, %d, %s, _) = %d, want = %d", utils.Host1NICID, test.netProto, test.remoteAddr, res, stack.DADStarting)
 			}
 
 			expectResults := 1
@@ -1318,12 +1261,12 @@ func TestDAD(t *testing.T) {
 				// same address. The handler for the new request should be called once
 				// the original DAD request completes.
 				expectResults = 2
-				if res, err := host1Stack.CheckDuplicateAddress(host1NICID, test.netProto, test.remoteAddr, func(r stack.DADResult) {
+				if res, err := host1Stack.CheckDuplicateAddress(utils.Host1NICID, test.netProto, test.remoteAddr, func(r stack.DADResult) {
 					ch <- r
 				}); err != nil {
-					t.Fatalf("host1Stack.CheckDuplicateAddress(%d, %d, %s, _): %s", host1NICID, test.netProto, test.remoteAddr, err)
+					t.Fatalf("host1Stack.CheckDuplicateAddress(%d, %d, %s, _): %s", utils.Host1NICID, test.netProto, test.remoteAddr, err)
 				} else if res != stack.DADAlreadyRunning {
-					t.Errorf("got host1Stack.CheckDuplicateAddress(%d, %d, %s, _) = %d, want = %d", host1NICID, test.netProto, test.remoteAddr, res, stack.DADAlreadyRunning)
+					t.Errorf("got host1Stack.CheckDuplicateAddress(%d, %d, %s, _) = %d, want = %d", utils.Host1NICID, test.netProto, test.remoteAddr, res, stack.DADAlreadyRunning)
 				}
 
 				clock.Advance(delta)
diff --git a/pkg/tcpip/tests/integration/loopback_test.go b/pkg/tcpip/tests/integration/loopback_test.go
index ab67762ef..c56155ea2 100644
--- a/pkg/tcpip/tests/integration/loopback_test.go
+++ b/pkg/tcpip/tests/integration/loopback_test.go
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package integration_test
+package loopback_test
 
 import (
 	"bytes"
@@ -28,6 +28,7 @@ import (
 	"gvisor.dev/gvisor/pkg/tcpip/network/ipv4"
 	"gvisor.dev/gvisor/pkg/tcpip/network/ipv6"
 	"gvisor.dev/gvisor/pkg/tcpip/stack"
+	"gvisor.dev/gvisor/pkg/tcpip/tests/utils"
 	"gvisor.dev/gvisor/pkg/tcpip/transport/tcp"
 	"gvisor.dev/gvisor/pkg/tcpip/transport/udp"
 	"gvisor.dev/gvisor/pkg/waiter"
@@ -109,7 +110,7 @@ func TestLoopbackAcceptAllInSubnetUDP(t *testing.T) {
 
 	ipv4ProtocolAddress := tcpip.ProtocolAddress{
 		Protocol:          header.IPv4ProtocolNumber,
-		AddressWithPrefix: ipv4Addr,
+		AddressWithPrefix: utils.Ipv4Addr,
 	}
 	ipv4Bytes := []byte(ipv4ProtocolAddress.AddressWithPrefix.Address)
 	ipv4Bytes[len(ipv4Bytes)-1]++
@@ -117,9 +118,9 @@ func TestLoopbackAcceptAllInSubnetUDP(t *testing.T) {
 
 	ipv6ProtocolAddress := tcpip.ProtocolAddress{
 		Protocol:          header.IPv6ProtocolNumber,
-		AddressWithPrefix: ipv6Addr,
+		AddressWithPrefix: utils.Ipv6Addr,
 	}
-	ipv6Bytes := []byte(ipv6Addr.Address)
+	ipv6Bytes := []byte(utils.Ipv6Addr.Address)
 	ipv6Bytes[len(ipv6Bytes)-1]++
 	otherIPv6Address := tcpip.Address(ipv6Bytes)
 
@@ -145,7 +146,7 @@ func TestLoopbackAcceptAllInSubnetUDP(t *testing.T) {
 		{
 			name:       "IPv4 bind to wildcard send to other address",
 			addAddress: ipv4ProtocolAddress,
-			dstAddr:    remoteIPv4Addr,
+			dstAddr:    utils.RemoteIPv4Addr,
 			expectRx:   false,
 		},
 		{
@@ -173,8 +174,8 @@ func TestLoopbackAcceptAllInSubnetUDP(t *testing.T) {
 		{
 			name:       "IPv6 bind and send to assigned address",
 			addAddress: ipv6ProtocolAddress,
-			bindAddr:   ipv6Addr.Address,
-			dstAddr:    ipv6Addr.Address,
+			bindAddr:   utils.Ipv6Addr.Address,
+			dstAddr:    utils.Ipv6Addr.Address,
 			expectRx:   true,
 		},
 		{
@@ -277,9 +278,9 @@ func TestLoopbackSubnetLifetimeBoundToAddr(t *testing.T) {
 
 	protoAddr := tcpip.ProtocolAddress{
 		Protocol:          ipv4.ProtocolNumber,
-		AddressWithPrefix: ipv4Addr,
+		AddressWithPrefix: utils.Ipv4Addr,
 	}
-	addrBytes := []byte(ipv4Addr.Address)
+	addrBytes := []byte(utils.Ipv4Addr.Address)
 	addrBytes[len(addrBytes)-1]++
 	otherAddr := tcpip.Address(addrBytes)
 
@@ -299,9 +300,9 @@ func TestLoopbackSubnetLifetimeBoundToAddr(t *testing.T) {
 		},
 	})
 
-	r, err := s.FindRoute(nicID, otherAddr, remoteIPv4Addr, ipv4.ProtocolNumber, false /* multicastLoop */)
+	r, err := s.FindRoute(nicID, otherAddr, utils.RemoteIPv4Addr, ipv4.ProtocolNumber, false /* multicastLoop */)
 	if err != nil {
-		t.Fatalf("s.FindRoute(%d, %s, %s, %d, false): %s", nicID, otherAddr, remoteIPv4Addr, ipv4.ProtocolNumber, err)
+		t.Fatalf("s.FindRoute(%d, %s, %s, %d, false): %s", nicID, otherAddr, utils.RemoteIPv4Addr, ipv4.ProtocolNumber, err)
 	}
 	defer r.Release()
 
@@ -344,7 +345,7 @@ func TestLoopbackAcceptAllInSubnetTCP(t *testing.T) {
 
 	ipv4ProtocolAddress := tcpip.ProtocolAddress{
 		Protocol:          header.IPv4ProtocolNumber,
-		AddressWithPrefix: ipv4Addr,
+		AddressWithPrefix: utils.Ipv4Addr,
 	}
 	ipv4ProtocolAddress.AddressWithPrefix.PrefixLen = 8
 	ipv4Bytes := []byte(ipv4ProtocolAddress.AddressWithPrefix.Address)
@@ -353,9 +354,9 @@ func TestLoopbackAcceptAllInSubnetTCP(t *testing.T) {
 
 	ipv6ProtocolAddress := tcpip.ProtocolAddress{
 		Protocol:          header.IPv6ProtocolNumber,
-		AddressWithPrefix: ipv6Addr,
+		AddressWithPrefix: utils.Ipv6Addr,
 	}
-	ipv6Bytes := []byte(ipv6Addr.Address)
+	ipv6Bytes := []byte(utils.Ipv6Addr.Address)
 	ipv6Bytes[len(ipv6Bytes)-1]++
 	otherIPv6Address := tcpip.Address(ipv6Bytes)
 
@@ -381,7 +382,7 @@ func TestLoopbackAcceptAllInSubnetTCP(t *testing.T) {
 		{
 			name:         "IPv4 bind to wildcard send to other address",
 			addAddress:   ipv4ProtocolAddress,
-			dstAddr:      remoteIPv4Addr,
+			dstAddr:      utils.RemoteIPv4Addr,
 			expectAccept: false,
 		},
 		{
@@ -409,8 +410,8 @@ func TestLoopbackAcceptAllInSubnetTCP(t *testing.T) {
 		{
 			name:         "IPv6 bind and send to assigned address",
 			addAddress:   ipv6ProtocolAddress,
-			bindAddr:     ipv6Addr.Address,
-			dstAddr:      ipv6Addr.Address,
+			bindAddr:     utils.Ipv6Addr.Address,
+			dstAddr:      utils.Ipv6Addr.Address,
 			expectAccept: true,
 		},
 		{
diff --git a/pkg/tcpip/tests/integration/multicast_broadcast_test.go b/pkg/tcpip/tests/integration/multicast_broadcast_test.go
index d685fdd36..e4439ba79 100644
--- a/pkg/tcpip/tests/integration/multicast_broadcast_test.go
+++ b/pkg/tcpip/tests/integration/multicast_broadcast_test.go
@@ -12,11 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package integration_test
+package multicast_broadcast_test
 
 import (
 	"bytes"
-	"net"
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
@@ -29,6 +28,7 @@ import (
 	"gvisor.dev/gvisor/pkg/tcpip/network/ipv4"
 	"gvisor.dev/gvisor/pkg/tcpip/network/ipv6"
 	"gvisor.dev/gvisor/pkg/tcpip/stack"
+	"gvisor.dev/gvisor/pkg/tcpip/tests/utils"
 	"gvisor.dev/gvisor/pkg/tcpip/transport/icmp"
 	"gvisor.dev/gvisor/pkg/tcpip/transport/udp"
 	"gvisor.dev/gvisor/pkg/waiter"
@@ -37,29 +37,6 @@ import (
 const (
 	defaultMTU = 1280
 	ttl        = 255
-
-	remotePort = 5555
-	localPort  = 80
-)
-
-var (
-	ipv4Addr = tcpip.AddressWithPrefix{
-		Address:   tcpip.Address(net.ParseIP("192.168.1.58").To4()),
-		PrefixLen: 24,
-	}
-	ipv4Subnet      = ipv4Addr.Subnet()
-	ipv4SubnetBcast = ipv4Subnet.Broadcast()
-
-	ipv6Addr = tcpip.AddressWithPrefix{
-		Address:   tcpip.Address(net.ParseIP("200a::1").To16()),
-		PrefixLen: 64,
-	}
-	ipv6Subnet      = ipv6Addr.Subnet()
-	ipv6SubnetBcast = ipv6Subnet.Broadcast()
-
-	// Remote addrs.
-	remoteIPv4Addr = tcpip.Address(net.ParseIP("10.0.0.1").To4())
-	remoteIPv6Addr = tcpip.Address(net.ParseIP("200b::1").To16())
 )
 
 // TestPingMulticastBroadcast tests that responding to an Echo Request destined
@@ -81,7 +58,7 @@ func TestPingMulticastBroadcast(t *testing.T) {
 			TotalLength: uint16(totalLen),
 			Protocol:    uint8(icmp.ProtocolNumber4),
 			TTL:         ttl,
-			SrcAddr:     remoteIPv4Addr,
+			SrcAddr:     utils.RemoteIPv4Addr,
 			DstAddr:     dst,
 		})
 		ip.SetChecksum(^ip.CalculateChecksum())
@@ -98,13 +75,13 @@ func TestPingMulticastBroadcast(t *testing.T) {
 		pkt.SetType(header.ICMPv6EchoRequest)
 		pkt.SetCode(0)
 		pkt.SetChecksum(0)
-		pkt.SetChecksum(header.ICMPv6Checksum(pkt, remoteIPv6Addr, dst, buffer.VectorisedView{}))
+		pkt.SetChecksum(header.ICMPv6Checksum(pkt, utils.RemoteIPv6Addr, dst, buffer.VectorisedView{}))
 		ip := header.IPv6(hdr.Prepend(header.IPv6MinimumSize))
 		ip.Encode(&header.IPv6Fields{
 			PayloadLength:     header.ICMPv6MinimumSize,
 			TransportProtocol: icmp.ProtocolNumber6,
 			HopLimit:          ttl,
-			SrcAddr:           remoteIPv6Addr,
+			SrcAddr:           utils.RemoteIPv6Addr,
 			DstAddr:           dst,
 		})
 
@@ -119,11 +96,11 @@ func TestPingMulticastBroadcast(t *testing.T) {
 	}{
 		{
 			name:    "IPv4 unicast",
-			dstAddr: ipv4Addr.Address,
+			dstAddr: utils.Ipv4Addr.Address,
 		},
 		{
 			name:    "IPv4 directed broadcast",
-			dstAddr: ipv4SubnetBcast,
+			dstAddr: utils.Ipv4SubnetBcast,
 		},
 		{
 			name:    "IPv4 broadcast",
@@ -135,7 +112,7 @@ func TestPingMulticastBroadcast(t *testing.T) {
 		},
 		{
 			name:    "IPv6 unicast",
-			dstAddr: ipv6Addr.Address,
+			dstAddr: utils.Ipv6Addr.Address,
 		},
 		{
 			name:    "IPv6 all-nodes multicast",
@@ -154,11 +131,11 @@ func TestPingMulticastBroadcast(t *testing.T) {
 			if err := s.CreateNIC(nicID, e); err != nil {
 				t.Fatalf("CreateNIC(%d, _): %s", nicID, err)
 			}
-			ipv4ProtoAddr := tcpip.ProtocolAddress{Protocol: header.IPv4ProtocolNumber, AddressWithPrefix: ipv4Addr}
+			ipv4ProtoAddr := tcpip.ProtocolAddress{Protocol: header.IPv4ProtocolNumber, AddressWithPrefix: utils.Ipv4Addr}
 			if err := s.AddProtocolAddress(nicID, ipv4ProtoAddr); err != nil {
 				t.Fatalf("AddProtocolAddress(%d, %#v): %s", nicID, ipv4ProtoAddr, err)
 			}
-			ipv6ProtoAddr := tcpip.ProtocolAddress{Protocol: header.IPv6ProtocolNumber, AddressWithPrefix: ipv6Addr}
+			ipv6ProtoAddr := tcpip.ProtocolAddress{Protocol: header.IPv6ProtocolNumber, AddressWithPrefix: utils.Ipv6Addr}
 			if err := s.AddProtocolAddress(nicID, ipv6ProtoAddr); err != nil {
 				t.Fatalf("AddProtocolAddress(%d, %#v): %s", nicID, ipv6ProtoAddr, err)
 			}
@@ -183,13 +160,13 @@ func TestPingMulticastBroadcast(t *testing.T) {
 			switch l := len(test.dstAddr); l {
 			case header.IPv4AddressSize:
 				rxICMP = rxIPv4ICMP
-				expectedSrc = ipv4Addr.Address
-				expectedDst = remoteIPv4Addr
+				expectedSrc = utils.Ipv4Addr.Address
+				expectedDst = utils.RemoteIPv4Addr
 				protoNum = header.IPv4ProtocolNumber
 			case header.IPv6AddressSize:
 				rxICMP = rxIPv6ICMP
-				expectedSrc = ipv6Addr.Address
-				expectedDst = remoteIPv6Addr
+				expectedSrc = utils.Ipv6Addr.Address
+				expectedDst = utils.RemoteIPv6Addr
 				protoNum = header.IPv6ProtocolNumber
 			default:
 				t.Fatalf("got unexpected address length = %d bytes", l)
@@ -226,8 +203,8 @@ func rxIPv4UDP(e *channel.Endpoint, src, dst tcpip.Address, data []byte) {
 	hdr := buffer.NewPrependable(totalLen)
 	u := header.UDP(hdr.Prepend(payloadLen))
 	u.Encode(&header.UDPFields{
-		SrcPort: remotePort,
-		DstPort: localPort,
+		SrcPort: utils.RemotePort,
+		DstPort: utils.LocalPort,
 		Length:  uint16(payloadLen),
 	})
 	copy(u.Payload(), data)
@@ -255,8 +232,8 @@ func rxIPv6UDP(e *channel.Endpoint, src, dst tcpip.Address, data []byte) {
 	hdr := buffer.NewPrependable(header.IPv6MinimumSize + payloadLen)
 	u := header.UDP(hdr.Prepend(payloadLen))
 	u.Encode(&header.UDPFields{
-		SrcPort: remotePort,
-		DstPort: localPort,
+		SrcPort: utils.RemotePort,
+		DstPort: utils.LocalPort,
 		Length:  uint16(payloadLen),
 	})
 	copy(u.Payload(), data)
@@ -298,68 +275,68 @@ func TestIncomingMulticastAndBroadcast(t *testing.T) {
 		{
 			name:       "IPv4 unicast binding to unicast",
 			proto:      header.IPv4ProtocolNumber,
-			remoteAddr: remoteIPv4Addr,
-			localAddr:  ipv4Addr,
+			remoteAddr: utils.RemoteIPv4Addr,
+			localAddr:  utils.Ipv4Addr,
 			rxUDP:      rxIPv4UDP,
-			bindAddr:   ipv4Addr.Address,
-			dstAddr:    ipv4Addr.Address,
+			bindAddr:   utils.Ipv4Addr.Address,
+			dstAddr:    utils.Ipv4Addr.Address,
 			expectRx:   true,
 		},
 		{
 			name:       "IPv4 unicast binding to broadcast",
 			proto:      header.IPv4ProtocolNumber,
-			remoteAddr: remoteIPv4Addr,
-			localAddr:  ipv4Addr,
+			remoteAddr: utils.RemoteIPv4Addr,
+			localAddr:  utils.Ipv4Addr,
 			rxUDP:      rxIPv4UDP,
 			bindAddr:   header.IPv4Broadcast,
-			dstAddr:    ipv4Addr.Address,
+			dstAddr:    utils.Ipv4Addr.Address,
 			expectRx:   false,
 		},
 		{
 			name:       "IPv4 unicast binding to wildcard",
 			proto:      header.IPv4ProtocolNumber,
-			remoteAddr: remoteIPv4Addr,
-			localAddr:  ipv4Addr,
+			remoteAddr: utils.RemoteIPv4Addr,
+			localAddr:  utils.Ipv4Addr,
 			rxUDP:      rxIPv4UDP,
-			dstAddr:    ipv4Addr.Address,
+			dstAddr:    utils.Ipv4Addr.Address,
 			expectRx:   true,
 		},
 
 		{
 			name:       "IPv4 directed broadcast binding to subnet broadcast",
 			proto:      header.IPv4ProtocolNumber,
-			remoteAddr: remoteIPv4Addr,
-			localAddr:  ipv4Addr,
+			remoteAddr: utils.RemoteIPv4Addr,
+			localAddr:  utils.Ipv4Addr,
 			rxUDP:      rxIPv4UDP,
-			bindAddr:   ipv4SubnetBcast,
-			dstAddr:    ipv4SubnetBcast,
+			bindAddr:   utils.Ipv4SubnetBcast,
+			dstAddr:    utils.Ipv4SubnetBcast,
 			expectRx:   true,
 		},
 		{
 			name:       "IPv4 directed broadcast binding to broadcast",
 			proto:      header.IPv4ProtocolNumber,
-			remoteAddr: remoteIPv4Addr,
-			localAddr:  ipv4Addr,
+			remoteAddr: utils.RemoteIPv4Addr,
+			localAddr:  utils.Ipv4Addr,
 			rxUDP:      rxIPv4UDP,
 			bindAddr:   header.IPv4Broadcast,
-			dstAddr:    ipv4SubnetBcast,
+			dstAddr:    utils.Ipv4SubnetBcast,
 			expectRx:   false,
 		},
 		{
 			name:       "IPv4 directed broadcast binding to wildcard",
 			proto:      header.IPv4ProtocolNumber,
-			remoteAddr: remoteIPv4Addr,
-			localAddr:  ipv4Addr,
+			remoteAddr: utils.RemoteIPv4Addr,
+			localAddr:  utils.Ipv4Addr,
 			rxUDP:      rxIPv4UDP,
-			dstAddr:    ipv4SubnetBcast,
+			dstAddr:    utils.Ipv4SubnetBcast,
 			expectRx:   true,
 		},
 
 		{
 			name:       "IPv4 broadcast binding to broadcast",
 			proto:      header.IPv4ProtocolNumber,
-			remoteAddr: remoteIPv4Addr,
-			localAddr:  ipv4Addr,
+			remoteAddr: utils.RemoteIPv4Addr,
+			localAddr:  utils.Ipv4Addr,
 			rxUDP:      rxIPv4UDP,
 			bindAddr:   header.IPv4Broadcast,
 			dstAddr:    header.IPv4Broadcast,
@@ -368,28 +345,28 @@ func TestIncomingMulticastAndBroadcast(t *testing.T) {
 		{
 			name:       "IPv4 broadcast binding to subnet broadcast",
 			proto:      header.IPv4ProtocolNumber,
-			remoteAddr: remoteIPv4Addr,
-			localAddr:  ipv4Addr,
+			remoteAddr: utils.RemoteIPv4Addr,
+			localAddr:  utils.Ipv4Addr,
 			rxUDP:      rxIPv4UDP,
-			bindAddr:   ipv4SubnetBcast,
+			bindAddr:   utils.Ipv4SubnetBcast,
 			dstAddr:    header.IPv4Broadcast,
 			expectRx:   false,
 		},
 		{
 			name:       "IPv4 broadcast binding to wildcard",
 			proto:      header.IPv4ProtocolNumber,
-			remoteAddr: remoteIPv4Addr,
-			localAddr:  ipv4Addr,
+			remoteAddr: utils.RemoteIPv4Addr,
+			localAddr:  utils.Ipv4Addr,
 			rxUDP:      rxIPv4UDP,
-			dstAddr:    ipv4SubnetBcast,
+			dstAddr:    utils.Ipv4SubnetBcast,
 			expectRx:   true,
 		},
 
 		{
 			name:       "IPv4 all-systems multicast binding to all-systems multicast",
 			proto:      header.IPv4ProtocolNumber,
-			remoteAddr: remoteIPv4Addr,
-			localAddr:  ipv4Addr,
+			remoteAddr: utils.RemoteIPv4Addr,
+			localAddr:  utils.Ipv4Addr,
 			rxUDP:      rxIPv4UDP,
 			bindAddr:   header.IPv4AllSystems,
 			dstAddr:    header.IPv4AllSystems,
@@ -398,8 +375,8 @@ func TestIncomingMulticastAndBroadcast(t *testing.T) {
 		{
 			name:       "IPv4 all-systems multicast binding to wildcard",
 			proto:      header.IPv4ProtocolNumber,
-			remoteAddr: remoteIPv4Addr,
-			localAddr:  ipv4Addr,
+			remoteAddr: utils.RemoteIPv4Addr,
+			localAddr:  utils.Ipv4Addr,
 			rxUDP:      rxIPv4UDP,
 			dstAddr:    header.IPv4AllSystems,
 			expectRx:   true,
@@ -407,10 +384,10 @@ func TestIncomingMulticastAndBroadcast(t *testing.T) {
 		{
 			name:       "IPv4 all-systems multicast binding to unicast",
 			proto:      header.IPv4ProtocolNumber,
-			remoteAddr: remoteIPv4Addr,
-			localAddr:  ipv4Addr,
+			remoteAddr: utils.RemoteIPv4Addr,
+			localAddr:  utils.Ipv4Addr,
 			rxUDP:      rxIPv4UDP,
-			bindAddr:   ipv4Addr.Address,
+			bindAddr:   utils.Ipv4Addr.Address,
 			dstAddr:    header.IPv4AllSystems,
 			expectRx:   false,
 		},
@@ -418,19 +395,19 @@ func TestIncomingMulticastAndBroadcast(t *testing.T) {
 		// IPv6 has no notion of a broadcast.
 		{
 			name:       "IPv6 unicast binding to wildcard",
-			dstAddr:    ipv6Addr.Address,
+			dstAddr:    utils.Ipv6Addr.Address,
 			proto:      header.IPv6ProtocolNumber,
-			remoteAddr: remoteIPv6Addr,
-			localAddr:  ipv6Addr,
+			remoteAddr: utils.RemoteIPv6Addr,
+			localAddr:  utils.Ipv6Addr,
 			rxUDP:      rxIPv6UDP,
 			expectRx:   true,
 		},
 		{
 			name:       "IPv6 broadcast-like address binding to wildcard",
-			dstAddr:    ipv6SubnetBcast,
+			dstAddr:    utils.Ipv6SubnetBcast,
 			proto:      header.IPv6ProtocolNumber,
-			remoteAddr: remoteIPv6Addr,
-			localAddr:  ipv6Addr,
+			remoteAddr: utils.RemoteIPv6Addr,
+			localAddr:  utils.Ipv6Addr,
 			rxUDP:      rxIPv6UDP,
 			expectRx:   false,
 		},
@@ -458,7 +435,7 @@ func TestIncomingMulticastAndBroadcast(t *testing.T) {
 			}
 			defer ep.Close()
 
-			bindAddr := tcpip.FullAddress{Addr: test.bindAddr, Port: localPort}
+			bindAddr := tcpip.FullAddress{Addr: test.bindAddr, Port: utils.LocalPort}
 			if err := ep.Bind(bindAddr); err != nil {
 				t.Fatalf("ep.Bind(%#v): %s", bindAddr, err)
 			}
@@ -639,16 +616,16 @@ func TestUDPAddRemoveMembershipSocketOption(t *testing.T) {
 			name:          "IPv4 unicast binding to unicast",
 			multicastAddr: "\xe0\x01\x02\x03",
 			proto:         header.IPv4ProtocolNumber,
-			remoteAddr:    remoteIPv4Addr,
-			localAddr:     ipv4Addr,
+			remoteAddr:    utils.RemoteIPv4Addr,
+			localAddr:     utils.Ipv4Addr,
 			rxUDP:         rxIPv4UDP,
 		},
 		{
 			name:          "IPv6 broadcast-like address binding to wildcard",
 			multicastAddr: "\xff\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x03\x04",
 			proto:         header.IPv6ProtocolNumber,
-			remoteAddr:    remoteIPv6Addr,
-			localAddr:     ipv6Addr,
+			remoteAddr:    utils.RemoteIPv6Addr,
+			localAddr:     utils.Ipv6Addr,
 			rxUDP:         rxIPv6UDP,
 		},
 	}
@@ -719,7 +696,7 @@ func TestUDPAddRemoveMembershipSocketOption(t *testing.T) {
 					}
 					defer ep.Close()
 
-					bindAddr := tcpip.FullAddress{Port: localPort}
+					bindAddr := tcpip.FullAddress{Port: utils.LocalPort}
 					if err := ep.Bind(bindAddr); err != nil {
 						t.Fatalf("ep.Bind(%#v): %s", bindAddr, err)
 					}
diff --git a/pkg/tcpip/tests/integration/route_test.go b/pkg/tcpip/tests/integration/route_test.go
index 9654c9527..4455f6dd7 100644
--- a/pkg/tcpip/tests/integration/route_test.go
+++ b/pkg/tcpip/tests/integration/route_test.go
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package integration_test
+package route_test
 
 import (
 	"bytes"
@@ -28,6 +28,7 @@ import (
 	"gvisor.dev/gvisor/pkg/tcpip/network/ipv4"
 	"gvisor.dev/gvisor/pkg/tcpip/network/ipv6"
 	"gvisor.dev/gvisor/pkg/tcpip/stack"
+	"gvisor.dev/gvisor/pkg/tcpip/tests/utils"
 	"gvisor.dev/gvisor/pkg/tcpip/transport/icmp"
 	"gvisor.dev/gvisor/pkg/tcpip/transport/udp"
 	"gvisor.dev/gvisor/pkg/waiter"
@@ -107,7 +108,7 @@ func TestLocalPing(t *testing.T) {
 			transProto:        icmp.ProtocolNumber4,
 			netProto:          ipv4.ProtocolNumber,
 			linkEndpoint:      channelEP,
-			localAddr:         ipv4Addr.Address,
+			localAddr:         utils.Ipv4Addr.Address,
 			icmpBuf:           ipv4ICMPBuf,
 			checkLinkEndpoint: channelEPCheck,
 		},
@@ -116,7 +117,7 @@ func TestLocalPing(t *testing.T) {
 			transProto:        icmp.ProtocolNumber6,
 			netProto:          ipv6.ProtocolNumber,
 			linkEndpoint:      channelEP,
-			localAddr:         ipv6Addr.Address,
+			localAddr:         utils.Ipv6Addr.Address,
 			icmpBuf:           ipv6ICMPBuf,
 			checkLinkEndpoint: channelEPCheck,
 		},
@@ -253,13 +254,13 @@ func TestLocalUDP(t *testing.T) {
 	}{
 		{
 			name:             "IPv4",
-			canBePrimaryAddr: ipv4Addr1,
-			firstPrimaryAddr: ipv4Addr2,
+			canBePrimaryAddr: utils.Ipv4Addr1,
+			firstPrimaryAddr: utils.Ipv4Addr2,
 		},
 		{
 			name:             "IPv6",
-			canBePrimaryAddr: ipv6Addr1,
-			firstPrimaryAddr: ipv6Addr2,
+			canBePrimaryAddr: utils.Ipv6Addr1,
+			firstPrimaryAddr: utils.Ipv6Addr2,
 		},
 	}
 
diff --git a/pkg/tcpip/tests/utils/BUILD b/pkg/tcpip/tests/utils/BUILD
new file mode 100644
index 000000000..433004148
--- /dev/null
+++ b/pkg/tcpip/tests/utils/BUILD
@@ -0,0 +1,19 @@
+load("//tools:defs.bzl", "go_library")
+
+package(licenses = ["notice"])
+
+go_library(
+    name = "utils",
+    srcs = ["utils.go"],
+    visibility = ["//pkg/tcpip/tests:__subpackages__"],
+    deps = [
+        "//pkg/tcpip",
+        "//pkg/tcpip/header",
+        "//pkg/tcpip/link/ethernet",
+        "//pkg/tcpip/link/nested",
+        "//pkg/tcpip/link/pipe",
+        "//pkg/tcpip/network/ipv4",
+        "//pkg/tcpip/network/ipv6",
+        "//pkg/tcpip/stack",
+    ],
+)
diff --git a/pkg/tcpip/tests/utils/utils.go b/pkg/tcpip/tests/utils/utils.go
new file mode 100644
index 000000000..f414a2234
--- /dev/null
+++ b/pkg/tcpip/tests/utils/utils.go
@@ -0,0 +1,314 @@
+// Copyright 2020 The gVisor Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package utils holds common testing utilities for tcpip.
+package utils
+
+import (
+	"net"
+	"testing"
+
+	"gvisor.dev/gvisor/pkg/tcpip"
+	"gvisor.dev/gvisor/pkg/tcpip/header"
+	"gvisor.dev/gvisor/pkg/tcpip/link/ethernet"
+	"gvisor.dev/gvisor/pkg/tcpip/link/nested"
+	"gvisor.dev/gvisor/pkg/tcpip/link/pipe"
+	"gvisor.dev/gvisor/pkg/tcpip/network/ipv4"
+	"gvisor.dev/gvisor/pkg/tcpip/network/ipv6"
+	"gvisor.dev/gvisor/pkg/tcpip/stack"
+)
+
+// Common NIC IDs used by tests.
+const (
+	Host1NICID   = 1
+	RouterNICID1 = 2
+	RouterNICID2 = 3
+	Host2NICID   = 4
+)
+
+// Common link addresses used by tests.
+const (
+	LinkAddr1 = tcpip.LinkAddress("\x02\x03\x03\x04\x05\x06")
+	LinkAddr2 = tcpip.LinkAddress("\x02\x03\x03\x04\x05\x07")
+	LinkAddr3 = tcpip.LinkAddress("\x02\x03\x03\x04\x05\x08")
+	LinkAddr4 = tcpip.LinkAddress("\x02\x03\x03\x04\x05\x09")
+)
+
+// Common IP addresses used by tests.
+var (
+	Ipv4Addr = tcpip.AddressWithPrefix{
+		Address:   tcpip.Address(net.ParseIP("192.168.1.58").To4()),
+		PrefixLen: 24,
+	}
+	Ipv4Subnet      = Ipv4Addr.Subnet()
+	Ipv4SubnetBcast = Ipv4Subnet.Broadcast()
+
+	Ipv6Addr = tcpip.AddressWithPrefix{
+		Address:   tcpip.Address(net.ParseIP("200a::1").To16()),
+		PrefixLen: 64,
+	}
+	Ipv6Subnet      = Ipv6Addr.Subnet()
+	Ipv6SubnetBcast = Ipv6Subnet.Broadcast()
+
+	Ipv4Addr1 = tcpip.ProtocolAddress{
+		Protocol: ipv4.ProtocolNumber,
+		AddressWithPrefix: tcpip.AddressWithPrefix{
+			Address:   tcpip.Address(net.ParseIP("192.168.0.1").To4()),
+			PrefixLen: 24,
+		},
+	}
+	Ipv4Addr2 = tcpip.ProtocolAddress{
+		Protocol: ipv4.ProtocolNumber,
+		AddressWithPrefix: tcpip.AddressWithPrefix{
+			Address:   tcpip.Address(net.ParseIP("192.168.0.2").To4()),
+			PrefixLen: 8,
+		},
+	}
+	Ipv4Addr3 = tcpip.ProtocolAddress{
+		Protocol: ipv4.ProtocolNumber,
+		AddressWithPrefix: tcpip.AddressWithPrefix{
+			Address:   tcpip.Address(net.ParseIP("192.168.0.3").To4()),
+			PrefixLen: 8,
+		},
+	}
+	Ipv6Addr1 = tcpip.ProtocolAddress{
+		Protocol: ipv6.ProtocolNumber,
+		AddressWithPrefix: tcpip.AddressWithPrefix{
+			Address:   tcpip.Address(net.ParseIP("a::1").To16()),
+			PrefixLen: 64,
+		},
+	}
+	Ipv6Addr2 = tcpip.ProtocolAddress{
+		Protocol: ipv6.ProtocolNumber,
+		AddressWithPrefix: tcpip.AddressWithPrefix{
+			Address:   tcpip.Address(net.ParseIP("a::2").To16()),
+			PrefixLen: 64,
+		},
+	}
+	Ipv6Addr3 = tcpip.ProtocolAddress{
+		Protocol: ipv6.ProtocolNumber,
+		AddressWithPrefix: tcpip.AddressWithPrefix{
+			Address:   tcpip.Address(net.ParseIP("a::3").To16()),
+			PrefixLen: 64,
+		},
+	}
+
+	// Remote addrs.
+	RemoteIPv4Addr = tcpip.Address(net.ParseIP("10.0.0.1").To4())
+	RemoteIPv6Addr = tcpip.Address(net.ParseIP("200b::1").To16())
+)
+
+// Common ports for testing.
+const (
+	RemotePort = 5555
+	LocalPort  = 80
+)
+
+// Common IP addresses used for testing.
+var (
+	Host1IPv4Addr = tcpip.ProtocolAddress{
+		Protocol: ipv4.ProtocolNumber,
+		AddressWithPrefix: tcpip.AddressWithPrefix{
+			Address:   tcpip.Address(net.ParseIP("192.168.0.2").To4()),
+			PrefixLen: 24,
+		},
+	}
+	RouterNIC1IPv4Addr = tcpip.ProtocolAddress{
+		Protocol: ipv4.ProtocolNumber,
+		AddressWithPrefix: tcpip.AddressWithPrefix{
+			Address:   tcpip.Address(net.ParseIP("192.168.0.1").To4()),
+			PrefixLen: 24,
+		},
+	}
+	RouterNIC2IPv4Addr = tcpip.ProtocolAddress{
+		Protocol: ipv4.ProtocolNumber,
+		AddressWithPrefix: tcpip.AddressWithPrefix{
+			Address:   tcpip.Address(net.ParseIP("10.0.0.1").To4()),
+			PrefixLen: 8,
+		},
+	}
+	Host2IPv4Addr = tcpip.ProtocolAddress{
+		Protocol: ipv4.ProtocolNumber,
+		AddressWithPrefix: tcpip.AddressWithPrefix{
+			Address:   tcpip.Address(net.ParseIP("10.0.0.2").To4()),
+			PrefixLen: 8,
+		},
+	}
+	Host1IPv6Addr = tcpip.ProtocolAddress{
+		Protocol: ipv6.ProtocolNumber,
+		AddressWithPrefix: tcpip.AddressWithPrefix{
+			Address:   tcpip.Address(net.ParseIP("a::2").To16()),
+			PrefixLen: 64,
+		},
+	}
+	RouterNIC1IPv6Addr = tcpip.ProtocolAddress{
+		Protocol: ipv6.ProtocolNumber,
+		AddressWithPrefix: tcpip.AddressWithPrefix{
+			Address:   tcpip.Address(net.ParseIP("a::1").To16()),
+			PrefixLen: 64,
+		},
+	}
+	RouterNIC2IPv6Addr = tcpip.ProtocolAddress{
+		Protocol: ipv6.ProtocolNumber,
+		AddressWithPrefix: tcpip.AddressWithPrefix{
+			Address:   tcpip.Address(net.ParseIP("b::1").To16()),
+			PrefixLen: 64,
+		},
+	}
+	Host2IPv6Addr = tcpip.ProtocolAddress{
+		Protocol: ipv6.ProtocolNumber,
+		AddressWithPrefix: tcpip.AddressWithPrefix{
+			Address:   tcpip.Address(net.ParseIP("b::2").To16()),
+			PrefixLen: 64,
+		},
+	}
+)
+
+// NewEthernetEndpoint returns an ethernet link endpoint that wraps an inner
+// link endpoint and checks the destination link address before delivering
+// network packets to the network dispatcher.
+//
+// See ethernet.Endpoint for more details.
+func NewEthernetEndpoint(ep stack.LinkEndpoint) *EndpointWithDestinationCheck {
+	var e EndpointWithDestinationCheck
+	e.Endpoint.Init(ethernet.New(ep), &e)
+	return &e
+}
+
+// EndpointWithDestinationCheck is a link endpoint that checks the destination
+// link address before delivering network packets to the network dispatcher.
+type EndpointWithDestinationCheck struct {
+	nested.Endpoint
+}
+
+var _ stack.NetworkDispatcher = (*EndpointWithDestinationCheck)(nil)
+var _ stack.LinkEndpoint = (*EndpointWithDestinationCheck)(nil)
+
+// DeliverNetworkPacket implements stack.NetworkDispatcher.
+func (e *EndpointWithDestinationCheck) DeliverNetworkPacket(src, dst tcpip.LinkAddress, proto tcpip.NetworkProtocolNumber, pkt *stack.PacketBuffer) {
+	if dst == e.Endpoint.LinkAddress() || dst == header.EthernetBroadcastAddress || header.IsMulticastEthernetAddress(dst) {
+		e.Endpoint.DeliverNetworkPacket(src, dst, proto, pkt)
+	}
+}
+
+// SetupRoutedStacks creates the NICs, sets forwarding, adds addresses and sets
+// the route tables for the passed stacks.
+func SetupRoutedStacks(t *testing.T, host1Stack, routerStack, host2Stack *stack.Stack) {
+	host1NIC, routerNIC1 := pipe.New(LinkAddr1, LinkAddr2)
+	routerNIC2, host2NIC := pipe.New(LinkAddr3, LinkAddr4)
+
+	if err := host1Stack.CreateNIC(Host1NICID, NewEthernetEndpoint(host1NIC)); err != nil {
+		t.Fatalf("host1Stack.CreateNIC(%d, _): %s", Host1NICID, err)
+	}
+	if err := routerStack.CreateNIC(RouterNICID1, NewEthernetEndpoint(routerNIC1)); err != nil {
+		t.Fatalf("routerStack.CreateNIC(%d, _): %s", RouterNICID1, err)
+	}
+	if err := routerStack.CreateNIC(RouterNICID2, NewEthernetEndpoint(routerNIC2)); err != nil {
+		t.Fatalf("routerStack.CreateNIC(%d, _): %s", RouterNICID2, err)
+	}
+	if err := host2Stack.CreateNIC(Host2NICID, NewEthernetEndpoint(host2NIC)); err != nil {
+		t.Fatalf("host2Stack.CreateNIC(%d, _): %s", Host2NICID, err)
+	}
+
+	if err := routerStack.SetForwarding(ipv4.ProtocolNumber, true); err != nil {
+		t.Fatalf("routerStack.SetForwarding(%d): %s", ipv4.ProtocolNumber, err)
+	}
+	if err := routerStack.SetForwarding(ipv6.ProtocolNumber, true); err != nil {
+		t.Fatalf("routerStack.SetForwarding(%d): %s", ipv6.ProtocolNumber, err)
+	}
+
+	if err := host1Stack.AddProtocolAddress(Host1NICID, Host1IPv4Addr); err != nil {
+		t.Fatalf("host1Stack.AddProtocolAddress(%d, %#v): %s", Host1NICID, Host1IPv4Addr, err)
+	}
+	if err := routerStack.AddProtocolAddress(RouterNICID1, RouterNIC1IPv4Addr); err != nil {
+		t.Fatalf("routerStack.AddProtocolAddress(%d, %#v): %s", RouterNICID1, RouterNIC1IPv4Addr, err)
+	}
+	if err := routerStack.AddProtocolAddress(RouterNICID2, RouterNIC2IPv4Addr); err != nil {
+		t.Fatalf("routerStack.AddProtocolAddress(%d, %#v): %s", RouterNICID2, RouterNIC2IPv4Addr, err)
+	}
+	if err := host2Stack.AddProtocolAddress(Host2NICID, Host2IPv4Addr); err != nil {
+		t.Fatalf("host2Stack.AddProtocolAddress(%d, %#v): %s", Host2NICID, Host2IPv4Addr, err)
+	}
+	if err := host1Stack.AddProtocolAddress(Host1NICID, Host1IPv6Addr); err != nil {
+		t.Fatalf("host1Stack.AddProtocolAddress(%d, %#v): %s", Host1NICID, Host1IPv6Addr, err)
+	}
+	if err := routerStack.AddProtocolAddress(RouterNICID1, RouterNIC1IPv6Addr); err != nil {
+		t.Fatalf("routerStack.AddProtocolAddress(%d, %#v): %s", RouterNICID1, RouterNIC1IPv6Addr, err)
+	}
+	if err := routerStack.AddProtocolAddress(RouterNICID2, RouterNIC2IPv6Addr); err != nil {
+		t.Fatalf("routerStack.AddProtocolAddress(%d, %#v): %s", RouterNICID2, RouterNIC2IPv6Addr, err)
+	}
+	if err := host2Stack.AddProtocolAddress(Host2NICID, Host2IPv6Addr); err != nil {
+		t.Fatalf("host2Stack.AddProtocolAddress(%d, %#v): %s", Host2NICID, Host2IPv6Addr, err)
+	}
+
+	host1Stack.SetRouteTable([]tcpip.Route{
+		{
+			Destination: Host1IPv4Addr.AddressWithPrefix.Subnet(),
+			NIC:         Host1NICID,
+		},
+		{
+			Destination: Host1IPv6Addr.AddressWithPrefix.Subnet(),
+			NIC:         Host1NICID,
+		},
+		{
+			Destination: Host2IPv4Addr.AddressWithPrefix.Subnet(),
+			Gateway:     RouterNIC1IPv4Addr.AddressWithPrefix.Address,
+			NIC:         Host1NICID,
+		},
+		{
+			Destination: Host2IPv6Addr.AddressWithPrefix.Subnet(),
+			Gateway:     RouterNIC1IPv6Addr.AddressWithPrefix.Address,
+			NIC:         Host1NICID,
+		},
+	})
+	routerStack.SetRouteTable([]tcpip.Route{
+		{
+			Destination: RouterNIC1IPv4Addr.AddressWithPrefix.Subnet(),
+			NIC:         RouterNICID1,
+		},
+		{
+			Destination: RouterNIC1IPv6Addr.AddressWithPrefix.Subnet(),
+			NIC:         RouterNICID1,
+		},
+		{
+			Destination: RouterNIC2IPv4Addr.AddressWithPrefix.Subnet(),
+			NIC:         RouterNICID2,
+		},
+		{
+			Destination: RouterNIC2IPv6Addr.AddressWithPrefix.Subnet(),
+			NIC:         RouterNICID2,
+		},
+	})
+	host2Stack.SetRouteTable([]tcpip.Route{
+		{
+			Destination: Host2IPv4Addr.AddressWithPrefix.Subnet(),
+			NIC:         Host2NICID,
+		},
+		{
+			Destination: Host2IPv6Addr.AddressWithPrefix.Subnet(),
+			NIC:         Host2NICID,
+		},
+		{
+			Destination: Host1IPv4Addr.AddressWithPrefix.Subnet(),
+			Gateway:     RouterNIC2IPv4Addr.AddressWithPrefix.Address,
+			NIC:         Host2NICID,
+		},
+		{
+			Destination: Host1IPv6Addr.AddressWithPrefix.Subnet(),
+			Gateway:     RouterNIC2IPv6Addr.AddressWithPrefix.Address,
+			NIC:         Host2NICID,
+		},
+	})
+}