.config/coc/extensions/coc-go-data/tools/pkg/mod/github.com/google/go-cmp@v0.5.1/cmp/internal/value/name_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.md file.
   4
   5 package value
   6
   7 import (
   8         "reflect"
   9         "strings"
  10         "testing"
  11 )
  12
  13 type Named struct{}
  14
  15 var pkgPath = reflect.TypeOf(Named{}).PkgPath()
  16
  17 func TestTypeString(t *testing.T) {
  18         tests := []struct {
  19                 in   interface{}
  20                 want string
  21         }{{
  22                 in:   bool(false),
  23                 want: "bool",
  24         }, {
  25                 in:   int(0),
  26                 want: "int",
  27         }, {
  28                 in:   float64(0),
  29                 want: "float64",
  30         }, {
  31                 in:   string(""),
  32                 want: "string",
  33         }, {
  34                 in:   Named{},
  35                 want: "$PackagePath.Named",
  36         }, {
  37                 in:   (chan Named)(nil),
  38                 want: "chan $PackagePath.Named",
  39         }, {
  40                 in:   (<-chan Named)(nil),
  41                 want: "<-chan $PackagePath.Named",
  42         }, {
  43                 in:   (chan<- Named)(nil),
  44                 want: "chan<- $PackagePath.Named",
  45         }, {
  46                 in:   (func())(nil),
  47                 want: "func()",
  48         }, {
  49                 in:   (func(Named))(nil),
  50                 want: "func($PackagePath.Named)",
  51         }, {
  52                 in:   (func() Named)(nil),
  53                 want: "func() $PackagePath.Named",
  54         }, {
  55                 in:   (func(int, Named) (int, error))(nil),
  56                 want: "func(int, $PackagePath.Named) (int, error)",
  57         }, {
  58                 in:   (func(...Named))(nil),
  59                 want: "func(...$PackagePath.Named)",
  60         }, {
  61                 in:   struct{}{},
  62                 want: "struct{}",
  63         }, {
  64                 in:   struct{ Named }{},
  65                 want: "struct{ $PackagePath.Named }",
  66         }, {
  67                 in: struct {
  68                         Named `tag`
  69                 }{},
  70                 want: "struct{ $PackagePath.Named \"tag\" }",
  71         }, {
  72                 in:   struct{ Named Named }{},
  73                 want: "struct{ Named $PackagePath.Named }",
  74         }, {
  75                 in: struct {
  76                         Named Named `tag`
  77                 }{},
  78                 want: "struct{ Named $PackagePath.Named \"tag\" }",
  79         }, {
  80                 in: struct {
  81                         Int   int
  82                         Named Named
  83                 }{},
  84                 want: "struct{ Int int; Named $PackagePath.Named }",
  85         }, {
  86                 in: struct {
  87                         _ int
  88                         x Named
  89                 }{},
  90                 want: "struct{ $FieldPrefix._ int; $FieldPrefix.x $PackagePath.Named }",
  91         }, {
  92                 in:   []Named(nil),
  93                 want: "[]$PackagePath.Named",
  94         }, {
  95                 in:   []*Named(nil),
  96                 want: "[]*$PackagePath.Named",
  97         }, {
  98                 in:   [10]Named{},
  99                 want: "[10]$PackagePath.Named",
 100         }, {
 101                 in:   [10]*Named{},
 102                 want: "[10]*$PackagePath.Named",
 103         }, {
 104                 in:   map[string]string(nil),
 105                 want: "map[string]string",
 106         }, {
 107                 in:   map[Named]Named(nil),
 108                 want: "map[$PackagePath.Named]$PackagePath.Named",
 109         }, {
 110                 in:   (*Named)(nil),
 111                 want: "*$PackagePath.Named",
 112         }, {
 113                 in:   (*interface{})(nil),
 114                 want: "*interface{}",
 115         }, {
 116                 in:   (*interface{ Read([]byte) (int, error) })(nil),
 117                 want: "*interface{ Read([]uint8) (int, error) }",
 118         }, {
 119                 in: (*interface {
 120                         F1()
 121                         F2(Named)
 122                         F3() Named
 123                         F4(int, Named) (int, error)
 124                         F5(...Named)
 125                 })(nil),
 126                 want: "*interface{ F1(); F2($PackagePath.Named); F3() $PackagePath.Named; F4(int, $PackagePath.Named) (int, error); F5(...$PackagePath.Named) }",
 127         }}
 128
 129         for _, tt := range tests {
 130                 typ := reflect.TypeOf(tt.in)
 131                 wantShort := tt.want
 132                 wantShort = strings.Replace(wantShort, "$PackagePath", "value", -1)
 133                 wantShort = strings.Replace(wantShort, "$FieldPrefix.", "", -1)
 134                 if gotShort := TypeString(typ, false); gotShort != wantShort {
 135                         t.Errorf("TypeString(%v, false) mismatch:\ngot:  %v\nwant: %v", typ, gotShort, wantShort)
 136                 }
 137                 wantQualified := tt.want
 138                 wantQualified = strings.Replace(wantQualified, "$PackagePath", `"`+pkgPath+`"`, -1)
 139                 wantQualified = strings.Replace(wantQualified, "$FieldPrefix", `"`+pkgPath+`"`, -1)
 140                 if gotQualified := TypeString(typ, true); gotQualified != wantQualified {
 141                         t.Errorf("TypeString(%v, true) mismatch:\ngot:  %v\nwant: %v", typ, gotQualified, wantQualified)
 142                 }
 143         }
 144 }