← Back to branch summary

~ubuntu-branches/ubuntu/utopic/hockeypuck/utopic-proposed

« back to all changes in this revision

Viewing changes to build/src/code.google.com/p/gorilla/schema/decoder_test.go

  • Committer: Package Import Robot
  • Author(s): Casey Marshall
  • Date: 2014-04-13 20:06:01 UTC
  • Revision ID: package-import@ubuntu.com-20140413200601-oxdlqn1gy0x8m55u
Tags: 1.0~rel20140413+7a1892a~trusty
Hockeypuck 1.0 release

Show diffs side-by-side

added added

removed removed

Lines of Context:
build/src/code.google.com/p/gorilla/schema/decoder_test.go
 
1
// Copyright 2012 The Gorilla Authors. All rights reserved.
 
2
// Use of this source code is governed by a BSD-style
 
3
// license that can be found in the LICENSE file.
 
4
 
 
5
package schema
 
6
 
 
7
import (
 
8
        //"reflect"
 
9
        "testing"
 
10
)
 
11
 
 
12
// All cases we want to cover, in a nutshell.
 
13
type S1 struct {
 
14
        F01 int     `schema:"f1"`
 
15
        F02 *int    `schema:"f2"`
 
16
        F03 []int   `schema:"f3"`
 
17
        F04 []*int  `schema:"f4"`
 
18
        F05 *[]int  `schema:"f5"`
 
19
        F06 *[]*int `schema:"f6"`
 
20
        F07 S2      `schema:"f7"`
 
21
        F08 *S1     `schema:"f8"`
 
22
        F09 int     `schema:"-"`
 
23
        F10 []S1    `schema:"f10"`
 
24
        F11 []*S1   `schema:"f11"`
 
25
        F12 *[]S1   `schema:"f12"`
 
26
        F13 *[]*S1  `schema:"f13"`
 
27
}
 
28
 
 
29
type S2 struct {
 
30
        F01 *[]*int `schema:"f1"`
 
31
}
 
