dbhelper_test.go - randomcrap - random crap programs of varying quality
(HTM) git clone git://git.codemadness.org/randomcrap
(DIR) Log
(DIR) Files
(DIR) Refs
(DIR) README
(DIR) LICENSE
---
dbhelper_test.go (20772B)
---
1 // TODO:
2 // - also test nil case.
3 // - test lowercase/uppercase names (query -> struct).
4 // - test convert(float) (float64), decimal etc.
5 // - test custom type with nil case.
6 // - add test to unmarshal to embedded struct type.
7 // - add test for fields that cannot be set (unexported field).
8 // - add test for fields that exist from result but not in struct.
9 // - add test for fields that exist in struct but not in result.
10 // x test from database []byte to custom type with float64
11 // x test from database []byte to custom embedded type with float64
12 // x add test from database assign []byte to custom type with float64.
13
14 package dbhelper
15
16 import (
17 "database/sql"
18 "flag"
19 "fmt"
20 "log"
21 "os"
22 "testing"
23 "time"
24 )
25
26 import _ "github.com/denisenkom/go-mssqldb"
27
28 type TestFieldNormal struct {
29 Field1 int64
30 Field2 string
31 }
32
33 func getfieldnormal(db *sql.DB) ([]TestFieldNormal, error) {
34 query := `SELECT 1 AS field1, '2' AS field2`
35 res, err := GetResults(db, query, []KeyValue{})
36 if err != nil {
37 return nil, err
38 }
39 defer res.Close()
40
41 var items []TestFieldNormal
42 err = res.Unmarshal(&items)
43 if err != nil {
44 return nil, err
45 }
46 return items, err
47 }
48
49 type TestFieldExistStruct struct {
50 Field1 int64
51 Field2 string
52 }
53
54 func getfieldexiststruct(db *sql.DB) ([]TestFieldExistStruct, error) {
55 query := `SELECT 1 AS field1`
56 res, err := GetResults(db, query, []KeyValue{})
57 if err != nil {
58 return nil, err
59 }
60 defer res.Close()
61
62 var items []TestFieldExistStruct
63 err = res.Unmarshal(&items)
64 if err != nil {
65 return nil, err
66 }
67 return items, err
68 }
69
70 type TestFieldExistResult struct {
71 Field1 int64
72 }
73
74 func getfieldexistresult(db *sql.DB) ([]TestFieldExistResult, error) {
75 query := `SELECT 1 AS field1, '2' AS field2`
76 res, err := GetResults(db, query, []KeyValue{})
77 if err != nil {
78 return nil, err
79 }
80 defer res.Close()
81
82 var items []TestFieldExistResult
83 err = res.Unmarshal(&items)
84 if err != nil {
85 return nil, err
86 }
87 return items, err
88 }
89
90 func getfieldnil(db *sql.DB) ([]TestFieldNormal, error) {
91 query := `
92 SELECT
93 NULL AS field1, NULL AS field2
94 UNION
95 SELECT
96 1 AS field1, '2' AS field2
97 `
98 res, err := GetResults(db, query, []KeyValue{})
99 if err != nil {
100 return nil, err
101 }
102 defer res.Close()
103
104 var items []TestFieldNormal
105 err = res.Unmarshal(&items)
106 if err != nil {
107 return nil, err
108 }
109 return items, err
110 }
111
112 type TestFieldError struct {
113 Field1 int64
114 Field2 int64
115 }
116
117 // error, field2 is int64 in struct but string in query.
118 func getfielderror(db *sql.DB) ([]TestFieldError, error) {
119 query := `SELECT 1 AS field1, '2' AS field2`
120 res, err := GetResults(db, query, []KeyValue{})
121 if err != nil {
122 return nil, err
123 }
124 defer res.Close()
125
126 var items []TestFieldError
127 err = res.Unmarshal(&items)
128 if err != nil {
129 return nil, err
130 }
131 return items, err
132 }
133
134 type TestFieldDecimal struct {
135 Field1 []byte
136 Field2 float64
137 Field3 float64
138 Field4 float64
139 }
140
141 func getfielddecimal(db *sql.DB) ([]TestFieldDecimal, error) {
142 query := `SELECT 0.1 AS field1, 0.2 AS field2, 0.3 AS field3, 0.4 AS field4`
143 res, err := GetResults(db, query, []KeyValue{})
144 if err != nil {
145 return nil, err
146 }
147 defer res.Close()
148
149 var items []TestFieldDecimal
150 err = res.Unmarshal(&items)
151 if err != nil {
152 return nil, err
153 }
154 return items, err
155 }
156
157 func getfielddecimalnil(db *sql.DB) ([]TestFieldDecimal, error) {
158 query := `
159 SELECT NULL AS field1, NULL AS field2, NULL AS field3, NULL AS field4
160 UNION
161 SELECT
162 0.1 AS field1,
163 CONVERT(decimal(15,1), 0.2) AS field2,
164 convert(float, 0.3) AS field3,
165 0.4 AS field4
166 `
167 res, err := GetResults(db, query, []KeyValue{})
168 if err != nil {
169 return nil, err
170 }
171 defer res.Close()
172
173 var items []TestFieldDecimal
174 err = res.Unmarshal(&items)
175 if err != nil {
176 return nil, err
177 }
178 return items, err
179 }
180
181 type TestFieldCaseError struct {
182 Field1 int64
183 }
184
185 type TestFieldConvertCaseError struct {
186 Field1 int64 `db:"FIELd1"`
187 }
188
189 func getfieldcaseerror(db *sql.DB) ([]TestFieldCaseError, error) {
190 query := `
191 SELECT
192 convert(int, 1) AS FIELD1
193 `
194 res, err := GetResults(db, query, []KeyValue{})
195 if err != nil {
196 return nil, err
197 }
198 defer res.Close()
199
200 var items []TestFieldCaseError
201 err = res.Unmarshal(&items)
202 if err != nil {
203 return nil, err
204 }
205 return items, err
206 }
207
208 func getfieldconvertcaseerror(db *sql.DB) ([]TestFieldConvertCaseError, error) {
209 query := `
210 SELECT
211 convert(int, 1) AS FIELD1
212 `
213 res, err := GetResults(db, query, []KeyValue{})
214 if err != nil {
215 return nil, err
216 }
217 defer res.Close()
218
219 var items []TestFieldConvertCaseError
220 err = res.Unmarshal(&items)
221 if err != nil {
222 return nil, err
223 }
224 return items, err
225 }
226
227 type TestFieldConvertSimple struct {
228 Field1 string `db:",int64"`
229 Field2 string `db:",float64"`
230 Field3 string `db:",string"`
231 Field4 string `db:"Field4,int64"`
232 Field5 string `db:"Field5,float64"`
233 Field6 string `db:"Field6,string"`
234 Field7 time.Time `db:"Field7"`
235 Field8 time.Time `db:"field8"`
236 Field9 time.Time `db:"FIELD9"`
237 }
238
239 func getfieldconvertsimple(db *sql.DB) ([]TestFieldConvertSimple, error) {
240 query := `
241 SELECT
242 convert(int, 1) AS field1,
243 convert(decimal(15,2), 0.2) AS field2,
244 'str' AS field3,
245 convert(int, 1) AS field4,
246 0.2 AS field5,
247 'str' AS field6,
248 CONVERT(datetime, '2015-01-02 03:04:05.670') AS field7,
249 CONVERT(datetime, '2015-01-02 03:04:05.670') AS field8,
250 CONVERT(datetime, '2015-01-02 03:04:05.670') AS field9
251 `
252 res, err := GetResults(db, query, []KeyValue{})
253 if err != nil {
254 return nil, err
255 }
256 defer res.Close()
257
258 var items []TestFieldConvertSimple
259 err = res.Unmarshal(&items)
260 if err != nil {
261 return nil, err
262 }
263 return items, err
264 }
265
266 func getfieldconvertsimplenil(db *sql.DB) ([]TestFieldConvertSimple, error) {
267 query := `
268 SELECT
269 NULL AS field1,
270 NULL AS field2,
271 NULL AS field3,
272 NULL AS field4,
273 NULL AS field5,
274 NULL AS field6,
275 NULL AS field7,
276 NULL AS field8,
277 NULL AS field9
278 UNION
279 SELECT
280 convert(int, 1) AS field1,
281 convert(decimal(15,2), 0.2) AS field2,
282 'str' AS field3,
283 convert(int, 1) AS field4,
284 0.2 AS field5,
285 'str' AS field6,
286 CONVERT(datetime, '2015-01-02 03:04:05.670') AS field7,
287 CONVERT(datetime, '2015-01-02 03:04:05.670') AS field8,
288 CONVERT(datetime, '2015-01-02 03:04:05.670') AS field9
289 `
290 res, err := GetResults(db, query, []KeyValue{})
291 if err != nil {
292 return nil, err
293 }
294 defer res.Close()
295
296 var items []TestFieldConvertSimple
297 err = res.Unmarshal(&items)
298 if err != nil {
299 return nil, err
300 }
301 return items, err
302 }
303
304 type CustomTime time.Time
305
306 func (c CustomTime) Bla() int {
307 return 42
308 }
309
310 func (c CustomTime) String() string {
311 return time.Time(c).Format("2006-01-02 15:04:05.999")
312 }
313
314 type TestFieldConvertCustom struct {
315 Field1 CustomTime `db:"field1,time.Time"`
316 }
317
318 func getfieldconvertcustom(db *sql.DB) ([]TestFieldConvertCustom, error) {
319 query := `
320 SELECT
321 CONVERT(datetime, '2015-01-02 03:04:05.670') AS field1
322 `
323 res, err := GetResults(db, query, []KeyValue{})
324 if err != nil {
325 return nil, err
326 }
327 defer res.Close()
328
329 var items []TestFieldConvertCustom
330 err = res.Unmarshal(&items)
331 if err != nil {
332 return nil, err
333 }
334 return items, err
335 }
336
337 type CustomTimeEmbed struct {
338 time.Time
339 }
340
341 func (c CustomTimeEmbed) String() string {
342 return c.Time.Format("2006-01-02 15:04:05.999")
343 }
344
345 type TestFieldConvertCustomEmbed struct {
346 Field1 CustomTimeEmbed `db:"field1,time.Time"`
347 }
348
349 func getfieldconvertcustomembed(db *sql.DB) ([]TestFieldConvertCustomEmbed, error) {
350 query := `
351 SELECT
352 CONVERT(datetime, '2015-01-02 03:04:05.670') AS field1
353 `
354 res, err := GetResults(db, query, []KeyValue{})
355 if err != nil {
356 return nil, err
357 }
358 defer res.Close()
359
360 var items []TestFieldConvertCustomEmbed
361 err = res.Unmarshal(&items)
362 if err != nil {
363 return nil, err
364 }
365 return items, err
366 }
367
368 type Float64 float64
369
370 type CustomFloat64Embed struct {
371 Float64
372 }
373
374 func (c CustomFloat64Embed) String() string {
375 return fmt.Sprintf("bla: %.4f", c.Float64)
376 }
377
378 type TestFieldConvertCustomFloat64Embed struct {
379 Field1 CustomFloat64Embed `db:"field1,float64"`
380 }
381
382 func getfieldconvertcustombytefloat64embed(db *sql.DB) ([]TestFieldConvertCustomFloat64Embed, error) {
383 query := `
384 SELECT
385 convert(decimal(15,3), 1.234) AS field1
386 `
387 res, err := GetResults(db, query, []KeyValue{})
388 if err != nil {
389 return nil, err
390 }
391 defer res.Close()
392
393 var items []TestFieldConvertCustomFloat64Embed
394 err = res.Unmarshal(&items)
395 if err != nil {
396 return nil, err
397 }
398 return items, err
399 }
400
401 func getfieldconvertcustomfloat64embed(db *sql.DB) ([]TestFieldConvertCustomFloat64Embed, error) {
402 query := `
403 SELECT
404 convert(float, 1.234) AS field1
405 `
406 res, err := GetResults(db, query, []KeyValue{})
407 if err != nil {
408 return nil, err
409 }
410 defer res.Close()
411
412 var items []TestFieldConvertCustomFloat64Embed
413 err = res.Unmarshal(&items)
414 if err != nil {
415 return nil, err
416 }
417 return items, err
418 }
419
420 type CustomFloat64EmbedUnexported struct {
421 float64
422 }
423
424 func (c CustomFloat64EmbedUnexported) String() string {
425 return fmt.Sprintf("bla: %.4f", c.float64)
426 }
427
428 type TestFieldConvertCustomFloat64EmbedUnexported struct {
429 Field1 CustomFloat64EmbedUnexported `db:"field1,float64"`
430 }
431
432 func getfieldconvertcustomfloat64embedunexported(db *sql.DB) ([]TestFieldConvertCustomFloat64EmbedUnexported, error) {
433 query := `
434 SELECT
435 convert(decimal(15,3), 1.234) AS field1
436 `
437 res, err := GetResults(db, query, []KeyValue{})
438 if err != nil {
439 return nil, err
440 }
441 defer res.Close()
442
443 var items []TestFieldConvertCustomFloat64EmbedUnexported
444 err = res.Unmarshal(&items)
445 if err != nil {
446 return nil, err
447 }
448 return items, err
449 }
450
451 func getfieldconvertcustomembednil(db *sql.DB) ([]TestFieldConvertCustomEmbed, error) {
452 query := `
453 SELECT
454 NULL AS field1
455 UNION
456 SELECT
457 CONVERT(datetime, '2015-01-02 03:04:05.670') AS field1
458 `
459 res, err := GetResults(db, query, []KeyValue{})
460 if err != nil {
461 return nil, err
462 }
463 defer res.Close()
464
465 var items []TestFieldConvertCustomEmbed
466 err = res.Unmarshal(&items)
467 if err != nil {
468 return nil, err
469 }
470 return items, err
471 }
472
473 type CustomTimeAssign time.Time
474
475 func (c CustomTimeAssign) Bla() int {
476 return 42
477 }
478
479 func (c CustomTimeAssign) String() string {
480 return time.Time(c).Format("2006-01-02 15:04:05.999")
481 }
482
483 type TestFieldAssignCustomTime struct {
484 Field1 CustomTimeAssign `db:"field1"`
485 }
486
487 func getfieldassigncustom(db *sql.DB) ([]TestFieldAssignCustomTime, error) {
488 query := `
489 SELECT
490 CONVERT(datetime, '2015-01-02 03:04:05.670') AS field1
491 `
492 res, err := GetResults(db, query, []KeyValue{})
493 if err != nil {
494 return nil, err
495 }
496 defer res.Close()
497
498 var items []TestFieldAssignCustomTime
499 err = res.Unmarshal(&items)
500 if err != nil {
501 return nil, err
502 }
503 return items, err
504 }
505
506 func getfieldconvertcustomnil(db *sql.DB) ([]TestFieldConvertCustom, error) {
507 query := `
508 SELECT
509 NULL AS field1
510 UNION
511 SELECT
512 CONVERT(datetime, '2015-01-02 03:04:05.670') AS field1
513 `
514 res, err := GetResults(db, query, []KeyValue{})
515 if err != nil {
516 return nil, err
517 }
518 defer res.Close()
519
520 var items []TestFieldConvertCustom
521 err = res.Unmarshal(&items)
522 if err != nil {
523 return nil, err
524 }
525 return items, err
526 }
527
528 type TestFieldOrder struct {
529 Field2 int64
530 Field3 int64
531 Field1 int64
532 }
533
534 func getfieldorder(db *sql.DB) ([]TestFieldOrder, error) {
535 query := `
536 SELECT
537 3 AS field3,
538 2 AS field2,
539 1 AS field1
540 `
541 res, err := GetResults(db, query, []KeyValue{})
542 if err != nil {
543 return nil, err
544 }
545 defer res.Close()
546
547 var items []TestFieldOrder
548 err = res.Unmarshal(&items)
549 if err != nil {
550 return nil, err
551 }
552 return items, err
553 }
554
555 var db *sql.DB
556
557 func TestMain(m *testing.M) {
558 var err error
559 var config_dsn string
560
561 flag.StringVar(&config_dsn, "dsn", config_dsn, "SQL DSN, see specific driver for options")
562 flag.Parse()
563
564 if config_dsn == "" {
565 fmt.Fprintf(os.Stderr, "Usage: %s:\n", os.Args[0])
566 flag.PrintDefaults()
567 os.Exit(1)
568 }
569
570 // setup db connection.
571 db, err = sql.Open("mssql", config_dsn)
572 if err != nil {
573 log.Fatalln(err)
574 }
575 defer db.Close()
576
577 // test actual connection.
578 err = db.Ping()
579 if err != nil {
580 log.Fatalln(err)
581 }
582
583 os.Exit(m.Run())
584 }
585
586 func TestUnmarshalNormal(t *testing.T) {
587 items, err := getfieldnormal(db)
588 if err != nil {
589 t.Error("error set:", err)
590 }
591 if len(items) != 1 {
592 t.Error("item count mismatch")
593 return
594 }
595 }
596
597 func TestUnmarshalExistStruct(t *testing.T) {
598 items, err := getfieldexiststruct(db)
599 if err == nil {
600 t.Error("error not set")
601 }
602 if len(items) != 0 {
603 t.Error("item count mismatch")
604 return
605 }
606 }
607
608 func TestUnmarshalExistResult(t *testing.T) {
609 items, err := getfieldexistresult(db)
610 if err != nil {
611 t.Error("error set:", err)
612 }
613 if len(items) != 1 {
614 t.Error("item count mismatch")
615 return
616 }
617 }
618
619 func TestUnmarshalError(t *testing.T) {
620 items, err := getfielderror(db)
621 if err == nil {
622 t.Error("error not set")
623 }
624 if len(items) != 0 {
625 t.Error("item count mismatch")
626 return
627 }
628 }
629
630 func TestUnmarshalFirstRowNil(t *testing.T) {
631 items, err := getfieldnil(db)
632 if err != nil {
633 t.Error("error set:", err)
634 }
635 if len(items) != 2 {
636 t.Error("item count mismatch")
637 return
638 }
639 }
640
641 func TestUnmarshalDecimal(t *testing.T) {
642 items, err := getfielddecimal(db)
643 if err != nil {
644 t.Error("error set:", err)
645 }
646 if len(items) != 1 {
647 t.Error("item count mismatch")
648 return
649 }
650 item := items[0]
651 if item.Field1[0] != 48 || item.Field1[1] != 46 || item.Field1[2] != 49 {
652 t.Error("value field1 mismatch")
653 }
654 if item.Field2 != 0.2 {
655 t.Error("value field2 mismatch", item.Field2, 0.2)
656 }
657 if item.Field3 != 0.3 {
658 t.Error("value field3 mismatch", item.Field3, 0.3)
659 }
660 if item.Field4 != 0.4 {
661 t.Error("value field4 mismatch", item.Field4, 0.4)
662 }
663 }
664
665 func TestUnmarshalDecimalNil(t *testing.T) {
666 items, err := getfielddecimalnil(db)
667 if err != nil {
668 t.Error("error set:", err)
669 }
670 if len(items) != 2 {
671 t.Error("item count mismatch")
672 return
673 }
674 item := items[1]
675 if item.Field1[0] != 48 || item.Field1[1] != 46 || item.Field1[2] != 49 {
676 t.Error("value field1 mismatch")
677 }
678 if item.Field2 != 0.2 {
679 t.Error("value field2 mismatch", item.Field2, 0.2)
680 }
681 if item.Field3 != 0.3 {
682 t.Error("value field3 mismatch", item.Field3, 0.3)
683 }
684 if item.Field4 != 0.4 {
685 t.Error("value field4 mismatch", item.Field4, 0.4)
686 }
687 }
688
689 func TestUnmarshalConvertSimple(t *testing.T) {
690 items, err := getfieldconvertsimple(db)
691 if err != nil {
692 t.Error("error set:", err)
693 }
694 if len(items) != 1 {
695 t.Error("item count mismatch")
696 return
697 }
698 if items[0].Field1 != "\x01" {
699 t.Error("value field1 mismatch:",
700 items[0].Field1, "!=", "\x01")
701 }
702 if items[0].Field2 != "0.20" {
703 t.Error("value field2 mismatch",
704 items[0].Field2, "!=", "0.20")
705 }
706 if items[0].Field3 != "str" {
707 t.Error("value field3 mismatch",
708 items[0].Field3, "!=", "str")
709 }
710 if items[0].Field4 != "\x01" {
711 t.Error("value field4 mismatch",
712 items[0].Field4, "!=", "\x01")
713 }
714 if items[0].Field5 != "0.2" {
715 t.Error("value field5 mismatch",
716 items[0].Field5, "!=", "0.2")
717 }
718 if items[0].Field6 != "str" {
719 t.Error("value field6 mismatch",
720 items[0].Field6, "!=", "str")
721 }
722 f7 := items[0].Field7.Format("2006-01-02 15:04:05.999")
723 if f7 != "2015-01-02 03:04:05.67" {
724 t.Error("value field7 mismatch",
725 f7, "!=", "2015-01-02 03:04:05.67")
726 }
727 f8 := items[0].Field8.Format("2006-01-02 15:04:05.999")
728 if f8 != "2015-01-02 03:04:05.67" {
729 t.Error("value field9 mismatch",
730 f8, "!=", "2015-01-02 03:04:05.67")
731 }
732 f9 := items[0].Field9.Format("2006-01-02 15:04:05.999")
733 if f9 != "2015-01-02 03:04:05.67" {
734 t.Error("value field9 mismatch",
735 f9, "!=", "2015-01-02 03:04:05.67")
736 }
737 }
738
739 func TestUnmarshalConvertSimpleNil(t *testing.T) {
740 items, err := getfieldconvertsimplenil(db)
741 if err != nil {
742 t.Error("error set:", err)
743 }
744 if len(items) != 2 {
745 t.Error("item count mismatch")
746 return
747 }
748 if items[1].Field1 != "\x01" {
749 t.Error("value field1 mismatch:",
750 items[1].Field1, "!=", "\x01")
751 }
752 if items[1].Field2 != "0.20" {
753 t.Error("value field2 mismatch",
754 items[1].Field2, "!=", "0.20")
755 }
756 if items[1].Field3 != "str" {
757 t.Error("value field3 mismatch",
758 items[1].Field3, "!=", "str")
759 }
760 if items[1].Field4 != "\x01" {
761 t.Error("value field4 mismatch",
762 items[1].Field4, "!=", "\x01")
763 }
764 if items[1].Field5 != "0.2" {
765 t.Error("value field5 mismatch",
766 items[1].Field5, "!=", "0.2")
767 }
768 if items[1].Field6 != "str" {
769 t.Error("value field6 mismatch",
770 items[1].Field6, "!=", "str")
771 }
772 f7 := items[1].Field7.Format("2006-01-02 15:04:05.999")
773 if f7 != "2015-01-02 03:04:05.67" {
774 t.Error("value field7 mismatch",
775 f7, "!=", "2015-01-02 03:04:05.67")
776 }
777 f8 := items[1].Field8.Format("2006-01-02 15:04:05.999")
778 if f8 != "2015-01-02 03:04:05.67" {
779 t.Error("value field9 mismatch",
780 f8, "!=", "2015-01-02 03:04:05.67")
781 }
782 f9 := items[1].Field9.Format("2006-01-02 15:04:05.999")
783 if f9 != "2015-01-02 03:04:05.67" {
784 t.Error("value field9 mismatch",
785 f9, "!=", "2015-01-02 03:04:05.67")
786 }
787 }
788
789 func TestUnmarshalConvertCustom(t *testing.T) {
790 items, err := getfieldconvertcustom(db)
791 if err != nil {
792 t.Error("error set:", err)
793 }
794 if len(items) != 1 {
795 t.Error("item count mismatch")
796 return
797 }
798 // custom, has stringer
799 f1 := fmt.Sprint(items[0].Field1)
800 if f1 != "2015-01-02 03:04:05.67" {
801 t.Error("value field mismatch",
802 f1, "!=", "2015-01-02 03:04:05.67")
803 }
804 }
805
806 func TestUnmarshalConvertCustomNil(t *testing.T) {
807 items, err := getfieldconvertcustomnil(db)
808 if err != nil {
809 t.Error("error set:", err)
810 }
811 if len(items) != 2 {
812 t.Error("item count mismatch")
813 return
814 }
815 // custom, has stringer
816 f1 := fmt.Sprint(items[1].Field1)
817 if f1 != "2015-01-02 03:04:05.67" {
818 t.Error("value field1 mismatch",
819 f1, "!=", "2015-01-02 03:04:05.67")
820 }
821 }
822
823 func TestUnmarshalConvertCustomEmbed(t *testing.T) {
824 items, err := getfieldconvertcustomembed(db)
825 if err != nil {
826 t.Error("error set:", err)
827 }
828 if len(items) != 1 {
829 t.Error("item count mismatch")
830 return
831 }
832 // custom, has stringer
833 f1 := fmt.Sprint(items[0].Field1)
834 if f1 != "2015-01-02 03:04:05.67" {
835 t.Error("value field1 mismatch",
836 f1, "!=", "2015-01-02 03:04:05.67")
837 }
838 }
839
840 func TestUnmarshalConvertCustomByteFloat64Embed(t *testing.T) {
841 items, err := getfieldconvertcustombytefloat64embed(db)
842 if err != nil {
843 t.Error("error set:", err)
844 }
845 if len(items) != 1 {
846 t.Error("item count mismatch")
847 return
848 }
849 // custom, has stringer
850 f1 := fmt.Sprint(items[0].Field1)
851 if f1 != "bla: 1.2340" {
852 t.Error("value field1 mismatch",
853 f1, "!=", "bla: 1.2340")
854 }
855 }
856
857 func TestUnmarshalConvertCustomFloat64Embed(t *testing.T) {
858 items, err := getfieldconvertcustomfloat64embed(db)
859 if err != nil {
860 t.Error("error set:", err)
861 }
862 if len(items) != 1 {
863 t.Error("item count mismatch")
864 return
865 }
866 // custom, has stringer
867 f1 := fmt.Sprint(items[0].Field1)
868 if f1 != "bla: 1.2340" {
869 t.Error("value field1 mismatch",
870 f1, "!=", "bla: 1.2340")
871 }
872 }
873
874 func TestUnmarshalConvertCustomEmbedNil(t *testing.T) {
875 items, err := getfieldconvertcustomembednil(db)
876 if err != nil {
877 t.Error("error set:", err)
878 }
879 if len(items) != 2 {
880 t.Error("item count mismatch")
881 return
882 }
883 // custom, has stringer
884 f1 := fmt.Sprint(items[1].Field1)
885 if f1 != "2015-01-02 03:04:05.67" {
886 t.Error("value field1 mismatch",
887 f1, "!=", "2015-01-02 03:04:05.67")
888 }
889 }
890
891 // assign to custom type is wrong, should error.
892 func TestUnmarshalAssignCustom(t *testing.T) {
893 items, err := getfieldassigncustom(db)
894 if err == nil {
895 t.Error("error not set")
896 }
897 if len(items) != 0 {
898 t.Error("item count mismatch")
899 return
900 }
901 }
902
903 // convert to unexported field, should error.
904 func TestUnmarshalConvertCustomFloat64EmbedUnexported(t *testing.T) {
905 items, err := getfieldconvertcustomfloat64embedunexported(db)
906 if err == nil {
907 t.Error("error not set")
908 }
909 if len(items) != 0 {
910 t.Error("item count mismatch")
911 return
912 }
913 }
914
915 func TestUnmarshalFieldCaseError(t *testing.T) {
916 items, err := getfieldcaseerror(db)
917 if err != nil {
918 t.Error("error set:", err)
919 }
920 if len(items) != 1 {
921 t.Error("item count mismatch")
922 return
923 }
924 if items[0].Field1 != 1 {
925 t.Error("value field1 mismatch", items[0].Field1, 1)
926 }
927 }
928
929 func TestUnmarshalFieldConvertCaseError(t *testing.T) {
930 items, err := getfieldconvertcaseerror(db)
931 if err != nil {
932 t.Error("error set:", err)
933 }
934 if len(items) != 1 {
935 t.Error("item count mismatch")
936 return
937 }
938 if items[0].Field1 != 1 {
939 t.Error("value field1 mismatch", items[0].Field1, 1)
940 }
941 }
942
943 func TestUnmarshalFieldOrder(t *testing.T) {
944 items, err := getfieldorder(db)
945 if err != nil {
946 t.Error("error set:", err)
947 }
948 if len(items) != 1 {
949 t.Error("item count mismatch")
950 return
951 }
952 if items[0].Field1 != 1 {
953 t.Error("value field1 mismatch", items[0].Field1, 1)
954 }
955 if items[0].Field2 != 2 {
956 t.Error("value field1 mismatch", items[0].Field2, 2)
957 }
958 if items[0].Field3 != 3 {
959 t.Error("value field1 mismatch", items[0].Field3, 3)
960 }
961 }