.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/sys@v0.0.0-20210124154548-22da62e12c0c/unix/syscall_internal_darwin_test.go

   1 // Copyright 2020 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 unix
   6
   7 import (
   8         "reflect"
   9         "testing"
  10         "unsafe"
  11 )
  12
  13 func Test_anyToSockaddr_darwin(t *testing.T) {
  14         tests := []struct {
  15                 name string
  16                 rsa  *RawSockaddrAny
  17                 sa   Sockaddr
  18                 err  error
  19         }{
  20                 {
  21                         name: "AF_SYSTEM emtpy",
  22                         rsa:  sockaddrCtlToAny(RawSockaddrCtl{}),
  23                         err:  EAFNOSUPPORT,
  24                 },
  25                 {
  26                         name: "AF_SYSTEM no sysaddr",
  27                         rsa: sockaddrCtlToAny(RawSockaddrCtl{
  28                                 Sc_family: AF_SYSTEM,
  29                         }),
  30                         err: EAFNOSUPPORT,
  31                 },
  32                 {
  33                         name: "AF_SYSTEM/AF_SYS_CONTROL empty ",
  34                         rsa: sockaddrCtlToAny(RawSockaddrCtl{
  35                                 Sc_family:  AF_SYSTEM,
  36                                 Ss_sysaddr: AF_SYS_CONTROL,
  37                         }),
  38                         sa: &SockaddrCtl{},
  39                 },
  40                 {
  41                         name: "AF_SYSTEM ID and unit",
  42                         rsa: sockaddrCtlToAny(RawSockaddrCtl{
  43                                 Sc_family:  AF_SYSTEM,
  44                                 Ss_sysaddr: AF_SYS_CONTROL,
  45                                 Sc_id:      0x42,
  46                                 Sc_unit:    0xC71,
  47                         }),
  48                         sa: &SockaddrCtl{
  49                                 ID:   0x42,
  50                                 Unit: 0xC71,
  51                         },
  52                 },
  53         }
  54
  55         for _, tt := range tests {
  56                 t.Run(tt.name, func(t *testing.T) {
  57                         fd := int(0)
  58                         sa, err := anyToSockaddr(fd, tt.rsa)
  59                         if err != tt.err {
  60                                 t.Fatalf("unexpected error: %v, want: %v", err, tt.err)
  61                         }
  62
  63                         if !reflect.DeepEqual(sa, tt.sa) {
  64                                 t.Fatalf("unexpected Sockaddr:\n got: %#v\nwant: %#v", sa, tt.sa)
  65                         }
  66                 })
  67         }
  68 }
  69
  70 func TestSockaddrCtl_sockaddr(t *testing.T) {
  71         tests := []struct {
  72                 name string
  73                 sa   *SockaddrCtl
  74                 raw  *RawSockaddrCtl
  75                 err  error
  76         }{
  77                 {
  78                         name: "empty",
  79                         sa:   &SockaddrCtl{},
  80                         raw: &RawSockaddrCtl{
  81                                 Sc_len:     SizeofSockaddrCtl,
  82                                 Sc_family:  AF_SYSTEM,
  83                                 Ss_sysaddr: AF_SYS_CONTROL,
  84                         },
  85                 },
  86                 {
  87                         name: "with ID and unit",
  88                         sa: &SockaddrCtl{
  89                                 ID:   0x42,
  90                                 Unit: 0xff,
  91                         },
  92                         raw: &RawSockaddrCtl{
  93                                 Sc_len:     SizeofSockaddrCtl,
  94                                 Sc_family:  AF_SYSTEM,
  95                                 Ss_sysaddr: AF_SYS_CONTROL,
  96                                 Sc_id:      0x42,
  97                                 Sc_unit:    0xff,
  98                         },
  99                 },
 100         }
 101
 102         for _, tt := range tests {
 103                 t.Run(tt.name, func(t *testing.T) {
 104                         out, l, err := tt.sa.sockaddr()
 105                         if err != tt.err {
 106                                 t.Fatalf("unexpected error: %v, want: %v", err, tt.err)
 107                         }
 108
 109                         // Must be 0 on error or a fixed size otherwise.
 110                         if (tt.err != nil && l != 0) || (tt.raw != nil && l != SizeofSockaddrCtl) {
 111                                 t.Fatalf("unexpected Socklen: %d", l)
 112                         }
 113
 114                         if out != nil {
 115                                 raw := (*RawSockaddrCtl)(out)
 116                                 if !reflect.DeepEqual(raw, tt.raw) {
 117                                         t.Fatalf("unexpected RawSockaddrCtl:\n got: %#v\nwant: %#v", raw, tt.raw)
 118                                 }
 119                         }
 120                 })
 121         }
 122 }
 123
 124 func sockaddrCtlToAny(in RawSockaddrCtl) *RawSockaddrAny {
 125         var out RawSockaddrAny
 126         copy(
 127                 (*(*[SizeofSockaddrAny]byte)(unsafe.Pointer(&out)))[:],
 128                 (*(*[SizeofSockaddrCtl]byte)(unsafe.Pointer(&in)))[:],
 129         )
 130         return &out
 131 }