32
 
 
33
func TestAll(t *testing.T) {
 
34
        v := map[string][]string{
 
35
                "f1":             {"1"},
 
36
                "f2":             {"2"},
 
37
                "f3":             {"31", "32"},
 
38
                "f4":             {"41", "42"},
 
39
                "f5":             {"51", "52"},
 
40
                "f6":             {"61", "62"},
 
41
                "f7.f1":          {"71", "72"},
 
42
                "f8.f8.f7.f1":    {"81", "82"},
 
43
                "f9":             {"9"},
 
44
                "f10.0.f10.0.f6": {"101", "102"},
 
45
                "f10.0.f10.1.f6": {"103", "104"},
 
46
                "f11.0.f11.0.f6": {"111", "112"},
 
47
                "f11.0.f11.1.f6": {"113", "114"},
 
48
                "f12.0.f12.0.f6": {"121", "122"},
 
49
                "f12.0.f12.1.f6": {"123", "124"},
 
50
                "f13.0.f13.0.f6": {"131", "132"},
 
51
                "f13.0.f13.1.f6": {"133", "134"},
 
52
        }
 
53
        f2 := 2
 
54
        f41, f42 := 41, 42
 
55
        f61, f62 := 61, 62
 
56
        f71, f72 := 71, 72
 
57
        f81, f82 := 81, 82
 
58
        f101, f102, f103, f104 := 101, 102, 103, 104
 
59
        f111, f112, f113, f114 := 111, 112, 113, 114
 
60
        f121, f122, f123, f124 := 121, 122, 123, 124
 
61
        f131, f132, f133, f134 := 131, 132, 133, 134
 
62
        e := S1{
 
63
                F01: 1,
 
64
                F02: &f2,
 
65
                F03: []int{31, 32},
 
66
                F04: []*int{&f41, &f42},
 
67
                F05: &[]int{51, 52},
 
68
                F06: &[]*int{&f61, &f62},
 
69
                F07: S2{
 
70
                        F01: &[]*int{&f71, &f72},
 
71
                },
 
72
                F08: &S1{
 
73
                        F08: &S1{
 
74
                                F07: S2{
 
75
                                        F01: &[]*int{&f81, &f82},
 
76
                                },
 
77
                        },
 
78
                },
 
79
                F09: 0,
 
80
                F10: []S1{
 
81
                        S1{
 
82
                                F10: []S1{
 
83
                                        S1{F06: &[]*int{&f101, &f102}},
 
84
                                        S1{F06: &[]*int{&f103, &f104}},
 
85
                                },
 
86
                        },
 
87
                },
 
88
                F11: []*S1{
 
89
                        &S1{
 
90
                                F11: []*S1{
 
91
                                        &S1{F06: &[]*int{&f111, &f112}},
 
92
                                        &S1{F06: &[]*int{&f113, &f114}},
 
93
                                },
 
94
                        },
 
95
                },
 
96
                F12: &[]S1{
 
97
                        S1{
 
98
                                F12: &[]S1{
 
99
                                        S1{F06: &[]*int{&f121, &f122}},
 
100
                                        S1{F06: &[]*int{&f123, &f124}},
 
101
                                },
 
102
                        },
 
103
                },
 
104
                F13: &[]*S1{
 
105
                        &S1{
 
106
                                F13: &[]*S1{
 
107
                                        &S1{F06: &[]*int{&f131, &f132}},
 
108
                                        &S1{F06: &[]*int{&f133, &f134}},
 
109
                                },
 
110
                        },
 
111
                },
 
112
        }
 
113
 
 
114
        s := &S1{}
 
115
        _ = NewDecoder().Decode(s, v)
 
116
 
 
117
        vals := func(values []*int) []int {
 
118
                r := make([]int, len(values))
 
119
                for k, v := range values {
 
120
                        r[k] = *v
 
121
                }
 
122
                return r
 
123
        }
 
124
 
 
125
        if s.F01 != e.F01 {
 
126
                t.Errorf("f1: expected %v, got %v", e.F01, s.F01)
 
127
        }
 
128
        if s.F02 == nil {
 
129
                t.Errorf("f2: expected %v, got nil", *e.F02)
 
130
        } else if *s.F02 != *e.F02 {
 
131
                t.Errorf("f2: expected %v, got %v", *e.F02, *s.F02)
 
132
        }
 
133
        if s.F03 == nil {
 
134
                t.Errorf("f3: expected %v, got nil", e.F03)
 
135
        } else if len(s.F03) != 2 || s.F03[0] != e.F03[0] || s.F03[1] != e.F03[1] {
 
136
                t.Errorf("f3: expected %v, got %v", e.F03, s.F03)
 
137
        }
 
138
        if s.F04 == nil {
 
139
                t.Errorf("f4: expected %v, got nil", e.F04)
 
140
        } else {
 
141
                if len(s.F04) != 2 || *(s.F04)[0] != *(e.F04)[0] || *(s.F04)[1] != *(e.F04)[1] {
 
142
                        t.Errorf("f4: expected %v, got %v", vals(e.F04), vals(s.F04))
 
143
                }
 
144
        }
 
145
        if s.F05 == nil {
 
146
                t.Errorf("f5: expected %v, got nil", e.F05)
 
147
        } else {
 
148
                sF05, eF05 := *s.F05, *e.F05
 
149
                if len(sF05) != 2 || sF05[0] != eF05[0] || sF05[1] != eF05[1] {
 
150
                        t.Errorf("f5: expected %v, got %v", eF05, sF05)
 
151
                }
 
152
        }
 
153
        if s.F06 == nil {
 
154
                t.Errorf("f6: expected %v, got nil", vals(*e.F06))
 
155
        } else {
 
156
                sF06, eF06 := *s.F06, *e.F06
 
157
                if len(sF06) != 2 || *(sF06)[0] != *(eF06)[0] || *(sF06)[1] != *(eF06)[1] {
 
158
                        t.Errorf("f6: expected %v, got %v", vals(eF06), vals(sF06))
 
159
                }
 
160
        }
 
161
        if s.F07.F01 == nil {
 
162
                t.Errorf("f7.f1: expected %v, got nil", vals(*e.F07.F01))
 
163
        } else {
 
164
                sF07, eF07 := *s.F07.F01, *e.F07.F01
 
165
                if len(sF07) != 2 || *(sF07)[0] != *(eF07)[0] || *(sF07)[1] != *(eF07)[1] {
 
166
                        t.Errorf("f7.f1: expected %v, got %v", vals(eF07), vals(sF07))
 
167
                }
 
168
        }
 
169
        if s.F08 == nil {
 
170
                t.Errorf("f8: got nil")
 
171
        } else if s.F08.F08 == nil {
 
172
                t.Errorf("f8.f8: got nil")
 
173
        } else if s.F08.F08.F07.F01 == nil {
 
174
                t.Errorf("f8.f8.f7.f1: expected %v, got nil", vals(*e.F08.F08.F07.F01))
 
175
        } else {
 
176
                sF08, eF08 := *s.F08.F08.F07.F01, *e.F08.F08.F07.F01
 
177
                if len(sF08) != 2 || *(sF08)[0] != *(eF08)[0] || *(sF08)[1] != *(eF08)[1] {
 
178
                        t.Errorf("f8.f8.f7.f1: expected %v, got %v", vals(eF08), vals(sF08))
 
179
                }
 
180
        }
 
181
        if s.F09 != e.F09 {
 
182
                t.Errorf("f9: expected %v, got %v", e.F09, s.F09)
 
183
        }
 
184
        if s.F10 == nil {
 
185
                t.Errorf("f10: got nil")
 
186
        } else if len(s.F10) != 1 {
 
187
                t.Errorf("f10: expected 1 element, got %v", s.F10)
 
188
        } else {
 
189
                if len(s.F10[0].F10) != 2 {
 
190
                        t.Errorf("f10.0.f10: expected 1 element, got %v", s.F10[0].F10)
 
191
                } else {
 
192
                        sF10, eF10 := *s.F10[0].F10[0].F06, *e.F10[0].F10[0].F06
 
193
                        if sF10 == nil {
 
194
                                t.Errorf("f10.0.f10.0.f6: expected %v, got nil", vals(eF10))
 
195
                        } else {
 
196
                                if len(sF10) != 2 || *(sF10)[0] != *(eF10)[0] || *(sF10)[1] != *(eF10)[1] {
 
197
                                        t.Errorf("f10.0.f10.0.f6: expected %v, got %v", vals(eF10), vals(sF10))
 
198
                                }
 
199
                        }
 
200
                        sF10, eF10 = *s.F10[0].F10[1].F06, *e.F10[0].F10[1].F06
 
201
                        if sF10 == nil {
 
202
                                t.Errorf("f10.0.f10.0.f6: expected %v, got nil", vals(eF10))
 
203
                        } else {
 
204
                                if len(sF10) != 2 || *(sF10)[0] != *(eF10)[0] || *(sF10)[1] != *(eF10)[1] {
 
205
                                        t.Errorf("f10.0.f10.0.f6: expected %v, got %v", vals(eF10), vals(sF10))
 
206
                                }
 
207
                        }
 
208
                }
 
209
        }
 
210
        if s.F11 == nil {
 
211
                t.Errorf("f11: got nil")
 
212
        } else if len(s.F11) != 1 {
 
213
                t.Errorf("f11: expected 1 element, got %v", s.F11)
 
214
        } else {
 
215
                if len(s.F11[0].F11) != 2 {
 
216
                        t.Errorf("f11.0.f11: expected 1 element, got %v", s.F11[0].F11)
 
217
                } else {
 
218
                        sF11, eF11 := *s.F11[0].F11[0].F06, *e.F11[0].F11[0].F06
 
219
                        if sF11 == nil {
 
220
                                t.Errorf("f11.0.f11.0.f6: expected %v, got nil", vals(eF11))
 
221
                        } else {
 
222
                                if len(sF11) != 2 || *(sF11)[0] != *(eF11)[0] || *(sF11)[1] != *(eF11)[1] {
 
223
                                        t.Errorf("f11.0.f11.0.f6: expected %v, got %v", vals(eF11), vals(sF11))
 
224
                                }
 
225
                        }
 
226
                        sF11, eF11 = *s.F11[0].F11[1].F06, *e.F11[0].F11[1].F06
 
227
                        if sF11 == nil {
 
228
                                t.Errorf("f11.0.f11.0.f6: expected %v, got nil", vals(eF11))
 
229
                        } else {
 
230
                                if len(sF11) != 2 || *(sF11)[0] != *(eF11)[0] || *(sF11)[1] != *(eF11)[1] {
 
231
                                        t.Errorf("f11.0.f11.0.f6: expected %v, got %v", vals(eF11), vals(sF11))
 
232
                                }
 
233
                        }
 
234
                }
 
235
        }
 
236
        if s.F12 == nil {
 
237
                t.Errorf("f12: got nil")
 
238
        } else if len(*s.F12) != 1 {
 
239
                t.Errorf("f12: expected 1 element, got %v", *s.F12)
 
240
        } else {
 
241
                sF12, eF12 := *(s.F12), *(e.F12)
 
242
                if len(*sF12[0].F12) != 2 {
 
243
                        t.Errorf("f12.0.f12: expected 1 element, got %v", *sF12[0].F12)
 
244
                } else {
 
245
                        sF122, eF122 := *(*sF12[0].F12)[0].F06, *(*eF12[0].F12)[0].F06
 
246
                        if sF122 == nil {
 
247
                                t.Errorf("f12.0.f12.0.f6: expected %v, got nil", vals(eF122))
 
248
                        } else {
 
249
                                if len(sF122) != 2 || *(sF122)[0] != *(eF122)[0] || *(sF122)[1] != *(eF122)[1] {
 
250
                                        t.Errorf("f12.0.f12.0.f6: expected %v, got %v", vals(eF122), vals(sF122))
 
251
                                }
 
252
                        }
 
253
                        sF122, eF122 = *(*sF12[0].F12)[1].F06, *(*eF12[0].F12)[1].F06
 
254
                        if sF122 == nil {
 
255
                                t.Errorf("f12.0.f12.0.f6: expected %v, got nil", vals(eF122))
 
256
                        } else {
 
257
                                if len(sF122) != 2 || *(sF122)[0] != *(eF122)[0] || *(sF122)[1] != *(eF122)[1] {
 
258
                                        t.Errorf("f12.0.f12.0.f6: expected %v, got %v", vals(eF122), vals(sF122))
 
259
                                }
 
260
                        }
 
261
                }
 
262
        }
 
263
        if s.F13 == nil {
 
264
                t.Errorf("f13: got nil")
 
265
        } else if len(*s.F13) != 1 {
 
266
                t.Errorf("f13: expected 1 element, got %v", *s.F13)
 
267
        } else {
 
268
                sF13, eF13 := *(s.F13), *(e.F13)
 
269
                if len(*sF13[0].F13) != 2 {
 
270
                        t.Errorf("f13.0.f13: expected 1 element, got %v", *sF13[0].F13)
 
271
                } else {
 
272
                        sF132, eF132 := *(*sF13[0].F13)[0].F06, *(*eF13[0].F13)[0].F06
 
273
                        if sF132 == nil {
 
274
                                t.Errorf("f13.0.f13.0.f6: expected %v, got nil", vals(eF132))
 
275
                        } else {
 
276
                                if len(sF132) != 2 || *(sF132)[0] != *(eF132)[0] || *(sF132)[1] != *(eF132)[1] {
 
277
                                        t.Errorf("f13.0.f13.0.f6: expected %v, got %v", vals(eF132), vals(sF132))
 
278
                                }
 
279
                        }
 
280
                        sF132, eF132 = *(*sF13[0].F13)[1].F06, *(*eF13[0].F13)[1].F06
 
281
                        if sF132 == nil {
 
282
                                t.Errorf("f13.0.f13.0.f6: expected %v, got nil", vals(eF132))
 
283
                        } else {
 
284
                                if len(sF132) != 2 || *(sF132)[0] != *(eF132)[0] || *(sF132)[1] != *(eF132)[1] {
 
285
                                        t.Errorf("f13.0.f13.0.f6: expected %v, got %v", vals(eF132), vals(sF132))
 
286
                                }
 
287
                        }
 
288
                }
 
289
        }
 
290
}
 
