gitee.com/go-spring2/spring-base@v1.1.3/util/type_test.go (about) 1 /* 2 * Copyright 2012-2019 the original author or authors. 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * https://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package util_test 18 19 import ( 20 "context" 21 "errors" 22 "fmt" 23 "io" 24 "os" 25 "reflect" 26 "testing" 27 "unsafe" 28 29 "gitee.com/go-spring2/spring-base/assert" 30 "gitee.com/go-spring2/spring-base/util" 31 "gitee.com/go-spring2/spring-base/util/testdata" 32 pkg1 "gitee.com/go-spring2/spring-base/util/testdata/pkg/bar" 33 pkg2 "gitee.com/go-spring2/spring-base/util/testdata/pkg/foo" 34 ) 35 36 type SamePkg struct{} 37 38 func (p *SamePkg) Package() { 39 fmt.Println("gitee.com/go-spring2/spring-base/util/util_test.SamePkg") 40 } 41 42 func TestPkgPath(t *testing.T) { 43 // the name and package path of built-in type are empty. 44 45 data := []struct { 46 typ reflect.Type 47 kind reflect.Kind 48 name string 49 pkg string 50 }{ 51 { 52 reflect.TypeOf(false), 53 reflect.Bool, 54 "bool", 55 "", 56 }, 57 { 58 reflect.TypeOf(new(bool)), 59 reflect.Ptr, 60 "", 61 "", 62 }, 63 { 64 reflect.TypeOf(make([]bool, 0)), 65 reflect.Slice, 66 "", 67 "", 68 }, 69 { 70 reflect.TypeOf(int(3)), 71 reflect.Int, 72 "int", 73 "", 74 }, 75 { 76 reflect.TypeOf(new(int)), 77 reflect.Ptr, 78 "", 79 "", 80 }, 81 { 82 reflect.TypeOf(make([]int, 0)), 83 reflect.Slice, 84 "", 85 "", 86 }, 87 { 88 reflect.TypeOf(uint(3)), 89 reflect.Uint, 90 "uint", 91 "", 92 }, 93 { 94 reflect.TypeOf(new(uint)), 95 reflect.Ptr, 96 "", 97 "", 98 }, 99 { 100 reflect.TypeOf(make([]uint, 0)), 101 reflect.Slice, 102 "", 103 "", 104 }, 105 { 106 reflect.TypeOf(float32(3)), 107 reflect.Float32, 108 "float32", 109 "", 110 }, 111 { 112 reflect.TypeOf(new(float32)), 113 reflect.Ptr, 114 "", 115 "", 116 }, 117 { 118 reflect.TypeOf(make([]float32, 0)), 119 reflect.Slice, 120 "", 121 "", 122 }, 123 { 124 reflect.TypeOf(complex64(3)), 125 reflect.Complex64, 126 "complex64", 127 "", 128 }, 129 { 130 reflect.TypeOf(new(complex64)), 131 reflect.Ptr, 132 "", 133 "", 134 }, 135 { 136 reflect.TypeOf(make([]complex64, 0)), 137 reflect.Slice, 138 "", 139 "", 140 }, 141 { 142 reflect.TypeOf("3"), 143 reflect.String, 144 "string", 145 "", 146 }, 147 { 148 reflect.TypeOf(new(string)), 149 reflect.Ptr, 150 "", 151 "", 152 }, 153 { 154 reflect.TypeOf(make([]string, 0)), 155 reflect.Slice, 156 "", 157 "", 158 }, 159 { 160 reflect.TypeOf(map[int]int{}), 161 reflect.Map, 162 "", 163 "", 164 }, 165 { 166 reflect.TypeOf(new(map[int]int)), 167 reflect.Ptr, 168 "", 169 "", 170 }, 171 { 172 reflect.TypeOf(make([]map[int]int, 0)), 173 reflect.Slice, 174 "", 175 "", 176 }, 177 { 178 reflect.TypeOf(pkg1.SamePkg{}), 179 reflect.Struct, 180 "SamePkg", 181 "gitee.com/go-spring2/spring-base/util/testdata/pkg/bar", 182 }, 183 { 184 reflect.TypeOf(new(pkg1.SamePkg)), 185 reflect.Ptr, 186 "", 187 "", 188 }, 189 { 190 reflect.TypeOf(make([]pkg1.SamePkg, 0)), 191 reflect.Slice, 192 "", 193 "", 194 }, 195 { 196 reflect.TypeOf(make([]*pkg1.SamePkg, 0)), 197 reflect.Slice, 198 "", 199 "", 200 }, 201 { 202 reflect.TypeOf(pkg2.SamePkg{}), 203 reflect.Struct, 204 "SamePkg", 205 "gitee.com/go-spring2/spring-base/util/testdata/pkg/foo", 206 }, 207 { 208 reflect.TypeOf(new(pkg2.SamePkg)), 209 reflect.Ptr, 210 "", 211 "", 212 }, 213 { 214 reflect.TypeOf(make([]pkg2.SamePkg, 0)), 215 reflect.Slice, 216 "", 217 "", 218 }, 219 { 220 reflect.TypeOf((*error)(nil)), 221 reflect.Ptr, 222 "", 223 "", 224 }, 225 { 226 reflect.TypeOf((*error)(nil)).Elem(), 227 reflect.Interface, 228 "error", 229 "", 230 }, 231 { 232 reflect.TypeOf((*io.Reader)(nil)), 233 reflect.Ptr, 234 "", 235 "", 236 }, 237 { 238 reflect.TypeOf((*io.Reader)(nil)).Elem(), 239 reflect.Interface, 240 "Reader", 241 "io", 242 }, 243 } 244 245 for _, d := range data { 246 assert.Equal(t, d.typ.Kind(), d.kind) 247 assert.Equal(t, d.typ.Name(), d.name) 248 assert.Equal(t, d.typ.PkgPath(), d.pkg) 249 } 250 } 251 252 func TestTypeName(t *testing.T) { 253 254 data := map[interface{}]struct { 255 typeName string 256 baseName string 257 }{ 258 reflect.TypeOf(3): {"int", "int"}, 259 reflect.TypeOf(new(int)): {"int", "*int"}, 260 reflect.TypeOf(make([]int, 0)): {"int", "[]int"}, 261 reflect.TypeOf(&[]int{3}): {"int", "*[]int"}, 262 reflect.TypeOf(make([]*int, 0)): {"int", "[]*int"}, 263 reflect.TypeOf(make([][]int, 0)): {"int", "[][]int"}, 264 reflect.TypeOf(make(map[int]int)): {"map[int]int", "map[int]int"}, 265 266 reflect.TypeOf(int8(3)): {"int8", "int8"}, 267 reflect.TypeOf(new(int8)): {"int8", "*int8"}, 268 reflect.TypeOf(make([]int8, 0)): {"int8", "[]int8"}, 269 reflect.TypeOf(&[]int8{3}): {"int8", "*[]int8"}, 270 reflect.TypeOf(make(map[int8]int8)): {"map[int8]int8", "map[int8]int8"}, 271 272 reflect.TypeOf(int16(3)): {"int16", "int16"}, 273 reflect.TypeOf(new(int16)): {"int16", "*int16"}, 274 reflect.TypeOf(make([]int16, 0)): {"int16", "[]int16"}, 275 reflect.TypeOf(&[]int16{3}): {"int16", "*[]int16"}, 276 reflect.TypeOf(make(map[int16]int16)): {"map[int16]int16", "map[int16]int16"}, 277 278 reflect.TypeOf(int32(3)): {"int32", "int32"}, 279 reflect.TypeOf(new(int32)): {"int32", "*int32"}, 280 reflect.TypeOf(make([]int32, 0)): {"int32", "[]int32"}, 281 reflect.TypeOf(&[]int32{3}): {"int32", "*[]int32"}, 282 reflect.TypeOf(make(map[int32]int32)): {"map[int32]int32", "map[int32]int32"}, 283 284 reflect.TypeOf(int64(3)): {"int64", "int64"}, 285 reflect.TypeOf(new(int64)): {"int64", "*int64"}, 286 reflect.TypeOf(make([]int64, 0)): {"int64", "[]int64"}, 287 reflect.TypeOf(&[]int64{3}): {"int64", "*[]int64"}, 288 reflect.TypeOf(make(map[int64]int64)): {"map[int64]int64", "map[int64]int64"}, 289 290 reflect.TypeOf(uint(3)): {"uint", "uint"}, 291 reflect.TypeOf(new(uint)): {"uint", "*uint"}, 292 reflect.TypeOf(make([]uint, 0)): {"uint", "[]uint"}, 293 reflect.TypeOf(&[]uint{3}): {"uint", "*[]uint"}, 294 reflect.TypeOf(make(map[uint]uint)): {"map[uint]uint", "map[uint]uint"}, 295 296 reflect.TypeOf(uint8(3)): {"uint8", "uint8"}, 297 reflect.TypeOf(new(uint8)): {"uint8", "*uint8"}, 298 reflect.TypeOf(make([]uint8, 0)): {"uint8", "[]uint8"}, 299 reflect.TypeOf(&[]uint8{3}): {"uint8", "*[]uint8"}, 300 reflect.TypeOf(make(map[uint8]uint8)): {"map[uint8]uint8", "map[uint8]uint8"}, 301 302 reflect.ValueOf(uint16(3)): {"uint16", "uint16"}, 303 reflect.ValueOf(new(uint16)): {"uint16", "*uint16"}, 304 reflect.ValueOf(make([]uint16, 0)): {"uint16", "[]uint16"}, 305 reflect.ValueOf(&[]uint16{3}): {"uint16", "*[]uint16"}, 306 reflect.ValueOf(make(map[uint16]uint16)): {"map[uint16]uint16", "map[uint16]uint16"}, 307 308 reflect.ValueOf(uint32(3)): {"uint32", "uint32"}, 309 reflect.ValueOf(new(uint32)): {"uint32", "*uint32"}, 310 reflect.ValueOf(make([]uint32, 0)): {"uint32", "[]uint32"}, 311 reflect.ValueOf(&[]uint32{3}): {"uint32", "*[]uint32"}, 312 reflect.ValueOf(make(map[uint32]uint32)): {"map[uint32]uint32", "map[uint32]uint32"}, 313 314 reflect.ValueOf(uint64(3)): {"uint64", "uint64"}, 315 reflect.ValueOf(new(uint64)): {"uint64", "*uint64"}, 316 reflect.ValueOf(make([]uint64, 0)): {"uint64", "[]uint64"}, 317 reflect.ValueOf(&[]uint64{3}): {"uint64", "*[]uint64"}, 318 reflect.ValueOf(make(map[uint64]uint64)): {"map[uint64]uint64", "map[uint64]uint64"}, 319 320 reflect.ValueOf(true): {"bool", "bool"}, 321 reflect.ValueOf(new(bool)): {"bool", "*bool"}, 322 reflect.ValueOf(make([]bool, 0)): {"bool", "[]bool"}, 323 reflect.ValueOf(&[]bool{true}): {"bool", "*[]bool"}, 324 reflect.ValueOf(make(map[bool]bool)): {"map[bool]bool", "map[bool]bool"}, 325 326 reflect.ValueOf(float32(3)): {"float32", "float32"}, 327 reflect.ValueOf(new(float32)): {"float32", "*float32"}, 328 reflect.ValueOf(make([]float32, 0)): {"float32", "[]float32"}, 329 reflect.ValueOf(&[]float32{3}): {"float32", "*[]float32"}, 330 reflect.ValueOf(make(map[float32]float32)): {"map[float32]float32", "map[float32]float32"}, 331 332 float64(3): {"float64", "float64"}, 333 new(float64): {"float64", "*float64"}, 334 reflect.TypeOf(make([]float64, 0)): {"float64", "[]float64"}, 335 reflect.TypeOf(&[]float64{3}): {"float64", "*[]float64"}, 336 reflect.TypeOf(make(map[float64]float64)): {"map[float64]float64", "map[float64]float64"}, 337 338 complex64(3): {"complex64", "complex64"}, 339 new(complex64): {"complex64", "*complex64"}, 340 reflect.TypeOf(make([]complex64, 0)): {"complex64", "[]complex64"}, 341 reflect.TypeOf(&[]complex64{3}): {"complex64", "*[]complex64"}, 342 reflect.TypeOf(make(map[complex64]complex64)): {"map[complex64]complex64", "map[complex64]complex64"}, 343 344 complex128(3): {"complex128", "complex128"}, 345 new(complex128): {"complex128", "*complex128"}, 346 reflect.TypeOf(make([]complex128, 0)): {"complex128", "[]complex128"}, 347 reflect.TypeOf(&[]complex128{3}): {"complex128", "*[]complex128"}, 348 reflect.TypeOf(make(map[complex128]complex128)): {"map[complex128]complex128", "map[complex128]complex128"}, 349 350 make(chan int): {"chan int", "chan int"}, 351 make(chan struct{}): {"chan struct {}", "chan struct {}"}, 352 reflect.TypeOf(func() {}): {"func()", "func()"}, 353 354 reflect.TypeOf((*error)(nil)).Elem(): {"error", "error"}, 355 reflect.TypeOf((*fmt.Stringer)(nil)).Elem(): {"fmt/fmt.Stringer", "fmt.Stringer"}, 356 357 "string": {"string", "string"}, 358 new(string): {"string", "*string"}, 359 reflect.TypeOf(make([]string, 0)): {"string", "[]string"}, 360 reflect.TypeOf(&[]string{"string"}): {"string", "*[]string"}, 361 reflect.TypeOf(make(map[string]string)): {"map[string]string", "map[string]string"}, 362 363 pkg1.SamePkg{}: {"gitee.com/go-spring2/spring-base/util/testdata/pkg/bar/pkg.SamePkg", "pkg.SamePkg"}, 364 new(pkg1.SamePkg): {"gitee.com/go-spring2/spring-base/util/testdata/pkg/bar/pkg.SamePkg", "*pkg.SamePkg"}, 365 reflect.TypeOf(make([]pkg1.SamePkg, 0)): {"gitee.com/go-spring2/spring-base/util/testdata/pkg/bar/pkg.SamePkg", "[]pkg.SamePkg"}, 366 reflect.TypeOf(&[]pkg1.SamePkg{}): {"gitee.com/go-spring2/spring-base/util/testdata/pkg/bar/pkg.SamePkg", "*[]pkg.SamePkg"}, 367 reflect.TypeOf(make(map[int]pkg1.SamePkg)): {"map[int]pkg.SamePkg", "map[int]pkg.SamePkg"}, 368 369 pkg2.SamePkg{}: {"gitee.com/go-spring2/spring-base/util/testdata/pkg/foo/pkg.SamePkg", "pkg.SamePkg"}, 370 new(pkg2.SamePkg): {"gitee.com/go-spring2/spring-base/util/testdata/pkg/foo/pkg.SamePkg", "*pkg.SamePkg"}, 371 reflect.TypeOf(make([]pkg2.SamePkg, 0)): {"gitee.com/go-spring2/spring-base/util/testdata/pkg/foo/pkg.SamePkg", "[]pkg.SamePkg"}, 372 reflect.TypeOf(&[]pkg2.SamePkg{}): {"gitee.com/go-spring2/spring-base/util/testdata/pkg/foo/pkg.SamePkg", "*[]pkg.SamePkg"}, 373 reflect.TypeOf(make(map[int]pkg2.SamePkg)): {"map[int]pkg.SamePkg", "map[int]pkg.SamePkg"}, 374 375 SamePkg{}: {"gitee.com/go-spring2/spring-base/util/util_test.SamePkg", "util_test.SamePkg"}, 376 new(SamePkg): {"gitee.com/go-spring2/spring-base/util/util_test.SamePkg", "*util_test.SamePkg"}, 377 reflect.TypeOf(make([]SamePkg, 0)): {"gitee.com/go-spring2/spring-base/util/util_test.SamePkg", "[]util_test.SamePkg"}, 378 reflect.TypeOf(&[]SamePkg{}): {"gitee.com/go-spring2/spring-base/util/util_test.SamePkg", "*[]util_test.SamePkg"}, 379 reflect.TypeOf(make(map[int]SamePkg)): {"map[int]util_test.SamePkg", "map[int]util_test.SamePkg"}, 380 } 381 382 for i, v := range data { 383 typeName := util.TypeName(i) 384 assert.Equal(t, typeName, v.typeName) 385 switch a := i.(type) { 386 case reflect.Type: 387 assert.Equal(t, a.String(), v.baseName) 388 case reflect.Value: 389 assert.Equal(t, a.Type().String(), v.baseName) 390 default: 391 assert.Equal(t, reflect.TypeOf(a).String(), v.baseName) 392 } 393 } 394 } 395 396 func TestIsValueType(t *testing.T) { 397 398 data := []struct { 399 i interface{} 400 v bool 401 }{ 402 {true, true}, // Bool 403 {int(1), true}, // Int 404 {int8(1), true}, // Int8 405 {int16(1), true}, // Int16 406 {int32(1), true}, // Int32 407 {int64(1), true}, // Int64 408 {uint(1), true}, // Uint 409 {uint8(1), true}, // Uint8 410 {uint16(1), true}, // Uint16 411 {uint32(1), true}, // Uint32 412 {uint64(1), true}, // Uint64 413 {uintptr(0), false}, // Uintptr 414 {float32(1), true}, // Float32 415 {float64(1), true}, // Float64 416 {complex64(1), true}, // Complex64 417 {complex128(1), true}, // Complex128 418 {[1]int{0}, true}, // Array 419 {make(chan struct{}), false}, // Chan 420 {func() {}, false}, // Func 421 {reflect.TypeOf((*error)(nil)).Elem(), false}, // Interface 422 {make(map[int]int), true}, // Map 423 {make(map[string]*int), false}, // 424 {new(int), false}, // Ptr 425 {new(struct{}), false}, // 426 {[]int{0}, true}, // Slice 427 {[]*int{}, false}, // 428 {"this is a string", true}, // String 429 {struct{}{}, true}, // Struct 430 {unsafe.Pointer(new(int)), false}, // UnsafePointer 431 } 432 433 for _, d := range data { 434 var typ reflect.Type 435 switch i := d.i.(type) { 436 case reflect.Type: 437 typ = i 438 default: 439 typ = reflect.TypeOf(i) 440 } 441 if r := util.IsValueType(typ); d.v != r { 442 t.Errorf("%v expect %v but %v", typ, d.v, r) 443 } 444 } 445 } 446 447 func TestIsBeanType(t *testing.T) { 448 449 data := []struct { 450 i interface{} 451 v bool 452 }{ 453 {true, false}, // Bool 454 {int(1), false}, // Int 455 {int8(1), false}, // Int8 456 {int16(1), false}, // Int16 457 {int32(1), false}, // Int32 458 {int64(1), false}, // Int64 459 {uint(1), false}, // Uint 460 {uint8(1), false}, // Uint8 461 {uint16(1), false}, // Uint16 462 {uint32(1), false}, // Uint32 463 {uint64(1), false}, // Uint64 464 {uintptr(0), false}, // Uintptr 465 {float32(1), false}, // Float32 466 {float64(1), false}, // Float64 467 {complex64(1), false}, // Complex64 468 {complex128(1), false}, // Complex128 469 {[1]int{0}, false}, // Array 470 {make(chan struct{}), true}, // Chan 471 {func() {}, true}, // Func 472 {reflect.TypeOf((*error)(nil)).Elem(), true}, // Interface 473 {make(map[int]int), false}, // Map 474 {make(map[string]*int), false}, // 475 {new(int), false}, // 476 {new(struct{}), true}, // 477 {[]int{0}, false}, // Slice 478 {[]*int{}, false}, // 479 {"this is a string", false}, // String 480 {struct{}{}, false}, // Struct 481 {unsafe.Pointer(new(int)), false}, // UnsafePointer 482 } 483 484 for _, d := range data { 485 var typ reflect.Type 486 switch i := d.i.(type) { 487 case reflect.Type: 488 typ = i 489 default: 490 typ = reflect.TypeOf(i) 491 } 492 if r := util.IsBeanType(typ); d.v != r { 493 t.Errorf("%v expect %v but %v", typ, d.v, r) 494 } 495 } 496 } 497 498 func TestIsConverter(t *testing.T) { 499 assert.False(t, util.IsConverter(reflect.TypeOf(3))) 500 assert.False(t, util.IsConverter(reflect.TypeOf(func() {}))) 501 assert.False(t, util.IsConverter(reflect.TypeOf(func(key string) {}))) 502 assert.False(t, util.IsConverter(reflect.TypeOf(func(key string) string { return "" }))) 503 assert.True(t, util.IsConverter(reflect.TypeOf(func(key string) (string, error) { return "", nil }))) 504 } 505 506 func TestIsErrorType(t *testing.T) { 507 err := fmt.Errorf("error") 508 assert.True(t, util.IsErrorType(reflect.TypeOf(err))) 509 err = os.ErrClosed 510 assert.True(t, util.IsErrorType(reflect.TypeOf(err))) 511 } 512 513 func TestIsContextType(t *testing.T) { 514 ctx := context.TODO() 515 assert.True(t, util.IsContextType(reflect.TypeOf(ctx))) 516 ctx = context.WithValue(context.TODO(), "a", "3") 517 assert.True(t, util.IsContextType(reflect.TypeOf(ctx))) 518 } 519 520 func TestReturnNothing(t *testing.T) { 521 assert.True(t, util.ReturnNothing(reflect.TypeOf(func() {}))) 522 assert.True(t, util.ReturnNothing(reflect.TypeOf(func(key string) {}))) 523 assert.False(t, util.ReturnNothing(reflect.TypeOf(func() string { return "" }))) 524 } 525 526 func TestReturnOnlyError(t *testing.T) { 527 assert.True(t, util.ReturnOnlyError(reflect.TypeOf(func() error { return nil }))) 528 assert.True(t, util.ReturnOnlyError(reflect.TypeOf(func(string) error { return nil }))) 529 assert.False(t, util.ReturnOnlyError(reflect.TypeOf(func() (string, error) { return "", nil }))) 530 } 531 532 func TestIsStructPtr(t *testing.T) { 533 assert.False(t, util.IsStructPtr(reflect.TypeOf(3))) 534 assert.False(t, util.IsStructPtr(reflect.TypeOf(func() {}))) 535 assert.False(t, util.IsStructPtr(reflect.TypeOf(struct{}{}))) 536 assert.False(t, util.IsStructPtr(reflect.TypeOf(struct{ a string }{}))) 537 assert.True(t, util.IsStructPtr(reflect.TypeOf(&struct{ a string }{}))) 538 } 539 540 func TestIsConstructor(t *testing.T) { 541 assert.False(t, util.IsConstructor(reflect.TypeOf(func() {}))) 542 assert.True(t, util.IsConstructor(reflect.TypeOf(func() string { return "" }))) 543 assert.True(t, util.IsConstructor(reflect.TypeOf(func() *string { return nil }))) 544 assert.True(t, util.IsConstructor(reflect.TypeOf(func() *testdata.Receiver { return nil }))) 545 assert.True(t, util.IsConstructor(reflect.TypeOf(func() (*testdata.Receiver, error) { return nil, nil }))) 546 assert.False(t, util.IsConstructor(reflect.TypeOf(func() (bool, *testdata.Receiver, error) { return false, nil, nil }))) 547 } 548 549 func TestHasReceiver(t *testing.T) { 550 assert.False(t, util.HasReceiver(reflect.TypeOf(func() {}), reflect.ValueOf(new(testdata.Receiver)))) 551 assert.True(t, util.HasReceiver(reflect.TypeOf(func(*testdata.Receiver) {}), reflect.ValueOf(new(testdata.Receiver)))) 552 assert.True(t, util.HasReceiver(reflect.TypeOf(func(*testdata.Receiver, int) {}), reflect.ValueOf(new(testdata.Receiver)))) 553 assert.True(t, util.HasReceiver(reflect.TypeOf(func(fmt.Stringer, int) {}), reflect.ValueOf(new(testdata.Receiver)))) 554 assert.False(t, util.HasReceiver(reflect.TypeOf(func(error, int) {}), reflect.ValueOf(new(testdata.Receiver)))) 555 } 556 557 func TestIsBeanReceiver(t *testing.T) { 558 assert.False(t, util.IsBeanReceiver(reflect.TypeOf("abc"))) 559 assert.False(t, util.IsBeanReceiver(reflect.TypeOf(new(string)))) 560 assert.True(t, util.IsBeanReceiver(reflect.TypeOf(errors.New("abc")))) 561 assert.False(t, util.IsBeanReceiver(reflect.TypeOf([]string{}))) 562 assert.False(t, util.IsBeanReceiver(reflect.TypeOf([]*string{}))) 563 assert.True(t, util.IsBeanReceiver(reflect.TypeOf([]fmt.Stringer{}))) 564 assert.False(t, util.IsBeanReceiver(reflect.TypeOf(map[string]string{}))) 565 assert.False(t, util.IsBeanReceiver(reflect.TypeOf(map[string]*string{}))) 566 assert.True(t, util.IsBeanReceiver(reflect.TypeOf(map[string]fmt.Stringer{}))) 567 }