vendor/golang.org/x/net/ipv4/readwrite_test.go

   1 // Copyright 2012 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package ipv4_test
   6
   7 import (
   8         "bytes"
   9         "net"
  10         "runtime"
  11         "strings"
  12         "sync"
  13         "testing"
  14
  15         "golang.org/x/net/internal/nettest"
  16         "golang.org/x/net/ipv4"
  17 )
  18
  19 func BenchmarkReadWriteUnicast(b *testing.B) {
  20         c, err := nettest.NewLocalPacketListener("udp4")
  21         if err != nil {
  22                 b.Skipf("not supported on %s/%s: %v", runtime.GOOS, runtime.GOARCH, err)
  23         }
  24         defer c.Close()
  25
  26         dst := c.LocalAddr()
  27         wb, rb := []byte("HELLO-R-U-THERE"), make([]byte, 128)
  28
  29         b.Run("NetUDP", func(b *testing.B) {
  30                 for i := 0; i < b.N; i++ {
  31                         if _, err := c.WriteTo(wb, dst); err != nil {
  32                                 b.Fatal(err)
  33                         }
  34                         if _, _, err := c.ReadFrom(rb); err != nil {
  35                                 b.Fatal(err)
  36                         }
  37                 }
  38         })
  39         b.Run("IPv4UDP", func(b *testing.B) {
  40                 p := ipv4.NewPacketConn(c)
  41                 cf := ipv4.FlagTTL | ipv4.FlagInterface
  42                 if err := p.SetControlMessage(cf, true); err != nil {
  43                         b.Fatal(err)
  44                 }
  45                 cm := ipv4.ControlMessage{TTL: 1}
  46                 ifi := nettest.RoutedInterface("ip4", net.FlagUp|net.FlagLoopback)
  47                 if ifi != nil {
  48                         cm.IfIndex = ifi.Index
  49                 }
  50
  51                 for i := 0; i < b.N; i++ {
  52                         if _, err := p.WriteTo(wb, &cm, dst); err != nil {
  53                                 b.Fatal(err)
  54                         }
  55                         if _, _, _, err := p.ReadFrom(rb); err != nil {
  56                                 b.Fatal(err)
  57                         }
  58                 }
  59         })
  60 }
  61
  62 func TestPacketConnConcurrentReadWriteUnicastUDP(t *testing.T) {
  63         switch runtime.GOOS {
  64         case "nacl", "plan9", "windows":
  65                 t.Skipf("not supported on %s", runtime.GOOS)
  66         }
  67
  68         c, err := nettest.NewLocalPacketListener("udp4")
  69         if err != nil {
  70                 t.Fatal(err)
  71         }
  72         defer c.Close()
  73         p := ipv4.NewPacketConn(c)
  74         defer p.Close()
  75
  76         dst := c.LocalAddr()
  77         ifi := nettest.RoutedInterface("ip4", net.FlagUp|net.FlagLoopback)
  78         cf := ipv4.FlagTTL | ipv4.FlagSrc | ipv4.FlagDst | ipv4.FlagInterface
  79         wb := []byte("HELLO-R-U-THERE")
  80
  81         if err := p.SetControlMessage(cf, true); err != nil { // probe before test
  82                 if nettest.ProtocolNotSupported(err) {
  83                         t.Skipf("not supported on %s", runtime.GOOS)
  84                 }
  85                 t.Fatal(err)
  86         }
  87
  88         var wg sync.WaitGroup
  89         reader := func() {
  90                 defer wg.Done()
  91                 rb := make([]byte, 128)
  92                 if n, cm, _, err := p.ReadFrom(rb); err != nil {
  93                         t.Error(err)
  94                         return
  95                 } else if !bytes.Equal(rb[:n], wb) {
  96                         t.Errorf("got %v; want %v", rb[:n], wb)
  97                         return
  98                 } else {
  99                         s := cm.String()
 100                         if strings.Contains(s, ",") {
 101                                 t.Errorf("should be space-separated values: %s", s)
 102                         }
 103                 }
 104         }
 105         writer := func(toggle bool) {
 106                 defer wg.Done()
 107                 cm := ipv4.ControlMessage{
 108                         Src: net.IPv4(127, 0, 0, 1),
 109                 }
 110                 if ifi != nil {
 111                         cm.IfIndex = ifi.Index
 112                 }
 113                 if err := p.SetControlMessage(cf, toggle); err != nil {
 114                         t.Error(err)
 115                         return
 116                 }
 117                 if n, err := p.WriteTo(wb, &cm, dst); err != nil {
 118                         t.Error(err)
 119                         return
 120                 } else if n != len(wb) {
 121                         t.Errorf("got %d; want %d", n, len(wb))
 122                         return
 123                 }
 124         }
 125
 126         const N = 10
 127         wg.Add(N)
 128         for i := 0; i < N; i++ {
 129                 go reader()
 130         }
 131         wg.Add(2 * N)
 132         for i := 0; i < 2*N; i++ {
 133                 go writer(i%2 != 0)
 134         }
 135         wg.Add(N)
 136         for i := 0; i < N; i++ {
 137                 go reader()
 138         }
 139         wg.Wait()
 140 }