291
 
 
292
// ----------------------------------------------------------------------------
 
293
 
 
294
type S3 struct {
 
295
        F01 bool
 
296
        F02 float32
 
297
        F03 float64
 
298
        F04 int
 
299
        F05 int8
 
300
        F06 int16
 
301
        F07 int32
 
302
        F08 int64
 
303
        F09 string
 
304
        F10 uint
 
305
        F11 uint8
 
306
        F12 uint16
 
307
        F13 uint32
 
308
        F14 uint64
 
309
}
 
310
 
 
311
func TestDefaultConverters(t *testing.T) {
 
312
        v := map[string][]string{
 
313
                "F01": {"true"},
 
314
                "F02": {"4.2"},
 
315
                "F03": {"4.3"},
 
316
                "F04": {"-42"},
 
317
                "F05": {"-43"},
 
318
                "F06": {"-44"},
 
319
                "F07": {"-45"},
 
320
                "F08": {"-46"},
 
321
                "F09": {"foo"},
 
322
                "F10": {"42"},
 
323
                "F11": {"43"},
 
324
                "F12": {"44"},
 
325
                "F13": {"45"},
 
326
                "F14": {"46"},
 
327
        }
 
328
        e := S3{
 
329
                F01: true,
 
330
                F02: 4.2,
 
331
                F03: 4.3,
 
332
                F04: -42,
 
333
                F05: -43,
 
334
                F06: -44,
 
335
                F07: -45,
 
336
                F08: -46,
 
337
                F09: "foo",
 
338
                F10: 42,
 
339
                F11: 43,
 
340
                F12: 44,
 
341
                F13: 45,
 
342
                F14: 46,
 
343
        }
 
344
        s := &S3{}
 
345
        _ = NewDecoder().Decode(s, v)
 
346
        if s.F01 != e.F01 {
 
347
                t.Errorf("F01: expected %v, got %v", e.F01, s.F01)
 
348
        }
 
349
        if s.F02 != e.F02 {
 
350
                t.Errorf("F02: expected %v, got %v", e.F02, s.F02)
 
351
        }
 
352
        if s.F03 != e.F03 {
 
353
                t.Errorf("F03: expected %v, got %v", e.F03, s.F03)
 
354
        }
 
355
        if s.F04 != e.F04 {
 
356
                t.Errorf("F04: expected %v, got %v", e.F04, s.F04)
 
357
        }
 
358
        if s.F05 != e.F05 {
 
359
                t.Errorf("F05: expected %v, got %v", e.F05, s.F05)
 
360
        }
 
361
        if s.F06 != e.F06 {
 
362
                t.Errorf("F06: expected %v, got %v", e.F06, s.F06)
 
363
        }
 
364
        if s.F07 != e.F07 {
 
365
                t.Errorf("F07: expected %v, got %v", e.F07, s.F07)
 
366
        }
 
367
        if s.F08 != e.F08 {
 
368
                t.Errorf("F08: expected %v, got %v", e.F08, s.F08)
 
369
        }
 
370
        if s.F09 != e.F09 {
 
371
                t.Errorf("F09: expected %v, got %v", e.F09, s.F09)
 
372
        }
 
373
        if s.F10 != e.F10 {
 
374
                t.Errorf("F10: expected %v, got %v", e.F10, s.F10)
 
375
        }
 
376
        if s.F11 != e.F11 {
 
377
                t.Errorf("F11: expected %v, got %v", e.F11, s.F11)
 
378
        }
 
379
        if s.F12 != e.F12 {
 
380
                t.Errorf("F12: expected %v, got %v", e.F12, s.F12)
 
381
        }
 
382
        if s.F13 != e.F13 {
 
383
                t.Errorf("F13: expected %v, got %v", e.F13, s.F13)
 
384
        }
 
385
        if s.F14 != e.F14 {
 
386
                t.Errorf("F14: expected %v, got %v", e.F14, s.F14)
 
387
        }
 
388
}
 
