├── generate ├── go.sum ├── go.mod └── main.go ├── global.go ├── .gitignore ├── benchmark ├── json_copy.go ├── go.mod ├── copy_small_struct_test.go ├── copy_medium_struct_test.go ├── go.sum └── copy_big_struct_test.go ├── go.mod ├── hash.go ├── handlers_test.go ├── LICENSE ├── field.go ├── mem.go ├── option.go ├── handlers.go ├── type.go ├── example_test.go ├── pair.go ├── go.sum ├── README.md ├── structs.go ├── copier.go ├── copier_test.go ├── copy_number.go └── copy_number_test.go /generate/go.sum: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /generate/go.mod: -------------------------------------------------------------------------------- 1 | module github.com/liguangsheng/generate 2 | 3 | go 1.15 4 | -------------------------------------------------------------------------------- /global.go: -------------------------------------------------------------------------------- 1 | package copy 2 | 3 | var _globalCopier = New() 4 | 5 | // Copy values 6 | func Copy(dest, src interface{}) error { 7 | return _globalCopier.Copy(dest, src) 8 | } 9 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Binaries for programs and plugins 2 | *.exe 3 | *.exe~ 4 | *.dll 5 | *.so 6 | *.dylib 7 | 8 | # Test binary, build with `go test -c` 9 | *.test 10 | 11 | # Output of the go coverage destol, specifically when used with LiteIDE 12 | *.out 13 | 14 | .idea -------------------------------------------------------------------------------- /benchmark/json_copy.go: -------------------------------------------------------------------------------- 1 | package benchmark 2 | 3 | import "github.com/json-iterator/go" 4 | 5 | var json = jsoniter.ConfigCompatibleWithStandardLibrary 6 | 7 | func jsonCopy(dest, src interface{}) error { 8 | bytes, _ := json.Marshal(src) 9 | return json.Unmarshal(bytes, dest) 10 | } 11 | -------------------------------------------------------------------------------- /benchmark/go.mod: -------------------------------------------------------------------------------- 1 | module github.com/liguangsheng/go-copy/benchmark 2 | 3 | go 1.15 4 | 5 | require ( 6 | github.com/jinzhu/copier v0.3.0 7 | github.com/json-iterator/go v1.1.10 8 | github.com/liguangsheng/go-copy v1.2.1 9 | github.com/ulule/deepcopier v0.0.0-20200430083143-45decc6639b6 10 | ) 11 | -------------------------------------------------------------------------------- /go.mod: -------------------------------------------------------------------------------- 1 | module github.com/liguangsheng/go-copy 2 | 3 | go 1.15 4 | 5 | require ( 6 | github.com/davecgh/go-spew v1.1.1 // indirect 7 | github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e 8 | github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect 9 | github.com/modern-go/reflect2 v1.0.1 10 | github.com/stretchr/testify v1.7.0 11 | ) 12 | -------------------------------------------------------------------------------- /hash.go: -------------------------------------------------------------------------------- 1 | package copy 2 | 3 | import ( 4 | "encoding/binary" 5 | "github.com/modern-go/reflect2" 6 | ) 7 | 8 | type hash [16]byte 9 | 10 | func hashType(dest, src interface{}) hash { 11 | return hashRType( 12 | reflect2.TypeOf(dest).RType(), 13 | reflect2.TypeOf(src).RType(), 14 | ) 15 | } 16 | 17 | func hashRType(dest, src uintptr) hash { 18 | var h hash 19 | binary.LittleEndian.PutUint64(h[8:], uint64(dest)) 20 | binary.LittleEndian.PutUint64(h[0:], uint64(src)) 21 | return h 22 | } 23 | -------------------------------------------------------------------------------- /handlers_test.go: -------------------------------------------------------------------------------- 1 | package copy 2 | 3 | import ( 4 | "github.com/stretchr/testify/assert" 5 | "testing" 6 | "time" 7 | ) 8 | 9 | func TestTimeToInt64(t *testing.T) { 10 | var src = time.Now() 11 | var dest int64 = 0 12 | assert.NoError(t, Copy(&dest, src)) 13 | assert.Equal(t, src.Unix(), dest) 14 | } 15 | 16 | func TestInt64ToTime(t *testing.T) { 17 | var src = time.Now().Unix() 18 | var dest time.Time 19 | assert.NoError(t, Copy(&dest, src)) 20 | assert.Equal(t, dest.Unix(), src) 21 | } 22 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2019 李广胜 4 | 5 | Permission is hereby granted, free of charge, dest any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), dest deal 7 | in the Software without restriction, including without limitation the rights 8 | dest use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and dest permit persons dest whom the Software is 10 | furnished dest do so, subject dest the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING src, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /field.go: -------------------------------------------------------------------------------- 1 | package copy 2 | 3 | import "reflect" 4 | 5 | type _field struct { 6 | raw reflect.StructField 7 | path string 8 | name string 9 | fullPath string 10 | offset uintptr 11 | } 12 | 13 | func deepFields(typ reflect.Type, parent *_field, namer NameFunc) []_field { 14 | typ = indirectType(typ) 15 | num := typ.NumField() 16 | var fields []_field 17 | for i := 0; i < num; i++ { 18 | field := _field{ 19 | raw: typ.Field(i), 20 | } 21 | 22 | name := namer(field.raw) 23 | if name == "" { 24 | continue 25 | } 26 | field.name = name 27 | 28 | if parent != nil { 29 | field.path = parent.fullPath 30 | field.offset = parent.offset + field.raw.Offset 31 | } else { 32 | field.offset = field.raw.Offset 33 | } 34 | field.fullPath = pathJoin(field.path, name) 35 | 36 | if field.raw.Anonymous && field.raw.Type.Kind() != reflect.Interface { 37 | fields = append(fields, deepFields(field.raw.Type, &field, namer)...) 38 | } else { 39 | fields = append(fields, field) 40 | } 41 | } 42 | return fields 43 | } 44 | 45 | func pathJoin(parent string, child string) string { 46 | if parent == "" { 47 | return child 48 | } 49 | return parent + "." + child 50 | } 51 | -------------------------------------------------------------------------------- /mem.go: -------------------------------------------------------------------------------- 1 | package copy 2 | 3 | import "unsafe" 4 | 5 | func memcpy(dest, src unsafe.Pointer, n uintptr) unsafe.Pointer { 6 | cnt := n >> 3 7 | 8 | for i := uintptr(0); i < cnt; i++ { 9 | var destPtr = (*uint64)(unsafe.Pointer(uintptr(dest) + uintptr(8*i))) 10 | var srcPtr = (*uint64)(unsafe.Pointer(uintptr(src) + uintptr(8*i))) 11 | *destPtr = *srcPtr 12 | } 13 | left := n & 7 14 | for i := uintptr(0); i < left; i++ { 15 | var destPtr = (*uint8)(unsafe.Pointer(uintptr(dest) + uintptr(8*cnt+i))) 16 | var srcPtr = (*uint8)(unsafe.Pointer(uintptr(src) + uintptr(8*cnt+i))) 17 | 18 | *destPtr = *srcPtr 19 | } 20 | return dest 21 | } 22 | 23 | func memset(dest unsafe.Pointer, c int8, n uintptr) unsafe.Pointer { 24 | left := n & 7 25 | cnt := n >> 3 26 | if cnt > 0 { 27 | left += 8 28 | } 29 | for i := uintptr(0); i < left; i++ { 30 | var destPtr = (*int8)(unsafe.Pointer(uintptr(dest) + uintptr(i))) 31 | *destPtr = c 32 | } 33 | if cnt < 2 { 34 | return dest 35 | } 36 | var firstPtr = (*int64)(dest) 37 | 38 | for i := uintptr(0); i < cnt-1; i++ { 39 | var destPtr = (*int64)(unsafe.Pointer(uintptr(dest) + uintptr(left+8*i))) 40 | *destPtr = *firstPtr 41 | } 42 | 43 | return dest 44 | } 45 | -------------------------------------------------------------------------------- /option.go: -------------------------------------------------------------------------------- 1 | package copy 2 | 3 | import ( 4 | "reflect" 5 | "strings" 6 | ) 7 | 8 | // Option dest New a Copier 9 | type Option func(cpr *Copier) 10 | 11 | // WithCacheSize New Copier with specify cache destSize 12 | func WithCacheSize(size int) Option { 13 | return func(cpr *Copier) { 14 | cpr.cap = size 15 | } 16 | } 17 | 18 | // WithNameFunc New Copier with specify name function 19 | func WithNameFunc(fn NameFunc) Option { 20 | return func(cpr *Copier) { 21 | cpr.nameFunc = fn 22 | } 23 | } 24 | 25 | // NameFunc function dest get _pair name 26 | type NameFunc func(field reflect.StructField) string 27 | 28 | // NameByFieldName get name by _pair name 29 | func NameByFieldName(field reflect.StructField) string { 30 | return field.Name 31 | } 32 | 33 | // NameByJSONTag get name by json tag 34 | func NameByJSONTag(field reflect.StructField) string { 35 | tag := strings.SplitN(field.Tag.Get("json"), ",", 2)[0] 36 | if tag == "-" { 37 | return "" 38 | } 39 | return tag 40 | } 41 | 42 | // NameByCopyTag get name by copy tag 43 | func NameByCopyTag(field reflect.StructField) string { 44 | tag := strings.SplitN(field.Tag.Get("copy"), ",", 2)[0] 45 | if tag == "-" { 46 | return "" 47 | } 48 | return tag 49 | } 50 | -------------------------------------------------------------------------------- /benchmark/copy_small_struct_test.go: -------------------------------------------------------------------------------- 1 | package benchmark 2 | 3 | import ( 4 | "testing" 5 | 6 | jzcopier "github.com/jinzhu/copier" 7 | "github.com/liguangsheng/go-copy" 8 | "github.com/ulule/deepcopier" 9 | ) 10 | 11 | type TestStructSmallA struct { 12 | Field1 int 13 | Field7 float64 14 | Field8 string 15 | } 16 | type TestStructSmallB struct { 17 | Field1 int 18 | Field7 float64 19 | Field8 string 20 | } 21 | 22 | func BenchmarkJinzhuCopySmall(b *testing.B) { 23 | var src = TestStructSmallA{} 24 | var dest TestStructSmallB 25 | for i := 0; i < b.N; i++ { 26 | jzcopier.Copy(&dest, src) 27 | } 28 | } 29 | 30 | func BenchmarkDeepCopySmall(b *testing.B) { 31 | var src = TestStructSmallA{} 32 | var dest TestStructSmallB 33 | for i := 0; i < b.N; i++ { 34 | deepcopier.Copy(src).To(&dest) 35 | } 36 | } 37 | 38 | func BenchmarkJSONCopySmall(b *testing.B) { 39 | var src = TestStructSmallA{} 40 | var dest TestStructSmallB 41 | for i := 0; i < b.N; i++ { 42 | jsonCopy(&dest, src) 43 | } 44 | } 45 | 46 | func BenchmarkThisRepoCopySmall(b *testing.B) { 47 | var src = TestStructSmallA{} 48 | var dest TestStructSmallB 49 | cpr := copy.New() 50 | cpr.Copy(&dest, src) 51 | for i := 0; i < b.N; i++ { 52 | cpr.Copy(&dest, src) 53 | } 54 | } 55 | -------------------------------------------------------------------------------- /handlers.go: -------------------------------------------------------------------------------- 1 | package copy 2 | 3 | import ( 4 | "github.com/modern-go/reflect2" 5 | "time" 6 | "unsafe" 7 | ) 8 | 9 | // Handler copy handler interface 10 | type Handler interface { 11 | Copy(destType, srcType reflect2.Type, destPtr, srcPtr unsafe.Pointer) error 12 | } 13 | 14 | // Samples interface 15 | type Samples interface { 16 | Samples() (dest, src interface{}) 17 | } 18 | 19 | // CustomHandler custom copy handler interfac3 20 | type CustomHandler interface { 21 | Handler 22 | Samples 23 | } 24 | 25 | type timeToInt64 struct{} 26 | 27 | func (d timeToInt64) Samples() (dest, src interface{}) { 28 | return int64(0), time.Time{} 29 | } 30 | 31 | func (d timeToInt64) Copy(destType, srcType reflect2.Type, destPtr, srcPtr unsafe.Pointer) error { 32 | unix := srcType.PackEFace(srcPtr).(*time.Time).Unix() 33 | destType.UnsafeSet(destPtr, reflect2.PtrOf(unix)) 34 | return nil 35 | } 36 | 37 | type int64ToTime struct{} 38 | 39 | func (d int64ToTime) Samples() (dest, src interface{}) { 40 | return time.Time{}, int64(0) 41 | } 42 | 43 | func (d int64ToTime) Copy(destType, srcType reflect2.Type, destPtr, srcPtr unsafe.Pointer) error { 44 | unix := srcType.PackEFace(srcPtr).(*int64) 45 | destType.UnsafeSet(destPtr, reflect2.PtrOf(time.Unix(*unix, 0))) 46 | return nil 47 | } 48 | -------------------------------------------------------------------------------- /type.go: -------------------------------------------------------------------------------- 1 | package copy 2 | 3 | import ( 4 | "github.com/modern-go/reflect2" 5 | "reflect" 6 | ) 7 | 8 | func indirectType(typ reflect.Type) reflect.Type { 9 | for typ.Kind() == reflect.Ptr || typ.Kind() == reflect.Slice { 10 | typ = typ.Elem() 11 | } 12 | return typ 13 | } 14 | 15 | func assignable(dest, src reflect2.Type) bool { 16 | if src.AssignableTo(dest) { 17 | return true 18 | } 19 | 20 | if isNumberKind(src.Kind()) && isNumberKind(dest.Kind()) { 21 | return true 22 | } 23 | 24 | if src.Kind() == reflect.Interface && src.Kind() == reflect.Interface { 25 | return dest.Implements(src) 26 | } 27 | 28 | if dest.Kind() == src.Kind() && src.Kind() != reflect.Struct { 29 | return true 30 | } 31 | 32 | return false 33 | } 34 | 35 | func isNumberKind(k reflect.Kind) bool { 36 | switch k { 37 | case reflect.Int, 38 | reflect.Int8, 39 | reflect.Int16, 40 | reflect.Int32, 41 | reflect.Int64, 42 | reflect.Uint, 43 | reflect.Uint8, 44 | reflect.Uint16, 45 | reflect.Uint32, 46 | reflect.Uint64, 47 | reflect.Uintptr, 48 | reflect.Float32, 49 | reflect.Float64: 50 | return true 51 | default: 52 | return false 53 | } 54 | } 55 | 56 | func isSignedIntsKind(k reflect.Kind) bool { 57 | switch k { 58 | case reflect.Int: 59 | fallthrough 60 | case reflect.Int8: 61 | fallthrough 62 | case reflect.Int16: 63 | fallthrough 64 | case reflect.Int32: 65 | fallthrough 66 | case reflect.Int64: 67 | return true 68 | } 69 | return false 70 | } 71 | -------------------------------------------------------------------------------- /benchmark/copy_medium_struct_test.go: -------------------------------------------------------------------------------- 1 | package benchmark 2 | 3 | import ( 4 | "testing" 5 | "time" 6 | 7 | jzcopier "github.com/jinzhu/copier" 8 | "github.com/liguangsheng/go-copy" 9 | "github.com/ulule/deepcopier" 10 | ) 11 | 12 | type TestStructMediumA struct { 13 | Field1 int 14 | Field2 int8 15 | Field3 int16 16 | Field4 int32 17 | Field5 int64 18 | Field6 float32 19 | Field7 float64 20 | Field8 string 21 | Field9 bool 22 | Field10 time.Time 23 | } 24 | type TestStructMediumB struct { 25 | Field1 int 26 | Field2 int8 27 | Field3 int16 28 | Field4 int32 29 | Field5 int64 30 | Field6 float32 31 | Field7 float64 32 | Field8 string 33 | Field9 bool 34 | Field10 time.Time 35 | } 36 | 37 | func BenchmarkJinzhuCopyMedium(b *testing.B) { 38 | var src = TestStructMediumA{} 39 | var dest TestStructMediumB 40 | for i := 0; i < b.N; i++ { 41 | jzcopier.Copy(&dest, src) 42 | } 43 | } 44 | 45 | func BenchmarkDeepCopyMedium(b *testing.B) { 46 | var src = TestStructMediumA{} 47 | var dest TestStructMediumB 48 | for i := 0; i < b.N; i++ { 49 | deepcopier.Copy(src).To(&dest) 50 | } 51 | } 52 | 53 | func BenchmarkJSONCopyMedium(b *testing.B) { 54 | var src = TestStructMediumA{} 55 | var dest TestStructMediumB 56 | for i := 0; i < b.N; i++ { 57 | jsonCopy(&dest, src) 58 | } 59 | } 60 | 61 | func BenchmarkThisRepoCopyMedium(b *testing.B) { 62 | var src = TestStructMediumA{} 63 | var dest TestStructMediumB 64 | cpr := copy.New() 65 | cpr.Copy(&dest, src) 66 | for i := 0; i < b.N; i++ { 67 | cpr.Copy(&dest, src) 68 | } 69 | } 70 | -------------------------------------------------------------------------------- /example_test.go: -------------------------------------------------------------------------------- 1 | package copy_test 2 | 3 | import ( 4 | "fmt" 5 | "github.com/liguangsheng/go-copy" 6 | "github.com/modern-go/reflect2" 7 | "time" 8 | "unsafe" 9 | ) 10 | 11 | // Example 12 | 13 | func Example() { 14 | var src = struct { 15 | Field1 time.Time 16 | Field2 int64 17 | }{ 18 | Field1: time.Now(), 19 | Field2: time.Now().Unix(), 20 | } 21 | var dest = struct { 22 | Field1 int64 23 | Field2 time.Time 24 | }{} 25 | if err := copy.Copy(&dest, src); err != nil { 26 | fmt.Println(err) 27 | } 28 | } 29 | 30 | // Example of custom handlers. 31 | 32 | type IntToString struct{} 33 | 34 | func (d *IntToString) Samples() (dest, src interface{}) { 35 | return "", int(0) 36 | } 37 | 38 | func (d *IntToString) Copy(destType, srcType reflect2.Type, destPtr, srcPtr unsafe.Pointer) error { 39 | val := *(srcType.PackEFace(srcPtr).(*int)) 40 | str := fmt.Sprintf("%d", val) 41 | destType.UnsafeSet(destPtr, reflect2.PtrOf(str)) 42 | return nil 43 | } 44 | 45 | func ExampleHandler() { 46 | var src int = 42 47 | var dest string 48 | copier := copy.New() 49 | copier.Register(&IntToString{}) 50 | if err := copier.Copy(&dest, src); err != nil { 51 | fmt.Println(err) 52 | } 53 | } 54 | 55 | // Example of name function 56 | func ExampleNameFunc() { 57 | var src = struct { 58 | Field1 int `copy:"copy_dest_field2"` 59 | Field2 int `copy:"copy_dest_field1"` 60 | }{ 61 | Field1: 111, 62 | Field2: 222, 63 | } 64 | var dest struct { 65 | Field1 int `copy:"copy_dest_field1"` 66 | Field2 int `copy:"copy_dest_field2"` 67 | } 68 | copier := copy.New(copy.WithCacheSize(10000), copy.WithNameFunc(copy.NameByCopyTag)) 69 | if err := copier.Copy(&dest, src); err != nil { 70 | fmt.Println(err) 71 | } else { 72 | fmt.Println(src) // {111 222} 73 | fmt.Println(dest) // {222 111} 74 | } 75 | } 76 | -------------------------------------------------------------------------------- /pair.go: -------------------------------------------------------------------------------- 1 | package copy 2 | 3 | import ( 4 | "unsafe" 5 | 6 | "github.com/modern-go/reflect2" 7 | ) 8 | 9 | const _mask uint8 = 0b10000000 10 | 11 | type _pair struct { 12 | ban bool 13 | assignable bool 14 | destSize uintptr 15 | srcSize uintptr 16 | destOffset uintptr 17 | srcOffset uintptr 18 | destType reflect2.Type 19 | srcType reflect2.Type 20 | } 21 | 22 | func (p *_pair) copy(dest, src unsafe.Pointer) { 23 | if p.copyNumber(unsafe.Pointer(uintptr(dest)+p.destOffset), unsafe.Pointer(uintptr(src)+p.srcOffset)) { 24 | return 25 | } 26 | 27 | max := p.destSize 28 | min := p.srcSize 29 | if max < min { 30 | max = p.srcSize 31 | min = p.destSize 32 | } 33 | memcpy( 34 | unsafe.Pointer(uintptr(dest)+p.destOffset), 35 | unsafe.Pointer(uintptr(src)+p.srcOffset), 36 | min, 37 | ) 38 | 39 | if p.destType != nil && p.srcType != nil { 40 | var c int8 = 0 41 | if isSignedIntsKind(p.srcType.Kind()) && isSignedIntsKind(p.destType.Kind()) && _mask&*(*uint8)(src) > 0 { 42 | c = -0b1 43 | } 44 | 45 | if max > min { 46 | memset(unsafe.Pointer(uintptr(dest)+p.destOffset+min), c, max-min) 47 | } 48 | } 49 | } 50 | 51 | func (p *_pair) merge(p2 *_pair) bool { 52 | dest1End := p.destOffset + p.destSize 53 | src1End := p.srcOffset + p.destSize 54 | dest2Start := p2.destOffset 55 | src2Start := p2.srcOffset 56 | if src2Start != src1End || dest2Start != dest1End { 57 | return false 58 | } 59 | 60 | p.destSize = p.destSize + p2.destType.Type1().Size() 61 | p.srcSize = p.destSize 62 | p.destType = nil 63 | p.srcType = nil 64 | p2.ban = true 65 | return true 66 | } 67 | 68 | func (p *_pair) copyNumber(dest, src unsafe.Pointer) bool { 69 | if p.destType == nil || p.srcType == nil { 70 | return false 71 | } 72 | 73 | return copyNumber(dest, src, p.destType.Kind(), p.srcType.Kind()) 74 | } 75 | -------------------------------------------------------------------------------- /go.sum: -------------------------------------------------------------------------------- 1 | github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= 2 | github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= 3 | github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= 4 | github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= 5 | github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e h1:1r7pUrabqp18hOBcwBwiTsbnFeTZHV9eER/QT5JVZxY= 6 | github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= 7 | github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= 8 | github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= 9 | github.com/modern-go/reflect2 v1.0.1 h1:9f412s+6RmYXLWZSEzVVgPGK7C2PphHj5RJrvfx9AWI= 10 | github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= 11 | github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= 12 | github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= 13 | github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= 14 | github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= 15 | github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= 16 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= 17 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= 18 | gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo= 19 | gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= 20 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | [![Go Report Card](https://goreportcard.com/badge/github.com/liguangsheng/go-copy)](https://goreportcard.com/report/github.com/liguangsheng/go-copy) 2 | 3 | # go-copy 4 | 5 | fast copy struct dest struct for golang. 6 | 7 | # example 8 | 9 | see [example_test.go](example_test.go) 10 | 11 | # benchmark 12 | ``` 13 | goos: windows 14 | goarch: amd64 15 | pkg: github.com/liguangsheng/go-copy/benchmark 16 | BenchmarkJinzhuCopyBig-8 10000 114140 ns/op 38944 B/op 675 allocs/op 17 | BenchmarkDeepCopyBig-8 732 1482533 ns/op 1907792 B/op 25759 allocs/op 18 | BenchmarkJSONCopyBig-8 50223 23857 ns/op 4438 B/op 142 allocs/op 19 | BenchmarkThisRepoCopyBig-8 1486052 807 ns/op 896 B/op 1 allocs/op 20 | BenchmarkJinzhuCopyMedium-8 226514 5669 ns/op 4136 B/op 72 allocs/op 21 | BenchmarkDeepCopyMedium-8 53980 20994 ns/op 21672 B/op 331 allocs/op 22 | BenchmarkJSONCopyMedium-8 521784 2466 ns/op 440 B/op 16 allocs/op 23 | BenchmarkThisRepoCopyMedium-8 3804498 297 ns/op 96 B/op 1 allocs/op 24 | BenchmarkJinzhuCopySmall-8 750013 1745 ns/op 1200 B/op 25 allocs/op 25 | BenchmarkDeepCopySmall-8 406654 3108 ns/op 2520 B/op 49 allocs/op 26 | BenchmarkJSONCopySmall-8 1889121 613 ns/op 104 B/op 5 allocs/op 27 | BenchmarkThisRepoCopySmall-8 5519410 226 ns/op 32 B/op 1 allocs/op 28 | PASS 29 | ok github.com/liguangsheng/go-copy/benchmark 17.516s 30 | ``` 31 | 32 | -------------------------------------------------------------------------------- /structs.go: -------------------------------------------------------------------------------- 1 | package copy 2 | 3 | import ( 4 | "github.com/modern-go/reflect2" 5 | "reflect" 6 | "unsafe" 7 | ) 8 | 9 | type structsHandler struct { 10 | copier *Copier 11 | fields []*_pair 12 | } 13 | 14 | func (s *structsHandler) Copy(destType, srcType reflect2.Type, destPtr, srcPtr unsafe.Pointer) error { 15 | for _, i := range s.fields { 16 | if err := s.copier.copy(destPtr, srcPtr, i); err != nil { 17 | return err 18 | } 19 | } 20 | return nil 21 | } 22 | 23 | func parseStructs(destType, srcType reflect2.Type, nameFunc NameFunc) []*_pair { 24 | if destType.Kind() != reflect.Struct || srcType.Kind() != reflect.Struct { 25 | return nil 26 | } 27 | 28 | nameMap := make(map[string][]_field) 29 | fullNameMap := make(map[string]_field) 30 | for _, field := range deepFields(srcType.Type1(), nil, nameFunc) { 31 | nameMap[field.name] = append(nameMap[field.name], field) 32 | fullNameMap[field.fullPath] = field 33 | } 34 | 35 | var fields []*_pair 36 | for _, destField := range deepFields(destType.Type1(), nil, nameFunc) { 37 | srcFields, ok := nameMap[destField.name] 38 | if !ok { 39 | continue 40 | } 41 | 42 | var srcField *_field 43 | if len(srcFields) == 1 { 44 | srcField = &srcFields[0] 45 | } else { 46 | matched, ok := fullNameMap[destField.fullPath] 47 | if ok { 48 | srcField = &matched 49 | } 50 | } 51 | 52 | if srcField != nil { 53 | fields = append(fields, &_pair{ 54 | assignable: assignable(reflect2.Type2(destField.raw.Type), reflect2.Type2(srcField.raw.Type)), 55 | srcType: reflect2.Type2(srcField.raw.Type), 56 | srcOffset: srcField.offset, 57 | destType: reflect2.Type2(destField.raw.Type), 58 | destOffset: destField.offset, 59 | destSize: destField.raw.Type.Size(), 60 | srcSize: srcField.raw.Type.Size(), 61 | }) 62 | } 63 | } 64 | 65 | return merge(fields) 66 | } 67 | 68 | func merge(pairs []*_pair) []*_pair { 69 | for i := 0; i < len(pairs); i++ { 70 | p := pairs[i] 71 | if !p.assignable || p.ban { 72 | continue 73 | } 74 | 75 | for j, p2 := range pairs { 76 | if i == j { 77 | continue 78 | } 79 | 80 | if p.merge(p2) { 81 | i-- 82 | break 83 | } 84 | } 85 | } 86 | 87 | var validFields []*_pair 88 | for _, f := range pairs { 89 | if !f.ban { 90 | validFields = append(validFields, f) 91 | } 92 | } 93 | return validFields 94 | } 95 | -------------------------------------------------------------------------------- /copier.go: -------------------------------------------------------------------------------- 1 | package copy 2 | 3 | import ( 4 | "errors" 5 | "reflect" 6 | "unsafe" 7 | 8 | "github.com/golang/groupcache/lru" 9 | "github.com/modern-go/reflect2" 10 | ) 11 | 12 | // New a *Copier 13 | func New(opts ...Option) *Copier { 14 | c := &Copier{ 15 | cache: lru.New(1000), 16 | nameFunc: NameByFieldName, 17 | } 18 | 19 | for _, opt := range opts { 20 | opt(c) 21 | } 22 | 23 | c.Register( 24 | timeToInt64{}, 25 | int64ToTime{}, 26 | ) 27 | 28 | return c 29 | } 30 | 31 | // Copier dest copy values 32 | type Copier struct { 33 | cap int 34 | cache *lru.Cache 35 | nameFunc NameFunc 36 | } 37 | 38 | // Register add typed Copier dest cache 39 | func (c *Copier) Register(handlers ...CustomHandler) { 40 | for _, h := range handlers { 41 | dest, src := h.Samples() 42 | hash := hashType(dest, src) 43 | c.cache.Add(hash, h) 44 | } 45 | } 46 | 47 | // Unregister remove typed Copier src cache 48 | func (c *Copier) Unregister(handlers ...Samples) { 49 | for _, h := range handlers { 50 | dest, src := h.Samples() 51 | hash := hashType(dest, src) 52 | c.cache.Remove(hash) 53 | } 54 | } 55 | 56 | // Copy values 57 | func (c *Copier) Copy(dest, src interface{}) error { 58 | var ( 59 | srcType = indirectType(reflect.TypeOf(src)) 60 | srcType2 = reflect2.Type2(srcType) 61 | srcPtr = reflect2.PtrOf(src) 62 | destType = indirectType(reflect.TypeOf(dest)) 63 | destType2 = reflect2.Type2(destType) 64 | destPtr = reflect2.PtrOf(dest) 65 | ) 66 | 67 | return c.copy(destPtr, srcPtr, &_pair{ 68 | assignable: assignable(destType2, srcType2), 69 | srcType: srcType2, 70 | destType: destType2, 71 | destSize: destType.Size(), 72 | srcSize: srcType.Size(), 73 | }) 74 | } 75 | 76 | func (c *Copier) copy(dest, src unsafe.Pointer, pair *_pair) error { 77 | // memory copy 78 | if pair.assignable { 79 | pair.copy(dest, src) 80 | return nil 81 | } 82 | 83 | // use cached copy handler 84 | hash := hashRType(pair.destType.RType(), pair.srcType.RType()) 85 | if handler, ok := c.cache.Get(hash); ok { 86 | return handler.(Handler).Copy(pair.destType, pair.srcType, dest, src) 87 | } 88 | 89 | fields := parseStructs(pair.destType, pair.srcType, c.nameFunc) 90 | if fields != nil { 91 | sh := &structsHandler{copier: c, fields: fields} 92 | c.cache.Add(hash, sh) 93 | return sh.Copy(pair.destType, pair.srcType, dest, src) 94 | } 95 | 96 | return errors.New("don't know how to copy") 97 | } 98 | -------------------------------------------------------------------------------- /generate/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "os" 5 | "reflect" 6 | "strings" 7 | "text/template" 8 | ) 9 | 10 | func main() { 11 | check(generateCopyNumberFunc()) 12 | check(generateCopyNumberTests()) 13 | } 14 | 15 | func check(err error) { 16 | if err != nil { 17 | panic(err) 18 | } 19 | } 20 | 21 | var kinds = []reflect.Kind{ 22 | reflect.Int8, 23 | reflect.Int16, 24 | reflect.Int32, 25 | reflect.Int64, 26 | reflect.Int, 27 | reflect.Uint8, 28 | reflect.Uint16, 29 | reflect.Uint32, 30 | reflect.Uint64, 31 | reflect.Uint, 32 | reflect.Uintptr, 33 | reflect.Float32, 34 | reflect.Float64, 35 | } 36 | 37 | var funcMap = template.FuncMap{ 38 | "title": strings.Title, 39 | } 40 | 41 | func generateCopyNumberFunc() error { 42 | tplString := `{{$destKinds := .kinds}}{{$srcKinds := .kinds}}package copy 43 | 44 | import ( 45 | "reflect" 46 | "unsafe" 47 | ) 48 | 49 | func copyNumber(dest, src unsafe.Pointer, destKind, srcKind reflect.Kind) bool { 50 | switch srcKind { 51 | {{range $srckind := $srcKinds}} {{$SrcKind := $srckind.String|title}} case reflect.{{$SrcKind}}: 52 | switch destKind { 53 | {{range $destkind := $destKinds}}{{$DestKind := $destkind.String|title}} case reflect.{{$DestKind}}: 54 | *((*{{$destkind}})(dest)) = {{$destkind}}(*((*{{$srckind}})(src))) 55 | return true 56 | {{end}} 57 | } 58 | {{end}} 59 | } 60 | return false 61 | } 62 | ` 63 | file, err := os.OpenFile("copy_number.go", os.O_CREATE|os.O_RDWR|os.O_TRUNC, os.ModePerm) 64 | if err != nil { 65 | return err 66 | } 67 | tpl := template.Must( 68 | template.New("generateCopyNumberFunc").Funcs(funcMap).Parse(tplString), 69 | ) 70 | 71 | err = tpl.Execute(file, map[string]interface{}{ 72 | "kinds": kinds, 73 | }) 74 | if err != nil { 75 | return err 76 | } 77 | return nil 78 | } 79 | 80 | func generateCopyNumberTests() error { 81 | tplString := `{{$destKinds := .kinds}}{{$srcKinds := .kinds}}package copy 82 | 83 | import ( 84 | "github.com/stretchr/testify/assert" 85 | "testing" 86 | ) 87 | 88 | func TestCopyNumber(t *testing.T){ 89 | {{range $srckind := $srcKinds}}{{$SrcKind := $srckind.String|title}} 90 | {{range $destkind := $destKinds}}{{$DestKind := $destkind.String|title}} 91 | t.Run("Test{{$SrcKind}}To{{$DestKind}}", func(t *testing.T) { 92 | var src {{$srckind}} = 18 93 | var dest {{$destkind}} = 10 94 | assert.NoError(t, Copy(&dest, src)) 95 | assert.Equal(t, {{$destkind}}(src), dest) 96 | }) 97 | {{end}} 98 | {{end}} 99 | } 100 | ` 101 | file, err := os.OpenFile("copy_number_test.go", os.O_CREATE|os.O_RDWR|os.O_TRUNC, os.ModePerm) 102 | if err != nil { 103 | return err 104 | } 105 | tpl := template.Must( 106 | template.New("generateCopyNumberTests").Funcs(funcMap).Parse(tplString), 107 | ) 108 | 109 | err = tpl.Execute(file, map[string]interface{}{ 110 | "kinds": kinds, 111 | }) 112 | if err != nil { 113 | return err 114 | } 115 | return nil 116 | } 117 | -------------------------------------------------------------------------------- /benchmark/go.sum: -------------------------------------------------------------------------------- 1 | github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= 2 | github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= 3 | github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= 4 | github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e h1:1r7pUrabqp18hOBcwBwiTsbnFeTZHV9eER/QT5JVZxY= 5 | github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= 6 | github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= 7 | github.com/jinzhu/copier v0.3.0 h1:P5zN9OYSxmtzZmwgcVmt5Iu8egfP53BGMPAFgEksKPI= 8 | github.com/jinzhu/copier v0.3.0/go.mod h1:24xnZezI2Yqac9J61UC6/dG/k76ttpq0DdJI3QmUvro= 9 | github.com/json-iterator/go v1.1.10 h1:Kz6Cvnvv2wGdaG/V8yMvfkmNiXq9Ya2KUv4rouJJr68= 10 | github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= 11 | github.com/liguangsheng/go-copy v1.2.1 h1:q9L19eZJGYWixX49uUlIGvdGvASK63SCcLMZCJ7HuCo= 12 | github.com/liguangsheng/go-copy v1.2.1/go.mod h1:w9dPWf4I9lmGrRC2sujlRZpO+7lma3R/GVk78B4e4uY= 13 | github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 h1:ZqeYNhU3OHLH3mGKHDcjJRFFRrJa6eAM5H+CtDdOsPc= 14 | github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= 15 | github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= 16 | github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= 17 | github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742 h1:Esafd1046DLDQ0W1YjYsBW+p8U2u7vzgW2SQVmlNazg= 18 | github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= 19 | github.com/modern-go/reflect2 v1.0.1 h1:9f412s+6RmYXLWZSEzVVgPGK7C2PphHj5RJrvfx9AWI= 20 | github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= 21 | github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= 22 | github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= 23 | github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= 24 | github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q= 25 | github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= 26 | github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= 27 | github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= 28 | github.com/ulule/deepcopier v0.0.0-20200430083143-45decc6639b6 h1:TtyC78WMafNW8QFfv3TeP3yWNDG+uxNkk9vOrnDu6JA= 29 | github.com/ulule/deepcopier v0.0.0-20200430083143-45decc6639b6/go.mod h1:h8272+G2omSmi30fBXiZDMkmHuOgonplfKIKjQWzlfs= 30 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= 31 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= 32 | gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo= 33 | gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= 34 | -------------------------------------------------------------------------------- /copier_test.go: -------------------------------------------------------------------------------- 1 | package copy 2 | 3 | import ( 4 | "fmt" 5 | "github.com/stretchr/testify/assert" 6 | "testing" 7 | ) 8 | 9 | func TestStringToString(t *testing.T) { 10 | var src = "sudo i love you" 11 | var dest = "i love you" 12 | assert.NoError(t, Copy(&dest, src)) 13 | assert.Equal(t, "sudo i love you", dest) 14 | } 15 | 16 | func TestInt32ToEnum(t *testing.T) { 17 | type enum int32 18 | var src int32 = 2242 19 | var dest enum 20 | assert.NoError(t, Copy(&dest, src)) 21 | assert.Equal(t, enum(2242), dest) 22 | } 23 | 24 | func TestEnumToInt32(t *testing.T) { 25 | type enum int32 26 | var src enum = 2242 27 | var dest int32 28 | assert.NoError(t, Copy(&dest, src)) 29 | assert.Equal(t, int32(2242), dest) 30 | } 31 | 32 | func TestStringToEnum(t *testing.T) { 33 | type enum string 34 | var src string = "enum string" 35 | var dest enum 36 | assert.NoError(t, Copy(&dest, src)) 37 | assert.Equal(t, enum("enum string"), dest) 38 | } 39 | 40 | func TestEnumToString(t *testing.T) { 41 | type enum string 42 | var src enum = "enum string" 43 | var dest string 44 | assert.NoError(t, Copy(&dest, src)) 45 | assert.Equal(t, string("enum string"), dest) 46 | } 47 | 48 | func TestStructToStruct(t *testing.T) { 49 | type ( 50 | FieldStruct struct { 51 | FieldInt int 52 | } 53 | SrcStruct struct { 54 | FieldInterface interface{} 55 | FieldInt int 56 | FieldInt64 int64 57 | FieldFloat64 float64 58 | FieldString string 59 | FieldStruct FieldStruct 60 | } 61 | DestStruct struct { 62 | FieldInterface interface{} 63 | FieldInt int 64 | FieldInt64 int64 65 | FieldFloat64 float64 66 | FieldString string 67 | FieldStruct FieldStruct 68 | } 69 | ) 70 | 71 | var ( 72 | src = SrcStruct{ 73 | FieldInterface: "interface _field", 74 | FieldInt: 1, 75 | FieldString: "you are a good guy", 76 | FieldInt64: 3, 77 | FieldFloat64: 3.141592654, 78 | FieldStruct: FieldStruct{FieldInt: 42}, 79 | } 80 | dest = DestStruct{} 81 | cpr = New() 82 | a = assert.New(t) 83 | ) 84 | a.NoError(cpr.Copy(&dest, src)) 85 | a.Equal("interface _field", dest.FieldInterface) 86 | a.Equal(int(1), dest.FieldInt) 87 | a.Equal("you are a good guy", dest.FieldString) 88 | a.Equal(int64(3), dest.FieldInt64) 89 | a.Equal(float64(3.141592654), dest.FieldFloat64) 90 | a.Equal(42, dest.FieldStruct.FieldInt) 91 | } 92 | 93 | func TestEmbeddingStruct(t *testing.T) { 94 | type Embedding struct { 95 | FieldString string 96 | DuplicateField string 97 | UniqueEmbeddingField string 98 | } 99 | type Embedding2 struct { 100 | FieldString string 101 | DuplicateField string 102 | } 103 | var src = struct { 104 | DuplicateField string 105 | Embedding 106 | Embedding2 107 | }{ 108 | DuplicateField: "outer duplicate _pair", 109 | Embedding: Embedding{ 110 | FieldString: "embedding string _pair", 111 | DuplicateField: "inner duplicate _pair", 112 | UniqueEmbeddingField: "unique embedding string _pair", 113 | }, 114 | Embedding2: Embedding2{ 115 | FieldString: "embedding string _pair - 2", 116 | DuplicateField: "inner duplicate _pair - 2", 117 | }, 118 | } 119 | 120 | var dest struct { 121 | Embedding 122 | DuplicateField string 123 | Embedding2 124 | UniqueEmbeddingField string 125 | FieldEmpty string 126 | } 127 | t.Run("", func(t *testing.T) { 128 | 129 | }) 130 | 131 | a := assert.New(t) 132 | a.NoError(Copy(&dest, src)) 133 | a.Equal("embedding string _pair", dest.Embedding.FieldString) 134 | a.Equal("inner duplicate _pair", dest.Embedding.DuplicateField) 135 | a.Equal("outer duplicate _pair", dest.DuplicateField) 136 | a.Equal("embedding string _pair - 2", dest.Embedding2.FieldString) 137 | a.Equal("inner duplicate _pair - 2", dest.Embedding2.DuplicateField) 138 | a.Equal("unique embedding string _pair", dest.UniqueEmbeddingField) 139 | a.Equal("", dest.FieldEmpty) 140 | } 141 | 142 | type Interface interface { 143 | Foo() 144 | } 145 | 146 | type StringInterface string 147 | 148 | func (StringInterface) Foo() { fmt.Println("foo") } 149 | 150 | type Interface2 interface { 151 | Bar() 152 | } 153 | 154 | func TestInterfaceNotImplemented(t *testing.T) { 155 | type ( 156 | SrcStruct struct { 157 | InterfaceToInterface2 Interface 158 | } 159 | DestStruct struct { 160 | InterfaceToInterface2 Interface2 161 | } 162 | ) 163 | 164 | var ( 165 | src = SrcStruct{ 166 | InterfaceToInterface2: StringInterface("string interface"), 167 | } 168 | dest = DestStruct{} 169 | cpr = New() 170 | a = assert.New(t) 171 | ) 172 | 173 | a.NotNil(cpr.Copy(&dest, src)) 174 | a.Nil(dest.InterfaceToInterface2) 175 | } 176 | -------------------------------------------------------------------------------- /benchmark/copy_big_struct_test.go: -------------------------------------------------------------------------------- 1 | package benchmark 2 | 3 | import ( 4 | "testing" 5 | "time" 6 | 7 | jzcopier "github.com/jinzhu/copier" 8 | "github.com/liguangsheng/go-copy" 9 | "github.com/ulule/deepcopier" 10 | ) 11 | 12 | type TestStructBigA struct { 13 | Field0 int 14 | Field1 int8 15 | Field2 int16 16 | Field3 int32 17 | Field4 int64 18 | Field5 float32 19 | Field6 float64 20 | Field7 string 21 | Field8 bool 22 | Field9 time.Time 23 | Field10 int 24 | Field11 int8 25 | Field12 int16 26 | Field13 int32 27 | Field14 int64 28 | Field15 float32 29 | Field16 float64 30 | Field17 string 31 | Field18 bool 32 | Field19 time.Time 33 | Field20 int 34 | Field21 int8 35 | Field22 int16 36 | Field23 int32 37 | Field24 int64 38 | Field25 float32 39 | Field26 float64 40 | Field27 string 41 | Field28 bool 42 | Field29 time.Time 43 | Field30 int 44 | Field31 int8 45 | Field32 int16 46 | Field33 int32 47 | Field34 int64 48 | Field35 float32 49 | Field36 float64 50 | Field37 string 51 | Field38 bool 52 | Field39 time.Time 53 | Field40 int 54 | Field41 int8 55 | Field42 int16 56 | Field43 int32 57 | Field44 int64 58 | Field45 float32 59 | Field46 float64 60 | Field47 string 61 | Field48 bool 62 | Field49 time.Time 63 | Field50 int 64 | Field51 int8 65 | Field52 int16 66 | Field53 int32 67 | Field54 int64 68 | Field55 float32 69 | Field56 float64 70 | Field57 string 71 | Field58 bool 72 | Field59 time.Time 73 | Field60 int 74 | Field61 int8 75 | Field62 int16 76 | Field63 int32 77 | Field64 int64 78 | Field65 float32 79 | Field66 float64 80 | Field67 string 81 | Field68 bool 82 | Field69 time.Time 83 | Field70 int 84 | Field71 int8 85 | Field72 int16 86 | Field73 int32 87 | Field74 int64 88 | Field75 float32 89 | Field76 float64 90 | Field77 string 91 | Field78 bool 92 | Field79 time.Time 93 | Field80 int 94 | Field81 int8 95 | Field82 int16 96 | Field83 int32 97 | Field84 int64 98 | Field85 float32 99 | Field86 float64 100 | Field87 string 101 | Field88 bool 102 | Field89 time.Time 103 | Field90 int 104 | Field91 int8 105 | Field92 int16 106 | Field93 int32 107 | Field94 int64 108 | Field95 float32 109 | Field96 float64 110 | Field97 string 111 | Field98 bool 112 | Field99 time.Time 113 | } 114 | type TestStructBigB struct { 115 | Field0 int 116 | Field1 int8 117 | Field2 int16 118 | Field3 int32 119 | Field4 int64 120 | Field5 float32 121 | Field6 float64 122 | Field7 string 123 | Field8 bool 124 | Field9 time.Time 125 | Field10 int 126 | Field11 int8 127 | Field12 int16 128 | Field13 int32 129 | Field14 int64 130 | Field15 float32 131 | Field16 float64 132 | Field17 string 133 | Field18 bool 134 | Field19 time.Time 135 | Field20 int 136 | Field21 int8 137 | Field22 int16 138 | Field23 int32 139 | Field24 int64 140 | Field25 float32 141 | Field26 float64 142 | Field27 string 143 | Field28 bool 144 | Field29 time.Time 145 | Field30 int 146 | Field31 int8 147 | Field32 int16 148 | Field33 int32 149 | Field34 int64 150 | Field35 float32 151 | Field36 float64 152 | Field37 string 153 | Field38 bool 154 | Field39 time.Time 155 | Field40 int 156 | Field41 int8 157 | Field42 int16 158 | Field43 int32 159 | Field44 int64 160 | Field45 float32 161 | Field46 float64 162 | Field47 string 163 | Field48 bool 164 | Field49 time.Time 165 | Field50 int 166 | Field51 int8 167 | Field52 int16 168 | Field53 int32 169 | Field54 int64 170 | Field55 float32 171 | Field56 float64 172 | Field57 string 173 | Field58 bool 174 | Field59 time.Time 175 | Field60 int 176 | Field61 int8 177 | Field62 int16 178 | Field63 int32 179 | Field64 int64 180 | Field65 float32 181 | Field66 float64 182 | Field67 string 183 | Field68 bool 184 | Field69 time.Time 185 | Field70 int 186 | Field71 int8 187 | Field72 int16 188 | Field73 int32 189 | Field74 int64 190 | Field75 float32 191 | Field76 float64 192 | Field77 string 193 | Field78 bool 194 | Field79 time.Time 195 | Field80 int 196 | Field81 int8 197 | Field82 int16 198 | Field83 int32 199 | Field84 int64 200 | Field85 float32 201 | Field86 float64 202 | Field87 string 203 | Field88 bool 204 | Field89 time.Time 205 | Field90 int 206 | Field91 int8 207 | Field92 int16 208 | Field93 int32 209 | Field94 int64 210 | Field95 float32 211 | Field96 float64 212 | Field97 string 213 | Field98 bool 214 | Field99 time.Time 215 | } 216 | 217 | func BenchmarkJinzhuCopyBig(b *testing.B) { 218 | var src = TestStructBigA{} 219 | var dest TestStructBigB 220 | for i := 0; i < b.N; i++ { 221 | jzcopier.Copy(&dest, src) 222 | } 223 | } 224 | 225 | func BenchmarkDeepCopyBig(b *testing.B) { 226 | var src = TestStructBigA{} 227 | var dest TestStructBigB 228 | for i := 0; i < b.N; i++ { 229 | deepcopier.Copy(src).To(&dest) 230 | } 231 | } 232 | 233 | func BenchmarkJSONCopyBig(b *testing.B) { 234 | var src = TestStructBigA{} 235 | var dest TestStructBigB 236 | for i := 0; i < b.N; i++ { 237 | jsonCopy(&dest, src) 238 | } 239 | } 240 | 241 | func BenchmarkThisRepoCopyBig(b *testing.B) { 242 | var src = TestStructBigA{} 243 | var dest TestStructBigB 244 | cpr := copy.New() 245 | cpr.Copy(&dest, src) 246 | for i := 0; i < b.N; i++ { 247 | cpr.Copy(&dest, src) 248 | } 249 | } 250 | -------------------------------------------------------------------------------- /copy_number.go: -------------------------------------------------------------------------------- 1 | package copy 2 | 3 | import ( 4 | "reflect" 5 | "unsafe" 6 | ) 7 | 8 | func copyNumber(dest, src unsafe.Pointer, destKind, srcKind reflect.Kind) bool { 9 | switch srcKind { 10 | case reflect.Int8: 11 | switch destKind { 12 | case reflect.Int8: 13 | *((*int8)(dest)) = int8(*((*int8)(src))) 14 | return true 15 | case reflect.Int16: 16 | *((*int16)(dest)) = int16(*((*int8)(src))) 17 | return true 18 | case reflect.Int32: 19 | *((*int32)(dest)) = int32(*((*int8)(src))) 20 | return true 21 | case reflect.Int64: 22 | *((*int64)(dest)) = int64(*((*int8)(src))) 23 | return true 24 | case reflect.Int: 25 | *((*int)(dest)) = int(*((*int8)(src))) 26 | return true 27 | case reflect.Uint8: 28 | *((*uint8)(dest)) = uint8(*((*int8)(src))) 29 | return true 30 | case reflect.Uint16: 31 | *((*uint16)(dest)) = uint16(*((*int8)(src))) 32 | return true 33 | case reflect.Uint32: 34 | *((*uint32)(dest)) = uint32(*((*int8)(src))) 35 | return true 36 | case reflect.Uint64: 37 | *((*uint64)(dest)) = uint64(*((*int8)(src))) 38 | return true 39 | case reflect.Uint: 40 | *((*uint)(dest)) = uint(*((*int8)(src))) 41 | return true 42 | case reflect.Uintptr: 43 | *((*uintptr)(dest)) = uintptr(*((*int8)(src))) 44 | return true 45 | case reflect.Float32: 46 | *((*float32)(dest)) = float32(*((*int8)(src))) 47 | return true 48 | case reflect.Float64: 49 | *((*float64)(dest)) = float64(*((*int8)(src))) 50 | return true 51 | 52 | } 53 | case reflect.Int16: 54 | switch destKind { 55 | case reflect.Int8: 56 | *((*int8)(dest)) = int8(*((*int16)(src))) 57 | return true 58 | case reflect.Int16: 59 | *((*int16)(dest)) = int16(*((*int16)(src))) 60 | return true 61 | case reflect.Int32: 62 | *((*int32)(dest)) = int32(*((*int16)(src))) 63 | return true 64 | case reflect.Int64: 65 | *((*int64)(dest)) = int64(*((*int16)(src))) 66 | return true 67 | case reflect.Int: 68 | *((*int)(dest)) = int(*((*int16)(src))) 69 | return true 70 | case reflect.Uint8: 71 | *((*uint8)(dest)) = uint8(*((*int16)(src))) 72 | return true 73 | case reflect.Uint16: 74 | *((*uint16)(dest)) = uint16(*((*int16)(src))) 75 | return true 76 | case reflect.Uint32: 77 | *((*uint32)(dest)) = uint32(*((*int16)(src))) 78 | return true 79 | case reflect.Uint64: 80 | *((*uint64)(dest)) = uint64(*((*int16)(src))) 81 | return true 82 | case reflect.Uint: 83 | *((*uint)(dest)) = uint(*((*int16)(src))) 84 | return true 85 | case reflect.Uintptr: 86 | *((*uintptr)(dest)) = uintptr(*((*int16)(src))) 87 | return true 88 | case reflect.Float32: 89 | *((*float32)(dest)) = float32(*((*int16)(src))) 90 | return true 91 | case reflect.Float64: 92 | *((*float64)(dest)) = float64(*((*int16)(src))) 93 | return true 94 | 95 | } 96 | case reflect.Int32: 97 | switch destKind { 98 | case reflect.Int8: 99 | *((*int8)(dest)) = int8(*((*int32)(src))) 100 | return true 101 | case reflect.Int16: 102 | *((*int16)(dest)) = int16(*((*int32)(src))) 103 | return true 104 | case reflect.Int32: 105 | *((*int32)(dest)) = int32(*((*int32)(src))) 106 | return true 107 | case reflect.Int64: 108 | *((*int64)(dest)) = int64(*((*int32)(src))) 109 | return true 110 | case reflect.Int: 111 | *((*int)(dest)) = int(*((*int32)(src))) 112 | return true 113 | case reflect.Uint8: 114 | *((*uint8)(dest)) = uint8(*((*int32)(src))) 115 | return true 116 | case reflect.Uint16: 117 | *((*uint16)(dest)) = uint16(*((*int32)(src))) 118 | return true 119 | case reflect.Uint32: 120 | *((*uint32)(dest)) = uint32(*((*int32)(src))) 121 | return true 122 | case reflect.Uint64: 123 | *((*uint64)(dest)) = uint64(*((*int32)(src))) 124 | return true 125 | case reflect.Uint: 126 | *((*uint)(dest)) = uint(*((*int32)(src))) 127 | return true 128 | case reflect.Uintptr: 129 | *((*uintptr)(dest)) = uintptr(*((*int32)(src))) 130 | return true 131 | case reflect.Float32: 132 | *((*float32)(dest)) = float32(*((*int32)(src))) 133 | return true 134 | case reflect.Float64: 135 | *((*float64)(dest)) = float64(*((*int32)(src))) 136 | return true 137 | 138 | } 139 | case reflect.Int64: 140 | switch destKind { 141 | case reflect.Int8: 142 | *((*int8)(dest)) = int8(*((*int64)(src))) 143 | return true 144 | case reflect.Int16: 145 | *((*int16)(dest)) = int16(*((*int64)(src))) 146 | return true 147 | case reflect.Int32: 148 | *((*int32)(dest)) = int32(*((*int64)(src))) 149 | return true 150 | case reflect.Int64: 151 | *((*int64)(dest)) = int64(*((*int64)(src))) 152 | return true 153 | case reflect.Int: 154 | *((*int)(dest)) = int(*((*int64)(src))) 155 | return true 156 | case reflect.Uint8: 157 | *((*uint8)(dest)) = uint8(*((*int64)(src))) 158 | return true 159 | case reflect.Uint16: 160 | *((*uint16)(dest)) = uint16(*((*int64)(src))) 161 | return true 162 | case reflect.Uint32: 163 | *((*uint32)(dest)) = uint32(*((*int64)(src))) 164 | return true 165 | case reflect.Uint64: 166 | *((*uint64)(dest)) = uint64(*((*int64)(src))) 167 | return true 168 | case reflect.Uint: 169 | *((*uint)(dest)) = uint(*((*int64)(src))) 170 | return true 171 | case reflect.Uintptr: 172 | *((*uintptr)(dest)) = uintptr(*((*int64)(src))) 173 | return true 174 | case reflect.Float32: 175 | *((*float32)(dest)) = float32(*((*int64)(src))) 176 | return true 177 | case reflect.Float64: 178 | *((*float64)(dest)) = float64(*((*int64)(src))) 179 | return true 180 | 181 | } 182 | case reflect.Int: 183 | switch destKind { 184 | case reflect.Int8: 185 | *((*int8)(dest)) = int8(*((*int)(src))) 186 | return true 187 | case reflect.Int16: 188 | *((*int16)(dest)) = int16(*((*int)(src))) 189 | return true 190 | case reflect.Int32: 191 | *((*int32)(dest)) = int32(*((*int)(src))) 192 | return true 193 | case reflect.Int64: 194 | *((*int64)(dest)) = int64(*((*int)(src))) 195 | return true 196 | case reflect.Int: 197 | *((*int)(dest)) = int(*((*int)(src))) 198 | return true 199 | case reflect.Uint8: 200 | *((*uint8)(dest)) = uint8(*((*int)(src))) 201 | return true 202 | case reflect.Uint16: 203 | *((*uint16)(dest)) = uint16(*((*int)(src))) 204 | return true 205 | case reflect.Uint32: 206 | *((*uint32)(dest)) = uint32(*((*int)(src))) 207 | return true 208 | case reflect.Uint64: 209 | *((*uint64)(dest)) = uint64(*((*int)(src))) 210 | return true 211 | case reflect.Uint: 212 | *((*uint)(dest)) = uint(*((*int)(src))) 213 | return true 214 | case reflect.Uintptr: 215 | *((*uintptr)(dest)) = uintptr(*((*int)(src))) 216 | return true 217 | case reflect.Float32: 218 | *((*float32)(dest)) = float32(*((*int)(src))) 219 | return true 220 | case reflect.Float64: 221 | *((*float64)(dest)) = float64(*((*int)(src))) 222 | return true 223 | 224 | } 225 | case reflect.Uint8: 226 | switch destKind { 227 | case reflect.Int8: 228 | *((*int8)(dest)) = int8(*((*uint8)(src))) 229 | return true 230 | case reflect.Int16: 231 | *((*int16)(dest)) = int16(*((*uint8)(src))) 232 | return true 233 | case reflect.Int32: 234 | *((*int32)(dest)) = int32(*((*uint8)(src))) 235 | return true 236 | case reflect.Int64: 237 | *((*int64)(dest)) = int64(*((*uint8)(src))) 238 | return true 239 | case reflect.Int: 240 | *((*int)(dest)) = int(*((*uint8)(src))) 241 | return true 242 | case reflect.Uint8: 243 | *((*uint8)(dest)) = uint8(*((*uint8)(src))) 244 | return true 245 | case reflect.Uint16: 246 | *((*uint16)(dest)) = uint16(*((*uint8)(src))) 247 | return true 248 | case reflect.Uint32: 249 | *((*uint32)(dest)) = uint32(*((*uint8)(src))) 250 | return true 251 | case reflect.Uint64: 252 | *((*uint64)(dest)) = uint64(*((*uint8)(src))) 253 | return true 254 | case reflect.Uint: 255 | *((*uint)(dest)) = uint(*((*uint8)(src))) 256 | return true 257 | case reflect.Uintptr: 258 | *((*uintptr)(dest)) = uintptr(*((*uint8)(src))) 259 | return true 260 | case reflect.Float32: 261 | *((*float32)(dest)) = float32(*((*uint8)(src))) 262 | return true 263 | case reflect.Float64: 264 | *((*float64)(dest)) = float64(*((*uint8)(src))) 265 | return true 266 | 267 | } 268 | case reflect.Uint16: 269 | switch destKind { 270 | case reflect.Int8: 271 | *((*int8)(dest)) = int8(*((*uint16)(src))) 272 | return true 273 | case reflect.Int16: 274 | *((*int16)(dest)) = int16(*((*uint16)(src))) 275 | return true 276 | case reflect.Int32: 277 | *((*int32)(dest)) = int32(*((*uint16)(src))) 278 | return true 279 | case reflect.Int64: 280 | *((*int64)(dest)) = int64(*((*uint16)(src))) 281 | return true 282 | case reflect.Int: 283 | *((*int)(dest)) = int(*((*uint16)(src))) 284 | return true 285 | case reflect.Uint8: 286 | *((*uint8)(dest)) = uint8(*((*uint16)(src))) 287 | return true 288 | case reflect.Uint16: 289 | *((*uint16)(dest)) = uint16(*((*uint16)(src))) 290 | return true 291 | case reflect.Uint32: 292 | *((*uint32)(dest)) = uint32(*((*uint16)(src))) 293 | return true 294 | case reflect.Uint64: 295 | *((*uint64)(dest)) = uint64(*((*uint16)(src))) 296 | return true 297 | case reflect.Uint: 298 | *((*uint)(dest)) = uint(*((*uint16)(src))) 299 | return true 300 | case reflect.Uintptr: 301 | *((*uintptr)(dest)) = uintptr(*((*uint16)(src))) 302 | return true 303 | case reflect.Float32: 304 | *((*float32)(dest)) = float32(*((*uint16)(src))) 305 | return true 306 | case reflect.Float64: 307 | *((*float64)(dest)) = float64(*((*uint16)(src))) 308 | return true 309 | 310 | } 311 | case reflect.Uint32: 312 | switch destKind { 313 | case reflect.Int8: 314 | *((*int8)(dest)) = int8(*((*uint32)(src))) 315 | return true 316 | case reflect.Int16: 317 | *((*int16)(dest)) = int16(*((*uint32)(src))) 318 | return true 319 | case reflect.Int32: 320 | *((*int32)(dest)) = int32(*((*uint32)(src))) 321 | return true 322 | case reflect.Int64: 323 | *((*int64)(dest)) = int64(*((*uint32)(src))) 324 | return true 325 | case reflect.Int: 326 | *((*int)(dest)) = int(*((*uint32)(src))) 327 | return true 328 | case reflect.Uint8: 329 | *((*uint8)(dest)) = uint8(*((*uint32)(src))) 330 | return true 331 | case reflect.Uint16: 332 | *((*uint16)(dest)) = uint16(*((*uint32)(src))) 333 | return true 334 | case reflect.Uint32: 335 | *((*uint32)(dest)) = uint32(*((*uint32)(src))) 336 | return true 337 | case reflect.Uint64: 338 | *((*uint64)(dest)) = uint64(*((*uint32)(src))) 339 | return true 340 | case reflect.Uint: 341 | *((*uint)(dest)) = uint(*((*uint32)(src))) 342 | return true 343 | case reflect.Uintptr: 344 | *((*uintptr)(dest)) = uintptr(*((*uint32)(src))) 345 | return true 346 | case reflect.Float32: 347 | *((*float32)(dest)) = float32(*((*uint32)(src))) 348 | return true 349 | case reflect.Float64: 350 | *((*float64)(dest)) = float64(*((*uint32)(src))) 351 | return true 352 | 353 | } 354 | case reflect.Uint64: 355 | switch destKind { 356 | case reflect.Int8: 357 | *((*int8)(dest)) = int8(*((*uint64)(src))) 358 | return true 359 | case reflect.Int16: 360 | *((*int16)(dest)) = int16(*((*uint64)(src))) 361 | return true 362 | case reflect.Int32: 363 | *((*int32)(dest)) = int32(*((*uint64)(src))) 364 | return true 365 | case reflect.Int64: 366 | *((*int64)(dest)) = int64(*((*uint64)(src))) 367 | return true 368 | case reflect.Int: 369 | *((*int)(dest)) = int(*((*uint64)(src))) 370 | return true 371 | case reflect.Uint8: 372 | *((*uint8)(dest)) = uint8(*((*uint64)(src))) 373 | return true 374 | case reflect.Uint16: 375 | *((*uint16)(dest)) = uint16(*((*uint64)(src))) 376 | return true 377 | case reflect.Uint32: 378 | *((*uint32)(dest)) = uint32(*((*uint64)(src))) 379 | return true 380 | case reflect.Uint64: 381 | *((*uint64)(dest)) = uint64(*((*uint64)(src))) 382 | return true 383 | case reflect.Uint: 384 | *((*uint)(dest)) = uint(*((*uint64)(src))) 385 | return true 386 | case reflect.Uintptr: 387 | *((*uintptr)(dest)) = uintptr(*((*uint64)(src))) 388 | return true 389 | case reflect.Float32: 390 | *((*float32)(dest)) = float32(*((*uint64)(src))) 391 | return true 392 | case reflect.Float64: 393 | *((*float64)(dest)) = float64(*((*uint64)(src))) 394 | return true 395 | 396 | } 397 | case reflect.Uint: 398 | switch destKind { 399 | case reflect.Int8: 400 | *((*int8)(dest)) = int8(*((*uint)(src))) 401 | return true 402 | case reflect.Int16: 403 | *((*int16)(dest)) = int16(*((*uint)(src))) 404 | return true 405 | case reflect.Int32: 406 | *((*int32)(dest)) = int32(*((*uint)(src))) 407 | return true 408 | case reflect.Int64: 409 | *((*int64)(dest)) = int64(*((*uint)(src))) 410 | return true 411 | case reflect.Int: 412 | *((*int)(dest)) = int(*((*uint)(src))) 413 | return true 414 | case reflect.Uint8: 415 | *((*uint8)(dest)) = uint8(*((*uint)(src))) 416 | return true 417 | case reflect.Uint16: 418 | *((*uint16)(dest)) = uint16(*((*uint)(src))) 419 | return true 420 | case reflect.Uint32: 421 | *((*uint32)(dest)) = uint32(*((*uint)(src))) 422 | return true 423 | case reflect.Uint64: 424 | *((*uint64)(dest)) = uint64(*((*uint)(src))) 425 | return true 426 | case reflect.Uint: 427 | *((*uint)(dest)) = uint(*((*uint)(src))) 428 | return true 429 | case reflect.Uintptr: 430 | *((*uintptr)(dest)) = uintptr(*((*uint)(src))) 431 | return true 432 | case reflect.Float32: 433 | *((*float32)(dest)) = float32(*((*uint)(src))) 434 | return true 435 | case reflect.Float64: 436 | *((*float64)(dest)) = float64(*((*uint)(src))) 437 | return true 438 | 439 | } 440 | case reflect.Uintptr: 441 | switch destKind { 442 | case reflect.Int8: 443 | *((*int8)(dest)) = int8(*((*uintptr)(src))) 444 | return true 445 | case reflect.Int16: 446 | *((*int16)(dest)) = int16(*((*uintptr)(src))) 447 | return true 448 | case reflect.Int32: 449 | *((*int32)(dest)) = int32(*((*uintptr)(src))) 450 | return true 451 | case reflect.Int64: 452 | *((*int64)(dest)) = int64(*((*uintptr)(src))) 453 | return true 454 | case reflect.Int: 455 | *((*int)(dest)) = int(*((*uintptr)(src))) 456 | return true 457 | case reflect.Uint8: 458 | *((*uint8)(dest)) = uint8(*((*uintptr)(src))) 459 | return true 460 | case reflect.Uint16: 461 | *((*uint16)(dest)) = uint16(*((*uintptr)(src))) 462 | return true 463 | case reflect.Uint32: 464 | *((*uint32)(dest)) = uint32(*((*uintptr)(src))) 465 | return true 466 | case reflect.Uint64: 467 | *((*uint64)(dest)) = uint64(*((*uintptr)(src))) 468 | return true 469 | case reflect.Uint: 470 | *((*uint)(dest)) = uint(*((*uintptr)(src))) 471 | return true 472 | case reflect.Uintptr: 473 | *((*uintptr)(dest)) = uintptr(*((*uintptr)(src))) 474 | return true 475 | case reflect.Float32: 476 | *((*float32)(dest)) = float32(*((*uintptr)(src))) 477 | return true 478 | case reflect.Float64: 479 | *((*float64)(dest)) = float64(*((*uintptr)(src))) 480 | return true 481 | 482 | } 483 | case reflect.Float32: 484 | switch destKind { 485 | case reflect.Int8: 486 | *((*int8)(dest)) = int8(*((*float32)(src))) 487 | return true 488 | case reflect.Int16: 489 | *((*int16)(dest)) = int16(*((*float32)(src))) 490 | return true 491 | case reflect.Int32: 492 | *((*int32)(dest)) = int32(*((*float32)(src))) 493 | return true 494 | case reflect.Int64: 495 | *((*int64)(dest)) = int64(*((*float32)(src))) 496 | return true 497 | case reflect.Int: 498 | *((*int)(dest)) = int(*((*float32)(src))) 499 | return true 500 | case reflect.Uint8: 501 | *((*uint8)(dest)) = uint8(*((*float32)(src))) 502 | return true 503 | case reflect.Uint16: 504 | *((*uint16)(dest)) = uint16(*((*float32)(src))) 505 | return true 506 | case reflect.Uint32: 507 | *((*uint32)(dest)) = uint32(*((*float32)(src))) 508 | return true 509 | case reflect.Uint64: 510 | *((*uint64)(dest)) = uint64(*((*float32)(src))) 511 | return true 512 | case reflect.Uint: 513 | *((*uint)(dest)) = uint(*((*float32)(src))) 514 | return true 515 | case reflect.Uintptr: 516 | *((*uintptr)(dest)) = uintptr(*((*float32)(src))) 517 | return true 518 | case reflect.Float32: 519 | *((*float32)(dest)) = float32(*((*float32)(src))) 520 | return true 521 | case reflect.Float64: 522 | *((*float64)(dest)) = float64(*((*float32)(src))) 523 | return true 524 | 525 | } 526 | case reflect.Float64: 527 | switch destKind { 528 | case reflect.Int8: 529 | *((*int8)(dest)) = int8(*((*float64)(src))) 530 | return true 531 | case reflect.Int16: 532 | *((*int16)(dest)) = int16(*((*float64)(src))) 533 | return true 534 | case reflect.Int32: 535 | *((*int32)(dest)) = int32(*((*float64)(src))) 536 | return true 537 | case reflect.Int64: 538 | *((*int64)(dest)) = int64(*((*float64)(src))) 539 | return true 540 | case reflect.Int: 541 | *((*int)(dest)) = int(*((*float64)(src))) 542 | return true 543 | case reflect.Uint8: 544 | *((*uint8)(dest)) = uint8(*((*float64)(src))) 545 | return true 546 | case reflect.Uint16: 547 | *((*uint16)(dest)) = uint16(*((*float64)(src))) 548 | return true 549 | case reflect.Uint32: 550 | *((*uint32)(dest)) = uint32(*((*float64)(src))) 551 | return true 552 | case reflect.Uint64: 553 | *((*uint64)(dest)) = uint64(*((*float64)(src))) 554 | return true 555 | case reflect.Uint: 556 | *((*uint)(dest)) = uint(*((*float64)(src))) 557 | return true 558 | case reflect.Uintptr: 559 | *((*uintptr)(dest)) = uintptr(*((*float64)(src))) 560 | return true 561 | case reflect.Float32: 562 | *((*float32)(dest)) = float32(*((*float64)(src))) 563 | return true 564 | case reflect.Float64: 565 | *((*float64)(dest)) = float64(*((*float64)(src))) 566 | return true 567 | 568 | } 569 | 570 | } 571 | return false 572 | } 573 | -------------------------------------------------------------------------------- /copy_number_test.go: -------------------------------------------------------------------------------- 1 | package copy 2 | 3 | import ( 4 | "github.com/stretchr/testify/assert" 5 | "testing" 6 | ) 7 | 8 | func TestCopyNumber(t *testing.T) { 9 | 10 | t.Run("TestInt8ToInt8", func(t *testing.T) { 11 | var src int8 = 18 12 | var dest int8 = 10 13 | assert.NoError(t, Copy(&dest, src)) 14 | assert.Equal(t, int8(src), dest) 15 | }) 16 | 17 | t.Run("TestInt8ToInt16", func(t *testing.T) { 18 | var src int8 = 18 19 | var dest int16 = 10 20 | assert.NoError(t, Copy(&dest, src)) 21 | assert.Equal(t, int16(src), dest) 22 | }) 23 | 24 | t.Run("TestInt8ToInt32", func(t *testing.T) { 25 | var src int8 = 18 26 | var dest int32 = 10 27 | assert.NoError(t, Copy(&dest, src)) 28 | assert.Equal(t, int32(src), dest) 29 | }) 30 | 31 | t.Run("TestInt8ToInt64", func(t *testing.T) { 32 | var src int8 = 18 33 | var dest int64 = 10 34 | assert.NoError(t, Copy(&dest, src)) 35 | assert.Equal(t, int64(src), dest) 36 | }) 37 | 38 | t.Run("TestInt8ToInt", func(t *testing.T) { 39 | var src int8 = 18 40 | var dest int = 10 41 | assert.NoError(t, Copy(&dest, src)) 42 | assert.Equal(t, int(src), dest) 43 | }) 44 | 45 | t.Run("TestInt8ToUint8", func(t *testing.T) { 46 | var src int8 = 18 47 | var dest uint8 = 10 48 | assert.NoError(t, Copy(&dest, src)) 49 | assert.Equal(t, uint8(src), dest) 50 | }) 51 | 52 | t.Run("TestInt8ToUint16", func(t *testing.T) { 53 | var src int8 = 18 54 | var dest uint16 = 10 55 | assert.NoError(t, Copy(&dest, src)) 56 | assert.Equal(t, uint16(src), dest) 57 | }) 58 | 59 | t.Run("TestInt8ToUint32", func(t *testing.T) { 60 | var src int8 = 18 61 | var dest uint32 = 10 62 | assert.NoError(t, Copy(&dest, src)) 63 | assert.Equal(t, uint32(src), dest) 64 | }) 65 | 66 | t.Run("TestInt8ToUint64", func(t *testing.T) { 67 | var src int8 = 18 68 | var dest uint64 = 10 69 | assert.NoError(t, Copy(&dest, src)) 70 | assert.Equal(t, uint64(src), dest) 71 | }) 72 | 73 | t.Run("TestInt8ToUint", func(t *testing.T) { 74 | var src int8 = 18 75 | var dest uint = 10 76 | assert.NoError(t, Copy(&dest, src)) 77 | assert.Equal(t, uint(src), dest) 78 | }) 79 | 80 | t.Run("TestInt8ToUintptr", func(t *testing.T) { 81 | var src int8 = 18 82 | var dest uintptr = 10 83 | assert.NoError(t, Copy(&dest, src)) 84 | assert.Equal(t, uintptr(src), dest) 85 | }) 86 | 87 | t.Run("TestInt8ToFloat32", func(t *testing.T) { 88 | var src int8 = 18 89 | var dest float32 = 10 90 | assert.NoError(t, Copy(&dest, src)) 91 | assert.Equal(t, float32(src), dest) 92 | }) 93 | 94 | t.Run("TestInt8ToFloat64", func(t *testing.T) { 95 | var src int8 = 18 96 | var dest float64 = 10 97 | assert.NoError(t, Copy(&dest, src)) 98 | assert.Equal(t, float64(src), dest) 99 | }) 100 | 101 | t.Run("TestInt16ToInt8", func(t *testing.T) { 102 | var src int16 = 18 103 | var dest int8 = 10 104 | assert.NoError(t, Copy(&dest, src)) 105 | assert.Equal(t, int8(src), dest) 106 | }) 107 | 108 | t.Run("TestInt16ToInt16", func(t *testing.T) { 109 | var src int16 = 18 110 | var dest int16 = 10 111 | assert.NoError(t, Copy(&dest, src)) 112 | assert.Equal(t, int16(src), dest) 113 | }) 114 | 115 | t.Run("TestInt16ToInt32", func(t *testing.T) { 116 | var src int16 = 18 117 | var dest int32 = 10 118 | assert.NoError(t, Copy(&dest, src)) 119 | assert.Equal(t, int32(src), dest) 120 | }) 121 | 122 | t.Run("TestInt16ToInt64", func(t *testing.T) { 123 | var src int16 = 18 124 | var dest int64 = 10 125 | assert.NoError(t, Copy(&dest, src)) 126 | assert.Equal(t, int64(src), dest) 127 | }) 128 | 129 | t.Run("TestInt16ToInt", func(t *testing.T) { 130 | var src int16 = 18 131 | var dest int = 10 132 | assert.NoError(t, Copy(&dest, src)) 133 | assert.Equal(t, int(src), dest) 134 | }) 135 | 136 | t.Run("TestInt16ToUint8", func(t *testing.T) { 137 | var src int16 = 18 138 | var dest uint8 = 10 139 | assert.NoError(t, Copy(&dest, src)) 140 | assert.Equal(t, uint8(src), dest) 141 | }) 142 | 143 | t.Run("TestInt16ToUint16", func(t *testing.T) { 144 | var src int16 = 18 145 | var dest uint16 = 10 146 | assert.NoError(t, Copy(&dest, src)) 147 | assert.Equal(t, uint16(src), dest) 148 | }) 149 | 150 | t.Run("TestInt16ToUint32", func(t *testing.T) { 151 | var src int16 = 18 152 | var dest uint32 = 10 153 | assert.NoError(t, Copy(&dest, src)) 154 | assert.Equal(t, uint32(src), dest) 155 | }) 156 | 157 | t.Run("TestInt16ToUint64", func(t *testing.T) { 158 | var src int16 = 18 159 | var dest uint64 = 10 160 | assert.NoError(t, Copy(&dest, src)) 161 | assert.Equal(t, uint64(src), dest) 162 | }) 163 | 164 | t.Run("TestInt16ToUint", func(t *testing.T) { 165 | var src int16 = 18 166 | var dest uint = 10 167 | assert.NoError(t, Copy(&dest, src)) 168 | assert.Equal(t, uint(src), dest) 169 | }) 170 | 171 | t.Run("TestInt16ToUintptr", func(t *testing.T) { 172 | var src int16 = 18 173 | var dest uintptr = 10 174 | assert.NoError(t, Copy(&dest, src)) 175 | assert.Equal(t, uintptr(src), dest) 176 | }) 177 | 178 | t.Run("TestInt16ToFloat32", func(t *testing.T) { 179 | var src int16 = 18 180 | var dest float32 = 10 181 | assert.NoError(t, Copy(&dest, src)) 182 | assert.Equal(t, float32(src), dest) 183 | }) 184 | 185 | t.Run("TestInt16ToFloat64", func(t *testing.T) { 186 | var src int16 = 18 187 | var dest float64 = 10 188 | assert.NoError(t, Copy(&dest, src)) 189 | assert.Equal(t, float64(src), dest) 190 | }) 191 | 192 | t.Run("TestInt32ToInt8", func(t *testing.T) { 193 | var src int32 = 18 194 | var dest int8 = 10 195 | assert.NoError(t, Copy(&dest, src)) 196 | assert.Equal(t, int8(src), dest) 197 | }) 198 | 199 | t.Run("TestInt32ToInt16", func(t *testing.T) { 200 | var src int32 = 18 201 | var dest int16 = 10 202 | assert.NoError(t, Copy(&dest, src)) 203 | assert.Equal(t, int16(src), dest) 204 | }) 205 | 206 | t.Run("TestInt32ToInt32", func(t *testing.T) { 207 | var src int32 = 18 208 | var dest int32 = 10 209 | assert.NoError(t, Copy(&dest, src)) 210 | assert.Equal(t, int32(src), dest) 211 | }) 212 | 213 | t.Run("TestInt32ToInt64", func(t *testing.T) { 214 | var src int32 = 18 215 | var dest int64 = 10 216 | assert.NoError(t, Copy(&dest, src)) 217 | assert.Equal(t, int64(src), dest) 218 | }) 219 | 220 | t.Run("TestInt32ToInt", func(t *testing.T) { 221 | var src int32 = 18 222 | var dest int = 10 223 | assert.NoError(t, Copy(&dest, src)) 224 | assert.Equal(t, int(src), dest) 225 | }) 226 | 227 | t.Run("TestInt32ToUint8", func(t *testing.T) { 228 | var src int32 = 18 229 | var dest uint8 = 10 230 | assert.NoError(t, Copy(&dest, src)) 231 | assert.Equal(t, uint8(src), dest) 232 | }) 233 | 234 | t.Run("TestInt32ToUint16", func(t *testing.T) { 235 | var src int32 = 18 236 | var dest uint16 = 10 237 | assert.NoError(t, Copy(&dest, src)) 238 | assert.Equal(t, uint16(src), dest) 239 | }) 240 | 241 | t.Run("TestInt32ToUint32", func(t *testing.T) { 242 | var src int32 = 18 243 | var dest uint32 = 10 244 | assert.NoError(t, Copy(&dest, src)) 245 | assert.Equal(t, uint32(src), dest) 246 | }) 247 | 248 | t.Run("TestInt32ToUint64", func(t *testing.T) { 249 | var src int32 = 18 250 | var dest uint64 = 10 251 | assert.NoError(t, Copy(&dest, src)) 252 | assert.Equal(t, uint64(src), dest) 253 | }) 254 | 255 | t.Run("TestInt32ToUint", func(t *testing.T) { 256 | var src int32 = 18 257 | var dest uint = 10 258 | assert.NoError(t, Copy(&dest, src)) 259 | assert.Equal(t, uint(src), dest) 260 | }) 261 | 262 | t.Run("TestInt32ToUintptr", func(t *testing.T) { 263 | var src int32 = 18 264 | var dest uintptr = 10 265 | assert.NoError(t, Copy(&dest, src)) 266 | assert.Equal(t, uintptr(src), dest) 267 | }) 268 | 269 | t.Run("TestInt32ToFloat32", func(t *testing.T) { 270 | var src int32 = 18 271 | var dest float32 = 10 272 | assert.NoError(t, Copy(&dest, src)) 273 | assert.Equal(t, float32(src), dest) 274 | }) 275 | 276 | t.Run("TestInt32ToFloat64", func(t *testing.T) { 277 | var src int32 = 18 278 | var dest float64 = 10 279 | assert.NoError(t, Copy(&dest, src)) 280 | assert.Equal(t, float64(src), dest) 281 | }) 282 | 283 | t.Run("TestInt64ToInt8", func(t *testing.T) { 284 | var src int64 = 18 285 | var dest int8 = 10 286 | assert.NoError(t, Copy(&dest, src)) 287 | assert.Equal(t, int8(src), dest) 288 | }) 289 | 290 | t.Run("TestInt64ToInt16", func(t *testing.T) { 291 | var src int64 = 18 292 | var dest int16 = 10 293 | assert.NoError(t, Copy(&dest, src)) 294 | assert.Equal(t, int16(src), dest) 295 | }) 296 | 297 | t.Run("TestInt64ToInt32", func(t *testing.T) { 298 | var src int64 = 18 299 | var dest int32 = 10 300 | assert.NoError(t, Copy(&dest, src)) 301 | assert.Equal(t, int32(src), dest) 302 | }) 303 | 304 | t.Run("TestInt64ToInt64", func(t *testing.T) { 305 | var src int64 = 18 306 | var dest int64 = 10 307 | assert.NoError(t, Copy(&dest, src)) 308 | assert.Equal(t, int64(src), dest) 309 | }) 310 | 311 | t.Run("TestInt64ToInt", func(t *testing.T) { 312 | var src int64 = 18 313 | var dest int = 10 314 | assert.NoError(t, Copy(&dest, src)) 315 | assert.Equal(t, int(src), dest) 316 | }) 317 | 318 | t.Run("TestInt64ToUint8", func(t *testing.T) { 319 | var src int64 = 18 320 | var dest uint8 = 10 321 | assert.NoError(t, Copy(&dest, src)) 322 | assert.Equal(t, uint8(src), dest) 323 | }) 324 | 325 | t.Run("TestInt64ToUint16", func(t *testing.T) { 326 | var src int64 = 18 327 | var dest uint16 = 10 328 | assert.NoError(t, Copy(&dest, src)) 329 | assert.Equal(t, uint16(src), dest) 330 | }) 331 | 332 | t.Run("TestInt64ToUint32", func(t *testing.T) { 333 | var src int64 = 18 334 | var dest uint32 = 10 335 | assert.NoError(t, Copy(&dest, src)) 336 | assert.Equal(t, uint32(src), dest) 337 | }) 338 | 339 | t.Run("TestInt64ToUint64", func(t *testing.T) { 340 | var src int64 = 18 341 | var dest uint64 = 10 342 | assert.NoError(t, Copy(&dest, src)) 343 | assert.Equal(t, uint64(src), dest) 344 | }) 345 | 346 | t.Run("TestInt64ToUint", func(t *testing.T) { 347 | var src int64 = 18 348 | var dest uint = 10 349 | assert.NoError(t, Copy(&dest, src)) 350 | assert.Equal(t, uint(src), dest) 351 | }) 352 | 353 | t.Run("TestInt64ToUintptr", func(t *testing.T) { 354 | var src int64 = 18 355 | var dest uintptr = 10 356 | assert.NoError(t, Copy(&dest, src)) 357 | assert.Equal(t, uintptr(src), dest) 358 | }) 359 | 360 | t.Run("TestInt64ToFloat32", func(t *testing.T) { 361 | var src int64 = 18 362 | var dest float32 = 10 363 | assert.NoError(t, Copy(&dest, src)) 364 | assert.Equal(t, float32(src), dest) 365 | }) 366 | 367 | t.Run("TestInt64ToFloat64", func(t *testing.T) { 368 | var src int64 = 18 369 | var dest float64 = 10 370 | assert.NoError(t, Copy(&dest, src)) 371 | assert.Equal(t, float64(src), dest) 372 | }) 373 | 374 | t.Run("TestIntToInt8", func(t *testing.T) { 375 | var src int = 18 376 | var dest int8 = 10 377 | assert.NoError(t, Copy(&dest, src)) 378 | assert.Equal(t, int8(src), dest) 379 | }) 380 | 381 | t.Run("TestIntToInt16", func(t *testing.T) { 382 | var src int = 18 383 | var dest int16 = 10 384 | assert.NoError(t, Copy(&dest, src)) 385 | assert.Equal(t, int16(src), dest) 386 | }) 387 | 388 | t.Run("TestIntToInt32", func(t *testing.T) { 389 | var src int = 18 390 | var dest int32 = 10 391 | assert.NoError(t, Copy(&dest, src)) 392 | assert.Equal(t, int32(src), dest) 393 | }) 394 | 395 | t.Run("TestIntToInt64", func(t *testing.T) { 396 | var src int = 18 397 | var dest int64 = 10 398 | assert.NoError(t, Copy(&dest, src)) 399 | assert.Equal(t, int64(src), dest) 400 | }) 401 | 402 | t.Run("TestIntToInt", func(t *testing.T) { 403 | var src int = 18 404 | var dest int = 10 405 | assert.NoError(t, Copy(&dest, src)) 406 | assert.Equal(t, int(src), dest) 407 | }) 408 | 409 | t.Run("TestIntToUint8", func(t *testing.T) { 410 | var src int = 18 411 | var dest uint8 = 10 412 | assert.NoError(t, Copy(&dest, src)) 413 | assert.Equal(t, uint8(src), dest) 414 | }) 415 | 416 | t.Run("TestIntToUint16", func(t *testing.T) { 417 | var src int = 18 418 | var dest uint16 = 10 419 | assert.NoError(t, Copy(&dest, src)) 420 | assert.Equal(t, uint16(src), dest) 421 | }) 422 | 423 | t.Run("TestIntToUint32", func(t *testing.T) { 424 | var src int = 18 425 | var dest uint32 = 10 426 | assert.NoError(t, Copy(&dest, src)) 427 | assert.Equal(t, uint32(src), dest) 428 | }) 429 | 430 | t.Run("TestIntToUint64", func(t *testing.T) { 431 | var src int = 18 432 | var dest uint64 = 10 433 | assert.NoError(t, Copy(&dest, src)) 434 | assert.Equal(t, uint64(src), dest) 435 | }) 436 | 437 | t.Run("TestIntToUint", func(t *testing.T) { 438 | var src int = 18 439 | var dest uint = 10 440 | assert.NoError(t, Copy(&dest, src)) 441 | assert.Equal(t, uint(src), dest) 442 | }) 443 | 444 | t.Run("TestIntToUintptr", func(t *testing.T) { 445 | var src int = 18 446 | var dest uintptr = 10 447 | assert.NoError(t, Copy(&dest, src)) 448 | assert.Equal(t, uintptr(src), dest) 449 | }) 450 | 451 | t.Run("TestIntToFloat32", func(t *testing.T) { 452 | var src int = 18 453 | var dest float32 = 10 454 | assert.NoError(t, Copy(&dest, src)) 455 | assert.Equal(t, float32(src), dest) 456 | }) 457 | 458 | t.Run("TestIntToFloat64", func(t *testing.T) { 459 | var src int = 18 460 | var dest float64 = 10 461 | assert.NoError(t, Copy(&dest, src)) 462 | assert.Equal(t, float64(src), dest) 463 | }) 464 | 465 | t.Run("TestUint8ToInt8", func(t *testing.T) { 466 | var src uint8 = 18 467 | var dest int8 = 10 468 | assert.NoError(t, Copy(&dest, src)) 469 | assert.Equal(t, int8(src), dest) 470 | }) 471 | 472 | t.Run("TestUint8ToInt16", func(t *testing.T) { 473 | var src uint8 = 18 474 | var dest int16 = 10 475 | assert.NoError(t, Copy(&dest, src)) 476 | assert.Equal(t, int16(src), dest) 477 | }) 478 | 479 | t.Run("TestUint8ToInt32", func(t *testing.T) { 480 | var src uint8 = 18 481 | var dest int32 = 10 482 | assert.NoError(t, Copy(&dest, src)) 483 | assert.Equal(t, int32(src), dest) 484 | }) 485 | 486 | t.Run("TestUint8ToInt64", func(t *testing.T) { 487 | var src uint8 = 18 488 | var dest int64 = 10 489 | assert.NoError(t, Copy(&dest, src)) 490 | assert.Equal(t, int64(src), dest) 491 | }) 492 | 493 | t.Run("TestUint8ToInt", func(t *testing.T) { 494 | var src uint8 = 18 495 | var dest int = 10 496 | assert.NoError(t, Copy(&dest, src)) 497 | assert.Equal(t, int(src), dest) 498 | }) 499 | 500 | t.Run("TestUint8ToUint8", func(t *testing.T) { 501 | var src uint8 = 18 502 | var dest uint8 = 10 503 | assert.NoError(t, Copy(&dest, src)) 504 | assert.Equal(t, uint8(src), dest) 505 | }) 506 | 507 | t.Run("TestUint8ToUint16", func(t *testing.T) { 508 | var src uint8 = 18 509 | var dest uint16 = 10 510 | assert.NoError(t, Copy(&dest, src)) 511 | assert.Equal(t, uint16(src), dest) 512 | }) 513 | 514 | t.Run("TestUint8ToUint32", func(t *testing.T) { 515 | var src uint8 = 18 516 | var dest uint32 = 10 517 | assert.NoError(t, Copy(&dest, src)) 518 | assert.Equal(t, uint32(src), dest) 519 | }) 520 | 521 | t.Run("TestUint8ToUint64", func(t *testing.T) { 522 | var src uint8 = 18 523 | var dest uint64 = 10 524 | assert.NoError(t, Copy(&dest, src)) 525 | assert.Equal(t, uint64(src), dest) 526 | }) 527 | 528 | t.Run("TestUint8ToUint", func(t *testing.T) { 529 | var src uint8 = 18 530 | var dest uint = 10 531 | assert.NoError(t, Copy(&dest, src)) 532 | assert.Equal(t, uint(src), dest) 533 | }) 534 | 535 | t.Run("TestUint8ToUintptr", func(t *testing.T) { 536 | var src uint8 = 18 537 | var dest uintptr = 10 538 | assert.NoError(t, Copy(&dest, src)) 539 | assert.Equal(t, uintptr(src), dest) 540 | }) 541 | 542 | t.Run("TestUint8ToFloat32", func(t *testing.T) { 543 | var src uint8 = 18 544 | var dest float32 = 10 545 | assert.NoError(t, Copy(&dest, src)) 546 | assert.Equal(t, float32(src), dest) 547 | }) 548 | 549 | t.Run("TestUint8ToFloat64", func(t *testing.T) { 550 | var src uint8 = 18 551 | var dest float64 = 10 552 | assert.NoError(t, Copy(&dest, src)) 553 | assert.Equal(t, float64(src), dest) 554 | }) 555 | 556 | t.Run("TestUint16ToInt8", func(t *testing.T) { 557 | var src uint16 = 18 558 | var dest int8 = 10 559 | assert.NoError(t, Copy(&dest, src)) 560 | assert.Equal(t, int8(src), dest) 561 | }) 562 | 563 | t.Run("TestUint16ToInt16", func(t *testing.T) { 564 | var src uint16 = 18 565 | var dest int16 = 10 566 | assert.NoError(t, Copy(&dest, src)) 567 | assert.Equal(t, int16(src), dest) 568 | }) 569 | 570 | t.Run("TestUint16ToInt32", func(t *testing.T) { 571 | var src uint16 = 18 572 | var dest int32 = 10 573 | assert.NoError(t, Copy(&dest, src)) 574 | assert.Equal(t, int32(src), dest) 575 | }) 576 | 577 | t.Run("TestUint16ToInt64", func(t *testing.T) { 578 | var src uint16 = 18 579 | var dest int64 = 10 580 | assert.NoError(t, Copy(&dest, src)) 581 | assert.Equal(t, int64(src), dest) 582 | }) 583 | 584 | t.Run("TestUint16ToInt", func(t *testing.T) { 585 | var src uint16 = 18 586 | var dest int = 10 587 | assert.NoError(t, Copy(&dest, src)) 588 | assert.Equal(t, int(src), dest) 589 | }) 590 | 591 | t.Run("TestUint16ToUint8", func(t *testing.T) { 592 | var src uint16 = 18 593 | var dest uint8 = 10 594 | assert.NoError(t, Copy(&dest, src)) 595 | assert.Equal(t, uint8(src), dest) 596 | }) 597 | 598 | t.Run("TestUint16ToUint16", func(t *testing.T) { 599 | var src uint16 = 18 600 | var dest uint16 = 10 601 | assert.NoError(t, Copy(&dest, src)) 602 | assert.Equal(t, uint16(src), dest) 603 | }) 604 | 605 | t.Run("TestUint16ToUint32", func(t *testing.T) { 606 | var src uint16 = 18 607 | var dest uint32 = 10 608 | assert.NoError(t, Copy(&dest, src)) 609 | assert.Equal(t, uint32(src), dest) 610 | }) 611 | 612 | t.Run("TestUint16ToUint64", func(t *testing.T) { 613 | var src uint16 = 18 614 | var dest uint64 = 10 615 | assert.NoError(t, Copy(&dest, src)) 616 | assert.Equal(t, uint64(src), dest) 617 | }) 618 | 619 | t.Run("TestUint16ToUint", func(t *testing.T) { 620 | var src uint16 = 18 621 | var dest uint = 10 622 | assert.NoError(t, Copy(&dest, src)) 623 | assert.Equal(t, uint(src), dest) 624 | }) 625 | 626 | t.Run("TestUint16ToUintptr", func(t *testing.T) { 627 | var src uint16 = 18 628 | var dest uintptr = 10 629 | assert.NoError(t, Copy(&dest, src)) 630 | assert.Equal(t, uintptr(src), dest) 631 | }) 632 | 633 | t.Run("TestUint16ToFloat32", func(t *testing.T) { 634 | var src uint16 = 18 635 | var dest float32 = 10 636 | assert.NoError(t, Copy(&dest, src)) 637 | assert.Equal(t, float32(src), dest) 638 | }) 639 | 640 | t.Run("TestUint16ToFloat64", func(t *testing.T) { 641 | var src uint16 = 18 642 | var dest float64 = 10 643 | assert.NoError(t, Copy(&dest, src)) 644 | assert.Equal(t, float64(src), dest) 645 | }) 646 | 647 | t.Run("TestUint32ToInt8", func(t *testing.T) { 648 | var src uint32 = 18 649 | var dest int8 = 10 650 | assert.NoError(t, Copy(&dest, src)) 651 | assert.Equal(t, int8(src), dest) 652 | }) 653 | 654 | t.Run("TestUint32ToInt16", func(t *testing.T) { 655 | var src uint32 = 18 656 | var dest int16 = 10 657 | assert.NoError(t, Copy(&dest, src)) 658 | assert.Equal(t, int16(src), dest) 659 | }) 660 | 661 | t.Run("TestUint32ToInt32", func(t *testing.T) { 662 | var src uint32 = 18 663 | var dest int32 = 10 664 | assert.NoError(t, Copy(&dest, src)) 665 | assert.Equal(t, int32(src), dest) 666 | }) 667 | 668 | t.Run("TestUint32ToInt64", func(t *testing.T) { 669 | var src uint32 = 18 670 | var dest int64 = 10 671 | assert.NoError(t, Copy(&dest, src)) 672 | assert.Equal(t, int64(src), dest) 673 | }) 674 | 675 | t.Run("TestUint32ToInt", func(t *testing.T) { 676 | var src uint32 = 18 677 | var dest int = 10 678 | assert.NoError(t, Copy(&dest, src)) 679 | assert.Equal(t, int(src), dest) 680 | }) 681 | 682 | t.Run("TestUint32ToUint8", func(t *testing.T) { 683 | var src uint32 = 18 684 | var dest uint8 = 10 685 | assert.NoError(t, Copy(&dest, src)) 686 | assert.Equal(t, uint8(src), dest) 687 | }) 688 | 689 | t.Run("TestUint32ToUint16", func(t *testing.T) { 690 | var src uint32 = 18 691 | var dest uint16 = 10 692 | assert.NoError(t, Copy(&dest, src)) 693 | assert.Equal(t, uint16(src), dest) 694 | }) 695 | 696 | t.Run("TestUint32ToUint32", func(t *testing.T) { 697 | var src uint32 = 18 698 | var dest uint32 = 10 699 | assert.NoError(t, Copy(&dest, src)) 700 | assert.Equal(t, uint32(src), dest) 701 | }) 702 | 703 | t.Run("TestUint32ToUint64", func(t *testing.T) { 704 | var src uint32 = 18 705 | var dest uint64 = 10 706 | assert.NoError(t, Copy(&dest, src)) 707 | assert.Equal(t, uint64(src), dest) 708 | }) 709 | 710 | t.Run("TestUint32ToUint", func(t *testing.T) { 711 | var src uint32 = 18 712 | var dest uint = 10 713 | assert.NoError(t, Copy(&dest, src)) 714 | assert.Equal(t, uint(src), dest) 715 | }) 716 | 717 | t.Run("TestUint32ToUintptr", func(t *testing.T) { 718 | var src uint32 = 18 719 | var dest uintptr = 10 720 | assert.NoError(t, Copy(&dest, src)) 721 | assert.Equal(t, uintptr(src), dest) 722 | }) 723 | 724 | t.Run("TestUint32ToFloat32", func(t *testing.T) { 725 | var src uint32 = 18 726 | var dest float32 = 10 727 | assert.NoError(t, Copy(&dest, src)) 728 | assert.Equal(t, float32(src), dest) 729 | }) 730 | 731 | t.Run("TestUint32ToFloat64", func(t *testing.T) { 732 | var src uint32 = 18 733 | var dest float64 = 10 734 | assert.NoError(t, Copy(&dest, src)) 735 | assert.Equal(t, float64(src), dest) 736 | }) 737 | 738 | t.Run("TestUint64ToInt8", func(t *testing.T) { 739 | var src uint64 = 18 740 | var dest int8 = 10 741 | assert.NoError(t, Copy(&dest, src)) 742 | assert.Equal(t, int8(src), dest) 743 | }) 744 | 745 | t.Run("TestUint64ToInt16", func(t *testing.T) { 746 | var src uint64 = 18 747 | var dest int16 = 10 748 | assert.NoError(t, Copy(&dest, src)) 749 | assert.Equal(t, int16(src), dest) 750 | }) 751 | 752 | t.Run("TestUint64ToInt32", func(t *testing.T) { 753 | var src uint64 = 18 754 | var dest int32 = 10 755 | assert.NoError(t, Copy(&dest, src)) 756 | assert.Equal(t, int32(src), dest) 757 | }) 758 | 759 | t.Run("TestUint64ToInt64", func(t *testing.T) { 760 | var src uint64 = 18 761 | var dest int64 = 10 762 | assert.NoError(t, Copy(&dest, src)) 763 | assert.Equal(t, int64(src), dest) 764 | }) 765 | 766 | t.Run("TestUint64ToInt", func(t *testing.T) { 767 | var src uint64 = 18 768 | var dest int = 10 769 | assert.NoError(t, Copy(&dest, src)) 770 | assert.Equal(t, int(src), dest) 771 | }) 772 | 773 | t.Run("TestUint64ToUint8", func(t *testing.T) { 774 | var src uint64 = 18 775 | var dest uint8 = 10 776 | assert.NoError(t, Copy(&dest, src)) 777 | assert.Equal(t, uint8(src), dest) 778 | }) 779 | 780 | t.Run("TestUint64ToUint16", func(t *testing.T) { 781 | var src uint64 = 18 782 | var dest uint16 = 10 783 | assert.NoError(t, Copy(&dest, src)) 784 | assert.Equal(t, uint16(src), dest) 785 | }) 786 | 787 | t.Run("TestUint64ToUint32", func(t *testing.T) { 788 | var src uint64 = 18 789 | var dest uint32 = 10 790 | assert.NoError(t, Copy(&dest, src)) 791 | assert.Equal(t, uint32(src), dest) 792 | }) 793 | 794 | t.Run("TestUint64ToUint64", func(t *testing.T) { 795 | var src uint64 = 18 796 | var dest uint64 = 10 797 | assert.NoError(t, Copy(&dest, src)) 798 | assert.Equal(t, uint64(src), dest) 799 | }) 800 | 801 | t.Run("TestUint64ToUint", func(t *testing.T) { 802 | var src uint64 = 18 803 | var dest uint = 10 804 | assert.NoError(t, Copy(&dest, src)) 805 | assert.Equal(t, uint(src), dest) 806 | }) 807 | 808 | t.Run("TestUint64ToUintptr", func(t *testing.T) { 809 | var src uint64 = 18 810 | var dest uintptr = 10 811 | assert.NoError(t, Copy(&dest, src)) 812 | assert.Equal(t, uintptr(src), dest) 813 | }) 814 | 815 | t.Run("TestUint64ToFloat32", func(t *testing.T) { 816 | var src uint64 = 18 817 | var dest float32 = 10 818 | assert.NoError(t, Copy(&dest, src)) 819 | assert.Equal(t, float32(src), dest) 820 | }) 821 | 822 | t.Run("TestUint64ToFloat64", func(t *testing.T) { 823 | var src uint64 = 18 824 | var dest float64 = 10 825 | assert.NoError(t, Copy(&dest, src)) 826 | assert.Equal(t, float64(src), dest) 827 | }) 828 | 829 | t.Run("TestUintToInt8", func(t *testing.T) { 830 | var src uint = 18 831 | var dest int8 = 10 832 | assert.NoError(t, Copy(&dest, src)) 833 | assert.Equal(t, int8(src), dest) 834 | }) 835 | 836 | t.Run("TestUintToInt16", func(t *testing.T) { 837 | var src uint = 18 838 | var dest int16 = 10 839 | assert.NoError(t, Copy(&dest, src)) 840 | assert.Equal(t, int16(src), dest) 841 | }) 842 | 843 | t.Run("TestUintToInt32", func(t *testing.T) { 844 | var src uint = 18 845 | var dest int32 = 10 846 | assert.NoError(t, Copy(&dest, src)) 847 | assert.Equal(t, int32(src), dest) 848 | }) 849 | 850 | t.Run("TestUintToInt64", func(t *testing.T) { 851 | var src uint = 18 852 | var dest int64 = 10 853 | assert.NoError(t, Copy(&dest, src)) 854 | assert.Equal(t, int64(src), dest) 855 | }) 856 | 857 | t.Run("TestUintToInt", func(t *testing.T) { 858 | var src uint = 18 859 | var dest int = 10 860 | assert.NoError(t, Copy(&dest, src)) 861 | assert.Equal(t, int(src), dest) 862 | }) 863 | 864 | t.Run("TestUintToUint8", func(t *testing.T) { 865 | var src uint = 18 866 | var dest uint8 = 10 867 | assert.NoError(t, Copy(&dest, src)) 868 | assert.Equal(t, uint8(src), dest) 869 | }) 870 | 871 | t.Run("TestUintToUint16", func(t *testing.T) { 872 | var src uint = 18 873 | var dest uint16 = 10 874 | assert.NoError(t, Copy(&dest, src)) 875 | assert.Equal(t, uint16(src), dest) 876 | }) 877 | 878 | t.Run("TestUintToUint32", func(t *testing.T) { 879 | var src uint = 18 880 | var dest uint32 = 10 881 | assert.NoError(t, Copy(&dest, src)) 882 | assert.Equal(t, uint32(src), dest) 883 | }) 884 | 885 | t.Run("TestUintToUint64", func(t *testing.T) { 886 | var src uint = 18 887 | var dest uint64 = 10 888 | assert.NoError(t, Copy(&dest, src)) 889 | assert.Equal(t, uint64(src), dest) 890 | }) 891 | 892 | t.Run("TestUintToUint", func(t *testing.T) { 893 | var src uint = 18 894 | var dest uint = 10 895 | assert.NoError(t, Copy(&dest, src)) 896 | assert.Equal(t, uint(src), dest) 897 | }) 898 | 899 | t.Run("TestUintToUintptr", func(t *testing.T) { 900 | var src uint = 18 901 | var dest uintptr = 10 902 | assert.NoError(t, Copy(&dest, src)) 903 | assert.Equal(t, uintptr(src), dest) 904 | }) 905 | 906 | t.Run("TestUintToFloat32", func(t *testing.T) { 907 | var src uint = 18 908 | var dest float32 = 10 909 | assert.NoError(t, Copy(&dest, src)) 910 | assert.Equal(t, float32(src), dest) 911 | }) 912 | 913 | t.Run("TestUintToFloat64", func(t *testing.T) { 914 | var src uint = 18 915 | var dest float64 = 10 916 | assert.NoError(t, Copy(&dest, src)) 917 | assert.Equal(t, float64(src), dest) 918 | }) 919 | 920 | t.Run("TestUintptrToInt8", func(t *testing.T) { 921 | var src uintptr = 18 922 | var dest int8 = 10 923 | assert.NoError(t, Copy(&dest, src)) 924 | assert.Equal(t, int8(src), dest) 925 | }) 926 | 927 | t.Run("TestUintptrToInt16", func(t *testing.T) { 928 | var src uintptr = 18 929 | var dest int16 = 10 930 | assert.NoError(t, Copy(&dest, src)) 931 | assert.Equal(t, int16(src), dest) 932 | }) 933 | 934 | t.Run("TestUintptrToInt32", func(t *testing.T) { 935 | var src uintptr = 18 936 | var dest int32 = 10 937 | assert.NoError(t, Copy(&dest, src)) 938 | assert.Equal(t, int32(src), dest) 939 | }) 940 | 941 | t.Run("TestUintptrToInt64", func(t *testing.T) { 942 | var src uintptr = 18 943 | var dest int64 = 10 944 | assert.NoError(t, Copy(&dest, src)) 945 | assert.Equal(t, int64(src), dest) 946 | }) 947 | 948 | t.Run("TestUintptrToInt", func(t *testing.T) { 949 | var src uintptr = 18 950 | var dest int = 10 951 | assert.NoError(t, Copy(&dest, src)) 952 | assert.Equal(t, int(src), dest) 953 | }) 954 | 955 | t.Run("TestUintptrToUint8", func(t *testing.T) { 956 | var src uintptr = 18 957 | var dest uint8 = 10 958 | assert.NoError(t, Copy(&dest, src)) 959 | assert.Equal(t, uint8(src), dest) 960 | }) 961 | 962 | t.Run("TestUintptrToUint16", func(t *testing.T) { 963 | var src uintptr = 18 964 | var dest uint16 = 10 965 | assert.NoError(t, Copy(&dest, src)) 966 | assert.Equal(t, uint16(src), dest) 967 | }) 968 | 969 | t.Run("TestUintptrToUint32", func(t *testing.T) { 970 | var src uintptr = 18 971 | var dest uint32 = 10 972 | assert.NoError(t, Copy(&dest, src)) 973 | assert.Equal(t, uint32(src), dest) 974 | }) 975 | 976 | t.Run("TestUintptrToUint64", func(t *testing.T) { 977 | var src uintptr = 18 978 | var dest uint64 = 10 979 | assert.NoError(t, Copy(&dest, src)) 980 | assert.Equal(t, uint64(src), dest) 981 | }) 982 | 983 | t.Run("TestUintptrToUint", func(t *testing.T) { 984 | var src uintptr = 18 985 | var dest uint = 10 986 | assert.NoError(t, Copy(&dest, src)) 987 | assert.Equal(t, uint(src), dest) 988 | }) 989 | 990 | t.Run("TestUintptrToUintptr", func(t *testing.T) { 991 | var src uintptr = 18 992 | var dest uintptr = 10 993 | assert.NoError(t, Copy(&dest, src)) 994 | assert.Equal(t, uintptr(src), dest) 995 | }) 996 | 997 | t.Run("TestUintptrToFloat32", func(t *testing.T) { 998 | var src uintptr = 18 999 | var dest float32 = 10 1000 | assert.NoError(t, Copy(&dest, src)) 1001 | assert.Equal(t, float32(src), dest) 1002 | }) 1003 | 1004 | t.Run("TestUintptrToFloat64", func(t *testing.T) { 1005 | var src uintptr = 18 1006 | var dest float64 = 10 1007 | assert.NoError(t, Copy(&dest, src)) 1008 | assert.Equal(t, float64(src), dest) 1009 | }) 1010 | 1011 | t.Run("TestFloat32ToInt8", func(t *testing.T) { 1012 | var src float32 = 18 1013 | var dest int8 = 10 1014 | assert.NoError(t, Copy(&dest, src)) 1015 | assert.Equal(t, int8(src), dest) 1016 | }) 1017 | 1018 | t.Run("TestFloat32ToInt16", func(t *testing.T) { 1019 | var src float32 = 18 1020 | var dest int16 = 10 1021 | assert.NoError(t, Copy(&dest, src)) 1022 | assert.Equal(t, int16(src), dest) 1023 | }) 1024 | 1025 | t.Run("TestFloat32ToInt32", func(t *testing.T) { 1026 | var src float32 = 18 1027 | var dest int32 = 10 1028 | assert.NoError(t, Copy(&dest, src)) 1029 | assert.Equal(t, int32(src), dest) 1030 | }) 1031 | 1032 | t.Run("TestFloat32ToInt64", func(t *testing.T) { 1033 | var src float32 = 18 1034 | var dest int64 = 10 1035 | assert.NoError(t, Copy(&dest, src)) 1036 | assert.Equal(t, int64(src), dest) 1037 | }) 1038 | 1039 | t.Run("TestFloat32ToInt", func(t *testing.T) { 1040 | var src float32 = 18 1041 | var dest int = 10 1042 | assert.NoError(t, Copy(&dest, src)) 1043 | assert.Equal(t, int(src), dest) 1044 | }) 1045 | 1046 | t.Run("TestFloat32ToUint8", func(t *testing.T) { 1047 | var src float32 = 18 1048 | var dest uint8 = 10 1049 | assert.NoError(t, Copy(&dest, src)) 1050 | assert.Equal(t, uint8(src), dest) 1051 | }) 1052 | 1053 | t.Run("TestFloat32ToUint16", func(t *testing.T) { 1054 | var src float32 = 18 1055 | var dest uint16 = 10 1056 | assert.NoError(t, Copy(&dest, src)) 1057 | assert.Equal(t, uint16(src), dest) 1058 | }) 1059 | 1060 | t.Run("TestFloat32ToUint32", func(t *testing.T) { 1061 | var src float32 = 18 1062 | var dest uint32 = 10 1063 | assert.NoError(t, Copy(&dest, src)) 1064 | assert.Equal(t, uint32(src), dest) 1065 | }) 1066 | 1067 | t.Run("TestFloat32ToUint64", func(t *testing.T) { 1068 | var src float32 = 18 1069 | var dest uint64 = 10 1070 | assert.NoError(t, Copy(&dest, src)) 1071 | assert.Equal(t, uint64(src), dest) 1072 | }) 1073 | 1074 | t.Run("TestFloat32ToUint", func(t *testing.T) { 1075 | var src float32 = 18 1076 | var dest uint = 10 1077 | assert.NoError(t, Copy(&dest, src)) 1078 | assert.Equal(t, uint(src), dest) 1079 | }) 1080 | 1081 | t.Run("TestFloat32ToUintptr", func(t *testing.T) { 1082 | var src float32 = 18 1083 | var dest uintptr = 10 1084 | assert.NoError(t, Copy(&dest, src)) 1085 | assert.Equal(t, uintptr(src), dest) 1086 | }) 1087 | 1088 | t.Run("TestFloat32ToFloat32", func(t *testing.T) { 1089 | var src float32 = 18 1090 | var dest float32 = 10 1091 | assert.NoError(t, Copy(&dest, src)) 1092 | assert.Equal(t, float32(src), dest) 1093 | }) 1094 | 1095 | t.Run("TestFloat32ToFloat64", func(t *testing.T) { 1096 | var src float32 = 18 1097 | var dest float64 = 10 1098 | assert.NoError(t, Copy(&dest, src)) 1099 | assert.Equal(t, float64(src), dest) 1100 | }) 1101 | 1102 | t.Run("TestFloat64ToInt8", func(t *testing.T) { 1103 | var src float64 = 18 1104 | var dest int8 = 10 1105 | assert.NoError(t, Copy(&dest, src)) 1106 | assert.Equal(t, int8(src), dest) 1107 | }) 1108 | 1109 | t.Run("TestFloat64ToInt16", func(t *testing.T) { 1110 | var src float64 = 18 1111 | var dest int16 = 10 1112 | assert.NoError(t, Copy(&dest, src)) 1113 | assert.Equal(t, int16(src), dest) 1114 | }) 1115 | 1116 | t.Run("TestFloat64ToInt32", func(t *testing.T) { 1117 | var src float64 = 18 1118 | var dest int32 = 10 1119 | assert.NoError(t, Copy(&dest, src)) 1120 | assert.Equal(t, int32(src), dest) 1121 | }) 1122 | 1123 | t.Run("TestFloat64ToInt64", func(t *testing.T) { 1124 | var src float64 = 18 1125 | var dest int64 = 10 1126 | assert.NoError(t, Copy(&dest, src)) 1127 | assert.Equal(t, int64(src), dest) 1128 | }) 1129 | 1130 | t.Run("TestFloat64ToInt", func(t *testing.T) { 1131 | var src float64 = 18 1132 | var dest int = 10 1133 | assert.NoError(t, Copy(&dest, src)) 1134 | assert.Equal(t, int(src), dest) 1135 | }) 1136 | 1137 | t.Run("TestFloat64ToUint8", func(t *testing.T) { 1138 | var src float64 = 18 1139 | var dest uint8 = 10 1140 | assert.NoError(t, Copy(&dest, src)) 1141 | assert.Equal(t, uint8(src), dest) 1142 | }) 1143 | 1144 | t.Run("TestFloat64ToUint16", func(t *testing.T) { 1145 | var src float64 = 18 1146 | var dest uint16 = 10 1147 | assert.NoError(t, Copy(&dest, src)) 1148 | assert.Equal(t, uint16(src), dest) 1149 | }) 1150 | 1151 | t.Run("TestFloat64ToUint32", func(t *testing.T) { 1152 | var src float64 = 18 1153 | var dest uint32 = 10 1154 | assert.NoError(t, Copy(&dest, src)) 1155 | assert.Equal(t, uint32(src), dest) 1156 | }) 1157 | 1158 | t.Run("TestFloat64ToUint64", func(t *testing.T) { 1159 | var src float64 = 18 1160 | var dest uint64 = 10 1161 | assert.NoError(t, Copy(&dest, src)) 1162 | assert.Equal(t, uint64(src), dest) 1163 | }) 1164 | 1165 | t.Run("TestFloat64ToUint", func(t *testing.T) { 1166 | var src float64 = 18 1167 | var dest uint = 10 1168 | assert.NoError(t, Copy(&dest, src)) 1169 | assert.Equal(t, uint(src), dest) 1170 | }) 1171 | 1172 | t.Run("TestFloat64ToUintptr", func(t *testing.T) { 1173 | var src float64 = 18 1174 | var dest uintptr = 10 1175 | assert.NoError(t, Copy(&dest, src)) 1176 | assert.Equal(t, uintptr(src), dest) 1177 | }) 1178 | 1179 | t.Run("TestFloat64ToFloat32", func(t *testing.T) { 1180 | var src float64 = 18 1181 | var dest float32 = 10 1182 | assert.NoError(t, Copy(&dest, src)) 1183 | assert.Equal(t, float32(src), dest) 1184 | }) 1185 | 1186 | t.Run("TestFloat64ToFloat64", func(t *testing.T) { 1187 | var src float64 = 18 1188 | var dest float64 = 10 1189 | assert.NoError(t, Copy(&dest, src)) 1190 | assert.Equal(t, float64(src), dest) 1191 | }) 1192 | 1193 | } 1194 | --------------------------------------------------------------------------------