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
9package codec
10
11import "testing"
12import "fmt"
13import "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
20func init() { _ = fmt.Printf } // so we can include fmt as needed
21
22type 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 -}}
43type {{ .MethodNamePfx "typMbs" false }} []{{ .Elem }}
44func (_ {{ .MethodNamePfx "typMbs" false }}) MapBySlice() { }
45{{end}}{{end}}{{end}}
46
47{{range .Values }}{{if not .Primitive }}{{if .MapKey -}}
48type {{ .MethodNamePfx "typMap" false }} map[{{ .MapKey }}]{{ .Elem }}
49{{end}}{{end}}{{end}}
50
51func __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
143func __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
184func 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
194func 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 -}}
227func Test{{ . }}Mammoth(t *testing.T) {
228 doTestMammoth(t, test{{ . }}H)
229}
230{{end}}
231{{range $i, $e := .Formats -}}
232func Test{{ . }}MammothMapsAndSlices(t *testing.T) {
233 doTestMammothMapsAndSlices(t, test{{ . }}H)
234}
235{{end}}
View as plain text