389
 
 
390
// ----------------------------------------------------------------------------
 
391
 
 
392
func TestInlineStruct(t *testing.T) {
 
393
        s1 := &struct {
 
394
                F01 bool
 
395
        }{}
 
396
        s2 := &struct {
 
397
                F01 int
 
398
        }{}
 
399
        v1 := map[string][]string{
 
400
                "F01": {"true"},
 
401
        }
 
402
        v2 := map[string][]string{
 
403
                "F01": {"42"},
 
404
        }
 
405
        decoder := NewDecoder()
 
406
        _ = decoder.Decode(s1, v1)
 
407
        if s1.F01 != true {
 
408
                t.Errorf("s1: expected %v, got %v", true, s1.F01)
 
409
        }
 
410
        _ = decoder.Decode(s2, v2)
 
411
        if s2.F01 != 42 {
 
412
                t.Errorf("s2: expected %v, got %v", 42, s2.F01)
 
413
        }
 
414
}
 
415
 
 
416
// ----------------------------------------------------------------------------
 
417
 
 
418
type Foo struct {
 
419
        F01 int
 
420
        F02 Bar
 
421
        Bif []Baz
 
422
}
 
423
 
 
424
type Bar struct {
 
425
        F01 string
 
426
        F02 string
 
427
        F03 string
 
428
        F14 string
 
429
        S05 string
 
430
        Str string
 
431
}
 
