summaryrefslogtreecommitdiffhomepage
path: root/pkg
diff options
context:
space:
mode:
Diffstat (limited to 'pkg')
-rw-r--r--pkg/tcpip/network/ip/generic_multicast_protocol_test.go409
1 files changed, 169 insertions, 240 deletions
diff --git a/pkg/tcpip/network/ip/generic_multicast_protocol_test.go b/pkg/tcpip/network/ip/generic_multicast_protocol_test.go
index f56f7aa90..85593f211 100644
--- a/pkg/tcpip/network/ip/generic_multicast_protocol_test.go
+++ b/pkg/tcpip/network/ip/generic_multicast_protocol_test.go
@@ -37,46 +37,105 @@ const (
var _ ip.MulticastGroupProtocol = (*mockMulticastGroupProtocol)(nil)
-type mockMulticastGroupProtocol struct {
- t *testing.T
-
- mu sync.RWMutex
+type mockMulticastGroupProtocolProtectedFields struct {
+ sync.RWMutex
- // Must only be accessed with mu held.
+ genericMulticastGroup ip.GenericMulticastProtocolState
sendReportGroupAddrCount map[tcpip.Address]int
+ sendLeaveGroupAddrCount map[tcpip.Address]int
+ makeQueuePackets bool
+ disabled bool
+}
- // Must only be accessed with mu held.
- sendLeaveGroupAddrCount map[tcpip.Address]int
-
- // Must only be accessed with mu held.
- makeQueuePackets bool
+type mockMulticastGroupProtocol struct {
+ t *testing.T
- // Must only be accessed with mu held.
- disabled bool
+ mu mockMulticastGroupProtocolProtectedFields
}
-func (m *mockMulticastGroupProtocol) init() {
+func (m *mockMulticastGroupProtocol) init(opts ip.GenericMulticastProtocolOptions) {
m.mu.Lock()
defer m.mu.Unlock()
m.initLocked()
+ opts.Protocol = m
+ m.mu.genericMulticastGroup.Init(&m.mu.RWMutex, opts)
}
func (m *mockMulticastGroupProtocol) initLocked() {
- m.sendReportGroupAddrCount = make(map[tcpip.Address]int)
- m.sendLeaveGroupAddrCount = make(map[tcpip.Address]int)
+ m.mu.sendReportGroupAddrCount = make(map[tcpip.Address]int)
+ m.mu.sendLeaveGroupAddrCount = make(map[tcpip.Address]int)
}
func (m *mockMulticastGroupProtocol) setEnabled(v bool) {
m.mu.Lock()
defer m.mu.Unlock()
- m.disabled = !v
+ m.mu.disabled = !v
+}
+
+func (m *mockMulticastGroupProtocol) setQueuePackets(v bool) {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ m.mu.makeQueuePackets = v
+}
+
+func (m *mockMulticastGroupProtocol) joinGroup(addr tcpip.Address) {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ m.mu.genericMulticastGroup.JoinGroupLocked(addr)
+}
+
+func (m *mockMulticastGroupProtocol) leaveGroup(addr tcpip.Address) bool {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ return m.mu.genericMulticastGroup.LeaveGroupLocked(addr)
+}
+
+func (m *mockMulticastGroupProtocol) handleReport(addr tcpip.Address) {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ m.mu.genericMulticastGroup.HandleReportLocked(addr)
+}
+
+func (m *mockMulticastGroupProtocol) handleQuery(addr tcpip.Address, maxRespTime time.Duration) {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ m.mu.genericMulticastGroup.HandleQueryLocked(addr, maxRespTime)
+}
+
+func (m *mockMulticastGroupProtocol) isLocallyJoined(addr tcpip.Address) bool {
+ m.mu.RLock()
+ defer m.mu.RUnlock()
+ return m.mu.genericMulticastGroup.IsLocallyJoinedRLocked(addr)
+}
+
+func (m *mockMulticastGroupProtocol) makeAllNonMember() {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ m.mu.genericMulticastGroup.MakeAllNonMemberLocked()
+}
+
+func (m *mockMulticastGroupProtocol) initializeGroups() {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ m.mu.genericMulticastGroup.InitializeGroupsLocked()
+}
+
+func (m *mockMulticastGroupProtocol) sendQueuedReports() {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ m.mu.genericMulticastGroup.SendQueuedReportsLocked()
}
// Enabled implements ip.MulticastGroupProtocol.
//
// Precondition: m.mu must be read locked.
func (m *mockMulticastGroupProtocol) Enabled() bool {
- return !m.disabled
+ if m.mu.TryLock() {
+ m.mu.Unlock()
+ m.t.Fatal("got write lock, expected to not take the lock; generic multicast protocol must take the read or write lock before calling Enabled")
+ }
+
+ return !m.mu.disabled
}
// SendReport implements ip.MulticastGroupProtocol.
@@ -92,8 +151,8 @@ func (m *mockMulticastGroupProtocol) SendReport(groupAddress tcpip.Address) (boo
m.t.Fatalf("got read lock, expected to not take the lock; generic multicast protocol must take the write lock before sending report for %s", groupAddress)
}
- m.sendReportGroupAddrCount[groupAddress]++
- return !m.makeQueuePackets, nil
+ m.mu.sendReportGroupAddrCount[groupAddress]++
+ return !m.mu.makeQueuePackets, nil
}
// SendLeave implements ip.MulticastGroupProtocol.
@@ -109,7 +168,7 @@ func (m *mockMulticastGroupProtocol) SendLeave(groupAddress tcpip.Address) *tcpi
m.t.Fatalf("got read lock, expected to not take the lock; generic multicast protocol must take the write lock before sending leave for %s", groupAddress)
}
- m.sendLeaveGroupAddrCount[groupAddress]++
+ m.mu.sendLeaveGroupAddrCount[groupAddress]++
return nil
}
@@ -129,16 +188,19 @@ func (m *mockMulticastGroupProtocol) check(sendReportGroupAddresses []tcpip.Addr
diff := cmp.Diff(
&mockMulticastGroupProtocol{
- sendReportGroupAddrCount: sendReportGroupAddrCount,
- sendLeaveGroupAddrCount: sendLeaveGroupAddrCount,
+ mu: mockMulticastGroupProtocolProtectedFields{
+ sendReportGroupAddrCount: sendReportGroupAddrCount,
+ sendLeaveGroupAddrCount: sendLeaveGroupAddrCount,
+ },
},
m,
cmp.AllowUnexported(mockMulticastGroupProtocol{}),
+ cmp.AllowUnexported(mockMulticastGroupProtocolProtectedFields{}),
// ignore mockMulticastGroupProtocol.mu and mockMulticastGroupProtocol.t
cmp.FilterPath(
func(p cmp.Path) bool {
switch p.Last().String() {
- case ".mu", ".t", ".makeQueuePackets", ".disabled":
+ case ".RWMutex", ".t", ".makeQueuePackets", ".disabled", ".genericMulticastGroup":
return true
}
return false
@@ -170,24 +232,19 @@ func TestJoinGroup(t *testing.T) {
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
- var g ip.GenericMulticastProtocolState
mgp := mockMulticastGroupProtocol{t: t}
clock := faketime.NewManualClock()
- mgp.init()
- g.Init(&mgp.mu, ip.GenericMulticastProtocolOptions{
+ mgp.init(ip.GenericMulticastProtocolOptions{
Rand: rand.New(rand.NewSource(0)),
Clock: clock,
- Protocol: &mgp,
MaxUnsolicitedReportDelay: maxUnsolicitedReportDelay,
AllNodesAddress: addr2,
})
// Joining a group should send a report immediately and another after
// a random interval between 0 and the maximum unsolicited report delay.
- mgp.mu.Lock()
- g.JoinGroupLocked(test.addr)
- mgp.mu.Unlock()
+ mgp.joinGroup(test.addr)
if test.shouldSendReports {
if diff := mgp.check([]tcpip.Address{test.addr} /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Errorf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
@@ -229,22 +286,17 @@ func TestLeaveGroup(t *testing.T) {
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
- var g ip.GenericMulticastProtocolState
mgp := mockMulticastGroupProtocol{t: t}
clock := faketime.NewManualClock()
- mgp.init()
- g.Init(&mgp.mu, ip.GenericMulticastProtocolOptions{
+ mgp.init(ip.GenericMulticastProtocolOptions{
Rand: rand.New(rand.NewSource(1)),
Clock: clock,
- Protocol: &mgp,
MaxUnsolicitedReportDelay: maxUnsolicitedReportDelay,
AllNodesAddress: addr2,
})
- mgp.mu.Lock()
- g.JoinGroupLocked(test.addr)
- mgp.mu.Unlock()
+ mgp.joinGroup(test.addr)
if test.shouldSendMessages {
if diff := mgp.check([]tcpip.Address{test.addr} /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Fatalf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
@@ -254,11 +306,9 @@ func TestLeaveGroup(t *testing.T) {
// Leaving a group should send a leave report immediately and cancel any
// delayed reports.
{
- mgp.mu.Lock()
- res := g.LeaveGroupLocked(test.addr)
- mgp.mu.Unlock()
- if !res {
- t.Fatalf("got g.LeaveGroupLocked(%s) = false, want = true", test.addr)
+
+ if !mgp.leaveGroup(test.addr) {
+ t.Fatalf("got mgp.leaveGroup(%s) = false, want = true", test.addr)
}
}
if test.shouldSendMessages {
@@ -313,43 +363,32 @@ func TestHandleReport(t *testing.T) {
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
- var g ip.GenericMulticastProtocolState
mgp := mockMulticastGroupProtocol{t: t}
clock := faketime.NewManualClock()
- mgp.init()
- g.Init(&mgp.mu, ip.GenericMulticastProtocolOptions{
+ mgp.init(ip.GenericMulticastProtocolOptions{
Rand: rand.New(rand.NewSource(2)),
Clock: clock,
- Protocol: &mgp,
MaxUnsolicitedReportDelay: maxUnsolicitedReportDelay,
AllNodesAddress: addr3,
})
- mgp.mu.Lock()
- g.JoinGroupLocked(addr1)
- mgp.mu.Unlock()
+ mgp.joinGroup(addr1)
if diff := mgp.check([]tcpip.Address{addr1} /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Fatalf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
}
- mgp.mu.Lock()
- g.JoinGroupLocked(addr2)
- mgp.mu.Unlock()
+ mgp.joinGroup(addr2)
if diff := mgp.check([]tcpip.Address{addr2} /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Fatalf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
}
- mgp.mu.Lock()
- g.JoinGroupLocked(addr3)
- mgp.mu.Unlock()
+ mgp.joinGroup(addr3)
if diff := mgp.check(nil /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Fatalf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
}
// Receiving a report for a group we have a timer scheduled for should
// cancel our delayed report timer for the group.
- mgp.mu.Lock()
- g.HandleReportLocked(test.reportAddr)
- mgp.mu.Unlock()
+ mgp.handleReport(test.reportAddr)
if len(test.expectReportsFor) != 0 {
// Generic multicast protocol timers are expected to take the job mutex.
clock.Advance(maxUnsolicitedReportDelay)
@@ -408,34 +447,25 @@ func TestHandleQuery(t *testing.T) {
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
- var g ip.GenericMulticastProtocolState
mgp := mockMulticastGroupProtocol{t: t}
clock := faketime.NewManualClock()
- mgp.init()
- g.Init(&mgp.mu, ip.GenericMulticastProtocolOptions{
+ mgp.init(ip.GenericMulticastProtocolOptions{
Rand: rand.New(rand.NewSource(3)),
Clock: clock,
- Protocol: &mgp,
MaxUnsolicitedReportDelay: maxUnsolicitedReportDelay,
AllNodesAddress: addr3,
})
- mgp.mu.Lock()
- g.JoinGroupLocked(addr1)
- mgp.mu.Unlock()
+ mgp.joinGroup(addr1)
if diff := mgp.check([]tcpip.Address{addr1} /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Fatalf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
}
- mgp.mu.Lock()
- g.JoinGroupLocked(addr2)
- mgp.mu.Unlock()
+ mgp.joinGroup(addr2)
if diff := mgp.check([]tcpip.Address{addr2} /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Fatalf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
}
- mgp.mu.Lock()
- g.JoinGroupLocked(addr3)
- mgp.mu.Unlock()
+ mgp.joinGroup(addr3)
if diff := mgp.check(nil /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Fatalf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
}
@@ -447,9 +477,7 @@ func TestHandleQuery(t *testing.T) {
// Receiving a query should make us schedule a new delayed report if it
// is a query directed at us or a general query.
- mgp.mu.Lock()
- g.HandleQueryLocked(test.queryAddr, test.maxDelay)
- mgp.mu.Unlock()
+ mgp.handleQuery(test.queryAddr, test.maxDelay)
if len(test.expectReportsFor) != 0 {
clock.Advance(test.maxDelay)
if diff := mgp.check(test.expectReportsFor /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
@@ -467,40 +495,27 @@ func TestHandleQuery(t *testing.T) {
}
func TestJoinCount(t *testing.T) {
- var g ip.GenericMulticastProtocolState
mgp := mockMulticastGroupProtocol{t: t}
clock := faketime.NewManualClock()
- mgp.init()
- g.Init(&mgp.mu, ip.GenericMulticastProtocolOptions{
+ mgp.init(ip.GenericMulticastProtocolOptions{
Rand: rand.New(rand.NewSource(4)),
Clock: clock,
- Protocol: &mgp,
MaxUnsolicitedReportDelay: time.Second,
})
// Set the join count to 2 for a group.
- {
- mgp.mu.Lock()
- g.JoinGroupLocked(addr1)
- res := g.IsLocallyJoinedRLocked(addr1)
- mgp.mu.Unlock()
- if !res {
- t.Fatalf("got g.IsLocallyJoinedRLocked(%s) = false, want = true", addr1)
- }
+ mgp.joinGroup(addr1)
+ if !mgp.isLocallyJoined(addr1) {
+ t.Fatalf("got mgp.isLocallyJoined(%s) = false, want = true", addr1)
}
// Only the first join should trigger a report to be sent.
if diff := mgp.check([]tcpip.Address{addr1} /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Fatalf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
}
- {
- mgp.mu.Lock()
- g.JoinGroupLocked(addr1)
- res := g.IsLocallyJoinedRLocked(addr1)
- mgp.mu.Unlock()
- if !res {
- t.Errorf("got g.IsLocallyJoinedRLocked(%s) = false, want = true", addr1)
- }
+ mgp.joinGroup(addr1)
+ if !mgp.isLocallyJoined(addr1) {
+ t.Errorf("got mgp.isLocallyJoined(%s) = false, want = true", addr1)
}
if diff := mgp.check(nil /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Errorf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
@@ -510,17 +525,11 @@ func TestJoinCount(t *testing.T) {
}
// Group should still be considered joined after leaving once.
- {
- mgp.mu.Lock()
- leaveGroupRes := g.LeaveGroupLocked(addr1)
- isLocallyJoined := g.IsLocallyJoinedRLocked(addr1)
- mgp.mu.Unlock()
- if !leaveGroupRes {
- t.Errorf("got g.LeaveGroupLocked(%s) = false, want = true", addr1)
- }
- if !isLocallyJoined {
- t.Errorf("got g.IsLocallyJoinedRLocked(%s) = false, want = true", addr1)
- }
+ if !mgp.leaveGroup(addr1) {
+ t.Errorf("got mgp.leaveGroup(%s) = false, want = true", addr1)
+ }
+ if !mgp.isLocallyJoined(addr1) {
+ t.Errorf("got mgp.isLocallyJoined(%s) = false, want = true", addr1)
}
// A leave report should only be sent once the join count reaches 0.
if diff := mgp.check(nil /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
@@ -531,17 +540,11 @@ func TestJoinCount(t *testing.T) {
}
// Leaving once more should actually remove us from the group.
- {
- mgp.mu.Lock()
- leaveGroupRes := g.LeaveGroupLocked(addr1)
- isLocallyJoined := g.IsLocallyJoinedRLocked(addr1)
- mgp.mu.Unlock()
- if !leaveGroupRes {
- t.Errorf("got g.LeaveGroupLocked(%s) = false, want = true", addr1)
- }
- if isLocallyJoined {
- t.Errorf("got g.IsLocallyJoinedRLocked(%s) = true, want = false", addr1)
- }
+ if !mgp.leaveGroup(addr1) {
+ t.Errorf("got mgp.leaveGroup(%s) = false, want = true", addr1)
+ }
+ if mgp.isLocallyJoined(addr1) {
+ t.Errorf("got mgp.isLocallyJoined(%s) = true, want = false", addr1)
}
if diff := mgp.check(nil /* sendReportGroupAddresses */, []tcpip.Address{addr1} /* sendLeaveGroupAddresses */); diff != "" {
t.Errorf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
@@ -552,17 +555,11 @@ func TestJoinCount(t *testing.T) {
// Group should no longer be joined so we should not have anything to
// leave.
- {
- mgp.mu.Lock()
- leaveGroupRes := g.LeaveGroupLocked(addr1)
- isLocallyJoined := g.IsLocallyJoinedRLocked(addr1)
- mgp.mu.Unlock()
- if leaveGroupRes {
- t.Errorf("got g.LeaveGroupLocked(%s) = true, want = false", addr1)
- }
- if isLocallyJoined {
- t.Errorf("got g.IsLocallyJoinedRLocked(%s) = true, want = false", addr1)
- }
+ if mgp.leaveGroup(addr1) {
+ t.Errorf("got mgp.leaveGroup(%s) = true, want = false", addr1)
+ }
+ if mgp.isLocallyJoined(addr1) {
+ t.Errorf("got mgp.isLocallyJoined(%s) = true, want = false", addr1)
}
if diff := mgp.check(nil /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Errorf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
@@ -578,43 +575,32 @@ func TestJoinCount(t *testing.T) {
}
func TestMakeAllNonMemberAndInitialize(t *testing.T) {
- var g ip.GenericMulticastProtocolState
mgp := mockMulticastGroupProtocol{t: t}
clock := faketime.NewManualClock()
- mgp.init()
- g.Init(&mgp.mu, ip.GenericMulticastProtocolOptions{
+ mgp.init(ip.GenericMulticastProtocolOptions{
Rand: rand.New(rand.NewSource(3)),
Clock: clock,
- Protocol: &mgp,
MaxUnsolicitedReportDelay: maxUnsolicitedReportDelay,
AllNodesAddress: addr3,
})
- mgp.mu.Lock()
- g.JoinGroupLocked(addr1)
- mgp.mu.Unlock()
+ mgp.joinGroup(addr1)
if diff := mgp.check([]tcpip.Address{addr1} /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Fatalf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
}
- mgp.mu.Lock()
- g.JoinGroupLocked(addr2)
- mgp.mu.Unlock()
+ mgp.joinGroup(addr2)
if diff := mgp.check([]tcpip.Address{addr2} /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Fatalf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
}
- mgp.mu.Lock()
- g.JoinGroupLocked(addr3)
- mgp.mu.Unlock()
+ mgp.joinGroup(addr3)
if diff := mgp.check(nil /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Fatalf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
}
// Should send the leave reports for each but still consider them locally
// joined.
- mgp.mu.Lock()
- g.MakeAllNonMemberLocked()
- mgp.mu.Unlock()
+ mgp.makeAllNonMember()
if diff := mgp.check(nil /* sendReportGroupAddresses */, []tcpip.Address{addr1, addr2} /* sendLeaveGroupAddresses */); diff != "" {
t.Errorf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
}
@@ -624,18 +610,13 @@ func TestMakeAllNonMemberAndInitialize(t *testing.T) {
t.Errorf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
}
for _, group := range []tcpip.Address{addr1, addr2, addr3} {
- mgp.mu.RLock()
- res := g.IsLocallyJoinedRLocked(group)
- mgp.mu.RUnlock()
- if !res {
- t.Fatalf("got g.IsLocallyJoinedRLocked(%s) = false, want = true", group)
+ if !mgp.isLocallyJoined(group) {
+ t.Fatalf("got mgp.isLocallyJoined(%s) = false, want = true", group)
}
}
// Should send the initial set of unsolcited reports.
- mgp.mu.Lock()
- g.InitializeGroupsLocked()
- mgp.mu.Unlock()
+ mgp.initializeGroups()
if diff := mgp.check([]tcpip.Address{addr1, addr2} /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Errorf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
}
@@ -654,49 +635,34 @@ func TestMakeAllNonMemberAndInitialize(t *testing.T) {
// TestGroupStateNonMember tests that groups do not send packets when in the
// non-member state, but are still considered locally joined.
func TestGroupStateNonMember(t *testing.T) {
- var g ip.GenericMulticastProtocolState
mgp := mockMulticastGroupProtocol{t: t}
clock := faketime.NewManualClock()
- mgp.init()
- mgp.setEnabled(false)
- g.Init(&mgp.mu, ip.GenericMulticastProtocolOptions{
+ mgp.init(ip.GenericMulticastProtocolOptions{
Rand: rand.New(rand.NewSource(3)),
Clock: clock,
- Protocol: &mgp,
MaxUnsolicitedReportDelay: maxUnsolicitedReportDelay,
})
+ mgp.setEnabled(false)
// Joining groups should not send any reports.
- {
- mgp.mu.Lock()
- g.JoinGroupLocked(addr1)
- res := g.IsLocallyJoinedRLocked(addr1)
- mgp.mu.Unlock()
- if !res {
- t.Fatalf("got g.IsLocallyJoinedRLocked(%s) = false, want = true", addr1)
- }
+ mgp.joinGroup(addr1)
+ if !mgp.isLocallyJoined(addr1) {
+ t.Fatalf("got mgp.isLocallyJoined(%s) = false, want = true", addr1)
}
if diff := mgp.check(nil /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Fatalf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
}
- {
- mgp.mu.Lock()
- g.JoinGroupLocked(addr2)
- res := g.IsLocallyJoinedRLocked(addr2)
- mgp.mu.Unlock()
- if !res {
- t.Fatalf("got g.IsLocallyJoinedRLocked(%s) = false, want = true", addr2)
- }
+ mgp.joinGroup(addr2)
+ if !mgp.isLocallyJoined(addr1) {
+ t.Fatalf("got mgp.isLocallyJoined(%s) = false, want = true", addr2)
}
if diff := mgp.check(nil /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Fatalf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
}
// Receiving a query should not send any reports.
- mgp.mu.Lock()
- g.HandleQueryLocked(addr1, time.Nanosecond)
- mgp.mu.Unlock()
+ mgp.handleQuery(addr1, time.Nanosecond)
// Generic multicast protocol timers are expected to take the job mutex.
clock.Advance(time.Nanosecond)
if diff := mgp.check(nil /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
@@ -704,21 +670,11 @@ func TestGroupStateNonMember(t *testing.T) {
}
// Leaving groups should not send any leave messages.
- {
- mgp.mu.Lock()
- addr2LeaveRes := g.LeaveGroupLocked(addr2)
- addr1IsJoined := g.IsLocallyJoinedRLocked(addr1)
- addr2IsJoined := g.IsLocallyJoinedRLocked(addr2)
- mgp.mu.Unlock()
- if !addr2LeaveRes {
- t.Errorf("got g.LeaveGroupLocked(%s) = false, want = true", addr2)
- }
- if !addr1IsJoined {
- t.Errorf("got g.IsLocallyJoinedRLocked(%s) = false, want = true", addr1)
- }
- if addr2IsJoined {
- t.Errorf("got g.IsLocallyJoinedRLocked(%s) = true, want = false", addr2)
- }
+ if !mgp.leaveGroup(addr1) {
+ t.Errorf("got mgp.leaveGroup(%s) = false, want = true", addr2)
+ }
+ if mgp.isLocallyJoined(addr1) {
+ t.Errorf("got mgp.isLocallyJoined(%s) = true, want = false", addr2)
}
if diff := mgp.check(nil /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Fatalf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
@@ -731,23 +687,18 @@ func TestGroupStateNonMember(t *testing.T) {
}
func TestQueuedPackets(t *testing.T) {
- var g ip.GenericMulticastProtocolState
- var mgp mockMulticastGroupProtocol
- mgp.init()
clock := faketime.NewManualClock()
- g.Init(&mgp.mu, ip.GenericMulticastProtocolOptions{
+ mgp := mockMulticastGroupProtocol{t: t}
+ mgp.init(ip.GenericMulticastProtocolOptions{
Rand: rand.New(rand.NewSource(4)),
Clock: clock,
- Protocol: &mgp,
MaxUnsolicitedReportDelay: maxUnsolicitedReportDelay,
})
// Joining should trigger a SendReport, but mgp should report that we did not
// send the packet.
- mgp.mu.Lock()
- mgp.makeQueuePackets = true
- g.JoinGroupLocked(addr1)
- mgp.mu.Unlock()
+ mgp.setQueuePackets(true)
+ mgp.joinGroup(addr1)
if diff := mgp.check([]tcpip.Address{addr1} /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Fatalf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
}
@@ -760,10 +711,8 @@ func TestQueuedPackets(t *testing.T) {
}
// Mock being able to successfully send the report.
- mgp.mu.Lock()
- mgp.makeQueuePackets = false
- g.SendQueuedReportsLocked()
- mgp.mu.Unlock()
+ mgp.setQueuePackets(false)
+ mgp.sendQueuedReports()
if diff := mgp.check([]tcpip.Address{addr1} /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Errorf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
}
@@ -775,19 +724,15 @@ func TestQueuedPackets(t *testing.T) {
}
// Should not have anything else to send (we should be idle).
- mgp.mu.Lock()
- g.SendQueuedReportsLocked()
- mgp.mu.Unlock()
+ mgp.sendQueuedReports()
clock.Advance(time.Hour)
if diff := mgp.check(nil /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Fatalf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
}
// Receive a query but mock being unable to send reports again.
- mgp.mu.Lock()
- mgp.makeQueuePackets = true
- g.HandleQueryLocked(addr1, time.Nanosecond)
- mgp.mu.Unlock()
+ mgp.setQueuePackets(true)
+ mgp.handleQuery(addr1, time.Nanosecond)
clock.Advance(time.Nanosecond)
if diff := mgp.check([]tcpip.Address{addr1} /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Errorf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
@@ -795,28 +740,22 @@ func TestQueuedPackets(t *testing.T) {
// Mock being able to send reports again - we should have a packet queued to
// send.
- mgp.mu.Lock()
- mgp.makeQueuePackets = false
- g.SendQueuedReportsLocked()
- mgp.mu.Unlock()
+ mgp.setQueuePackets(false)
+ mgp.sendQueuedReports()
if diff := mgp.check([]tcpip.Address{addr1} /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Errorf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
}
// Should not have anything else to send.
- mgp.mu.Lock()
- g.SendQueuedReportsLocked()
- mgp.mu.Unlock()
+ mgp.sendQueuedReports()
clock.Advance(time.Hour)
if diff := mgp.check(nil /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Fatalf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
}
// Receive a query again, but mock being unable to send reports.
- mgp.mu.Lock()
- mgp.makeQueuePackets = true
- g.HandleQueryLocked(addr1, time.Nanosecond)
- mgp.mu.Unlock()
+ mgp.setQueuePackets(true)
+ mgp.handleQuery(addr1, time.Nanosecond)
clock.Advance(time.Nanosecond)
if diff := mgp.check([]tcpip.Address{addr1} /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Errorf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
@@ -825,10 +764,8 @@ func TestQueuedPackets(t *testing.T) {
// Receiving a report should should transition us into the idle member state,
// even if we had a packet queued. We should no longer have any packets to
// send.
- mgp.mu.Lock()
- g.HandleReportLocked(addr1)
- g.SendQueuedReportsLocked()
- mgp.mu.Unlock()
+ mgp.handleReport(addr1)
+ mgp.sendQueuedReports()
clock.Advance(time.Hour)
if diff := mgp.check(nil /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Fatalf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
@@ -836,27 +773,21 @@ func TestQueuedPackets(t *testing.T) {
// When we fail to send the initial set of reports, incoming reports should
// not affect a newly joined group's reports from being sent.
- mgp.mu.Lock()
- mgp.makeQueuePackets = true
- g.JoinGroupLocked(addr2)
- mgp.mu.Unlock()
+ mgp.setQueuePackets(true)
+ mgp.joinGroup(addr2)
if diff := mgp.check([]tcpip.Address{addr2} /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Fatalf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
}
- mgp.mu.Lock()
- g.HandleReportLocked(addr2)
+ mgp.handleReport(addr2)
// Attempting to send queued reports while still unable to send reports should
// not change the host state.
- g.SendQueuedReportsLocked()
- mgp.mu.Unlock()
+ mgp.sendQueuedReports()
if diff := mgp.check([]tcpip.Address{addr2} /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Fatalf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
}
// Mock being able to successfully send the report.
- mgp.mu.Lock()
- mgp.makeQueuePackets = false
- g.SendQueuedReportsLocked()
- mgp.mu.Unlock()
+ mgp.setQueuePackets(false)
+ mgp.sendQueuedReports()
if diff := mgp.check([]tcpip.Address{addr2} /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Errorf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
}
@@ -867,9 +798,7 @@ func TestQueuedPackets(t *testing.T) {
}
// Should not have anything else to send.
- mgp.mu.Lock()
- g.SendQueuedReportsLocked()
- mgp.mu.Unlock()
+ mgp.sendQueuedReports()
clock.Advance(time.Hour)
if diff := mgp.check(nil /* sendReportGroupAddresses */, nil /* sendLeaveGroupAddresses */); diff != "" {
t.Fatalf("mockMulticastGroupProtocol mismatch (-want +got):\n%s", diff)
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-19 00:46:48 +0000