Rename variables in IP forwarding tests

Previously, we named domain objects using numbers (e.g. "e1", "e2" etc).  This
change renames objects to clarify whether they are part of the incoming or
outgoing path.

PiperOrigin-RevId: 374226859

2 files changed, 63 insertions, 60 deletions

diff --git a/pkg/tcpip/network/ipv4/ipv4_test.go b/pkg/tcpip/network/ipv4/ipv4_test.go
index 5f45b9ee6..da9cc0ae8 100644
--- a/pkg/tcpip/network/ipv4/ipv4_test.go
+++ b/pkg/tcpip/network/ipv4/ipv4_test.go
@@ -118,27 +118,27 @@ type forwardedPacket struct {
 
 func TestForwarding(t *testing.T) {
 	const (
-		nicID1           = 1
-		nicID2           = 2
+		incomingNICID    = 1
+		outgoingNICID    = 2
 		randomSequence   = 123
 		randomIdent      = 42
 		randomTimeOffset = 0x10203040
 	)
 
-	ipv4Addr1 := tcpip.AddressWithPrefix{
+	incomingIPv4Addr := tcpip.AddressWithPrefix{
 		Address:   tcpip.Address(net.ParseIP("10.0.0.1").To4()),
 		PrefixLen: 8,
 	}
-	ipv4Addr2 := tcpip.AddressWithPrefix{
+	outgoingIPv4Addr := tcpip.AddressWithPrefix{
 		Address:   tcpip.Address(net.ParseIP("11.0.0.1").To4()),
 		PrefixLen: 8,
 	}
-	linkAddr2 := tcpip.LinkAddress("\x02\x03\x03\x04\x05\x06")
-	remoteIPv4Addr1 := tcpip.Address(net.ParseIP("10.0.0.2").To4())
-	remoteIPv4Addr2 := tcpip.Address(net.ParseIP("11.0.0.2").To4())
-	unreachableIPv4Addr := tcpip.Address(net.ParseIP("12.0.0.2").To4())
-	multicastIPv4Addr := tcpip.Address(net.ParseIP("225.0.0.0").To4())
-	linkLocalIPv4Addr := tcpip.Address(net.ParseIP("169.254.0.0").To4())
+	outgoingLinkAddr := tcpip.LinkAddress("\x02\x03\x03\x04\x05\x06")
+	remoteIPv4Addr1 := tcptestutil.MustParse4("10.0.0.2")
+	remoteIPv4Addr2 := tcptestutil.MustParse4("11.0.0.2")
+	unreachableIPv4Addr := tcptestutil.MustParse4("12.0.0.2")
+	multicastIPv4Addr := tcptestutil.MustParse4("225.0.0.0")
+	linkLocalIPv4Addr := tcptestutil.MustParse4("169.254.0.0")
 
 	tests := []struct {
 		name                         string
@@ -345,6 +345,7 @@ func TestForwarding(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			clock := faketime.NewManualClock()
+
 			s := stack.New(stack.Options{
 				NetworkProtocols:   []stack.NetworkProtocolFactory{ipv4.NewProtocol},
 				TransportProtocols: []stack.TransportProtocolFactory{icmp.NewProtocol4},
@@ -356,36 +357,36 @@ func TestForwarding(t *testing.T) {
 			clock.Advance(time.Millisecond * randomTimeOffset)
 
 			// We expect at most a single packet in response to our ICMP Echo Request.
-			e1 := channel.New(1, test.mtu, "")
-			if err := s.CreateNIC(nicID1, e1); err != nil {
-				t.Fatalf("CreateNIC(%d, _): %s", nicID1, err)
+			incomingEndpoint := channel.New(1, test.mtu, "")
+			if err := s.CreateNIC(incomingNICID, incomingEndpoint); err != nil {
+				t.Fatalf("CreateNIC(%d, _): %s", incomingNICID, err)
 			}
-			ipv4ProtoAddr1 := tcpip.ProtocolAddress{Protocol: header.IPv4ProtocolNumber, AddressWithPrefix: ipv4Addr1}
-			if err := s.AddProtocolAddress(nicID1, ipv4ProtoAddr1); err != nil {
-				t.Fatalf("AddProtocolAddress(%d, %#v): %s", nicID1, ipv4ProtoAddr1, err)
+			incomingIPv4ProtoAddr := tcpip.ProtocolAddress{Protocol: header.IPv4ProtocolNumber, AddressWithPrefix: incomingIPv4Addr}
+			if err := s.AddProtocolAddress(incomingNICID, incomingIPv4ProtoAddr); err != nil {
+				t.Fatalf("AddProtocolAddress(%d, %#v): %s", incomingNICID, incomingIPv4ProtoAddr, err)
 			}
 
 			expectedEmittedPacketCount := 1
 			if len(test.expectedFragmentsForwarded) > expectedEmittedPacketCount {
 				expectedEmittedPacketCount = len(test.expectedFragmentsForwarded)
 			}
-			e2 := channel.New(expectedEmittedPacketCount, test.mtu, linkAddr2)
-			if err := s.CreateNIC(nicID2, e2); err != nil {
-				t.Fatalf("CreateNIC(%d, _): %s", nicID2, err)
+			outgoingEndpoint := channel.New(expectedEmittedPacketCount, test.mtu, outgoingLinkAddr)
+			if err := s.CreateNIC(outgoingNICID, outgoingEndpoint); err != nil {
+				t.Fatalf("CreateNIC(%d, _): %s", outgoingNICID, err)
 			}
-			ipv4ProtoAddr2 := tcpip.ProtocolAddress{Protocol: header.IPv4ProtocolNumber, AddressWithPrefix: ipv4Addr2}
-			if err := s.AddProtocolAddress(nicID2, ipv4ProtoAddr2); err != nil {
-				t.Fatalf("AddProtocolAddress(%d, %#v): %s", nicID2, ipv4ProtoAddr2, err)
+			outgoingIPv4ProtoAddr := tcpip.ProtocolAddress{Protocol: header.IPv4ProtocolNumber, AddressWithPrefix: outgoingIPv4Addr}
+			if err := s.AddProtocolAddress(outgoingNICID, outgoingIPv4ProtoAddr); err != nil {
+				t.Fatalf("AddProtocolAddress(%d, %#v): %s", outgoingNICID, outgoingIPv4ProtoAddr, err)
 			}
 
 			s.SetRouteTable([]tcpip.Route{
 				{
-					Destination: ipv4Addr1.Subnet(),
-					NIC:         nicID1,
+					Destination: incomingIPv4Addr.Subnet(),
+					NIC:         incomingNICID,
 				},
 				{
-					Destination: ipv4Addr2.Subnet(),
-					NIC:         nicID2,
+					Destination: outgoingIPv4Addr.Subnet(),
+					NIC:         outgoingNICID,
 				},
 			})
 
@@ -431,9 +432,10 @@ func TestForwarding(t *testing.T) {
 				Data: hdr.View().ToVectorisedView(),
 			})
 			requestPkt.NetworkProtocolNumber = header.IPv4ProtocolNumber
-			e1.InjectInbound(header.IPv4ProtocolNumber, requestPkt)
+			incomingEndpoint.InjectInbound(header.IPv4ProtocolNumber, requestPkt)
+
+			reply, ok := incomingEndpoint.Read()
 
-			reply, ok := e1.Read()
 			if test.expectErrorICMP {
 				if !ok {
 					t.Fatalf("expected ICMP packet type %d through incoming NIC", test.icmpType)
@@ -452,7 +454,7 @@ func TestForwarding(t *testing.T) {
 				}
 
 				checker.IPv4(t, header.IPv4(stack.PayloadSince(reply.Pkt.NetworkHeader())),
-					checker.SrcAddr(ipv4Addr1.Address),
+					checker.SrcAddr(incomingIPv4Addr.Address),
 					checker.DstAddr(test.sourceAddr),
 					checker.TTL(ipv4.DefaultTTL),
 					checker.ICMPv4(
@@ -470,7 +472,7 @@ func TestForwarding(t *testing.T) {
 				if len(test.expectedFragmentsForwarded) != 0 {
 					fragmentedPackets := []*stack.PacketBuffer{}
 					for i := 0; i < len(test.expectedFragmentsForwarded); i++ {
-						reply, ok = e2.Read()
+						reply, ok = outgoingEndpoint.Read()
 						if !ok {
 							t.Fatal("expected ICMP Echo fragment through outgoing NIC")
 						}
@@ -489,7 +491,7 @@ func TestForwarding(t *testing.T) {
 						t.Error(err)
 					}
 				} else {
-					reply, ok = e2.Read()
+					reply, ok = outgoingEndpoint.Read()
 					if !ok {
 						t.Fatal("expected ICMP Echo packet through outgoing NIC")
 					}
@@ -508,11 +510,10 @@ func TestForwarding(t *testing.T) {
 					)
 				}
 			} else {
-				if reply, ok = e2.Read(); ok {
+				if reply, ok = outgoingEndpoint.Read(); ok {
 					t.Fatalf("expected no ICMP Echo packet through outgoing NIC, instead found: %#v", reply)
 				}
 			}
-
 			boolToInt := func(val bool) uint64 {
 				if val {
 					return 1
diff --git a/pkg/tcpip/network/ipv6/ipv6_test.go b/pkg/tcpip/network/ipv6/ipv6_test.go
index 30325160a..afc6c3547 100644
--- a/pkg/tcpip/network/ipv6/ipv6_test.go
+++ b/pkg/tcpip/network/ipv6/ipv6_test.go
@@ -3004,17 +3004,17 @@ func TestFragmentationErrors(t *testing.T) {
 
 func TestForwarding(t *testing.T) {
 	const (
-		nicID1         = 1
-		nicID2         = 2
+		incomingNICID  = 1
+		outgoingNICID  = 2
 		randomSequence = 123
 		randomIdent    = 42
 	)
 
-	ipv6Addr1 := tcpip.AddressWithPrefix{
+	incomingIPv6Addr := tcpip.AddressWithPrefix{
 		Address:   tcpip.Address(net.ParseIP("10::1").To16()),
 		PrefixLen: 64,
 	}
-	ipv6Addr2 := tcpip.AddressWithPrefix{
+	outgoingIPv6Addr := tcpip.AddressWithPrefix{
 		Address:   tcpip.Address(net.ParseIP("11::1").To16()),
 		PrefixLen: 64,
 	}
@@ -3022,6 +3022,7 @@ func TestForwarding(t *testing.T) {
 		Address:   tcpip.Address(net.ParseIP("ff00::").To16()),
 		PrefixLen: 64,
 	}
+
 	remoteIPv6Addr1 := tcpip.Address(net.ParseIP("10::2").To16())
 	remoteIPv6Addr2 := tcpip.Address(net.ParseIP("11::2").To16())
 	unreachableIPv6Addr := tcpip.Address(net.ParseIP("12::2").To16())
@@ -3296,36 +3297,36 @@ func TestForwarding(t *testing.T) {
 				TransportProtocols: []stack.TransportProtocolFactory{icmp.NewProtocol6},
 			})
 			// We expect at most a single packet in response to our ICMP Echo Request.
-			e1 := channel.New(1, header.IPv6MinimumMTU, "")
-			if err := s.CreateNIC(nicID1, e1); err != nil {
-				t.Fatalf("CreateNIC(%d, _): %s", nicID1, err)
+			incomingEndpoint := channel.New(1, header.IPv6MinimumMTU, "")
+			if err := s.CreateNIC(incomingNICID, incomingEndpoint); err != nil {
+				t.Fatalf("CreateNIC(%d, _): %s", incomingNICID, err)
 			}
-			ipv6ProtoAddr1 := tcpip.ProtocolAddress{Protocol: ProtocolNumber, AddressWithPrefix: ipv6Addr1}
-			if err := s.AddProtocolAddress(nicID1, ipv6ProtoAddr1); err != nil {
-				t.Fatalf("AddProtocolAddress(%d, %#v): %s", nicID1, ipv6ProtoAddr1, err)
+			incomingIPv6ProtoAddr := tcpip.ProtocolAddress{Protocol: ProtocolNumber, AddressWithPrefix: incomingIPv6Addr}
+			if err := s.AddProtocolAddress(incomingNICID, incomingIPv6ProtoAddr); err != nil {
+				t.Fatalf("AddProtocolAddress(%d, %#v): %s", incomingNICID, incomingIPv6ProtoAddr, err)
 			}
 
-			e2 := channel.New(1, header.IPv6MinimumMTU, "")
-			if err := s.CreateNIC(nicID2, e2); err != nil {
-				t.Fatalf("CreateNIC(%d, _): %s", nicID2, err)
+			outgoingEndpoint := channel.New(1, header.IPv6MinimumMTU, "")
+			if err := s.CreateNIC(outgoingNICID, outgoingEndpoint); err != nil {
+				t.Fatalf("CreateNIC(%d, _): %s", outgoingNICID, err)
 			}
-			ipv6ProtoAddr2 := tcpip.ProtocolAddress{Protocol: ProtocolNumber, AddressWithPrefix: ipv6Addr2}
-			if err := s.AddProtocolAddress(nicID2, ipv6ProtoAddr2); err != nil {
-				t.Fatalf("AddProtocolAddress(%d, %#v): %s", nicID2, ipv6ProtoAddr2, err)
+			outgoingIPv6ProtoAddr := tcpip.ProtocolAddress{Protocol: ProtocolNumber, AddressWithPrefix: outgoingIPv6Addr}
+			if err := s.AddProtocolAddress(outgoingNICID, outgoingIPv6ProtoAddr); err != nil {
+				t.Fatalf("AddProtocolAddress(%d, %#v): %s", outgoingNICID, outgoingIPv6ProtoAddr, err)
 			}
 
 			s.SetRouteTable([]tcpip.Route{
 				{
-					Destination: ipv6Addr1.Subnet(),
-					NIC:         nicID1,
+					Destination: incomingIPv6Addr.Subnet(),
+					NIC:         incomingNICID,
 				},
 				{
-					Destination: ipv6Addr2.Subnet(),
-					NIC:         nicID2,
+					Destination: outgoingIPv6Addr.Subnet(),
+					NIC:         outgoingNICID,
 				},
 				{
 					Destination: multicastIPv6Addr.Subnet(),
-					NIC:         nicID2,
+					NIC:         outgoingNICID,
 				},
 			})
 
@@ -3372,9 +3373,10 @@ func TestForwarding(t *testing.T) {
 			requestPkt := stack.NewPacketBuffer(stack.PacketBufferOptions{
 				Data: hdr.View().ToVectorisedView(),
 			})
-			e1.InjectInbound(ProtocolNumber, requestPkt)
+			incomingEndpoint.InjectInbound(ProtocolNumber, requestPkt)
+
+			reply, ok := incomingEndpoint.Read()
 
-			reply, ok := e1.Read()
 			if test.expectErrorICMP {
 				if !ok {
 					t.Fatalf("expected ICMP packet type %d through incoming NIC", test.icmpType)
@@ -3394,7 +3396,7 @@ func TestForwarding(t *testing.T) {
 				}
 
 				checker.IPv6(t, header.IPv6(stack.PayloadSince(reply.Pkt.NetworkHeader())),
-					checker.SrcAddr(ipv6Addr1.Address),
+					checker.SrcAddr(incomingIPv6Addr.Address),
 					checker.DstAddr(test.sourceAddr),
 					checker.TTL(DefaultTTL),
 					checker.ICMPv6(
@@ -3404,14 +3406,14 @@ func TestForwarding(t *testing.T) {
 					),
 				)
 
-				if n := e2.Drain(); n != 0 {
+				if n := outgoingEndpoint.Drain(); n != 0 {
 					t.Fatalf("got e2.Drain() = %d, want = 0", n)
 				}
 			} else if ok {
 				t.Fatalf("expected no ICMP packet through incoming NIC, instead found: %#v", reply)
 			}
 
-			reply, ok = e2.Read()
+			reply, ok = outgoingEndpoint.Read()
 			if test.expectPacketForwarded {
 				if !ok {
 					t.Fatal("expected ICMP Echo Request packet through outgoing NIC")
@@ -3429,7 +3431,7 @@ func TestForwarding(t *testing.T) {
 					),
 				)
 
-				if n := e1.Drain(); n != 0 {
+				if n := incomingEndpoint.Drain(); n != 0 {
 					t.Fatalf("got e1.Drain() = %d, want = 0", n)
 				}
 			} else if ok {