432
 
 
433
type Baz struct {
 
434
        F99 []string
 
435
}
 
436
 
 
437
func TestSimpleExample(t *testing.T) {
 
438
        data := map[string][]string{
 
439
                "F01":       {"1"},
 
440
                "F02.F01":   {"S1"},
 
441
                "F02.F02":   {"S2"},
 
442
                "F02.F03":   {"S3"},
 
443
                "F02.F14":   {"S4"},
 
444
                "F02.S05":   {"S5"},
 
445
                "F02.Str":   {"Str"},
 
446
                "Bif.0.F99": {"A", "B", "C"},
 
447
        }
 
448
 
 
449
        e := &Foo{
 
450
                F01: 1,
 
451
                F02: Bar{
 
452
                        F01: "S1",
 
453
                        F02: "S2",
 
454
                        F03: "S3",
 
455
                        F14: "S4",
 
456
                        S05: "S5",
 
457
                        Str: "Str",
 
458
                },
 
459
                Bif: []Baz{{
 
460
                        F99: []string{"A", "B", "C"}},
 
461
                },
 
462
        }
 
463
 
 
464
        s := &Foo{}
 
465
        _ = NewDecoder().Decode(s, data)
 
466
 
 
467
        if s.F01 != e.F01 {
 
468
                t.Errorf("F01: expected %v, got %v", e.F01, s.F01)
 
469
        }
 
470
        if s.F02.F01 != e.F02.F01 {
 
471
                t.Errorf("F02.F01: expected %v, got %v", e.F02.F01, s.F02.F01)
 
472
        }
 
473
        if s.F02.F02 != e.F02.F02 {
 
474
                t.Errorf("F02.F02: expected %v, got %v", e.F02.F02, s.F02.F02)
 
475
        }
 
476
        if s.F02.F03 != e.F02.F03 {
 
477
                t.Errorf("F02.F03: expected %v, got %v", e.F02.F03, s.F02.F03)
 
478
        }
 
479
        if s.F02.F14 != e.F02.F14 {
 
480
                t.Errorf("F02.F14: expected %v, got %v", e.F02.F14, s.F02.F14)
 
481
        }
 
482
        if s.F02.S05 != e.F02.S05 {
 
483
                t.Errorf("F02.S05: expected %v, got %v", e.F02.S05, s.F02.S05)
 
484
        }
 
485
        if s.F02.Str != e.F02.Str {
 
486
                t.Errorf("F02.Str: expected %v, got %v", e.F02.Str, s.F02.Str)
 
487
        }
 
488
        if len(s.Bif) != len(e.Bif) {
 
489
                t.Errorf("Bif len: expected %d, got %d", len(e.Bif), len(s.Bif))
 
490
        } else {
 
491
                if len(s.Bif[0].F99) != len(e.Bif[0].F99) {
 
492
                        t.Errorf("Bif[0].F99 len: expected %d, got %d", len(e.Bif[0].F99), len(s.Bif[0].F99))
 
493
                }
 
494
        }
 
495
}
 
496
 
 
497
// ----------------------------------------------------------------------------
 
498
 
 
499
type S4 struct {
 
500
        F01 int64
 
501
        F02 float64
 
502
        F03 bool
 
503
}
 
504
 
 
505
func TestConversionError(t *testing.T) {
 
506
        data := map[string][]string{
 
507
                "F01": {"foo"},
 
508
                "F02": {"bar"},
 
509
                "F03": {"baz"},
 
510
        }
 
511
        s := &S4{}
 
512
        e := NewDecoder().Decode(s, data)
 
513
 
 
514
        m := e.(MultiError)
 
515
        if len(m) != 3 {
 
516
                t.Errorf("Expected 3 errors, got %v", m)
 
517
        }
 
518
}