Use fake clocks in all tests

...except TCP tests and NDP tests that mutate globals. These will be
undertaken later.

Updates #5940.

PiperOrigin-RevId: 376145608

11 files changed, 323 insertions, 275 deletions

diff --git a/pkg/tcpip/checker/checker.go b/pkg/tcpip/checker/checker.go
index bab640faf..e0dfe5813 100644
--- a/pkg/tcpip/checker/checker.go
+++ b/pkg/tcpip/checker/checker.go
@@ -50,7 +50,7 @@ func IPv4(t *testing.T, b []byte, checkers ...NetworkChecker) {
 	ipv4 := header.IPv4(b)
 
 	if !ipv4.IsValid(len(b)) {
-		t.Error("Not a valid IPv4 packet")
+		t.Fatalf("Not a valid IPv4 packet: %x", ipv4)
 	}
 
 	if !ipv4.IsChecksumValid() {
@@ -72,7 +72,7 @@ func IPv6(t *testing.T, b []byte, checkers ...NetworkChecker) {
 
 	ipv6 := header.IPv6(b)
 	if !ipv6.IsValid(len(b)) {
-		t.Error("Not a valid IPv6 packet")
+		t.Fatalf("Not a valid IPv6 packet: %x", ipv6)
 	}
 
 	for _, f := range checkers {
diff --git a/pkg/tcpip/network/arp/BUILD b/pkg/tcpip/network/arp/BUILD
index a72eb1aad..6fa1aee18 100644
--- a/pkg/tcpip/network/arp/BUILD
+++ b/pkg/tcpip/network/arp/BUILD
@@ -28,13 +28,13 @@ go_test(
         ":arp",
         "//pkg/tcpip",
         "//pkg/tcpip/buffer",
+        "//pkg/tcpip/faketime",
         "//pkg/tcpip/header",
         "//pkg/tcpip/link/channel",
         "//pkg/tcpip/link/sniffer",
         "//pkg/tcpip/network/ipv4",
         "//pkg/tcpip/stack",
         "//pkg/tcpip/testutil",
-        "//pkg/tcpip/transport/icmp",
         "@com_github_google_go_cmp//cmp:go_default_library",
         "@com_github_google_go_cmp//cmp/cmpopts:go_default_library",
     ],
diff --git a/pkg/tcpip/network/arp/arp_test.go b/pkg/tcpip/network/arp/arp_test.go
index 3ca78490f..5fcbfeaa2 100644
--- a/pkg/tcpip/network/arp/arp_test.go
+++ b/pkg/tcpip/network/arp/arp_test.go
@@ -15,15 +15,14 @@
 package arp_test
 
 import (
-	"context"
 	"fmt"
 	"testing"
-	"time"
 
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
 	"gvisor.dev/gvisor/pkg/tcpip"
 	"gvisor.dev/gvisor/pkg/tcpip/buffer"
+	"gvisor.dev/gvisor/pkg/tcpip/faketime"
 	"gvisor.dev/gvisor/pkg/tcpip/header"
 	"gvisor.dev/gvisor/pkg/tcpip/link/channel"
 	"gvisor.dev/gvisor/pkg/tcpip/link/sniffer"
@@ -31,7 +30,6 @@ import (
 	"gvisor.dev/gvisor/pkg/tcpip/network/ipv4"
 	"gvisor.dev/gvisor/pkg/tcpip/stack"
 	"gvisor.dev/gvisor/pkg/tcpip/testutil"
-	"gvisor.dev/gvisor/pkg/tcpip/transport/icmp"
 )
 
 const (
@@ -39,15 +37,6 @@ const (
 
 	stackLinkAddr  = tcpip.LinkAddress("\x0a\x0a\x0b\x0b\x0c\x0c")
 	remoteLinkAddr = tcpip.LinkAddress("\x01\x02\x03\x04\x05\x06")
-
-	defaultChannelSize = 1
-	defaultMTU         = 65536
-
-	// eventChanSize defines the size of event channels used by the neighbor
-	// cache's event dispatcher. The size chosen here needs to be sufficient to
-	// queue all the events received during tests before consumption.
-	// If eventChanSize is too small, the tests may deadlock.
-	eventChanSize = 32
 )
 
 var (
@@ -123,24 +112,6 @@ func (d *arpDispatcher) OnNeighborRemoved(nicID tcpip.NICID, entry stack.Neighbo
 	d.C <- e
 }
 
-func (d *arpDispatcher) waitForEvent(ctx context.Context, want eventInfo) error {
-	select {
-	case got := <-d.C:
-		if diff := cmp.Diff(want, got, cmp.AllowUnexported(got), cmpopts.IgnoreFields(stack.NeighborEntry{}, "UpdatedAt")); diff != "" {
-			return fmt.Errorf("got invalid event (-want +got):\n%s", diff)
-		}
-	case <-ctx.Done():
-		return fmt.Errorf("%s for %s", ctx.Err(), want)
-	}
-	return nil
-}
-
-func (d *arpDispatcher) waitForEventWithTimeout(want eventInfo, timeout time.Duration) error {
-	ctx, cancel := context.WithTimeout(context.Background(), timeout)
-	defer cancel()
-	return d.waitForEvent(ctx, want)
-}
-
 func (d *arpDispatcher) nextEvent() (eventInfo, bool) {
 	select {
 	case event := <-d.C:
@@ -153,55 +124,45 @@ func (d *arpDispatcher) nextEvent() (eventInfo, bool) {
 type testContext struct {
 	s       *stack.Stack
 	linkEP  *channel.Endpoint
-	nudDisp *arpDispatcher
+	nudDisp arpDispatcher
 }
 
-func newTestContext(t *testing.T) *testContext {
-	c := stack.DefaultNUDConfigurations()
-	// Transition from Reachable to Stale almost immediately to test if receiving
-	// probes refreshes positive reachability.
-	c.BaseReachableTime = time.Microsecond
-
-	d := arpDispatcher{
-		// Create an event channel large enough so the neighbor cache doesn't block
-		// while dispatching events. Blocking could interfere with the timing of
-		// NUD transitions.
-		C: make(chan eventInfo, eventChanSize),
+func makeTestContext(t *testing.T, eventDepth int, packetDepth int) testContext {
+	t.Helper()
+
+	tc := testContext{
+		nudDisp: arpDispatcher{
+			C: make(chan eventInfo, eventDepth),
+		},
 	}
 
-	s := stack.New(stack.Options{
-		NetworkProtocols:   []stack.NetworkProtocolFactory{ipv4.NewProtocol, arp.NewProtocol},
-		TransportProtocols: []stack.TransportProtocolFactory{icmp.NewProtocol4},
-		NUDConfigs:         c,
-		NUDDisp:            &d,
+	tc.s = stack.New(stack.Options{
+		NetworkProtocols: []stack.NetworkProtocolFactory{ipv4.NewProtocol, arp.NewProtocol},
+		NUDDisp:          &tc.nudDisp,
+		Clock:            &faketime.NullClock{},
 	})
 
-	ep := channel.New(defaultChannelSize, defaultMTU, stackLinkAddr)
-	ep.LinkEPCapabilities |= stack.CapabilityResolutionRequired
-
-	wep := stack.LinkEndpoint(ep)
+	tc.linkEP = channel.New(packetDepth, header.IPv4MinimumMTU, stackLinkAddr)
+	tc.linkEP.LinkEPCapabilities |= stack.CapabilityResolutionRequired
 
+	wep := stack.LinkEndpoint(tc.linkEP)
 	if testing.Verbose() {
-		wep = sniffer.New(ep)
+		wep = sniffer.New(wep)
 	}
-	if err := s.CreateNIC(nicID, wep); err != nil {
-		t.Fatalf("CreateNIC failed: %v", err)
+	if err := tc.s.CreateNIC(nicID, wep); err != nil {
+		t.Fatalf("CreateNIC failed: %s", err)
 	}
 
-	if err := s.AddAddress(nicID, ipv4.ProtocolNumber, stackAddr); err != nil {
-		t.Fatalf("AddAddress for ipv4 failed: %v", err)
+	if err := tc.s.AddAddress(nicID, ipv4.ProtocolNumber, stackAddr); err != nil {
+		t.Fatalf("AddAddress for ipv4 failed: %s", err)
 	}
 
-	s.SetRouteTable([]tcpip.Route{{
+	tc.s.SetRouteTable([]tcpip.Route{{
 		Destination: header.IPv4EmptySubnet,
 		NIC:         nicID,
 	}})
 
-	return &testContext{
-		s:       s,
-		linkEP:  ep,
-		nudDisp: &d,
-	}
+	return tc
 }
 
 func (c *testContext) cleanup() {
@@ -209,7 +170,7 @@ func (c *testContext) cleanup() {
 }
 
 func TestMalformedPacket(t *testing.T) {
-	c := newTestContext(t)
+	c := makeTestContext(t, 0, 0)
 	defer c.cleanup()
 
 	v := make(buffer.View, header.ARPSize)
@@ -228,7 +189,7 @@ func TestMalformedPacket(t *testing.T) {
 }
 
 func TestDisabledEndpoint(t *testing.T) {
-	c := newTestContext(t)
+	c := makeTestContext(t, 0, 0)
 	defer c.cleanup()
 
 	ep, err := c.s.GetNetworkEndpoint(nicID, header.ARPProtocolNumber)
@@ -253,7 +214,7 @@ func TestDisabledEndpoint(t *testing.T) {
 }
 
 func TestDirectReply(t *testing.T) {
-	c := newTestContext(t)
+	c := makeTestContext(t, 0, 0)
 	defer c.cleanup()
 
 	const senderMAC = "\x01\x02\x03\x04\x05\x06"
@@ -284,7 +245,7 @@ func TestDirectReply(t *testing.T) {
 }
 
 func TestDirectRequest(t *testing.T) {
-	c := newTestContext(t)
+	c := makeTestContext(t, 1, 1)
 	defer c.cleanup()
 
 	tests := []struct {
@@ -391,17 +352,21 @@ func TestDirectRequest(t *testing.T) {
 			}
 
 			// Verify the sender was saved in the neighbor cache.
-			wantEvent := eventInfo{
-				eventType: entryAdded,
-				nicID:     nicID,
-				entry: stack.NeighborEntry{
-					Addr:     test.senderAddr,
-					LinkAddr: test.senderLinkAddr,
-					State:    stack.Stale,
-				},
-			}
-			if err := c.nudDisp.waitForEventWithTimeout(wantEvent, time.Second); err != nil {
-				t.Fatal(err)
+			if got, ok := c.nudDisp.nextEvent(); ok {
+				want := eventInfo{
+					eventType: entryAdded,
+					nicID:     nicID,
+					entry: stack.NeighborEntry{
+						Addr:     test.senderAddr,
+						LinkAddr: test.senderLinkAddr,
+						State:    stack.Stale,
+					},
+				}
+				if diff := cmp.Diff(want, got, cmp.AllowUnexported(eventInfo{}), cmpopts.IgnoreFields(stack.NeighborEntry{}, "UpdatedAt")); diff != "" {
+					t.Errorf("got invalid event (-want +got):\n%s", diff)
+				}
+			} else {
+				t.Fatal("event didn't arrive")
 			}
 
 			neighbors, err := c.s.Neighbors(nicID, ipv4.ProtocolNumber)
@@ -589,7 +554,7 @@ func TestLinkAddressRequest(t *testing.T) {
 			s := stack.New(stack.Options{
 				NetworkProtocols: []stack.NetworkProtocolFactory{arp.NewProtocol, ipv4.NewProtocol},
 			})
-			linkEP := channel.New(defaultChannelSize, defaultMTU, stackLinkAddr)
+			linkEP := channel.New(1, header.IPv4MinimumMTU, stackLinkAddr)
 			if err := s.CreateNIC(nicID, &testLinkEndpoint{LinkEndpoint: linkEP, writeErr: test.linkErr}); err != nil {
 				t.Fatalf("s.CreateNIC(%d, _): %s", nicID, err)
 			}
@@ -663,15 +628,16 @@ func TestLinkAddressRequest(t *testing.T) {
 }
 
 func TestDADARPRequestPacket(t *testing.T) {
+	clock := faketime.NewManualClock()
 	s := stack.New(stack.Options{
 		NetworkProtocols: []stack.NetworkProtocolFactory{arp.NewProtocolWithOptions(arp.Options{
 			DADConfigs: stack.DADConfigurations{
 				DupAddrDetectTransmits: 1,
-				RetransmitTimer:        time.Second,
 			},
 		}), ipv4.NewProtocol},
+		Clock: clock,
 	})
-	e := channel.New(1, defaultMTU, stackLinkAddr)
+	e := channel.New(1, header.IPv4MinimumMTU, stackLinkAddr)
 	if err := s.CreateNIC(nicID, e); err != nil {
 		t.Fatalf("s.CreateNIC(%d, _): %s", nicID, err)
 	}
@@ -682,7 +648,8 @@ func TestDADARPRequestPacket(t *testing.T) {
 		t.Fatalf("got s.CheckDuplicateAddress(%d, %d, %s, _) = %d, want = %d", nicID, header.IPv4ProtocolNumber, remoteAddr, res, stack.DADStarting)
 	}
 
-	pkt, ok := e.ReadContext(context.Background())
+	clock.RunImmediatelyScheduledJobs()
+	pkt, ok := e.Read()
 	if !ok {
 		t.Fatal("expected to send an ARP request")
 	}
diff --git a/pkg/tcpip/network/ipv4/ipv4_test.go b/pkg/tcpip/network/ipv4/ipv4_test.go
index 93d820a5b..0a1f02de0 100644
--- a/pkg/tcpip/network/ipv4/ipv4_test.go
+++ b/pkg/tcpip/network/ipv4/ipv4_test.go
@@ -16,7 +16,6 @@ package ipv4_test
 
 import (
 	"bytes"
-	"context"
 	"encoding/hex"
 	"fmt"
 	"io/ioutil"
@@ -3086,7 +3085,7 @@ func TestPacketQueing(t *testing.T) {
 				}))
 			},
 			checkResp: func(t *testing.T, e *channel.Endpoint) {
-				p, ok := e.ReadContext(context.Background())
+				p, ok := e.Read()
 				if !ok {
 					t.Fatalf("timed out waiting for packet")
 				}
@@ -3129,7 +3128,7 @@ func TestPacketQueing(t *testing.T) {
 				}))
 			},
 			checkResp: func(t *testing.T, e *channel.Endpoint) {
-				p, ok := e.ReadContext(context.Background())
+				p, ok := e.Read()
 				if !ok {
 					t.Fatalf("timed out waiting for packet")
 				}
@@ -3153,9 +3152,11 @@ func TestPacketQueing(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			e := channel.New(1, defaultMTU, host1NICLinkAddr)
 			e.LinkEPCapabilities |= stack.CapabilityResolutionRequired
+			clock := faketime.NewManualClock()
 			s := stack.New(stack.Options{
 				NetworkProtocols:   []stack.NetworkProtocolFactory{arp.NewProtocol, ipv4.NewProtocol},
 				TransportProtocols: []stack.TransportProtocolFactory{udp.NewProtocol},
+				Clock:              clock,
 			})
 
 			if err := s.CreateNIC(nicID, e); err != nil {
@@ -3178,7 +3179,8 @@ func TestPacketQueing(t *testing.T) {
 			// Wait for a ARP request since link address resolution should be
 			// performed.
 			{
-				p, ok := e.ReadContext(context.Background())
+				clock.RunImmediatelyScheduledJobs()
+				p, ok := e.Read()
 				if !ok {
 					t.Fatalf("timed out waiting for packet")
 				}
@@ -3219,6 +3221,7 @@ func TestPacketQueing(t *testing.T) {
 			}
 
 			// Expect the response now that the link address has resolved.
+			clock.RunImmediatelyScheduledJobs()
 			test.checkResp(t, e)
 
 			// Since link resolution was already performed, it shouldn't be performed
diff --git a/pkg/tcpip/network/ipv6/icmp_test.go b/pkg/tcpip/network/ipv6/icmp_test.go
index d7b04554e..c2e9544c1 100644
--- a/pkg/tcpip/network/ipv6/icmp_test.go
+++ b/pkg/tcpip/network/ipv6/icmp_test.go
@@ -16,7 +16,6 @@ package ipv6
 
 import (
 	"bytes"
-	"context"
 	"net"
 	"reflect"
 	"strings"
@@ -26,6 +25,7 @@ import (
 	"gvisor.dev/gvisor/pkg/tcpip"
 	"gvisor.dev/gvisor/pkg/tcpip/buffer"
 	"gvisor.dev/gvisor/pkg/tcpip/checker"
+	"gvisor.dev/gvisor/pkg/tcpip/faketime"
 	"gvisor.dev/gvisor/pkg/tcpip/header"
 	"gvisor.dev/gvisor/pkg/tcpip/link/channel"
 	"gvisor.dev/gvisor/pkg/tcpip/link/sniffer"
@@ -366,6 +366,8 @@ type testContext struct {
 
 	linkEP0 *channel.Endpoint
 	linkEP1 *channel.Endpoint
+
+	clock *faketime.ManualClock
 }
 
 type endpointWithResolutionCapability struct {
@@ -377,15 +379,19 @@ func (e endpointWithResolutionCapability) Capabilities() stack.LinkEndpointCapab
 }
 
 func newTestContext(t *testing.T) *testContext {
+	clock := faketime.NewManualClock()
 	c := &testContext{
 		s0: stack.New(stack.Options{
 			NetworkProtocols:   []stack.NetworkProtocolFactory{NewProtocol},
 			TransportProtocols: []stack.TransportProtocolFactory{icmp.NewProtocol6},
+			Clock:              clock,
 		}),
 		s1: stack.New(stack.Options{
 			NetworkProtocols:   []stack.NetworkProtocolFactory{NewProtocol},
 			TransportProtocols: []stack.TransportProtocolFactory{icmp.NewProtocol6},
+			Clock:              clock,
 		}),
+		clock: clock,
 	}
 
 	c.linkEP0 = channel.New(defaultChannelSize, defaultMTU, linkAddr0)
@@ -452,10 +458,14 @@ type routeArgs struct {
 	remoteLinkAddr tcpip.LinkAddress
 }
 
-func routeICMPv6Packet(t *testing.T, args routeArgs, fn func(*testing.T, header.ICMPv6)) {
+func routeICMPv6Packet(t *testing.T, clock *faketime.ManualClock, args routeArgs, fn func(*testing.T, header.ICMPv6)) {
 	t.Helper()
 
-	pi, _ := args.src.ReadContext(context.Background())
+	clock.RunImmediatelyScheduledJobs()
+	pi, ok := args.src.Read()
+	if !ok {
+		t.Fatal("packet didn't arrive")
+	}
 
 	{
 		pkt := stack.NewPacketBuffer(stack.PacketBufferOptions{
@@ -528,7 +538,7 @@ func TestLinkResolution(t *testing.T) {
 		{src: c.linkEP0, dst: c.linkEP1, typ: header.ICMPv6NeighborSolicit, remoteLinkAddr: header.EthernetAddressFromMulticastIPv6Address(header.SolicitedNodeAddr(lladdr1))},
 		{src: c.linkEP1, dst: c.linkEP0, typ: header.ICMPv6NeighborAdvert},
 	} {
-		routeICMPv6Packet(t, args, func(t *testing.T, icmpv6 header.ICMPv6) {
+		routeICMPv6Packet(t, c.clock, args, func(t *testing.T, icmpv6 header.ICMPv6) {
 			if got, want := tcpip.Address(icmpv6[8:][:16]), lladdr1; got != want {
 				t.Errorf("%d: got target = %s, want = %s", icmpv6.Type(), got, want)
 			}
@@ -539,7 +549,7 @@ func TestLinkResolution(t *testing.T) {
 		{src: c.linkEP0, dst: c.linkEP1, typ: header.ICMPv6EchoRequest},
 		{src: c.linkEP1, dst: c.linkEP0, typ: header.ICMPv6EchoReply},
 	} {
-		routeICMPv6Packet(t, args, nil)
+		routeICMPv6Packet(t, c.clock, args, nil)
 	}
 }
 
@@ -1320,7 +1330,7 @@ func TestPacketQueing(t *testing.T) {
 				}))
 			},
 			checkResp: func(t *testing.T, e *channel.Endpoint) {
-				p, ok := e.ReadContext(context.Background())
+				p, ok := e.Read()
 				if !ok {
 					t.Fatalf("timed out waiting for packet")
 				}
@@ -1366,7 +1376,7 @@ func TestPacketQueing(t *testing.T) {
 				}))
 			},
 			checkResp: func(t *testing.T, e *channel.Endpoint) {
-				p, ok := e.ReadContext(context.Background())
+				p, ok := e.Read()
 				if !ok {
 					t.Fatalf("timed out waiting for packet")
 				}
@@ -1391,9 +1401,11 @@ func TestPacketQueing(t *testing.T) {
 
 			e := channel.New(1, header.IPv6MinimumMTU, host1NICLinkAddr)
 			e.LinkEPCapabilities |= stack.CapabilityResolutionRequired
+			clock := faketime.NewManualClock()
 			s := stack.New(stack.Options{
 				NetworkProtocols:   []stack.NetworkProtocolFactory{NewProtocol},
 				TransportProtocols: []stack.TransportProtocolFactory{udp.NewProtocol},
+				Clock:              clock,
 			})
 
 			if err := s.CreateNIC(nicID, e); err != nil {
@@ -1416,7 +1428,8 @@ func TestPacketQueing(t *testing.T) {
 			// Wait for a neighbor solicitation since link address resolution should
 			// be performed.
 			{
-				p, ok := e.ReadContext(context.Background())
+				clock.RunImmediatelyScheduledJobs()
+				p, ok := e.Read()
 				if !ok {
 					t.Fatalf("timed out waiting for packet")
 				}
@@ -1470,6 +1483,7 @@ func TestPacketQueing(t *testing.T) {
 			}
 
 			// Expect the response now that the link address has resolved.
+			clock.RunImmediatelyScheduledJobs()
 			test.checkResp(t, e)
 
 			// Since link resolution was already performed, it shouldn't be performed
diff --git a/pkg/tcpip/network/ipv6/ndp_test.go b/pkg/tcpip/network/ipv6/ndp_test.go
index 0f24500e7..2c2416328 100644
--- a/pkg/tcpip/network/ipv6/ndp_test.go
+++ b/pkg/tcpip/network/ipv6/ndp_test.go
@@ -16,7 +16,6 @@ package ipv6
 
 import (
 	"bytes"
-	"context"
 	"math/rand"
 	"strings"
 	"testing"
@@ -400,8 +399,10 @@ func TestNeighborSolicitationResponse(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{NewProtocol},
+				Clock:            clock,
 			})
 			e := channel.New(1, 1280, nicLinkAddr)
 			e.LinkEPCapabilities |= stack.CapabilityResolutionRequired
@@ -471,7 +472,8 @@ func TestNeighborSolicitationResponse(t *testing.T) {
 			}
 
 			if test.performsLinkResolution {
-				p, got := e.ReadContext(context.Background())
+				clock.RunImmediatelyScheduledJobs()
+				p, got := e.Read()
 				if !got {
 					t.Fatal("expected an NDP NS response")
 				}
@@ -526,7 +528,8 @@ func TestNeighborSolicitationResponse(t *testing.T) {
 				}))
 			}
 
-			p, got := e.ReadContext(context.Background())
+			clock.RunImmediatelyScheduledJobs()
+			p, got := e.Read()
 			if !got {
 				t.Fatal("expected an NDP NA response")
 			}
@@ -850,12 +853,12 @@ func TestNDPValidation(t *testing.T) {
 						routerOnly := stats.RouterOnlyPacketsDroppedByHost
 						typStat := typ.statCounter(stats)
 
-						icmp := header.ICMPv6(buffer.NewView(typ.size + len(typ.extraData)))
-						copy(icmp[typ.size:], typ.extraData)
-						icmp.SetType(typ.typ)
-						icmp.SetCode(test.code)
-						icmp.SetChecksum(header.ICMPv6Checksum(header.ICMPv6ChecksumParams{
-							Header:      icmp[:typ.size],
+						icmpH := header.ICMPv6(buffer.NewView(typ.size + len(typ.extraData)))
+						copy(icmpH[typ.size:], typ.extraData)
+						icmpH.SetType(typ.typ)
+						icmpH.SetCode(test.code)
+						icmpH.SetChecksum(header.ICMPv6Checksum(header.ICMPv6ChecksumParams{
+							Header:      icmpH[:typ.size],
 							Src:         lladdr0,
 							Dst:         lladdr1,
 							PayloadCsum: header.Checksum(typ.extraData /* initial */, 0),
@@ -881,7 +884,7 @@ func TestNDPValidation(t *testing.T) {
 							t.FailNow()
 						}
 
-						handleIPv6Payload(buffer.View(icmp), test.hopLimit, test.atomicFragment, ep)
+						handleIPv6Payload(buffer.View(icmpH), test.hopLimit, test.atomicFragment, ep)
 
 						// Rx count of the NDP packet should have increased.
 						if got := typStat.Value(); got != 1 {
@@ -1260,7 +1263,8 @@ func TestCheckDuplicateAddress(t *testing.T) {
 	snmc := header.SolicitedNodeAddr(lladdr0)
 	remoteLinkAddr := header.EthernetAddressFromMulticastIPv6Address(snmc)
 	checkDADMsg := func() {
-		p, ok := e.ReadContext(context.Background())
+		clock.RunImmediatelyScheduledJobs()
+		p, ok := e.Read()
 		if !ok {
 			t.Fatalf("expected %d-th DAD message", dadPacketsSent)
 		}
diff --git a/pkg/tcpip/stack/ndp_test.go b/pkg/tcpip/stack/ndp_test.go
index 7af5ee953..133bacdd0 100644
--- a/pkg/tcpip/stack/ndp_test.go
+++ b/pkg/tcpip/stack/ndp_test.go
@@ -16,7 +16,6 @@ package stack_test
 
 import (
 	"bytes"
-	"context"
 	"encoding/binary"
 	"fmt"
 	"math/rand"
@@ -607,7 +606,10 @@ func TestDADResolve(t *testing.T) {
 
 			// Validate the sent Neighbor Solicitation messages.
 			for i := uint8(0); i < test.dupAddrDetectTransmits; i++ {
-				p, _ := e.ReadContext(context.Background())
+				p, ok := e.Read()
+				if !ok {
+					t.Fatal("packet didn't arrive")
+				}
 
 				// Make sure its an IPv6 packet.
 				if p.Proto != header.IPv6ProtocolNumber {
@@ -733,11 +735,13 @@ func TestDADFail(t *testing.T) {
 			dadConfigs.RetransmitTimer = time.Second * 2
 
 			e := channel.New(0, 1280, linkAddr1)
+			clock := faketime.NewManualClock()
 			s := stack.New(stack.Options{
 				NetworkProtocols: []stack.NetworkProtocolFactory{ipv6.NewProtocolWithOptions(ipv6.Options{
 					NDPDisp:    &ndpDisp,
 					DADConfigs: dadConfigs,
 				})},
+				Clock: clock,
 			})
 			if err := s.CreateNIC(nicID, e); err != nil {
 				t.Fatalf("CreateNIC(%d, _) = %s", nicID, err)
@@ -763,16 +767,17 @@ func TestDADFail(t *testing.T) {
 
 			// Wait for DAD to fail and make sure the address did
 			// not get resolved.
+			clock.Advance(time.Duration(dadConfigs.DupAddrDetectTransmits) * dadConfigs.RetransmitTimer)
 			select {
-			case <-time.After(time.Duration(dadConfigs.DupAddrDetectTransmits)*dadConfigs.RetransmitTimer + time.Second):
-				// If we don't get a failure event after the
-				// expected resolution time + extra 1s buffer,
-				// something is wrong.
-				t.Fatal("timed out waiting for DAD failure")
 			case e := <-ndpDisp.dadC:
 				if diff := checkDADEvent(e, nicID, addr1, &stack.DADDupAddrDetected{HolderLinkAddress: test.expectedHolderLinkAddress}); diff != "" {
 					t.Errorf("DAD event mismatch (-want +got):\n%s", diff)
 				}
+			default:
+				// If we don't get a failure event after the
+				// expected resolution time + extra 1s buffer,
+				// something is wrong.
+				t.Fatal("timed out waiting for DAD failure")
 			}
 			if err := checkGetMainNICAddress(s, nicID, header.IPv6ProtocolNumber, tcpip.AddressWithPrefix{}); err != nil {
 				t.Fatal(err)
@@ -841,11 +846,13 @@ func TestDADStop(t *testing.T) {
 			}
 
 			e := channel.New(0, 1280, linkAddr1)
+			clock := faketime.NewManualClock()
 			s := stack.New(stack.Options{
 				NetworkProtocols: []stack.NetworkProtocolFactory{ipv6.NewProtocolWithOptions(ipv6.Options{
 					NDPDisp:    &ndpDisp,
 					DADConfigs: dadConfigs,
 				})},
+				Clock: clock,
 			})
 			if err := s.CreateNIC(nicID, e); err != nil {
 				t.Fatalf("CreateNIC(%d, _): %s", nicID, err)
@@ -863,15 +870,16 @@ func TestDADStop(t *testing.T) {
 			test.stopFn(t, s)
 
 			// Wait for DAD to fail (since the address was removed during DAD).
+			clock.Advance(time.Duration(dadConfigs.DupAddrDetectTransmits) * dadConfigs.RetransmitTimer)
 			select {
-			case <-time.After(time.Duration(dadConfigs.DupAddrDetectTransmits)*dadConfigs.RetransmitTimer + time.Second):
-				// If we don't get a failure event after the expected resolution
-				// time + extra 1s buffer, something is wrong.
-				t.Fatal("timed out waiting for DAD failure")
 			case e := <-ndpDisp.dadC:
 				if diff := checkDADEvent(e, nicID, addr1, &stack.DADAborted{}); diff != "" {
 					t.Errorf("DAD event mismatch (-want +got):\n%s", diff)
 				}
+			default:
+				// If we don't get a failure event after the expected resolution
+				// time + extra 1s buffer, something is wrong.
+				t.Fatal("timed out waiting for DAD failure")
 			}
 
 			if !test.skipFinalAddrCheck {
@@ -922,10 +930,12 @@ func TestSetNDPConfigurations(t *testing.T) {
 				dadC: make(chan ndpDADEvent, 1),
 			}
 			e := channel.New(0, 1280, linkAddr1)
+			clock := faketime.NewManualClock()
 			s := stack.New(stack.Options{
 				NetworkProtocols: []stack.NetworkProtocolFactory{ipv6.NewProtocolWithOptions(ipv6.Options{
 					NDPDisp: &ndpDisp,
 				})},
+				Clock: clock,
 			})
 
 			expectDADEvent := func(nicID tcpip.NICID, addr tcpip.Address) {
@@ -1004,28 +1014,23 @@ func TestSetNDPConfigurations(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			// Sleep until right (500ms before) before resolution to
-			// make sure the address didn't resolve on NIC(1) yet.
-			const delta = 500 * time.Millisecond
-			time.Sleep(time.Duration(test.dupAddrDetectTransmits)*test.expectedRetransmitTimer - delta)
+			// Sleep until right before resolution to make sure the address didn't
+			// resolve on NIC(1) yet.
+			const delta = 1
+			clock.Advance(time.Duration(test.dupAddrDetectTransmits)*test.expectedRetransmitTimer - delta)
 			if err := checkGetMainNICAddress(s, nicID1, header.IPv6ProtocolNumber, tcpip.AddressWithPrefix{}); err != nil {
 				t.Fatal(err)
 			}
 
 			// Wait for DAD to resolve.
+			clock.Advance(delta)
 			select {
-			case <-time.After(2 * delta):
-				// We should get a resolution event after 500ms
-				// (delta) since we wait for 500ms less than the
-				// expected resolution time above to make sure
-				// that the address did not yet resolve. Waiting
-				// for 1s (2x delta) without a resolution event
-				// means something is wrong.
-				t.Fatal("timed out waiting for DAD resolution")
 			case e := <-ndpDisp.dadC:
 				if diff := checkDADEvent(e, nicID1, addr1, &stack.DADSucceeded{}); diff != "" {
 					t.Errorf("DAD event mismatch (-want +got):\n%s", diff)
 				}
+			default:
+				t.Fatal("timed out waiting for DAD resolution")
 			}
 			if err := checkGetMainNICAddress(s, nicID1, header.IPv6ProtocolNumber, addrWithPrefix1); err != nil {
 				t.Fatal(err)
@@ -1342,6 +1347,7 @@ func TestRouterDiscoveryDispatcherNoRemember(t *testing.T) {
 		routerC: make(chan ndpRouterEvent, 1),
 	}
 	e := channel.New(0, 1280, linkAddr1)
+	clock := faketime.NewManualClock()
 	s := stack.New(stack.Options{
 		NetworkProtocols: []stack.NetworkProtocolFactory{ipv6.NewProtocolWithOptions(ipv6.Options{
 			NDPConfigs: ipv6.NDPConfigurations{
@@ -1350,6 +1356,7 @@ func TestRouterDiscoveryDispatcherNoRemember(t *testing.T) {
 			},
 			NDPDisp: &ndpDisp,
 		})},
+		Clock: clock,
 	})
 
 	if err := s.CreateNIC(1, e); err != nil {
@@ -1371,10 +1378,11 @@ func TestRouterDiscoveryDispatcherNoRemember(t *testing.T) {
 	// Wait for the invalidation time plus some buffer to make sure we do
 	// not actually receive any invalidation events as we should not have
 	// remembered the router in the first place.
+	clock.Advance(lifetimeSeconds * time.Second)
 	select {
 	case <-ndpDisp.routerC:
 		t.Fatal("should not have received any router events")
-	case <-time.After(lifetimeSeconds*time.Second + defaultAsyncNegativeEventTimeout):
+	default:
 	}
 }
 
@@ -1385,6 +1393,7 @@ func TestRouterDiscovery(t *testing.T) {
 			rememberRouter: true,
 		}
 		e := channel.New(0, 1280, linkAddr1)
+		clock := faketime.NewManualClock()
 		s := stack.New(stack.Options{
 			NetworkProtocols: []stack.NetworkProtocolFactory{ipv6.NewProtocolWithOptions(ipv6.Options{
 				NDPConfigs: ipv6.NDPConfigurations{
@@ -1393,6 +1402,7 @@ func TestRouterDiscovery(t *testing.T) {
 				},
 				NDPDisp: &ndpDisp,
 			})},
+			Clock: clock,
 		})
 
 		expectRouterEvent := func(addr tcpip.Address, discovered bool) {
@@ -1411,12 +1421,13 @@ func TestRouterDiscovery(t *testing.T) {
 		expectAsyncRouterInvalidationEvent := func(addr tcpip.Address, timeout time.Duration) {
 			t.Helper()
 
+			clock.Advance(timeout)
 			select {
 			case e := <-ndpDisp.routerC:
 				if diff := checkRouterEvent(e, addr, false); diff != "" {
 					t.Errorf("router event mismatch (-want +got):\n%s", diff)
 				}
-			case <-time.After(timeout):
+			default:
 				t.Fatal("timed out waiting for router discovery event")
 			}
 		}
@@ -1463,7 +1474,7 @@ func TestRouterDiscovery(t *testing.T) {
 		// Wait for the normal lifetime plus an extra bit for the
 		// router to get invalidated. If we don't get an invalidation
 		// event after this time, then something is wrong.
-		expectAsyncRouterInvalidationEvent(llAddr2, l2LifetimeSeconds*time.Second+defaultAsyncPositiveEventTimeout)
+		expectAsyncRouterInvalidationEvent(llAddr2, l2LifetimeSeconds*time.Second)
 
 		// Rx an RA from lladdr2 with huge lifetime.
 		e.InjectInbound(header.IPv6ProtocolNumber, raBuf(llAddr2, 1000))
@@ -1480,7 +1491,7 @@ func TestRouterDiscovery(t *testing.T) {
 		// Wait for the normal lifetime plus an extra bit for the
 		// router to get invalidated. If we don't get an invalidation
 		// event after this time, then something is wrong.
-		expectAsyncRouterInvalidationEvent(llAddr3, l3LifetimeSeconds*time.Second+defaultAsyncPositiveEventTimeout)
+		expectAsyncRouterInvalidationEvent(llAddr3, l3LifetimeSeconds*time.Second)
 	})
 }
 
@@ -1549,6 +1560,7 @@ func TestPrefixDiscoveryDispatcherNoRemember(t *testing.T) {
 		prefixC: make(chan ndpPrefixEvent, 1),
 	}
 	e := channel.New(0, 1280, linkAddr1)
+	clock := faketime.NewManualClock()
 	s := stack.New(stack.Options{
 		NetworkProtocols: []stack.NetworkProtocolFactory{ipv6.NewProtocolWithOptions(ipv6.Options{
 			NDPConfigs: ipv6.NDPConfigurations{
@@ -1557,6 +1569,7 @@ func TestPrefixDiscoveryDispatcherNoRemember(t *testing.T) {
 			},
 			NDPDisp: &ndpDisp,
 		})},
+		Clock: clock,
 	})
 
 	if err := s.CreateNIC(1, e); err != nil {
@@ -1578,10 +1591,11 @@ func TestPrefixDiscoveryDispatcherNoRemember(t *testing.T) {
 	// Wait for the invalidation time plus some buffer to make sure we do
 	// not actually receive any invalidation events as we should not have
 	// remembered the prefix in the first place.
+	clock.Advance(lifetimeSeconds * time.Second)
 	select {
 	case <-ndpDisp.prefixC:
 		t.Fatal("should not have received any prefix events")
-	case <-time.After(lifetimeSeconds*time.Second + defaultAsyncNegativeEventTimeout):
+	default:
 	}
 }
 
@@ -1596,6 +1610,7 @@ func TestPrefixDiscovery(t *testing.T) {
 			rememberPrefix: true,
 		}
 		e := channel.New(0, 1280, linkAddr1)
+		clock := faketime.NewManualClock()
 		s := stack.New(stack.Options{
 			NetworkProtocols: []stack.NetworkProtocolFactory{ipv6.NewProtocolWithOptions(ipv6.Options{
 				NDPConfigs: ipv6.NDPConfigurations{
@@ -1604,6 +1619,7 @@ func TestPrefixDiscovery(t *testing.T) {
 				},
 				NDPDisp: &ndpDisp,
 			})},
+			Clock: clock,
 		})
 
 		if err := s.CreateNIC(1, e); err != nil {
@@ -1664,12 +1680,13 @@ func TestPrefixDiscovery(t *testing.T) {
 
 		// Wait for prefix2's most recent invalidation job plus some buffer to
 		// expire.
+		clock.Advance(time.Duration(lifetime) * time.Second)
 		select {
 		case e := <-ndpDisp.prefixC:
 			if diff := checkPrefixEvent(e, subnet2, false); diff != "" {
 				t.Errorf("prefix event mismatch (-want +got):\n%s", diff)
 			}
-		case <-time.After(time.Duration(lifetime)*time.Second + defaultAsyncPositiveEventTimeout):
+		default:
 			t.Fatal("timed out waiting for prefix discovery event")
 		}
 
@@ -1702,6 +1719,7 @@ func TestPrefixDiscoveryWithInfiniteLifetime(t *testing.T) {
 		rememberPrefix: true,
 	}
 	e := channel.New(0, 1280, linkAddr1)
+	clock := faketime.NewManualClock()
 	s := stack.New(stack.Options{
 		NetworkProtocols: []stack.NetworkProtocolFactory{ipv6.NewProtocolWithOptions(ipv6.Options{
 			NDPConfigs: ipv6.NDPConfigurations{
@@ -1710,6 +1728,7 @@ func TestPrefixDiscoveryWithInfiniteLifetime(t *testing.T) {
 			},
 			NDPDisp: &ndpDisp,
 		})},
+		Clock: clock,
 	})
 
 	if err := s.CreateNIC(1, e); err != nil {
@@ -1733,21 +1752,23 @@ func TestPrefixDiscoveryWithInfiniteLifetime(t *testing.T) {
 	// with infinite valid lifetime which should not get invalidated.
 	e.InjectInbound(header.IPv6ProtocolNumber, raBufWithPI(llAddr2, 0, prefix, true, false, testInfiniteLifetimeSeconds, 0))
 	expectPrefixEvent(subnet, true)
+	clock.Advance(testInfiniteLifetime)
 	select {
 	case <-ndpDisp.prefixC:
 		t.Fatal("unexpectedly invalidated a prefix with infinite lifetime")
-	case <-time.After(testInfiniteLifetime + defaultAsyncNegativeEventTimeout):
+	default:
 	}
 
 	// Receive an RA with finite lifetime.
 	// The prefix should get invalidated after 1s.
 	e.InjectInbound(header.IPv6ProtocolNumber, raBufWithPI(llAddr2, 0, prefix, true, false, testInfiniteLifetimeSeconds-1, 0))
+	clock.Advance(testInfiniteLifetime)
 	select {
 	case e := <-ndpDisp.prefixC:
 		if diff := checkPrefixEvent(e, subnet, false); diff != "" {
 			t.Errorf("prefix event mismatch (-want +got):\n%s", diff)
 		}
-	case <-time.After(testInfiniteLifetime):
+	default:
 		t.Fatal("timed out waiting for prefix discovery event")
 	}
 
@@ -1758,19 +1779,21 @@ func TestPrefixDiscoveryWithInfiniteLifetime(t *testing.T) {
 	// Receive an RA with prefix with an infinite lifetime.
 	// The prefix should not be invalidated.
 	e.InjectInbound(header.IPv6ProtocolNumber, raBufWithPI(llAddr2, 0, prefix, true, false, testInfiniteLifetimeSeconds, 0))
+	clock.Advance(testInfiniteLifetime)
 	select {
 	case <-ndpDisp.prefixC:
 		t.Fatal("unexpectedly invalidated a prefix with infinite lifetime")
-	case <-time.After(testInfiniteLifetime + defaultAsyncNegativeEventTimeout):
+	default:
 	}
 
 	// Receive an RA with a prefix with a lifetime value greater than the
 	// set infinite lifetime value.
 	e.InjectInbound(header.IPv6ProtocolNumber, raBufWithPI(llAddr2, 0, prefix, true, false, testInfiniteLifetimeSeconds+1, 0))
+	clock.Advance((testInfiniteLifetimeSeconds + 1) * time.Second)
 	select {
 	case <-ndpDisp.prefixC:
 		t.Fatal("unexpectedly invalidated a prefix with infinite lifetime")
-	case <-time.After((testInfiniteLifetimeSeconds+1)*time.Second + defaultAsyncNegativeEventTimeout):
+	default:
 	}
 
 	// Receive an RA with 0 lifetime.
@@ -3615,6 +3638,7 @@ func TestAutoGenAddrRemoval(t *testing.T) {
 		autoGenAddrC: make(chan ndpAutoGenAddrEvent, 1),
 	}
 	e := channel.New(0, 1280, linkAddr1)
+	clock := faketime.NewManualClock()
 	s := stack.New(stack.Options{
 		NetworkProtocols: []stack.NetworkProtocolFactory{ipv6.NewProtocolWithOptions(ipv6.Options{
 			NDPConfigs: ipv6.NDPConfigurations{
@@ -3623,6 +3647,7 @@ func TestAutoGenAddrRemoval(t *testing.T) {
 			},
 			NDPDisp: &ndpDisp,
 		})},
+		Clock: clock,
 	})
 
 	if err := s.CreateNIC(1, e); err != nil {
@@ -3656,10 +3681,11 @@ func TestAutoGenAddrRemoval(t *testing.T) {
 
 	// Wait for the original valid lifetime to make sure the original job got
 	// cancelled/cleaned up.
+	clock.Advance(lifetimeSeconds * time.Second)
 	select {
 	case <-ndpDisp.autoGenAddrC:
 		t.Fatal("unexpectedly received an auto gen addr event")
-	case <-time.After(lifetimeSeconds*time.Second + defaultAsyncNegativeEventTimeout):
+	default:
 	}
 }
 
@@ -3781,6 +3807,7 @@ func TestAutoGenAddrStaticConflict(t *testing.T) {
 		autoGenAddrC: make(chan ndpAutoGenAddrEvent, 1),
 	}
 	e := channel.New(0, 1280, linkAddr1)
+	clock := faketime.NewManualClock()
 	s := stack.New(stack.Options{
 		NetworkProtocols: []stack.NetworkProtocolFactory{ipv6.NewProtocolWithOptions(ipv6.Options{
 			NDPConfigs: ipv6.NDPConfigurations{
@@ -3789,6 +3816,7 @@ func TestAutoGenAddrStaticConflict(t *testing.T) {
 			},
 			NDPDisp: &ndpDisp,
 		})},
+		Clock: clock,
 	})
 
 	if err := s.CreateNIC(1, e); err != nil {
@@ -3818,30 +3846,36 @@ func TestAutoGenAddrStaticConflict(t *testing.T) {
 
 	// Should not get an invalidation event after the PI's invalidation
 	// time.
+	clock.Advance(lifetimeSeconds * time.Second)
 	select {
 	case <-ndpDisp.autoGenAddrC:
 		t.Fatal("unexpectedly received an auto gen addr event")
-	case <-time.After(lifetimeSeconds*time.Second + defaultAsyncNegativeEventTimeout):
+	default:
 	}
 	if !containsV6Addr(s.NICInfo()[1].ProtocolAddresses, addr) {
 		t.Fatalf("Should have %s in the list of addresses", addr1)
 	}
 }
 
-// TestAutoGenAddrWithOpaqueIID tests that SLAAC generated addresses will use
-// opaque interface identifiers when configured to do so.
-func TestAutoGenAddrWithOpaqueIID(t *testing.T) {
-	const nicID = 1
-	const nicName = "nic1"
-	var secretKeyBuf [header.OpaqueIIDSecretKeyMinBytes]byte
-	secretKey := secretKeyBuf[:]
+func makeSecretKey(t *testing.T) []byte {
+	secretKey := make([]byte, header.OpaqueIIDSecretKeyMinBytes)
 	n, err := cryptorand.Read(secretKey)
 	if err != nil {
 		t.Fatalf("cryptorand.Read(_): %s", err)
 	}
-	if n != header.OpaqueIIDSecretKeyMinBytes {
-		t.Fatalf("got cryptorand.Read(_) = (%d, _), want = (%d, _)", n, header.OpaqueIIDSecretKeyMinBytes)
+	if l := len(secretKey); n != l {
+		t.Fatalf("got cryptorand.Read(_) = (%d, nil), want = (%d, nil)", n, l)
 	}
+	return secretKey
+}
+
+// TestAutoGenAddrWithOpaqueIID tests that SLAAC generated addresses will use
+// opaque interface identifiers when configured to do so.
+func TestAutoGenAddrWithOpaqueIID(t *testing.T) {
+	const nicID = 1
+	const nicName = "nic1"
+
+	secretKey := makeSecretKey(t)
 
 	prefix1, subnet1, _ := prefixSubnetAddr(0, linkAddr1)
 	prefix2, subnet2, _ := prefixSubnetAddr(1, linkAddr1)
@@ -3863,6 +3897,7 @@ func TestAutoGenAddrWithOpaqueIID(t *testing.T) {
 		autoGenAddrC: make(chan ndpAutoGenAddrEvent, 1),
 	}
 	e := channel.New(0, 1280, linkAddr1)
+	clock := faketime.NewManualClock()
 	s := stack.New(stack.Options{
 		NetworkProtocols: []stack.NetworkProtocolFactory{ipv6.NewProtocolWithOptions(ipv6.Options{
 			NDPConfigs: ipv6.NDPConfigurations{
@@ -3877,6 +3912,7 @@ func TestAutoGenAddrWithOpaqueIID(t *testing.T) {
 				SecretKey: secretKey,
 			},
 		})},
+		Clock: clock,
 	})
 	opts := stack.NICOptions{Name: nicName}
 	if err := s.CreateNICWithOptions(nicID, e, opts); err != nil {
@@ -3915,12 +3951,13 @@ func TestAutoGenAddrWithOpaqueIID(t *testing.T) {
 	}
 
 	// Wait for addr of prefix1 to be invalidated.
+	clock.Advance(validLifetimeSecondPrefix1 * time.Second)
 	select {
 	case e := <-ndpDisp.autoGenAddrC:
 		if diff := checkAutoGenAddrEvent(e, addr1, invalidatedAddr); diff != "" {
 			t.Errorf("auto-gen addr event mismatch (-want +got):\n%s", diff)
 		}
-	case <-time.After(validLifetimeSecondPrefix1*time.Second + defaultAsyncPositiveEventTimeout):
+	default:
 		t.Fatal("timed out waiting for addr auto gen event")
 	}
 	if containsV6Addr(s.NICInfo()[nicID].ProtocolAddresses, addr1) {
@@ -3946,15 +3983,7 @@ func TestAutoGenAddrInResponseToDADConflicts(t *testing.T) {
 	}()
 	ipv6.MaxDesyncFactor = time.Nanosecond
 
-	var secretKeyBuf [header.OpaqueIIDSecretKeyMinBytes]byte
-	secretKey := secretKeyBuf[:]
-	n, err := cryptorand.Read(secretKey)
-	if err != nil {
-		t.Fatalf("cryptorand.Read(_): %s", err)
-	}
-	if n != header.OpaqueIIDSecretKeyMinBytes {
-		t.Fatalf("got cryptorand.Read(_) = (%d, _), want = (%d, _)", n, header.OpaqueIIDSecretKeyMinBytes)
-	}
+	secretKey := makeSecretKey(t)
 
 	prefix, subnet, _ := prefixSubnetAddr(0, linkAddr1)
 
@@ -4233,13 +4262,12 @@ func TestAutoGenAddrWithEUI64IIDNoDADRetries(t *testing.T) {
 		addrType := addrType
 
 		t.Run(addrType.name, func(t *testing.T) {
-			t.Parallel()
-
 			ndpDisp := ndpDispatcher{
 				dadC:         make(chan ndpDADEvent, 1),
 				autoGenAddrC: make(chan ndpAutoGenAddrEvent, 2),
 			}
 			e := channel.New(0, 1280, linkAddr1)
+			clock := faketime.NewManualClock()
 			s := stack.New(stack.Options{
 				NetworkProtocols: []stack.NetworkProtocolFactory{ipv6.NewProtocolWithOptions(ipv6.Options{
 					AutoGenLinkLocal: addrType.autoGenLinkLocal,
@@ -4250,6 +4278,7 @@ func TestAutoGenAddrWithEUI64IIDNoDADRetries(t *testing.T) {
 						RetransmitTimer:        retransmitTimer,
 					},
 				})},
+				Clock: clock,
 			})
 			if err := s.CreateNIC(nicID, e); err != nil {
 				t.Fatalf("CreateNIC(%d, _) = %s", nicID, err)
@@ -4294,7 +4323,7 @@ func TestAutoGenAddrWithEUI64IIDNoDADRetries(t *testing.T) {
 			select {
 			case e := <-ndpDisp.autoGenAddrC:
 				t.Fatalf("unexpectedly got an auto-generated address event = %+v", e)
-			case <-time.After(defaultAsyncNegativeEventTimeout):
+			default:
 			}
 		})
 	}
@@ -4311,15 +4340,7 @@ func TestAutoGenAddrContinuesLifetimesAfterRetry(t *testing.T) {
 	const maxRetries = 1
 	const lifetimeSeconds = 5
 
-	var secretKeyBuf [header.OpaqueIIDSecretKeyMinBytes]byte
-	secretKey := secretKeyBuf[:]
-	n, err := cryptorand.Read(secretKey)
-	if err != nil {
-		t.Fatalf("cryptorand.Read(_): %s", err)
-	}
-	if n != header.OpaqueIIDSecretKeyMinBytes {
-		t.Fatalf("got cryptorand.Read(_) = (%d, _), want = (%d, _)", n, header.OpaqueIIDSecretKeyMinBytes)
-	}
+	secretKey := makeSecretKey(t)
 
 	prefix, subnet, _ := prefixSubnetAddr(0, linkAddr1)
 
@@ -4328,6 +4349,7 @@ func TestAutoGenAddrContinuesLifetimesAfterRetry(t *testing.T) {
 		autoGenAddrC: make(chan ndpAutoGenAddrEvent, 2),
 	}
 	e := channel.New(0, 1280, linkAddr1)
+	clock := faketime.NewManualClock()
 	s := stack.New(stack.Options{
 		NetworkProtocols: []stack.NetworkProtocolFactory{ipv6.NewProtocolWithOptions(ipv6.Options{
 			DADConfigs: stack.DADConfigurations{
@@ -4347,6 +4369,7 @@ func TestAutoGenAddrContinuesLifetimesAfterRetry(t *testing.T) {
 				SecretKey: secretKey,
 			},
 		})},
+		Clock: clock,
 	})
 	opts := stack.NICOptions{Name: nicName}
 	if err := s.CreateNICWithOptions(nicID, e, opts); err != nil {
@@ -4377,7 +4400,7 @@ func TestAutoGenAddrContinuesLifetimesAfterRetry(t *testing.T) {
 	expectAutoGenAddrEvent(addr, newAddr)
 
 	// Simulate a DAD conflict after some time has passed.
-	time.Sleep(failureTimer)
+	clock.Advance(failureTimer)
 	rxNDPSolicit(e, addr.Address)
 	expectAutoGenAddrEvent(addr, invalidatedAddr)
 	select {
@@ -4392,12 +4415,13 @@ func TestAutoGenAddrContinuesLifetimesAfterRetry(t *testing.T) {
 	// Let the next address resolve.
 	addr.Address = tcpip.Address(header.AppendOpaqueInterfaceIdentifier(addrBytes[:header.IIDOffsetInIPv6Address], subnet, nicName, 1, secretKey))
 	expectAutoGenAddrEvent(addr, newAddr)
+	clock.Advance(dadTransmits * retransmitTimer)
 	select {
 	case e := <-ndpDisp.dadC:
 		if diff := checkDADEvent(e, nicID, addr.Address, &stack.DADSucceeded{}); diff != "" {
 			t.Errorf("DAD event mismatch (-want +got):\n%s", diff)
 		}
-	case <-time.After(dadTransmits*retransmitTimer + defaultAsyncPositiveEventTimeout):
+	default:
 		t.Fatal("timed out waiting for DAD event")
 	}
 
@@ -4411,6 +4435,7 @@ func TestAutoGenAddrContinuesLifetimesAfterRetry(t *testing.T) {
 	//
 	// We expect either just the invalidation event or the deprecation event
 	// followed by the invalidation event.
+	clock.Advance(lifetimeSeconds*time.Second - failureTimer - dadTransmits*retransmitTimer)
 	select {
 	case e := <-ndpDisp.autoGenAddrC:
 		if e.eventType == deprecatedAddr {
@@ -4423,7 +4448,7 @@ func TestAutoGenAddrContinuesLifetimesAfterRetry(t *testing.T) {
 				if diff := checkAutoGenAddrEvent(e, addr, invalidatedAddr); diff != "" {
 					t.Errorf("auto-gen addr event mismatch (-want +got):\n%s", diff)
 				}
-			case <-time.After(defaultAsyncPositiveEventTimeout):
+			default:
 				t.Fatal("timed out waiting for invalidated auto gen addr event after deprecation")
 			}
 		} else {
@@ -4431,7 +4456,7 @@ func TestAutoGenAddrContinuesLifetimesAfterRetry(t *testing.T) {
 				t.Errorf("auto-gen addr event mismatch (-want +got):\n%s", diff)
 			}
 		}
-	case <-time.After(lifetimeSeconds*time.Second - failureTimer - dadTransmits*retransmitTimer + defaultAsyncPositiveEventTimeout):
+	default:
 		t.Fatal("timed out waiting for auto gen addr event")
 	}
 }
@@ -4865,6 +4890,7 @@ func TestCleanupNDPState(t *testing.T) {
 				rememberPrefix: true,
 				autoGenAddrC:   make(chan ndpAutoGenAddrEvent, test.maxAutoGenAddrEvents),
 			}
+			clock := faketime.NewManualClock()
 			s := stack.New(stack.Options{
 				NetworkProtocols: []stack.NetworkProtocolFactory{ipv6.NewProtocolWithOptions(ipv6.Options{
 					AutoGenLinkLocal: true,
@@ -4876,6 +4902,7 @@ func TestCleanupNDPState(t *testing.T) {
 					},
 					NDPDisp: &ndpDisp,
 				})},
+				Clock: clock,
 			})
 
 			expectRouterEvent := func() (bool, ndpRouterEvent) {
@@ -5108,7 +5135,7 @@ func TestCleanupNDPState(t *testing.T) {
 
 			// Should not get any more events (invalidation timers should have been
 			// cancelled when the NDP state was cleaned up).
-			time.Sleep(lifetimeSeconds*time.Second + defaultAsyncNegativeEventTimeout)
+			clock.Advance(lifetimeSeconds * time.Second)
 			select {
 			case <-ndpDisp.routerC:
 				t.Error("unexpected router event")
@@ -5238,6 +5265,23 @@ func TestDHCPv6ConfigurationFromNDPDA(t *testing.T) {
 	expectNoDHCPv6Event()
 }
 
+var _ rand.Source = (*savingRandSource)(nil)
+
+type savingRandSource struct {
+	s rand.Source
+
+	lastInt63 int64
+}
+
+func (d *savingRandSource) Int63() int64 {
+	i := d.s.Int63()
+	d.lastInt63 = i
+	return i
+}
+func (d *savingRandSource) Seed(seed int64) {
+	d.s.Seed(seed)
+}
+
 // TestRouterSolicitation tests the initial Router Solicitations that are sent
 // when a NIC newly becomes enabled.
 func TestRouterSolicitation(t *testing.T) {
@@ -5404,6 +5448,9 @@ func TestRouterSolicitation(t *testing.T) {
 							t.Fatalf("unexpectedly got a packet = %#v", p)
 						}
 					}
+					randSource := savingRandSource{
+						s: rand.NewSource(time.Now().UnixNano()),
+					}
 					s := stack.New(stack.Options{
 						NetworkProtocols: []stack.NetworkProtocolFactory{ipv6.NewProtocolWithOptions(ipv6.Options{
 							NDPConfigs: ipv6.NDPConfigurations{
@@ -5413,8 +5460,10 @@ func TestRouterSolicitation(t *testing.T) {
 								MaxRtrSolicitationDelay: test.maxRtrSolicitDelay,
 							},
 						})},
-						Clock: clock,
+						Clock:      clock,
+						RandSource: &randSource,
 					})
+
 					if err := s.CreateNIC(nicID, &e); err != nil {
 						t.Fatalf("CreateNIC(%d, _) = %s", nicID, err)
 					}
@@ -5427,19 +5476,27 @@ func TestRouterSolicitation(t *testing.T) {
 
 					// Make sure each RS is sent at the right time.
 					remaining := test.maxRtrSolicit
-					if remaining > 0 {
-						waitForPkt(test.effectiveMaxRtrSolicitDelay)
+					if remaining != 0 {
+						maxRtrSolicitDelay := test.maxRtrSolicitDelay
+						if maxRtrSolicitDelay < 0 {
+							maxRtrSolicitDelay = ipv6.DefaultNDPConfigurations().MaxRtrSolicitationDelay
+						}
+						var actualRtrSolicitDelay time.Duration
+						if maxRtrSolicitDelay != 0 {
+							actualRtrSolicitDelay = time.Duration(randSource.lastInt63) % maxRtrSolicitDelay
+						}
+						waitForPkt(actualRtrSolicitDelay)
 						remaining--
 					}
 
 					subTest.afterFirstRS(t, s)
 
-					for ; remaining > 0; remaining-- {
-						if test.effectiveRtrSolicitInt > defaultAsyncPositiveEventTimeout {
+					for ; remaining != 0; remaining-- {
+						if test.effectiveRtrSolicitInt != 0 {
 							waitForNothing(test.effectiveRtrSolicitInt - time.Nanosecond)
 							waitForPkt(time.Nanosecond)
 						} else {
-							waitForPkt(test.effectiveRtrSolicitInt)
+							waitForPkt(0)
 						}
 					}
 
@@ -5535,12 +5592,11 @@ func TestStopStartSolicitingRouters(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			e := channel.New(maxRtrSolicitations, 1280, linkAddr1)
-			waitForPkt := func(timeout time.Duration) {
+			waitForPkt := func(clock *faketime.ManualClock, timeout time.Duration) {
 				t.Helper()
 
-				ctx, cancel := context.WithTimeout(context.Background(), timeout)
-				defer cancel()
-				p, ok := e.ReadContext(ctx)
+				clock.Advance(timeout)
+				p, ok := e.Read()
 				if !ok {
 					t.Fatal("timed out waiting for packet")
 				}
@@ -5554,6 +5610,7 @@ func TestStopStartSolicitingRouters(t *testing.T) {
 					checker.TTL(header.NDPHopLimit),
 					checker.NDPRS())
 			}
+			clock := faketime.NewManualClock()
 			s := stack.New(stack.Options{
 				NetworkProtocols: []stack.NetworkProtocolFactory{ipv6.NewProtocolWithOptions(ipv6.Options{
 					NDPConfigs: ipv6.NDPConfigurations{
@@ -5563,6 +5620,7 @@ func TestStopStartSolicitingRouters(t *testing.T) {
 						MaxRtrSolicitationDelay: delay,
 					},
 				})},
+				Clock: clock,
 			})
 			if err := s.CreateNIC(nicID, e); err != nil {
 				t.Fatalf("CreateNIC(%d, _) = %s", nicID, err)
@@ -5570,13 +5628,11 @@ func TestStopStartSolicitingRouters(t *testing.T) {
 
 			// Stop soliciting routers.
 			test.stopFn(t, s, true /* first */)
-			ctx, cancel := context.WithTimeout(context.Background(), delay+defaultAsyncNegativeEventTimeout)
-			defer cancel()
-			if _, ok := e.ReadContext(ctx); ok {
+			clock.Advance(delay)
+			if _, ok := e.Read(); ok {
 				// A single RS may have been sent before solicitations were stopped.
-				ctx, cancel := context.WithTimeout(context.Background(), interval+defaultAsyncNegativeEventTimeout)
-				defer cancel()
-				if _, ok = e.ReadContext(ctx); ok {
+				clock.Advance(interval)
+				if _, ok = e.Read(); ok {
 					t.Fatal("should not have sent more than one RS message")
 				}
 			}
@@ -5584,9 +5640,8 @@ func TestStopStartSolicitingRouters(t *testing.T) {
 			// Stopping router solicitations after it has already been stopped should
 			// do nothing.
 			test.stopFn(t, s, false /* first */)
-			ctx, cancel = context.WithTimeout(context.Background(), delay+defaultAsyncNegativeEventTimeout)
-			defer cancel()
-			if _, ok := e.ReadContext(ctx); ok {
+			clock.Advance(delay)
+			if _, ok := e.Read(); ok {
 				t.Fatal("unexpectedly got a packet after router solicitation has been stopepd")
 			}
 
@@ -5597,21 +5652,19 @@ func TestStopStartSolicitingRouters(t *testing.T) {
 
 			// Start soliciting routers.
 			test.startFn(t, s)
-			waitForPkt(delay + defaultAsyncPositiveEventTimeout)
-			waitForPkt(interval + defaultAsyncPositiveEventTimeout)
-			waitForPkt(interval + defaultAsyncPositiveEventTimeout)
-			ctx, cancel = context.WithTimeout(context.Background(), interval+defaultAsyncNegativeEventTimeout)
-			defer cancel()
-			if _, ok := e.ReadContext(ctx); ok {
+			waitForPkt(clock, delay)
+			waitForPkt(clock, interval)
+			waitForPkt(clock, interval)
+			clock.Advance(interval)
+			if _, ok := e.Read(); ok {
 				t.Fatal("unexpectedly got an extra packet after sending out the expected RSs")
 			}
 
 			// Starting router solicitations after it has already completed should do
 			// nothing.
 			test.startFn(t, s)
-			ctx, cancel = context.WithTimeout(context.Background(), delay+defaultAsyncNegativeEventTimeout)
-			defer cancel()
-			if _, ok := e.ReadContext(ctx); ok {
+			clock.Advance(interval)
+			if _, ok := e.Read(); ok {
 				t.Fatal("unexpectedly got a packet after finishing router solicitations")
 			}
 		})
diff --git a/pkg/tcpip/stack/stack_test.go b/pkg/tcpip/stack/stack_test.go
index 9c61dd939..21951d05a 100644
--- a/pkg/tcpip/stack/stack_test.go
+++ b/pkg/tcpip/stack/stack_test.go
@@ -2640,15 +2640,17 @@ func TestNICAutoGenAddrDoesDAD(t *testing.T) {
 	const nicID = 1
 
 	ndpDisp := ndpDispatcher{
-		dadC: make(chan ndpDADEvent),
+		dadC: make(chan ndpDADEvent, 1),
 	}
 	dadConfigs := stack.DefaultDADConfigurations()
+	clock := faketime.NewManualClock()
 	opts := stack.Options{
 		NetworkProtocols: []stack.NetworkProtocolFactory{ipv6.NewProtocolWithOptions(ipv6.Options{
 			AutoGenLinkLocal: true,
 			NDPDisp:          &ndpDisp,
 			DADConfigs:       dadConfigs,
 		})},
+		Clock: clock,
 	}
 
 	e := channel.New(int(dadConfigs.DupAddrDetectTransmits), 1280, linkAddr1)
@@ -2666,17 +2668,18 @@ func TestNICAutoGenAddrDoesDAD(t *testing.T) {
 	linkLocalAddr := header.LinkLocalAddr(linkAddr1)
 
 	// Wait for DAD to resolve.
+	clock.Advance(time.Duration(dadConfigs.DupAddrDetectTransmits) * dadConfigs.RetransmitTimer)
 	select {
-	case <-time.After(time.Duration(dadConfigs.DupAddrDetectTransmits)*dadConfigs.RetransmitTimer + time.Second):
+	case e := <-ndpDisp.dadC:
+		if diff := checkDADEvent(e, nicID, linkLocalAddr, &stack.DADSucceeded{}); diff != "" {
+			t.Errorf("dad event mismatch (-want +got):\n%s", diff)
+		}
+	default:
 		// We should get a resolution event after 1s (default time to
 		// resolve as per default NDP configurations). Waiting for that
 		// resolution time + an extra 1s without a resolution event
 		// means something is wrong.
 		t.Fatal("timed out waiting for DAD resolution")
-	case e := <-ndpDisp.dadC:
-		if diff := checkDADEvent(e, nicID, linkLocalAddr, &stack.DADSucceeded{}); diff != "" {
-			t.Errorf("dad event mismatch (-want +got):\n%s", diff)
-		}
 	}
 	if err := checkGetMainNICAddress(s, nicID, header.IPv6ProtocolNumber, tcpip.AddressWithPrefix{Address: linkLocalAddr, PrefixLen: header.IPv6LinkLocalPrefix.PrefixLen}); err != nil {
 		t.Fatal(err)
@@ -3307,8 +3310,9 @@ func TestDoDADWhenNICEnabled(t *testing.T) {
 	const nicID = 1
 
 	ndpDisp := ndpDispatcher{
-		dadC: make(chan ndpDADEvent),
+		dadC: make(chan ndpDADEvent, 1),
 	}
+	clock := faketime.NewManualClock()
 	opts := stack.Options{
 		NetworkProtocols: []stack.NetworkProtocolFactory{ipv6.NewProtocolWithOptions(ipv6.Options{
 			DADConfigs: stack.DADConfigurations{
@@ -3317,6 +3321,7 @@ func TestDoDADWhenNICEnabled(t *testing.T) {
 			},
 			NDPDisp: &ndpDisp,
 		})},
+		Clock: clock,
 	}
 
 	e := channel.New(dadTransmits, 1280, linkAddr1)
@@ -3361,13 +3366,14 @@ func TestDoDADWhenNICEnabled(t *testing.T) {
 	}
 
 	// Wait for DAD to resolve.
+	clock.Advance(dadTransmits * retransmitTimer)
 	select {
-	case <-time.After(dadTransmits*retransmitTimer + defaultAsyncPositiveEventTimeout):
-		t.Fatal("timed out waiting for DAD resolution")
 	case e := <-ndpDisp.dadC:
 		if diff := checkDADEvent(e, nicID, addr.AddressWithPrefix.Address, &stack.DADSucceeded{}); diff != "" {
 			t.Errorf("dad event mismatch (-want +got):\n%s", diff)
 		}
+	default:
+		t.Fatal("timed out waiting for DAD resolution")
 	}
 	if addrs := s.AllAddresses()[nicID]; !containsV6Addr(addrs, addr.AddressWithPrefix) {
 		t.Fatalf("got s.AllAddresses()[%d] = %+v, want = %+v", nicID, addrs, addr)
diff --git a/pkg/tcpip/timer_test.go b/pkg/tcpip/timer_test.go
index 8c43dd627..ed1ed8ac6 100644
--- a/pkg/tcpip/timer_test.go
+++ b/pkg/tcpip/timer_test.go
@@ -129,10 +129,14 @@ func TestJobReschedule(t *testing.T) {
 	wg.Wait()
 }
 
+func stdClockWithAfter() (tcpip.Clock, func(time.Duration) <-chan time.Time) {
+	return tcpip.NewStdClock(), time.After
+}
+
 func TestJobExecution(t *testing.T) {
 	t.Parallel()
 
-	clock := tcpip.NewStdClock()
+	clock, after := stdClockWithAfter()
 	var lock sync.Mutex
 	ch := make(chan struct{})
 
@@ -144,7 +148,7 @@ func TestJobExecution(t *testing.T) {
 	// Wait for timer to fire.
 	select {
 	case <-ch:
-	case <-time.After(middleDuration):
+	case <-after(middleDuration):
 		t.Fatal("timed out waiting for timer to fire")
 	}
 
@@ -152,14 +156,14 @@ func TestJobExecution(t *testing.T) {
 	select {
 	case <-ch:
 		t.Fatal("no other timers should have fired")
-	case <-time.After(middleDuration):
+	case <-after(middleDuration):
 	}
 }
 
 func TestCancellableTimerResetFromLongDuration(t *testing.T) {
 	t.Parallel()
 
-	clock := tcpip.NewStdClock()
+	clock, after := stdClockWithAfter()
 	var lock sync.Mutex
 	ch := make(chan struct{})
 
@@ -175,7 +179,7 @@ func TestCancellableTimerResetFromLongDuration(t *testing.T) {
 	// Wait for timer to fire.
 	select {
 	case <-ch:
-	case <-time.After(middleDuration):
+	case <-after(middleDuration):
 		t.Fatal("timed out waiting for timer to fire")
 	}
 
@@ -183,14 +187,14 @@ func TestCancellableTimerResetFromLongDuration(t *testing.T) {
 	select {
 	case <-ch:
 		t.Fatal("no other timers should have fired")
-	case <-time.After(middleDuration):
+	case <-after(middleDuration):
 	}
 }
 
 func TestJobRescheduleFromShortDuration(t *testing.T) {
 	t.Parallel()
 
-	clock := tcpip.NewStdClock()
+	clock, after := stdClockWithAfter()
 	var lock sync.Mutex
 	ch := make(chan struct{})
 
@@ -204,7 +208,7 @@ func TestJobRescheduleFromShortDuration(t *testing.T) {
 	select {
 	case <-ch:
 		t.Fatal("timer fired after being stopped")
-	case <-time.After(middleDuration):
+	case <-after(middleDuration):
 	}
 
 	job.Schedule(shortDuration)
@@ -212,7 +216,7 @@ func TestJobRescheduleFromShortDuration(t *testing.T) {
 	// Wait for timer to fire.
 	select {
 	case <-ch:
-	case <-time.After(middleDuration):
+	case <-after(middleDuration):
 		t.Fatal("timed out waiting for timer to fire")
 	}
 
@@ -220,14 +224,14 @@ func TestJobRescheduleFromShortDuration(t *testing.T) {
 	select {
 	case <-ch:
 		t.Fatal("no other timers should have fired")
-	case <-time.After(middleDuration):
+	case <-after(middleDuration):
 	}
 }
 
 func TestJobImmediatelyCancel(t *testing.T) {
 	t.Parallel()
 
-	clock := tcpip.NewStdClock()
+	clock, after := stdClockWithAfter()
 	var lock sync.Mutex
 	ch := make(chan struct{})
 
@@ -243,14 +247,19 @@ func TestJobImmediatelyCancel(t *testing.T) {
 	select {
 	case <-ch:
 		t.Fatal("timer fired after being stopped")
-	case <-time.After(middleDuration):
+	case <-after(middleDuration):
 	}
 }
 
+func stdClockWithAfterAndSleep() (tcpip.Clock, func(time.Duration) <-chan time.Time, func(time.Duration)) {
+	clock, after := stdClockWithAfter()
+	return clock, after, time.Sleep
+}
+
 func TestJobCancelledRescheduleWithoutLock(t *testing.T) {
 	t.Parallel()
 
-	clock := tcpip.NewStdClock()
+	clock, after, sleep := stdClockWithAfterAndSleep()
 	var lock sync.Mutex
 	ch := make(chan struct{})
 
@@ -265,7 +274,7 @@ func TestJobCancelledRescheduleWithoutLock(t *testing.T) {
 
 		lock.Lock()
 		// Sleep until the timer fires and gets blocked trying to take the lock.
-		time.Sleep(middleDuration * 2)
+		sleep(middleDuration * 2)
 		job.Cancel()
 		lock.Unlock()
 	}
@@ -275,14 +284,14 @@ func TestJobCancelledRescheduleWithoutLock(t *testing.T) {
 	select {
 	case <-ch:
 		t.Fatal("timer fired after being stopped")
-	case <-time.After(middleDuration * 2):
+	case <-after(middleDuration * 2):
 	}
 }
 
 func TestManyCancellableTimerResetAfterBlockedOnLock(t *testing.T) {
 	t.Parallel()
 
-	clock := tcpip.NewStdClock()
+	clock, after, sleep := stdClockWithAfterAndSleep()
 	var lock sync.Mutex
 	ch := make(chan struct{})
 
@@ -291,7 +300,7 @@ func TestManyCancellableTimerResetAfterBlockedOnLock(t *testing.T) {
 	job.Schedule(shortDuration)
 	for i := 0; i < 10; i++ {
 		// Sleep until the timer fires and gets blocked trying to take the lock.
-		time.Sleep(middleDuration)
+		sleep(middleDuration)
 		job.Cancel()
 		job.Schedule(shortDuration)
 	}
@@ -300,7 +309,7 @@ func TestManyCancellableTimerResetAfterBlockedOnLock(t *testing.T) {
 	// Wait for double the duration for the last timer to fire.
 	select {
 	case <-ch:
-	case <-time.After(middleDuration):
+	case <-after(middleDuration):
 		t.Fatal("timed out waiting for timer to fire")
 	}
 
@@ -308,14 +317,14 @@ func TestManyCancellableTimerResetAfterBlockedOnLock(t *testing.T) {
 	select {
 	case <-ch:
 		t.Fatal("no other timers should have fired")
-	case <-time.After(middleDuration):
+	case <-after(middleDuration):
 	}
 }
 
 func TestManyJobReschedulesUnderLock(t *testing.T) {
 	t.Parallel()
 
-	clock := tcpip.NewStdClock()
+	clock, after := stdClockWithAfter()
 	var lock sync.Mutex
 	ch := make(chan struct{})
 
@@ -331,7 +340,7 @@ func TestManyJobReschedulesUnderLock(t *testing.T) {
 	// Wait for double the duration for the last timer to fire.
 	select {
 	case <-ch:
-	case <-time.After(middleDuration):
+	case <-after(middleDuration):
 		t.Fatal("timed out waiting for timer to fire")
 	}
 
@@ -339,6 +348,6 @@ func TestManyJobReschedulesUnderLock(t *testing.T) {
 	select {
 	case <-ch:
 		t.Fatal("no other timers should have fired")
-	case <-time.After(middleDuration):
+	case <-after(middleDuration):
 	}
 }
diff --git a/pkg/tcpip/transport/udp/BUILD b/pkg/tcpip/transport/udp/BUILD
index dd5c910ae..cdc344ab7 100644
--- a/pkg/tcpip/transport/udp/BUILD
+++ b/pkg/tcpip/transport/udp/BUILD
@@ -49,6 +49,7 @@ go_test(
         "//pkg/tcpip",
         "//pkg/tcpip/buffer",
         "//pkg/tcpip/checker",
+        "//pkg/tcpip/faketime",
         "//pkg/tcpip/header",
         "//pkg/tcpip/link/channel",
         "//pkg/tcpip/link/loopback",
diff --git a/pkg/tcpip/transport/udp/udp_test.go b/pkg/tcpip/transport/udp/udp_test.go
index 2e283e52b..4008cacf2 100644
--- a/pkg/tcpip/transport/udp/udp_test.go
+++ b/pkg/tcpip/transport/udp/udp_test.go
@@ -16,17 +16,16 @@ package udp_test
 
 import (
 	"bytes"
-	"context"
 	"fmt"
 	"io/ioutil"
 	"math/rand"
 	"testing"
-	"time"
 
 	"github.com/google/go-cmp/cmp"
 	"gvisor.dev/gvisor/pkg/tcpip"
 	"gvisor.dev/gvisor/pkg/tcpip/buffer"
 	"gvisor.dev/gvisor/pkg/tcpip/checker"
+	"gvisor.dev/gvisor/pkg/tcpip/faketime"
 	"gvisor.dev/gvisor/pkg/tcpip/header"
 	"gvisor.dev/gvisor/pkg/tcpip/link/channel"
 	"gvisor.dev/gvisor/pkg/tcpip/link/loopback"
@@ -298,16 +297,18 @@ type testContext struct {
 
 func newDualTestContext(t *testing.T, mtu uint32) *testContext {
 	t.Helper()
-	return newDualTestContextWithOptions(t, mtu, stack.Options{
-		NetworkProtocols:   []stack.NetworkProtocolFactory{ipv4.NewProtocol, ipv6.NewProtocol},
-		TransportProtocols: []stack.TransportProtocolFactory{udp.NewProtocol, icmp.NewProtocol6, icmp.NewProtocol4},
-		HandleLocal:        true,
-	})
+	return newDualTestContextWithHandleLocal(t, mtu, true)
 }
 
-func newDualTestContextWithOptions(t *testing.T, mtu uint32, options stack.Options) *testContext {
+func newDualTestContextWithHandleLocal(t *testing.T, mtu uint32, handleLocal bool) *testContext {
 	t.Helper()
 
+	options := stack.Options{
+		NetworkProtocols:   []stack.NetworkProtocolFactory{ipv4.NewProtocol, ipv6.NewProtocol},
+		TransportProtocols: []stack.TransportProtocolFactory{udp.NewProtocol, icmp.NewProtocol6, icmp.NewProtocol4},
+		HandleLocal:        handleLocal,
+		Clock:              &faketime.NullClock{},
+	}
 	s := stack.New(options)
 	ep := channel.New(256, mtu, "")
 	wep := stack.LinkEndpoint(ep)
@@ -378,9 +379,7 @@ func (c *testContext) createEndpointForFlow(flow testFlow) {
 func (c *testContext) getPacketAndVerify(flow testFlow, checkers ...checker.NetworkChecker) []byte {
 	c.t.Helper()
 
-	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
-	defer cancel()
-	p, ok := c.linkEP.ReadContext(ctx)
+	p, ok := c.linkEP.Read()
 	if !ok {
 		c.t.Fatalf("Packet wasn't written out")
 		return nil
@@ -534,7 +533,9 @@ func newMinPayload(minSize int) []byte {
 func TestBindToDeviceOption(t *testing.T) {
 	s := stack.New(stack.Options{
 		NetworkProtocols:   []stack.NetworkProtocolFactory{ipv4.NewProtocol},
-		TransportProtocols: []stack.TransportProtocolFactory{udp.NewProtocol}})
+		TransportProtocols: []stack.TransportProtocolFactory{udp.NewProtocol},
+		Clock:              &faketime.NullClock{},
+	})
 
 	ep, err := s.NewEndpoint(udp.ProtocolNumber, ipv4.ProtocolNumber, &waiter.Queue{})
 	if err != nil {
@@ -606,7 +607,7 @@ func testReadInternal(c *testContext, flow testFlow, packetShouldBeDropped, expe
 		case <-ch:
 			res, err = c.ep.Read(&buf, tcpip.ReadOptions{NeedRemoteAddr: true})
 
-		case <-time.After(300 * time.Millisecond):
+		default:
 			if packetShouldBeDropped {
 				return // expected to time out
 			}
@@ -820,11 +821,7 @@ func TestV4ReadSelfSource(t *testing.T) {
 		{"NoHandleLocal", true, &tcpip.ErrWouldBlock{}, 1},
 	} {
 		t.Run(tt.name, func(t *testing.T) {
-			c := newDualTestContextWithOptions(t, defaultMTU, stack.Options{
-				NetworkProtocols:   []stack.NetworkProtocolFactory{ipv4.NewProtocol, ipv6.NewProtocol},
-				TransportProtocols: []stack.TransportProtocolFactory{udp.NewProtocol},
-				HandleLocal:        tt.handleLocal,
-			})
+			c := newDualTestContextWithHandleLocal(t, defaultMTU, tt.handleLocal)
 			defer c.cleanup()
 
 			c.createEndpointForFlow(unicastV4)
@@ -1034,17 +1031,17 @@ func testWriteAndVerifyInternal(c *testContext, flow testFlow, setDest bool, che
 	payload := testWriteNoVerify(c, flow, setDest)
 	// Received the packet and check the payload.
 	b := c.getPacketAndVerify(flow, checkers...)
-	var udp header.UDP
+	var udpH header.UDP
 	if flow.isV4() {
-		udp = header.UDP(header.IPv4(b).Payload())
+		udpH = header.IPv4(b).Payload()
 	} else {
-		udp = header.UDP(header.IPv6(b).Payload())
+		udpH = header.IPv6(b).Payload()
 	}
-	if !bytes.Equal(payload, udp.Payload()) {
-		c.t.Fatalf("Bad payload: got %x, want %x", udp.Payload(), payload)
+	if !bytes.Equal(payload, udpH.Payload()) {
+		c.t.Fatalf("Bad payload: got %x, want %x", udpH.Payload(), payload)
 	}
 
-	return udp.SourcePort()
+	return udpH.SourcePort()
 }
 
 func testDualWrite(c *testContext) uint16 {
@@ -1198,7 +1195,7 @@ func TestWriteOnConnectedInvalidPort(t *testing.T) {
 			r.Reset(payload)
 			n, err := c.ep.Write(&r, writeOpts)
 			if err != nil {
-				c.t.Fatalf("c.ep.Write(...) = %+s, want nil", err)
+				c.t.Fatalf("c.ep.Write(...) = %s, want nil", err)
 			}
 			if got, want := n, int64(len(payload)); got != want {
 				c.t.Fatalf("c.ep.Write(...) wrote %d bytes, want %d bytes", got, want)
@@ -1614,6 +1611,7 @@ func TestTTL(t *testing.T) {
 				}
 				s := stack.New(stack.Options{
 					NetworkProtocols: []stack.NetworkProtocolFactory{p},
+					Clock:            &faketime.NullClock{},
 				})
 				ep := s.NetworkProtocolInstance(n).NewEndpoint(&testInterface{}, nil)
 				wantTTL = ep.DefaultTTL()
@@ -1759,7 +1757,7 @@ func TestReceiveTosTClass(t *testing.T) {
 					c.t.Errorf("got GetSockOptBool(%s) = %t, want = %t", name, v, false)
 				}
 
-				want := true
+				const want = true
 				optionSetter(want)
 
 				got := optionGetter()
@@ -1889,18 +1887,14 @@ func TestV4UnknownDestination(t *testing.T) {
 				}
 			}
 			if !tc.icmpRequired {
-				ctx, cancel := context.WithTimeout(context.Background(), time.Second)
-				defer cancel()
-				if p, ok := c.linkEP.ReadContext(ctx); ok {
+				if p, ok := c.linkEP.Read(); ok {
 					t.Fatalf("unexpected packet received: %+v", p)
 				}
 				return
 			}
 
 			// ICMP required.
-			ctx, cancel := context.WithTimeout(context.Background(), time.Second)
-			defer cancel()
-			p, ok := c.linkEP.ReadContext(ctx)
+			p, ok := c.linkEP.Read()
 			if !ok {
 				t.Fatalf("packet wasn't written out")
 				return
@@ -1987,18 +1981,14 @@ func TestV6UnknownDestination(t *testing.T) {
 				}
 			}
 			if !tc.icmpRequired {
-				ctx, cancel := context.WithTimeout(context.Background(), time.Second)
-				defer cancel()
-				if p, ok := c.linkEP.ReadContext(ctx); ok {
+				if p, ok := c.linkEP.Read(); ok {
 					t.Fatalf("unexpected packet received: %+v", p)
 				}
 				return
 			}
 
 			// ICMP required.
-			ctx, cancel := context.WithTimeout(context.Background(), time.Second)
-			defer cancel()
-			p, ok := c.linkEP.ReadContext(ctx)
+			p, ok := c.linkEP.Read()
 			if !ok {
 				t.Fatalf("packet wasn't written out")
 				return
@@ -2486,6 +2476,7 @@ func TestOutgoingSubnetBroadcast(t *testing.T) {
 			s := stack.New(stack.Options{
 				NetworkProtocols:   []stack.NetworkProtocolFactory{ipv4.NewProtocol, ipv6.NewProtocol},
 				TransportProtocols: []stack.TransportProtocolFactory{udp.NewProtocol},
+				Clock:              &faketime.NullClock{},
 			})
 			e := channel.New(0, defaultMTU, "")
 			if err := s.CreateNIC(nicID1, e); err != nil {