GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

cloudflare/cfssl_trust

Public

mirrored from https://github.com/cloudflare/cfssl_trustAvailable

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
72e5ca0d26bbcab6b255f5495e1c2e255f0300a5

Branches

Tags

  • No tags available.
0Branches0Tags
Go to file
Add file
Code

Clone

HTTPS

Download ZIP

cfssl_trust/vendor/github.com/mitchellh/mapstructure

vendor/github.com/mitchellh/mapstructure/mapstructure_benchmark_test.go

279lines · modecode

RawDownload
Latest commit unavailable.
1package mapstructure
2
3import (
4 "encoding/json"
5 "testing"
6)
7
8func Benchmark_Decode(b *testing.B) {
9 type Person struct {
10 Name string
11 Age int
12 Emails []string
13 Extra map[string]string
14 }
15
16 input := map[string]interface{}{
17 "name": "Mitchell",
18 "age": 91,
19 "emails": []string{"one", "two", "three"},
20 "extra": map[string]string{
21 "twitter": "mitchellh",
22 },
23 }
24
25 var result Person
26 for i := 0; i < b.N; i++ {
27 Decode(input, &result)
28 }
29}
30
31// decodeViaJSON takes the map data and passes it through encoding/json to convert it into the
32// given Go native structure pointed to by v. v must be a pointer to a struct.
33func decodeViaJSON(data interface{}, v interface{}) error {
34 // Perform the task by simply marshalling the input into JSON,
35 // then unmarshalling it into target native Go struct.
36 b, err := json.Marshal(data)
37 if err != nil {
38 return err
39 }
40 return json.Unmarshal(b, v)
41}
42
43func Benchmark_DecodeViaJSON(b *testing.B) {
44 type Person struct {
45 Name string
46 Age int
47 Emails []string
48 Extra map[string]string
49 }
50
51 input := map[string]interface{}{
52 "name": "Mitchell",
53 "age": 91,
54 "emails": []string{"one", "two", "three"},
55 "extra": map[string]string{
56 "twitter": "mitchellh",
57 },
58 }
59
60 var result Person
61 for i := 0; i < b.N; i++ {
62 decodeViaJSON(input, &result)
63 }
64}
65
66func Benchmark_DecodeBasic(b *testing.B) {
67 input := map[string]interface{}{
68 "vstring": "foo",
69 "vint": 42,
70 "Vuint": 42,
71 "vbool": true,
72 "Vfloat": 42.42,
73 "vsilent": true,
74 "vdata": 42,
75 }
76
77 var result Basic
78 for i := 0; i < b.N; i++ {
79 Decode(input, &result)
80 }
81}
82
83func Benchmark_DecodeEmbedded(b *testing.B) {
84 input := map[string]interface{}{
85 "vstring": "foo",
86 "Basic": map[string]interface{}{
87 "vstring": "innerfoo",
88 },
89 "vunique": "bar",
90 }
91
92 var result Embedded
93 for i := 0; i < b.N; i++ {
94 Decode(input, &result)
95 }
96}
97
98func Benchmark_DecodeTypeConversion(b *testing.B) {
99 input := map[string]interface{}{
100 "IntToFloat": 42,
101 "IntToUint": 42,
102 "IntToBool": 1,
103 "IntToString": 42,
104 "UintToInt": 42,
105 "UintToFloat": 42,
106 "UintToBool": 42,
107 "UintToString": 42,
108 "BoolToInt": true,
109 "BoolToUint": true,
110 "BoolToFloat": true,
111 "BoolToString": true,
112 "FloatToInt": 42.42,
113 "FloatToUint": 42.42,
114 "FloatToBool": 42.42,
115 "FloatToString": 42.42,
116 "StringToInt": "42",
117 "StringToUint": "42",
118 "StringToBool": "1",
119 "StringToFloat": "42.42",
120 "SliceToMap": []interface{}{},
121 "MapToSlice": map[string]interface{}{},
122 }
123
124 var resultStrict TypeConversionResult
125 for i := 0; i < b.N; i++ {
126 Decode(input, &resultStrict)
127 }
128}
129
130func Benchmark_DecodeMap(b *testing.B) {
131 input := map[string]interface{}{
132 "vfoo": "foo",
133 "vother": map[interface{}]interface{}{
134 "foo": "foo",
135 "bar": "bar",
136 },
137 }
138
139 var result Map
140 for i := 0; i < b.N; i++ {
141 Decode(input, &result)
142 }
143}
144
145func Benchmark_DecodeMapOfStruct(b *testing.B) {
146 input := map[string]interface{}{
147 "value": map[string]interface{}{
148 "foo": map[string]string{"vstring": "one"},
149 "bar": map[string]string{"vstring": "two"},
150 },
151 }
152
153 var result MapOfStruct
154 for i := 0; i < b.N; i++ {
155 Decode(input, &result)
156 }
157}
158
159func Benchmark_DecodeSlice(b *testing.B) {
160 input := map[string]interface{}{
161 "vfoo": "foo",
162 "vbar": []string{"foo", "bar", "baz"},
163 }
164
165 var result Slice
166 for i := 0; i < b.N; i++ {
167 Decode(input, &result)
168 }
169}
170
171func Benchmark_DecodeSliceOfStruct(b *testing.B) {
172 input := map[string]interface{}{
173 "value": []map[string]interface{}{
174 {"vstring": "one"},
175 {"vstring": "two"},
176 },
177 }
178
179 var result SliceOfStruct
180 for i := 0; i < b.N; i++ {
181 Decode(input, &result)
182 }
183}
184
185func Benchmark_DecodeWeaklyTypedInput(b *testing.B) {
186 type Person struct {
187 Name string
188 Age int
189 Emails []string
190 }
191
192 // This input can come from anywhere, but typically comes from
193 // something like decoding JSON, generated by a weakly typed language
194 // such as PHP.
195 input := map[string]interface{}{
196 "name": 123, // number => string
197 "age": "42", // string => number
198 "emails": map[string]interface{}{}, // empty map => empty array
199 }
200
201 var result Person
202 config := &DecoderConfig{
203 WeaklyTypedInput: true,
204 Result: &result,
205 }
206
207 decoder, err := NewDecoder(config)
208 if err != nil {
209 panic(err)
210 }
211
212 for i := 0; i < b.N; i++ {
213 decoder.Decode(input)
214 }
215}
216
217func Benchmark_DecodeMetadata(b *testing.B) {
218 type Person struct {
219 Name string
220 Age int
221 }
222
223 input := map[string]interface{}{
224 "name": "Mitchell",
225 "age": 91,
226 "email": "foo@bar.com",
227 }
228
229 var md Metadata
230 var result Person
231 config := &DecoderConfig{
232 Metadata: &md,
233 Result: &result,
234 }
235
236 decoder, err := NewDecoder(config)
237 if err != nil {
238 panic(err)
239 }
240
241 for i := 0; i < b.N; i++ {
242 decoder.Decode(input)
243 }
244}
245
246func Benchmark_DecodeMetadataEmbedded(b *testing.B) {
247 input := map[string]interface{}{
248 "vstring": "foo",
249 "vunique": "bar",
250 }
251
252 var md Metadata
253 var result EmbeddedSquash
254 config := &DecoderConfig{
255 Metadata: &md,
256 Result: &result,
257 }
258
259 decoder, err := NewDecoder(config)
260 if err != nil {
261 b.Fatalf("err: %s", err)
262 }
263
264 for i := 0; i < b.N; i++ {
265 decoder.Decode(input)
266 }
267}
268
269func Benchmark_DecodeTagged(b *testing.B) {
270 input := map[string]interface{}{
271 "foo": "bar",
272 "bar": "value",
273 }
274
275 var result Tagged
276 for i := 0; i < b.N; i++ {
277 Decode(input, &result)
278 }
279}
280