mammoth-test.go.tmpl (10062B)
1 // Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved. 2 // Use of this source code is governed by a MIT license found in the LICENSE file. 3 4 //go:build !codec.notmammoth 5 // +build codec.notmammoth 6 7 // Code generated from mammoth-test.go.tmpl - DO NOT EDIT. 8 9 package codec 10 11 import "testing" 12 import "fmt" 13 import "reflect" 14 15 // TestMammoth has all the different paths optimized in fast-path 16 // It has all the primitives, slices and maps. 17 // 18 // For each of those types, it has a pointer and a non-pointer field. 19 20 func init() { _ = fmt.Printf } // so we can include fmt as needed 21 22 type TestMammoth struct { 23 24 {{range .Values }}{{if .Primitive -}} 25 {{ .MethodNamePfx "F" true }} {{ .Primitive }} 26 {{ .MethodNamePfx "Fptr" true }} *{{ .Primitive }} 27 {{end}}{{end}} 28 29 {{range .Values }}{{if not .Primitive }}{{if not .MapKey -}} 30 {{ .MethodNamePfx "F" false }} []{{ .Elem }} 31 {{ .MethodNamePfx "Fptr" false }} *[]{{ .Elem }} 32 {{ .MethodNamePfx "Farr4" false }} [4]{{ .Elem }} 33 {{end}}{{end}}{{end}} 34 35 {{range .Values }}{{if not .Primitive }}{{if .MapKey -}} 36 {{ .MethodNamePfx "F" false }} map[{{ .MapKey }}]{{ .Elem }} 37 {{ .MethodNamePfx "Fptr" false }} *map[{{ .MapKey }}]{{ .Elem }} 38 {{end}}{{end}}{{end}} 39 40 } 41 42 {{range .Values }}{{if not .Primitive }}{{if not .MapKey -}} 43 type {{ .MethodNamePfx "typMbs" false }} []{{ .Elem }} 44 func (_ {{ .MethodNamePfx "typMbs" false }}) MapBySlice() { } 45 {{end}}{{end}}{{end}} 46 47 {{range .Values }}{{if not .Primitive }}{{if .MapKey -}} 48 type {{ .MethodNamePfx "typMap" false }} map[{{ .MapKey }}]{{ .Elem }} 49 {{end}}{{end}}{{end}} 50 51 func __doTestMammothSlices(t *testing.T, h Handle) { 52 {{range $i, $e := .Values }}{{if not .Primitive }}{{if not .MapKey -}} 53 var v{{$i}}va [8]{{ .Elem }} 54 for _, v := range [][]{{ .Elem }}{ nil, {}, { {{ nonzerocmd .Elem }}, {{ zerocmd .Elem }}, {{ zerocmd .Elem }}, {{ nonzerocmd .Elem }} } } { 55 {{/* 56 // fmt.Printf(">>>> running mammoth slice v{{$i}}: %v\n", v) 57 // - encode value to some []byte 58 // - decode into a length-wise-equal []byte 59 // - check if equal to initial slice 60 // - encode ptr to the value 61 // - check if encode bytes are same 62 // - decode into ptrs to: nil, then 1-elem slice, equal-length, then large len slice 63 // - decode into non-addressable slice of equal length, then larger len 64 // - for each decode, compare elem-by-elem to the original slice 65 // - 66 // - rinse and repeat for a MapBySlice version 67 // - 68 */ -}} 69 var v{{$i}}v1, v{{$i}}v2 []{{ .Elem }} 70 var bs{{$i}} []byte 71 v{{$i}}v1 = v 72 bs{{$i}} = testMarshalErr(v{{$i}}v1, h, t, "enc-slice-v{{$i}}") 73 if v == nil { 74 v{{$i}}v2 = make([]{{ .Elem }}, 2) 75 testUnmarshalErr(v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}") 76 testDeepEqualErr(v{{$i}}v2[0], v{{$i}}v2[1], t, "equal-slice-v{{$i}}") // should not change 77 testDeepEqualErr(len(v{{$i}}v2), 2, t, "equal-slice-v{{$i}}") // should not change 78 v{{$i}}v2 = make([]{{ .Elem }}, 2) 79 testUnmarshalErr(reflect.ValueOf(v{{$i}}v2), bs{{$i}}, h, t, "dec-slice-v{{$i}}-noaddr") // non-addressable value 80 testDeepEqualErr(v{{$i}}v2[0], v{{$i}}v2[1], t, "equal-slice-v{{$i}}-noaddr") // should not change 81 testDeepEqualErr(len(v{{$i}}v2), 2, t, "equal-slice-v{{$i}}") // should not change 82 } else { 83 v{{$i}}v2 = make([]{{ .Elem }}, len(v)) 84 testUnmarshalErr(v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}") 85 testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}") 86 v{{$i}}v2 = make([]{{ .Elem }}, len(v)) 87 testUnmarshalErr(reflect.ValueOf(v{{$i}}v2), bs{{$i}}, h, t, "dec-slice-v{{$i}}-noaddr") // non-addressable value 88 testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}-noaddr") 89 } 90 testReleaseBytes(bs{{$i}}) 91 // ... 92 bs{{$i}} = testMarshalErr(&v{{$i}}v1, h, t, "enc-slice-v{{$i}}-p") 93 v{{$i}}v2 = nil 94 testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}-p") 95 testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}-p") 96 v{{$i}}va = [8]{{ .Elem }}{} // clear the array 97 testUnmarshalErr(&v{{$i}}va, bs{{$i}}, h, t, "dec-array-v{{$i}}-p-1") 98 if v{{$i}}v1 == nil && v{{$i}}v2 == nil { v{{$i}}v2 = []{{ .Elem }}{} } // so we can compare to zero len slice below 99 testDeepEqualErr(v{{$i}}va[:len(v{{$i}}v2)], v{{$i}}v2, t, "equal-array-v{{$i}}-p-1") 100 v{{$i}}va = [8]{{ .Elem }}{} // clear the array 101 v{{$i}}v2 = v{{$i}}va[:1:1] 102 testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}-p-1") 103 testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}-p-1") 104 v{{$i}}va = [8]{{ .Elem }}{} // clear the array 105 v{{$i}}v2 = v{{$i}}va[:len(v{{$i}}v1):len(v{{$i}}v1)] 106 testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}-p-len") 107 testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}-p-len") 108 v{{$i}}va = [8]{{ .Elem }}{} // clear the array 109 v{{$i}}v2 = v{{$i}}va[:] 110 testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}-p-cap") 111 testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}-p-cap") 112 if len(v{{$i}}v1) > 1 { 113 v{{$i}}va = [8]{{ .Elem }}{} // clear the array 114 testUnmarshalErr((&v{{$i}}va)[:len(v{{$i}}v1)], bs{{$i}}, h, t, "dec-slice-v{{$i}}-p-len-noaddr") 115 testDeepEqualErr(v{{$i}}v1, v{{$i}}va[:len(v{{$i}}v1)], t, "equal-slice-v{{$i}}-p-len-noaddr") 116 v{{$i}}va = [8]{{ .Elem }}{} // clear the array 117 testUnmarshalErr((&v{{$i}}va)[:], bs{{$i}}, h, t, "dec-slice-v{{$i}}-p-cap-noaddr") 118 testDeepEqualErr(v{{$i}}v1, v{{$i}}va[:len(v{{$i}}v1)], t, "equal-slice-v{{$i}}-p-cap-noaddr") 119 } 120 testReleaseBytes(bs{{$i}}) 121 // ... 122 var v{{$i}}v3, v{{$i}}v4 {{ .MethodNamePfx "typMbs" false }} 123 v{{$i}}v2 = nil 124 if v != nil { v{{$i}}v2 = make([]{{ .Elem }}, len(v)) } 125 v{{$i}}v3 = {{ .MethodNamePfx "typMbs" false }}(v{{$i}}v1) 126 v{{$i}}v4 = {{ .MethodNamePfx "typMbs" false }}(v{{$i}}v2) 127 if v != nil { 128 bs{{$i}} = testMarshalErr(v{{$i}}v3, h, t, "enc-slice-v{{$i}}-custom") 129 testUnmarshalErr(v{{$i}}v4, bs{{$i}}, h, t, "dec-slice-v{{$i}}-custom") 130 testDeepEqualErr(v{{$i}}v3, v{{$i}}v4, t, "equal-slice-v{{$i}}-custom") 131 testReleaseBytes(bs{{$i}}) 132 } 133 bs{{$i}} = testMarshalErr(&v{{$i}}v3, h, t, "enc-slice-v{{$i}}-custom-p") 134 v{{$i}}v2 = nil 135 v{{$i}}v4 = {{ .MethodNamePfx "typMbs" false }}(v{{$i}}v2) 136 testUnmarshalErr(&v{{$i}}v4, bs{{$i}}, h, t, "dec-slice-v{{$i}}-custom-p") 137 testDeepEqualErr(v{{$i}}v3, v{{$i}}v4, t, "equal-slice-v{{$i}}-custom-p") 138 testReleaseBytes(bs{{$i}}) 139 } 140 {{end}}{{end}}{{end}} 141 } 142 143 func __doTestMammothMaps(t *testing.T, h Handle) { 144 {{range $i, $e := .Values }}{{if not .Primitive }}{{if .MapKey -}} 145 for _, v := range []map[{{ .MapKey }}]{{ .Elem }}{ nil, {}, { {{ nonzerocmd .MapKey }}:{{ zerocmd .Elem }} {{if ne "bool" .MapKey}}, {{ nonzerocmd .MapKey }}:{{ nonzerocmd .Elem }} {{end}} } } { 146 // fmt.Printf(">>>> running mammoth map v{{$i}}: %v\n", v) 147 var v{{$i}}v1, v{{$i}}v2 map[{{ .MapKey }}]{{ .Elem }} 148 var bs{{$i}} []byte 149 v{{$i}}v1 = v 150 bs{{$i}} = testMarshalErr(v{{$i}}v1, h, t, "enc-map-v{{$i}}") 151 if v != nil { 152 if v == nil { v{{$i}}v2 = nil } else { v{{$i}}v2 = make(map[{{ .MapKey }}]{{ .Elem }}, len(v)) } // reset map 153 testUnmarshalErr(v{{$i}}v2, bs{{$i}}, h, t, "dec-map-v{{$i}}") 154 testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-map-v{{$i}}") 155 if v == nil { v{{$i}}v2 = nil } else { v{{$i}}v2 = make(map[{{ .MapKey }}]{{ .Elem }}, len(v)) } // reset map 156 testUnmarshalErr(reflect.ValueOf(v{{$i}}v2), bs{{$i}}, h, t, "dec-map-v{{$i}}-noaddr") // decode into non-addressable map value 157 testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-map-v{{$i}}-noaddr") 158 } 159 if v == nil { v{{$i}}v2 = nil } else { v{{$i}}v2 = make(map[{{ .MapKey }}]{{ .Elem }}, len(v)) } // reset map 160 testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-map-v{{$i}}-p-len") 161 testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-map-v{{$i}}-p-len") 162 testReleaseBytes(bs{{$i}}) 163 bs{{$i}} = testMarshalErr(&v{{$i}}v1, h, t, "enc-map-v{{$i}}-p") 164 v{{$i}}v2 = nil 165 testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-map-v{{$i}}-p-nil") 166 testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-map-v{{$i}}-p-nil") 167 testReleaseBytes(bs{{$i}}) 168 // ... 169 if v == nil { v{{$i}}v2 = nil } else { v{{$i}}v2 = make(map[{{ .MapKey }}]{{ .Elem }}, len(v)) } // reset map 170 var v{{$i}}v3, v{{$i}}v4 {{ .MethodNamePfx "typMap" false }} 171 v{{$i}}v3 = {{ .MethodNamePfx "typMap" false }}(v{{$i}}v1) 172 v{{$i}}v4 = {{ .MethodNamePfx "typMap" false }}(v{{$i}}v2) 173 if v != nil { 174 bs{{$i}} = testMarshalErr(v{{$i}}v3, h, t, "enc-map-v{{$i}}-custom") 175 testUnmarshalErr(v{{$i}}v4, bs{{$i}}, h, t, "dec-map-v{{$i}}-p-len") 176 testDeepEqualErr(v{{$i}}v3, v{{$i}}v4, t, "equal-map-v{{$i}}-p-len") 177 testReleaseBytes(bs{{$i}}) 178 } 179 } 180 {{end}}{{end}}{{end}} 181 182 } 183 184 func doTestMammothMapsAndSlices(t *testing.T, h Handle) { 185 defer testSetup(t, &h)() 186 if mh, ok := h.(*MsgpackHandle); ok { 187 defer func(b bool) { mh.RawToString = b }(mh.RawToString) 188 mh.RawToString = true 189 } 190 __doTestMammothSlices(t, h) 191 __doTestMammothMaps(t, h) 192 } 193 194 func doTestMammoth(t *testing.T, h Handle) { 195 defer testSetup(t, &h)() 196 if mh, ok := h.(*MsgpackHandle); ok { 197 defer func(b bool) { mh.RawToString = b }(mh.RawToString) 198 mh.RawToString = true 199 } 200 201 name := h.Name() 202 var b []byte 203 204 var m, m2 TestMammoth 205 testRandomFillRV(reflect.ValueOf(&m).Elem()) 206 b = testMarshalErr(&m, h, t, "mammoth-"+name) 207 208 testUnmarshalErr(&m2, b, h, t, "mammoth-"+name) 209 testDeepEqualErr(&m, &m2, t, "mammoth-"+name) 210 testReleaseBytes(b) 211 212 if testing.Short() { 213 t.Skipf("skipping rest of mammoth test in -short mode") 214 } 215 216 var mm, mm2 TestMammoth2Wrapper 217 testRandomFillRV(reflect.ValueOf(&mm).Elem()) 218 b = testMarshalErr(&mm, h, t, "mammoth2-"+name) 219 // os.Stderr.Write([]byte("\n\n\n\n" + string(b) + "\n\n\n\n")) 220 testUnmarshalErr(&mm2, b, h, t, "mammoth2-"+name) 221 testDeepEqualErr(&mm, &mm2, t, "mammoth2-"+name) 222 // testMammoth2(t, name, h) 223 testReleaseBytes(b) 224 } 225 226 {{range $i, $e := .Formats -}} 227 func Test{{ . }}Mammoth(t *testing.T) { 228 doTestMammoth(t, test{{ . }}H) 229 } 230 {{end}} 231 {{range $i, $e := .Formats -}} 232 func Test{{ . }}MammothMapsAndSlices(t *testing.T) { 233 doTestMammothMapsAndSlices(t, test{{ . }}H) 234 } 235 {{end}}