vendor/github.com/miekg/dns/vendor/golang.org/x/net/internal/socket/socket_go1_9_test.go

   1 // Copyright 2017 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 // +build go1.9
   6 // +build darwin dragonfly freebsd linux netbsd openbsd solaris
   7
   8 package socket_test
   9
  10 import (
  11         "bytes"
  12         "fmt"
  13         "net"
  14         "runtime"
  15         "testing"
  16
  17         "golang.org/x/net/internal/nettest"
  18         "golang.org/x/net/internal/socket"
  19 )
  20
  21 type mockControl struct {
  22         Level int
  23         Type  int
  24         Data  []byte
  25 }
  26
  27 func TestControlMessage(t *testing.T) {
  28         for _, tt := range []struct {
  29                 cs []mockControl
  30         }{
  31                 {
  32                         []mockControl{
  33                                 {Level: 1, Type: 1},
  34                         },
  35                 },
  36                 {
  37                         []mockControl{
  38                                 {Level: 2, Type: 2, Data: []byte{0xfe}},
  39                         },
  40                 },
  41                 {
  42                         []mockControl{
  43                                 {Level: 3, Type: 3, Data: []byte{0xfe, 0xff, 0xff, 0xfe}},
  44                         },
  45                 },
  46                 {
  47                         []mockControl{
  48                                 {Level: 4, Type: 4, Data: []byte{0xfe, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0xfe}},
  49                         },
  50                 },
  51                 {
  52                         []mockControl{
  53                                 {Level: 4, Type: 4, Data: []byte{0xfe, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0xfe}},
  54                                 {Level: 2, Type: 2, Data: []byte{0xfe}},
  55                         },
  56                 },
  57         } {
  58                 var w []byte
  59                 var tailPadLen int
  60                 mm := socket.NewControlMessage([]int{0})
  61                 for i, c := range tt.cs {
  62                         m := socket.NewControlMessage([]int{len(c.Data)})
  63                         l := len(m) - len(mm)
  64                         if i == len(tt.cs)-1 && l > len(c.Data) {
  65                                 tailPadLen = l - len(c.Data)
  66                         }
  67                         w = append(w, m...)
  68                 }
  69
  70                 var err error
  71                 ww := make([]byte, len(w))
  72                 copy(ww, w)
  73                 m := socket.ControlMessage(ww)
  74                 for _, c := range tt.cs {
  75                         if err = m.MarshalHeader(c.Level, c.Type, len(c.Data)); err != nil {
  76                                 t.Fatalf("(%v).MarshalHeader() = %v", tt.cs, err)
  77                         }
  78                         copy(m.Data(len(c.Data)), c.Data)
  79                         m = m.Next(len(c.Data))
  80                 }
  81                 m = socket.ControlMessage(w)
  82                 for _, c := range tt.cs {
  83                         m, err = m.Marshal(c.Level, c.Type, c.Data)
  84                         if err != nil {
  85                                 t.Fatalf("(%v).Marshal() = %v", tt.cs, err)
  86                         }
  87                 }
  88                 if !bytes.Equal(ww, w) {
  89                         t.Fatalf("got %#v; want %#v", ww, w)
  90                 }
  91
  92                 ws := [][]byte{w}
  93                 if tailPadLen > 0 {
  94                         // Test a message with no tail padding.
  95                         nopad := w[:len(w)-tailPadLen]
  96                         ws = append(ws, [][]byte{nopad}...)
  97                 }
  98                 for _, w := range ws {
  99                         ms, err := socket.ControlMessage(w).Parse()
 100                         if err != nil {
 101                                 t.Fatalf("(%v).Parse() = %v", tt.cs, err)
 102                         }
 103                         for i, m := range ms {
 104                                 lvl, typ, dataLen, err := m.ParseHeader()
 105                                 if err != nil {
 106                                         t.Fatalf("(%v).ParseHeader() = %v", tt.cs, err)
 107                                 }
 108                                 if lvl != tt.cs[i].Level || typ != tt.cs[i].Type || dataLen != len(tt.cs[i].Data) {
 109                                         t.Fatalf("%v: got %d, %d, %d; want %d, %d, %d", tt.cs[i], lvl, typ, dataLen, tt.cs[i].Level, tt.cs[i].Type, len(tt.cs[i].Data))
 110                                 }
 111                         }
 112                 }
 113         }
 114 }
 115
 116 func TestUDP(t *testing.T) {
 117         c, err := nettest.NewLocalPacketListener("udp")
 118         if err != nil {
 119                 t.Skipf("not supported on %s/%s: %v", runtime.GOOS, runtime.GOARCH, err)
 120         }
 121         defer c.Close()
 122         cc, err := socket.NewConn(c.(net.Conn))
 123         if err != nil {
 124                 t.Fatal(err)
 125         }
 126
 127         t.Run("Message", func(t *testing.T) {
 128                 data := []byte("HELLO-R-U-THERE")
 129                 wm := socket.Message{
 130                         Buffers: bytes.SplitAfter(data, []byte("-")),
 131                         Addr:    c.LocalAddr(),
 132                 }
 133                 if err := cc.SendMsg(&wm, 0); err != nil {
 134                         t.Fatal(err)
 135                 }
 136                 b := make([]byte, 32)
 137                 rm := socket.Message{
 138                         Buffers: [][]byte{b[:1], b[1:3], b[3:7], b[7:11], b[11:]},
 139                 }
 140                 if err := cc.RecvMsg(&rm, 0); err != nil {
 141                         t.Fatal(err)
 142                 }
 143                 if !bytes.Equal(b[:rm.N], data) {
 144                         t.Fatalf("got %#v; want %#v", b[:rm.N], data)
 145                 }
 146         })
 147         switch runtime.GOOS {
 148         case "android", "linux":
 149                 t.Run("Messages", func(t *testing.T) {
 150                         data := []byte("HELLO-R-U-THERE")
 151                         wmbs := bytes.SplitAfter(data, []byte("-"))
 152                         wms := []socket.Message{
 153                                 {Buffers: wmbs[:1], Addr: c.LocalAddr()},
 154                                 {Buffers: wmbs[1:], Addr: c.LocalAddr()},
 155                         }
 156                         n, err := cc.SendMsgs(wms, 0)
 157                         if err != nil {
 158                                 t.Fatal(err)
 159                         }
 160                         if n != len(wms) {
 161                                 t.Fatalf("got %d; want %d", n, len(wms))
 162                         }
 163                         b := make([]byte, 32)
 164                         rmbs := [][][]byte{{b[:len(wmbs[0])]}, {b[len(wmbs[0]):]}}
 165                         rms := []socket.Message{
 166                                 {Buffers: rmbs[0]},
 167                                 {Buffers: rmbs[1]},
 168                         }
 169                         n, err = cc.RecvMsgs(rms, 0)
 170                         if err != nil {
 171                                 t.Fatal(err)
 172                         }
 173                         if n != len(rms) {
 174                                 t.Fatalf("got %d; want %d", n, len(rms))
 175                         }
 176                         nn := 0
 177                         for i := 0; i < n; i++ {
 178                                 nn += rms[i].N
 179                         }
 180                         if !bytes.Equal(b[:nn], data) {
 181                                 t.Fatalf("got %#v; want %#v", b[:nn], data)
 182                         }
 183                 })
 184         }
 185
 186         // The behavior of transmission for zero byte paylaod depends
 187         // on each platform implementation. Some may transmit only
 188         // protocol header and options, other may transmit nothing.
 189         // We test only that SendMsg and SendMsgs will not crash with
 190         // empty buffers.
 191         wm := socket.Message{
 192                 Buffers: [][]byte{{}},
 193                 Addr:    c.LocalAddr(),
 194         }
 195         cc.SendMsg(&wm, 0)
 196         wms := []socket.Message{
 197                 {Buffers: [][]byte{{}}, Addr: c.LocalAddr()},
 198         }
 199         cc.SendMsgs(wms, 0)
 200 }
 201
 202 func BenchmarkUDP(b *testing.B) {
 203         c, err := nettest.NewLocalPacketListener("udp")
 204         if err != nil {
 205                 b.Skipf("not supported on %s/%s: %v", runtime.GOOS, runtime.GOARCH, err)
 206         }
 207         defer c.Close()
 208         cc, err := socket.NewConn(c.(net.Conn))
 209         if err != nil {
 210                 b.Fatal(err)
 211         }
 212         data := []byte("HELLO-R-U-THERE")
 213         wm := socket.Message{
 214                 Buffers: [][]byte{data},
 215                 Addr:    c.LocalAddr(),
 216         }
 217         rm := socket.Message{
 218                 Buffers: [][]byte{make([]byte, 128)},
 219                 OOB:     make([]byte, 128),
 220         }
 221
 222         for M := 1; M <= 1<<9; M = M << 1 {
 223                 b.Run(fmt.Sprintf("Iter-%d", M), func(b *testing.B) {
 224                         for i := 0; i < b.N; i++ {
 225                                 for j := 0; j < M; j++ {
 226                                         if err := cc.SendMsg(&wm, 0); err != nil {
 227                                                 b.Fatal(err)
 228                                         }
 229                                         if err := cc.RecvMsg(&rm, 0); err != nil {
 230                                                 b.Fatal(err)
 231                                         }
 232                                 }
 233                         }
 234                 })
 235                 switch runtime.GOOS {
 236                 case "android", "linux":
 237                         wms := make([]socket.Message, M)
 238                         for i := range wms {
 239                                 wms[i].Buffers = [][]byte{data}
 240                                 wms[i].Addr = c.LocalAddr()
 241                         }
 242                         rms := make([]socket.Message, M)
 243                         for i := range rms {
 244                                 rms[i].Buffers = [][]byte{make([]byte, 128)}
 245                                 rms[i].OOB = make([]byte, 128)
 246                         }
 247                         b.Run(fmt.Sprintf("Batch-%d", M), func(b *testing.B) {
 248                                 for i := 0; i < b.N; i++ {
 249                                         if _, err := cc.SendMsgs(wms, 0); err != nil {
 250                                                 b.Fatal(err)
 251                                         }
 252                                         if _, err := cc.RecvMsgs(rms, 0); err != nil {
 253                                                 b.Fatal(err)
 254                                         }
 255                                 }
 256                         })
 257                 }
 258         }
 259 }