github.com/zhiqiangxu/go-ethereum@v1.9.16-0.20210824055606-be91cfdebc48/p2p/discover/v5_udp_test.go (about) 1 // Copyright 2019 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 package discover 18 19 import ( 20 "bytes" 21 "crypto/ecdsa" 22 "encoding/binary" 23 "fmt" 24 "math/rand" 25 "net" 26 "reflect" 27 "testing" 28 "time" 29 30 "github.com/zhiqiangxu/go-ethereum/internal/testlog" 31 "github.com/zhiqiangxu/go-ethereum/log" 32 "github.com/zhiqiangxu/go-ethereum/p2p/enode" 33 "github.com/zhiqiangxu/go-ethereum/p2p/enr" 34 "github.com/zhiqiangxu/go-ethereum/rlp" 35 ) 36 37 // Real sockets, real crypto: this test checks end-to-end connectivity for UDPv5. 38 func TestEndToEndV5(t *testing.T) { 39 t.Parallel() 40 41 var nodes []*UDPv5 42 for i := 0; i < 5; i++ { 43 var cfg Config 44 if len(nodes) > 0 { 45 bn := nodes[0].Self() 46 cfg.Bootnodes = []*enode.Node{bn} 47 } 48 node := startLocalhostV5(t, cfg) 49 nodes = append(nodes, node) 50 defer node.Close() 51 } 52 53 last := nodes[len(nodes)-1] 54 target := nodes[rand.Intn(len(nodes)-2)].Self() 55 results := last.Lookup(target.ID()) 56 if len(results) == 0 || results[0].ID() != target.ID() { 57 t.Fatalf("lookup returned wrong results: %v", results) 58 } 59 } 60 61 func startLocalhostV5(t *testing.T, cfg Config) *UDPv5 { 62 cfg.PrivateKey = newkey() 63 db, _ := enode.OpenDB("") 64 ln := enode.NewLocalNode(db, cfg.PrivateKey) 65 66 // Prefix logs with node ID. 67 lprefix := fmt.Sprintf("(%s)", ln.ID().TerminalString()) 68 lfmt := log.TerminalFormat(false) 69 cfg.Log = testlog.Logger(t, log.LvlTrace) 70 cfg.Log.SetHandler(log.FuncHandler(func(r *log.Record) error { 71 t.Logf("%s %s", lprefix, lfmt.Format(r)) 72 return nil 73 })) 74 75 // Listen. 76 socket, err := net.ListenUDP("udp4", &net.UDPAddr{IP: net.IP{127, 0, 0, 1}}) 77 if err != nil { 78 t.Fatal(err) 79 } 80 realaddr := socket.LocalAddr().(*net.UDPAddr) 81 ln.SetStaticIP(realaddr.IP) 82 ln.Set(enr.UDP(realaddr.Port)) 83 udp, err := ListenV5(socket, ln, cfg) 84 if err != nil { 85 t.Fatal(err) 86 } 87 return udp 88 } 89 90 // This test checks that incoming PING calls are handled correctly. 91 func TestUDPv5_pingHandling(t *testing.T) { 92 t.Parallel() 93 test := newUDPV5Test(t) 94 defer test.close() 95 96 test.packetIn(&pingV5{ReqID: []byte("foo")}) 97 test.waitPacketOut(func(p *pongV5, addr *net.UDPAddr, authTag []byte) { 98 if !bytes.Equal(p.ReqID, []byte("foo")) { 99 t.Error("wrong request ID in response:", p.ReqID) 100 } 101 if p.ENRSeq != test.table.self().Seq() { 102 t.Error("wrong ENR sequence number in response:", p.ENRSeq) 103 } 104 }) 105 } 106 107 // This test checks that incoming 'unknown' packets trigger the handshake. 108 func TestUDPv5_unknownPacket(t *testing.T) { 109 t.Parallel() 110 test := newUDPV5Test(t) 111 defer test.close() 112 113 authTag := [12]byte{1, 2, 3} 114 check := func(p *whoareyouV5, wantSeq uint64) { 115 t.Helper() 116 if !bytes.Equal(p.AuthTag, authTag[:]) { 117 t.Error("wrong token in WHOAREYOU:", p.AuthTag, authTag[:]) 118 } 119 if p.IDNonce == ([32]byte{}) { 120 t.Error("all zero ID nonce") 121 } 122 if p.RecordSeq != wantSeq { 123 t.Errorf("wrong record seq %d in WHOAREYOU, want %d", p.RecordSeq, wantSeq) 124 } 125 } 126 127 // Unknown packet from unknown node. 128 test.packetIn(&unknownV5{AuthTag: authTag[:]}) 129 test.waitPacketOut(func(p *whoareyouV5, addr *net.UDPAddr, _ []byte) { 130 check(p, 0) 131 }) 132 133 // Make node known. 134 n := test.getNode(test.remotekey, test.remoteaddr).Node() 135 test.table.addSeenNode(wrapNode(n)) 136 137 test.packetIn(&unknownV5{AuthTag: authTag[:]}) 138 test.waitPacketOut(func(p *whoareyouV5, addr *net.UDPAddr, _ []byte) { 139 check(p, n.Seq()) 140 }) 141 } 142 143 // This test checks that incoming FINDNODE calls are handled correctly. 144 func TestUDPv5_findnodeHandling(t *testing.T) { 145 t.Parallel() 146 test := newUDPV5Test(t) 147 defer test.close() 148 149 // Create test nodes and insert them into the table. 150 nodes := nodesAtDistance(test.table.self().ID(), 253, 10) 151 fillTable(test.table, wrapNodes(nodes)) 152 153 // Requesting with distance zero should return the node's own record. 154 test.packetIn(&findnodeV5{ReqID: []byte{0}, Distance: 0}) 155 test.expectNodes([]byte{0}, 1, []*enode.Node{test.udp.Self()}) 156 157 // Requesting with distance > 256 caps it at 256. 158 test.packetIn(&findnodeV5{ReqID: []byte{1}, Distance: 4234098}) 159 test.expectNodes([]byte{1}, 1, nil) 160 161 // This request gets no nodes because the corresponding bucket is empty. 162 test.packetIn(&findnodeV5{ReqID: []byte{2}, Distance: 254}) 163 test.expectNodes([]byte{2}, 1, nil) 164 165 // This request gets all test nodes. 166 test.packetIn(&findnodeV5{ReqID: []byte{3}, Distance: 253}) 167 test.expectNodes([]byte{3}, 4, nodes) 168 } 169 170 func (test *udpV5Test) expectNodes(wantReqID []byte, wantTotal uint8, wantNodes []*enode.Node) { 171 nodeSet := make(map[enode.ID]*enr.Record) 172 for _, n := range wantNodes { 173 nodeSet[n.ID()] = n.Record() 174 } 175 for { 176 test.waitPacketOut(func(p *nodesV5, addr *net.UDPAddr, authTag []byte) { 177 if len(p.Nodes) > 3 { 178 test.t.Fatalf("too many nodes in response") 179 } 180 if p.Total != wantTotal { 181 test.t.Fatalf("wrong total response count %d", p.Total) 182 } 183 if !bytes.Equal(p.ReqID, wantReqID) { 184 test.t.Fatalf("wrong request ID in response: %v", p.ReqID) 185 } 186 for _, record := range p.Nodes { 187 n, _ := enode.New(enode.ValidSchemesForTesting, record) 188 want := nodeSet[n.ID()] 189 if want == nil { 190 test.t.Fatalf("unexpected node in response: %v", n) 191 } 192 if !reflect.DeepEqual(record, want) { 193 test.t.Fatalf("wrong record in response: %v", n) 194 } 195 delete(nodeSet, n.ID()) 196 } 197 }) 198 if len(nodeSet) == 0 { 199 return 200 } 201 } 202 } 203 204 // This test checks that outgoing PING calls work. 205 func TestUDPv5_pingCall(t *testing.T) { 206 t.Parallel() 207 test := newUDPV5Test(t) 208 defer test.close() 209 210 remote := test.getNode(test.remotekey, test.remoteaddr).Node() 211 done := make(chan error, 1) 212 213 // This ping times out. 214 go func() { 215 _, err := test.udp.ping(remote) 216 done <- err 217 }() 218 test.waitPacketOut(func(p *pingV5, addr *net.UDPAddr, authTag []byte) {}) 219 if err := <-done; err != errTimeout { 220 t.Fatalf("want errTimeout, got %q", err) 221 } 222 223 // This ping works. 224 go func() { 225 _, err := test.udp.ping(remote) 226 done <- err 227 }() 228 test.waitPacketOut(func(p *pingV5, addr *net.UDPAddr, authTag []byte) { 229 test.packetInFrom(test.remotekey, test.remoteaddr, &pongV5{ReqID: p.ReqID}) 230 }) 231 if err := <-done; err != nil { 232 t.Fatal(err) 233 } 234 235 // This ping gets a reply from the wrong endpoint. 236 go func() { 237 _, err := test.udp.ping(remote) 238 done <- err 239 }() 240 test.waitPacketOut(func(p *pingV5, addr *net.UDPAddr, authTag []byte) { 241 wrongAddr := &net.UDPAddr{IP: net.IP{33, 44, 55, 22}, Port: 10101} 242 test.packetInFrom(test.remotekey, wrongAddr, &pongV5{ReqID: p.ReqID}) 243 }) 244 if err := <-done; err != errTimeout { 245 t.Fatalf("want errTimeout for reply from wrong IP, got %q", err) 246 } 247 } 248 249 // This test checks that outgoing FINDNODE calls work and multiple NODES 250 // replies are aggregated. 251 func TestUDPv5_findnodeCall(t *testing.T) { 252 t.Parallel() 253 test := newUDPV5Test(t) 254 defer test.close() 255 256 // Launch the request: 257 var ( 258 distance = 230 259 remote = test.getNode(test.remotekey, test.remoteaddr).Node() 260 nodes = nodesAtDistance(remote.ID(), distance, 8) 261 done = make(chan error, 1) 262 response []*enode.Node 263 ) 264 go func() { 265 var err error 266 response, err = test.udp.findnode(remote, distance) 267 done <- err 268 }() 269 270 // Serve the responses: 271 test.waitPacketOut(func(p *findnodeV5, addr *net.UDPAddr, authTag []byte) { 272 if p.Distance != uint(distance) { 273 t.Fatalf("wrong bucket: %d", p.Distance) 274 } 275 test.packetIn(&nodesV5{ 276 ReqID: p.ReqID, 277 Total: 2, 278 Nodes: nodesToRecords(nodes[:4]), 279 }) 280 test.packetIn(&nodesV5{ 281 ReqID: p.ReqID, 282 Total: 2, 283 Nodes: nodesToRecords(nodes[4:]), 284 }) 285 }) 286 287 // Check results: 288 if err := <-done; err != nil { 289 t.Fatalf("unexpected error: %v", err) 290 } 291 if !reflect.DeepEqual(response, nodes) { 292 t.Fatalf("wrong nodes in response") 293 } 294 295 // TODO: check invalid IPs 296 // TODO: check invalid/unsigned record 297 } 298 299 // This test checks that pending calls are re-sent when a handshake happens. 300 func TestUDPv5_callResend(t *testing.T) { 301 t.Parallel() 302 test := newUDPV5Test(t) 303 defer test.close() 304 305 remote := test.getNode(test.remotekey, test.remoteaddr).Node() 306 done := make(chan error, 2) 307 go func() { 308 _, err := test.udp.ping(remote) 309 done <- err 310 }() 311 go func() { 312 _, err := test.udp.ping(remote) 313 done <- err 314 }() 315 316 // Ping answered by WHOAREYOU. 317 test.waitPacketOut(func(p *pingV5, addr *net.UDPAddr, authTag []byte) { 318 test.packetIn(&whoareyouV5{AuthTag: authTag}) 319 }) 320 // Ping should be re-sent. 321 test.waitPacketOut(func(p *pingV5, addr *net.UDPAddr, authTag []byte) { 322 test.packetIn(&pongV5{ReqID: p.ReqID}) 323 }) 324 // Answer the other ping. 325 test.waitPacketOut(func(p *pingV5, addr *net.UDPAddr, authTag []byte) { 326 test.packetIn(&pongV5{ReqID: p.ReqID}) 327 }) 328 if err := <-done; err != nil { 329 t.Fatalf("unexpected ping error: %v", err) 330 } 331 if err := <-done; err != nil { 332 t.Fatalf("unexpected ping error: %v", err) 333 } 334 } 335 336 // This test ensures we don't allow multiple rounds of WHOAREYOU for a single call. 337 func TestUDPv5_multipleHandshakeRounds(t *testing.T) { 338 t.Parallel() 339 test := newUDPV5Test(t) 340 defer test.close() 341 342 remote := test.getNode(test.remotekey, test.remoteaddr).Node() 343 done := make(chan error, 1) 344 go func() { 345 _, err := test.udp.ping(remote) 346 done <- err 347 }() 348 349 // Ping answered by WHOAREYOU. 350 test.waitPacketOut(func(p *pingV5, addr *net.UDPAddr, authTag []byte) { 351 test.packetIn(&whoareyouV5{AuthTag: authTag}) 352 }) 353 // Ping answered by WHOAREYOU again. 354 test.waitPacketOut(func(p *pingV5, addr *net.UDPAddr, authTag []byte) { 355 test.packetIn(&whoareyouV5{AuthTag: authTag}) 356 }) 357 if err := <-done; err != errTimeout { 358 t.Fatalf("unexpected ping error: %q", err) 359 } 360 } 361 362 // This test checks that calls with n replies may take up to n * respTimeout. 363 func TestUDPv5_callTimeoutReset(t *testing.T) { 364 t.Parallel() 365 test := newUDPV5Test(t) 366 defer test.close() 367 368 // Launch the request: 369 var ( 370 distance = 230 371 remote = test.getNode(test.remotekey, test.remoteaddr).Node() 372 nodes = nodesAtDistance(remote.ID(), distance, 8) 373 done = make(chan error, 1) 374 ) 375 go func() { 376 _, err := test.udp.findnode(remote, distance) 377 done <- err 378 }() 379 380 // Serve two responses, slowly. 381 test.waitPacketOut(func(p *findnodeV5, addr *net.UDPAddr, authTag []byte) { 382 time.Sleep(respTimeout - 50*time.Millisecond) 383 test.packetIn(&nodesV5{ 384 ReqID: p.ReqID, 385 Total: 2, 386 Nodes: nodesToRecords(nodes[:4]), 387 }) 388 389 time.Sleep(respTimeout - 50*time.Millisecond) 390 test.packetIn(&nodesV5{ 391 ReqID: p.ReqID, 392 Total: 2, 393 Nodes: nodesToRecords(nodes[4:]), 394 }) 395 }) 396 if err := <-done; err != nil { 397 t.Fatalf("unexpected error: %q", err) 398 } 399 } 400 401 // This test checks that lookup works. 402 func TestUDPv5_lookup(t *testing.T) { 403 t.Parallel() 404 test := newUDPV5Test(t) 405 406 // Lookup on empty table returns no nodes. 407 if results := test.udp.Lookup(lookupTestnet.target.id()); len(results) > 0 { 408 t.Fatalf("lookup on empty table returned %d results: %#v", len(results), results) 409 } 410 411 // Ensure the tester knows all nodes in lookupTestnet by IP. 412 for d, nn := range lookupTestnet.dists { 413 for i, key := range nn { 414 n := lookupTestnet.node(d, i) 415 test.getNode(key, &net.UDPAddr{IP: n.IP(), Port: n.UDP()}) 416 } 417 } 418 419 // Seed table with initial node. 420 fillTable(test.table, []*node{wrapNode(lookupTestnet.node(256, 0))}) 421 422 // Start the lookup. 423 resultC := make(chan []*enode.Node, 1) 424 go func() { 425 resultC <- test.udp.Lookup(lookupTestnet.target.id()) 426 test.close() 427 }() 428 429 // Answer lookup packets. 430 for done := false; !done; { 431 done = test.waitPacketOut(func(p packetV5, to *net.UDPAddr, authTag []byte) { 432 recipient, key := lookupTestnet.nodeByAddr(to) 433 switch p := p.(type) { 434 case *pingV5: 435 test.packetInFrom(key, to, &pongV5{ReqID: p.ReqID}) 436 case *findnodeV5: 437 nodes := lookupTestnet.neighborsAtDistance(recipient, p.Distance, 3) 438 response := &nodesV5{ReqID: p.ReqID, Total: 1, Nodes: nodesToRecords(nodes)} 439 test.packetInFrom(key, to, response) 440 } 441 }) 442 } 443 444 // Verify result nodes. 445 checkLookupResults(t, lookupTestnet, <-resultC) 446 } 447 448 // This test checks the local node can be utilised to set key-values. 449 func TestUDPv5_LocalNode(t *testing.T) { 450 t.Parallel() 451 var cfg Config 452 node := startLocalhostV5(t, cfg) 453 defer node.Close() 454 localNd := node.LocalNode() 455 456 // set value in node's local record 457 testVal := [4]byte{'A', 'B', 'C', 'D'} 458 localNd.Set(enr.WithEntry("testing", &testVal)) 459 460 // retrieve the value from self to make sure it matches. 461 outputVal := [4]byte{} 462 if err := node.Self().Load(enr.WithEntry("testing", &outputVal)); err != nil { 463 t.Errorf("Could not load value from record: %v", err) 464 } 465 if testVal != outputVal { 466 t.Errorf("Wanted %#x to be retrieved from the record but instead got %#x", testVal, outputVal) 467 } 468 } 469 470 // udpV5Test is the framework for all tests above. 471 // It runs the UDPv5 transport on a virtual socket and allows testing outgoing packets. 472 type udpV5Test struct { 473 t *testing.T 474 pipe *dgramPipe 475 table *Table 476 db *enode.DB 477 udp *UDPv5 478 localkey, remotekey *ecdsa.PrivateKey 479 remoteaddr *net.UDPAddr 480 nodesByID map[enode.ID]*enode.LocalNode 481 nodesByIP map[string]*enode.LocalNode 482 } 483 484 type testCodec struct { 485 test *udpV5Test 486 id enode.ID 487 ctr uint64 488 } 489 490 type testCodecFrame struct { 491 NodeID enode.ID 492 AuthTag []byte 493 Ptype byte 494 Packet rlp.RawValue 495 } 496 497 func (c *testCodec) encode(toID enode.ID, addr string, p packetV5, _ *whoareyouV5) ([]byte, []byte, error) { 498 c.ctr++ 499 authTag := make([]byte, 8) 500 binary.BigEndian.PutUint64(authTag, c.ctr) 501 penc, _ := rlp.EncodeToBytes(p) 502 frame, err := rlp.EncodeToBytes(testCodecFrame{c.id, authTag, p.kind(), penc}) 503 return frame, authTag, err 504 } 505 506 func (c *testCodec) decode(input []byte, addr string) (enode.ID, *enode.Node, packetV5, error) { 507 frame, p, err := c.decodeFrame(input) 508 if err != nil { 509 return enode.ID{}, nil, nil, err 510 } 511 if p.kind() == p_whoareyouV5 { 512 frame.NodeID = enode.ID{} // match wireCodec behavior 513 } 514 return frame.NodeID, nil, p, nil 515 } 516 517 func (c *testCodec) decodeFrame(input []byte) (frame testCodecFrame, p packetV5, err error) { 518 if err = rlp.DecodeBytes(input, &frame); err != nil { 519 return frame, nil, fmt.Errorf("invalid frame: %v", err) 520 } 521 switch frame.Ptype { 522 case p_unknownV5: 523 dec := new(unknownV5) 524 err = rlp.DecodeBytes(frame.Packet, &dec) 525 p = dec 526 case p_whoareyouV5: 527 dec := new(whoareyouV5) 528 err = rlp.DecodeBytes(frame.Packet, &dec) 529 p = dec 530 default: 531 p, err = decodePacketBodyV5(frame.Ptype, frame.Packet) 532 } 533 return frame, p, err 534 } 535 536 func newUDPV5Test(t *testing.T) *udpV5Test { 537 test := &udpV5Test{ 538 t: t, 539 pipe: newpipe(), 540 localkey: newkey(), 541 remotekey: newkey(), 542 remoteaddr: &net.UDPAddr{IP: net.IP{10, 0, 1, 99}, Port: 30303}, 543 nodesByID: make(map[enode.ID]*enode.LocalNode), 544 nodesByIP: make(map[string]*enode.LocalNode), 545 } 546 test.db, _ = enode.OpenDB("") 547 ln := enode.NewLocalNode(test.db, test.localkey) 548 ln.SetStaticIP(net.IP{10, 0, 0, 1}) 549 ln.Set(enr.UDP(30303)) 550 test.udp, _ = ListenV5(test.pipe, ln, Config{ 551 PrivateKey: test.localkey, 552 Log: testlog.Logger(t, log.LvlTrace), 553 ValidSchemes: enode.ValidSchemesForTesting, 554 }) 555 test.udp.codec = &testCodec{test: test, id: ln.ID()} 556 test.table = test.udp.tab 557 test.nodesByID[ln.ID()] = ln 558 // Wait for initial refresh so the table doesn't send unexpected findnode. 559 <-test.table.initDone 560 return test 561 } 562 563 // handles a packet as if it had been sent to the transport. 564 func (test *udpV5Test) packetIn(packet packetV5) { 565 test.t.Helper() 566 test.packetInFrom(test.remotekey, test.remoteaddr, packet) 567 } 568 569 // handles a packet as if it had been sent to the transport by the key/endpoint. 570 func (test *udpV5Test) packetInFrom(key *ecdsa.PrivateKey, addr *net.UDPAddr, packet packetV5) { 571 test.t.Helper() 572 573 ln := test.getNode(key, addr) 574 codec := &testCodec{test: test, id: ln.ID()} 575 enc, _, err := codec.encode(test.udp.Self().ID(), addr.String(), packet, nil) 576 if err != nil { 577 test.t.Errorf("%s encode error: %v", packet.name(), err) 578 } 579 if test.udp.dispatchReadPacket(addr, enc) { 580 <-test.udp.readNextCh // unblock UDPv5.dispatch 581 } 582 } 583 584 // getNode ensures the test knows about a node at the given endpoint. 585 func (test *udpV5Test) getNode(key *ecdsa.PrivateKey, addr *net.UDPAddr) *enode.LocalNode { 586 id := encodePubkey(&key.PublicKey).id() 587 ln := test.nodesByID[id] 588 if ln == nil { 589 db, _ := enode.OpenDB("") 590 ln = enode.NewLocalNode(db, key) 591 ln.SetStaticIP(addr.IP) 592 ln.Set(enr.UDP(addr.Port)) 593 test.nodesByID[id] = ln 594 } 595 test.nodesByIP[string(addr.IP)] = ln 596 return ln 597 } 598 599 func (test *udpV5Test) waitPacketOut(validate interface{}) (closed bool) { 600 test.t.Helper() 601 fn := reflect.ValueOf(validate) 602 exptype := fn.Type().In(0) 603 604 dgram, err := test.pipe.receive() 605 if err == errClosed { 606 return true 607 } 608 if err == errTimeout { 609 test.t.Fatalf("timed out waiting for %v", exptype) 610 return false 611 } 612 ln := test.nodesByIP[string(dgram.to.IP)] 613 if ln == nil { 614 test.t.Fatalf("attempt to send to non-existing node %v", &dgram.to) 615 return false 616 } 617 codec := &testCodec{test: test, id: ln.ID()} 618 frame, p, err := codec.decodeFrame(dgram.data) 619 if err != nil { 620 test.t.Errorf("sent packet decode error: %v", err) 621 return false 622 } 623 if !reflect.TypeOf(p).AssignableTo(exptype) { 624 test.t.Errorf("sent packet type mismatch, got: %v, want: %v", reflect.TypeOf(p), exptype) 625 return false 626 } 627 fn.Call([]reflect.Value{reflect.ValueOf(p), reflect.ValueOf(&dgram.to), reflect.ValueOf(frame.AuthTag)}) 628 return false 629 } 630 631 func (test *udpV5Test) close() { 632 test.t.Helper() 633 634 test.udp.Close() 635 test.db.Close() 636 for id, n := range test.nodesByID { 637 if id != test.udp.Self().ID() { 638 n.Database().Close() 639 } 640 } 641 if len(test.pipe.queue) != 0 { 642 test.t.Fatalf("%d unmatched UDP packets in queue", len(test.pipe.queue)) 643 } 644 }