1// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
2// Use of this source code is governed by a MIT license found in the LICENSE file.
3
4// Code generated from mammoth-test.go.tmpl - DO NOT EDIT.
5
6package codec
7
8import "testing"
9import "fmt"
10import "reflect"
11
12// TestMammoth has all the different paths optimized in fast-path
13// It has all the primitives, slices and maps.
14//
15// For each of those types, it has a pointer and a non-pointer field.
16
17func init() { _ = fmt.Printf } // so we can include fmt as needed
18
19type TestMammoth struct {
20
21{{range .Values }}{{if .Primitive }}{{/*
22*/}}{{ .MethodNamePfx "F" true }} {{ .Primitive }}
23{{ .MethodNamePfx "Fptr" true }} *{{ .Primitive }}
24{{end}}{{end}}
25
26{{range .Values }}{{if not .Primitive }}{{if not .MapKey }}{{/*
27*/}}{{ .MethodNamePfx "F" false }} []{{ .Elem }}
28{{ .MethodNamePfx "Fptr" false }} *[]{{ .Elem }}
29{{end}}{{end}}{{end}}
30
31{{range .Values }}{{if not .Primitive }}{{if .MapKey }}{{/*
32*/}}{{ .MethodNamePfx "F" false }} map[{{ .MapKey }}]{{ .Elem }}
33{{ .MethodNamePfx "Fptr" false }} *map[{{ .MapKey }}]{{ .Elem }}
34{{end}}{{end}}{{end}}
35
36}
37
38{{range .Values }}{{if not .Primitive }}{{if not .MapKey }}{{/*
39*/}} type {{ .MethodNamePfx "typMbs" false }} []{{ .Elem }}
40func (_ {{ .MethodNamePfx "typMbs" false }}) MapBySlice() { }
41{{end}}{{end}}{{end}}
42
43{{range .Values }}{{if not .Primitive }}{{if .MapKey }}{{/*
44*/}} type {{ .MethodNamePfx "typMap" false }} map[{{ .MapKey }}]{{ .Elem }}
45{{end}}{{end}}{{end}}
46
47func doTestMammothSlices(t *testing.T, h Handle) {
48{{range $i, $e := .Values }}{{if not .Primitive }}{{if not .MapKey }}{{/*
49*/}}
50 var v{{$i}}va [8]{{ .Elem }}
51 for _, v := range [][]{{ .Elem }}{ nil, {}, { {{ nonzerocmd .Elem }}, {{ zerocmd .Elem }}, {{ zerocmd .Elem }}, {{ nonzerocmd .Elem }} } } { {{/*
52 // fmt.Printf(">>>> running mammoth slice v{{$i}}: %v\n", v)
53 // - encode value to some []byte
54 // - decode into a length-wise-equal []byte
55 // - check if equal to initial slice
56 // - encode ptr to the value
57 // - check if encode bytes are same
58 // - decode into ptrs to: nil, then 1-elem slice, equal-length, then large len slice
59 // - decode into non-addressable slice of equal length, then larger len
60 // - for each decode, compare elem-by-elem to the original slice
61 // -
62 // - rinse and repeat for a MapBySlice version
63 // -
64 */}}
65 var v{{$i}}v1, v{{$i}}v2 []{{ .Elem }}
66 v{{$i}}v1 = v
67 bs{{$i}} := testMarshalErr(v{{$i}}v1, h, t, "enc-slice-v{{$i}}")
68 if v == nil { v{{$i}}v2 = nil } else { v{{$i}}v2 = make([]{{ .Elem }}, len(v)) }
69 testUnmarshalErr(v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}")
70 testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}")
71 if v == nil { v{{$i}}v2 = nil } else { v{{$i}}v2 = make([]{{ .Elem }}, len(v)) }
72 testUnmarshalErr(reflect.ValueOf(v{{$i}}v2), bs{{$i}}, h, t, "dec-slice-v{{$i}}-noaddr") // non-addressable value
73 testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}-noaddr")
74 // ...
75 bs{{$i}} = testMarshalErr(&v{{$i}}v1, h, t, "enc-slice-v{{$i}}-p")
76 v{{$i}}v2 = nil
77 testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}-p")
78 testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}-p")
79 v{{$i}}va = [8]{{ .Elem }}{} // clear the array
80 v{{$i}}v2 = v{{$i}}va[:1:1]
81 testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}-p-1")
82 testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}-p-1")
83 v{{$i}}va = [8]{{ .Elem }}{} // clear the array
84 v{{$i}}v2 = v{{$i}}va[:len(v{{$i}}v1):len(v{{$i}}v1)]
85 testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}-p-len")
86 testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}-p-len")
87 v{{$i}}va = [8]{{ .Elem }}{} // clear the array
88 v{{$i}}v2 = v{{$i}}va[:]
89 testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}-p-cap")
90 testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}-p-cap")
91 if len(v{{$i}}v1) > 1 {
92 v{{$i}}va = [8]{{ .Elem }}{} // clear the array
93 testUnmarshalErr((&v{{$i}}va)[:len(v{{$i}}v1)], bs{{$i}}, h, t, "dec-slice-v{{$i}}-p-len-noaddr")
94 testDeepEqualErr(v{{$i}}v1, v{{$i}}va[:len(v{{$i}}v1)], t, "equal-slice-v{{$i}}-p-len-noaddr")
95 v{{$i}}va = [8]{{ .Elem }}{} // clear the array
96 testUnmarshalErr((&v{{$i}}va)[:], bs{{$i}}, h, t, "dec-slice-v{{$i}}-p-cap-noaddr")
97 testDeepEqualErr(v{{$i}}v1, v{{$i}}va[:len(v{{$i}}v1)], t, "equal-slice-v{{$i}}-p-cap-noaddr")
98 }
99 // ...
100 var v{{$i}}v3, v{{$i}}v4 {{ .MethodNamePfx "typMbs" false }}
101 v{{$i}}v2 = nil
102 if v != nil { v{{$i}}v2 = make([]{{ .Elem }}, len(v)) }
103 v{{$i}}v3 = {{ .MethodNamePfx "typMbs" false }}(v{{$i}}v1)
104 v{{$i}}v4 = {{ .MethodNamePfx "typMbs" false }}(v{{$i}}v2)
105 bs{{$i}} = testMarshalErr(v{{$i}}v3, h, t, "enc-slice-v{{$i}}-custom")
106 testUnmarshalErr(v{{$i}}v4, bs{{$i}}, h, t, "dec-slice-v{{$i}}-custom")
107 testDeepEqualErr(v{{$i}}v3, v{{$i}}v4, t, "equal-slice-v{{$i}}-custom")
108 bs{{$i}} = testMarshalErr(&v{{$i}}v3, h, t, "enc-slice-v{{$i}}-custom-p")
109 v{{$i}}v2 = nil
110 v{{$i}}v4 = {{ .MethodNamePfx "typMbs" false }}(v{{$i}}v2)
111 testUnmarshalErr(&v{{$i}}v4, bs{{$i}}, h, t, "dec-slice-v{{$i}}-custom-p")
112 testDeepEqualErr(v{{$i}}v3, v{{$i}}v4, t, "equal-slice-v{{$i}}-custom-p")
113 }
114{{end}}{{end}}{{end}}
115}
116
117func doTestMammothMaps(t *testing.T, h Handle) {
118{{range $i, $e := .Values }}{{if not .Primitive }}{{if .MapKey }}{{/*
119*/}}
120 for _, v := range []map[{{ .MapKey }}]{{ .Elem }}{ nil, {}, { {{ nonzerocmd .MapKey }}:{{ zerocmd .Elem }} {{if ne "bool" .MapKey}}, {{ nonzerocmd .MapKey }}:{{ nonzerocmd .Elem }} {{end}} } } {
121 // fmt.Printf(">>>> running mammoth map v{{$i}}: %v\n", v)
122 var v{{$i}}v1, v{{$i}}v2 map[{{ .MapKey }}]{{ .Elem }}
123 v{{$i}}v1 = v
124 bs{{$i}} := testMarshalErr(v{{$i}}v1, h, t, "enc-map-v{{$i}}")
125 if v == nil { v{{$i}}v2 = nil } else { v{{$i}}v2 = make(map[{{ .MapKey }}]{{ .Elem }}, len(v)) } // reset map
126 testUnmarshalErr(v{{$i}}v2, bs{{$i}}, h, t, "dec-map-v{{$i}}")
127 testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-map-v{{$i}}")
128 if v == nil { v{{$i}}v2 = nil } else { v{{$i}}v2 = make(map[{{ .MapKey }}]{{ .Elem }}, len(v)) } // reset map
129 testUnmarshalErr(reflect.ValueOf(v{{$i}}v2), bs{{$i}}, h, t, "dec-map-v{{$i}}-noaddr") // decode into non-addressable map value
130 testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-map-v{{$i}}-noaddr")
131 if v == nil { v{{$i}}v2 = nil } else { v{{$i}}v2 = make(map[{{ .MapKey }}]{{ .Elem }}, len(v)) } // reset map
132 testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-map-v{{$i}}-p-len")
133 testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-map-v{{$i}}-p-len")
134 bs{{$i}} = testMarshalErr(&v{{$i}}v1, h, t, "enc-map-v{{$i}}-p")
135 v{{$i}}v2 = nil
136 testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-map-v{{$i}}-p-nil")
137 testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-map-v{{$i}}-p-nil")
138 // ...
139 if v == nil { v{{$i}}v2 = nil } else { v{{$i}}v2 = make(map[{{ .MapKey }}]{{ .Elem }}, len(v)) } // reset map
140 var v{{$i}}v3, v{{$i}}v4 {{ .MethodNamePfx "typMap" false }}
141 v{{$i}}v3 = {{ .MethodNamePfx "typMap" false }}(v{{$i}}v1)
142 v{{$i}}v4 = {{ .MethodNamePfx "typMap" false }}(v{{$i}}v2)
143 bs{{$i}} = testMarshalErr(v{{$i}}v3, h, t, "enc-map-v{{$i}}-custom")
144 testUnmarshalErr(v{{$i}}v4, bs{{$i}}, h, t, "dec-map-v{{$i}}-p-len")
145 testDeepEqualErr(v{{$i}}v3, v{{$i}}v4, t, "equal-map-v{{$i}}-p-len")
146 }
147{{end}}{{end}}{{end}}
148
149}
150
151func doTestMammothMapsAndSlices(t *testing.T, h Handle) {
152 doTestMammothSlices(t, h)
153 doTestMammothMaps(t, h)
154}