podman

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}}
236