OSDN Git Service

feat: init cross_tx keepers (#146)
[bytom/vapor.git] / vendor / github.com / go-sql-driver / mysql / statement_test.go
1 // Go MySQL Driver - A MySQL-Driver for Go's database/sql package
2 //
3 // Copyright 2017 The Go-MySQL-Driver Authors. All rights reserved.
4 //
5 // This Source Code Form is subject to the terms of the Mozilla Public
6 // License, v. 2.0. If a copy of the MPL was not distributed with this file,
7 // You can obtain one at http://mozilla.org/MPL/2.0/.
8
9 package mysql
10
11 import (
12         "bytes"
13         "testing"
14 )
15
16 func TestConvertDerivedString(t *testing.T) {
17         type derived string
18
19         output, err := converter{}.ConvertValue(derived("value"))
20         if err != nil {
21                 t.Fatal("Derived string type not convertible", err)
22         }
23
24         if output != "value" {
25                 t.Fatalf("Derived string type not converted, got %#v %T", output, output)
26         }
27 }
28
29 func TestConvertDerivedByteSlice(t *testing.T) {
30         type derived []uint8
31
32         output, err := converter{}.ConvertValue(derived("value"))
33         if err != nil {
34                 t.Fatal("Byte slice not convertible", err)
35         }
36
37         if bytes.Compare(output.([]byte), []byte("value")) != 0 {
38                 t.Fatalf("Byte slice not converted, got %#v %T", output, output)
39         }
40 }
41
42 func TestConvertDerivedUnsupportedSlice(t *testing.T) {
43         type derived []int
44
45         _, err := converter{}.ConvertValue(derived{1})
46         if err == nil || err.Error() != "unsupported type mysql.derived, a slice of int" {
47                 t.Fatal("Unexpected error", err)
48         }
49 }
50
51 func TestConvertDerivedBool(t *testing.T) {
52         type derived bool
53
54         output, err := converter{}.ConvertValue(derived(true))
55         if err != nil {
56                 t.Fatal("Derived bool type not convertible", err)
57         }
58
59         if output != true {
60                 t.Fatalf("Derived bool type not converted, got %#v %T", output, output)
61         }
62 }
63
64 func TestConvertPointer(t *testing.T) {
65         str := "value"
66
67         output, err := converter{}.ConvertValue(&str)
68         if err != nil {
69                 t.Fatal("Pointer type not convertible", err)
70         }
71
72         if output != "value" {
73                 t.Fatalf("Pointer type not converted, got %#v %T", output, output)
74         }
75 }
76
77 func TestConvertSignedIntegers(t *testing.T) {
78         values := []interface{}{
79                 int8(-42),
80                 int16(-42),
81                 int32(-42),
82                 int64(-42),
83                 int(-42),
84         }
85
86         for _, value := range values {
87                 output, err := converter{}.ConvertValue(value)
88                 if err != nil {
89                         t.Fatalf("%T type not convertible %s", value, err)
90                 }
91
92                 if output != int64(-42) {
93                         t.Fatalf("%T type not converted, got %#v %T", value, output, output)
94                 }
95         }
96 }
97
98 func TestConvertUnsignedIntegers(t *testing.T) {
99         values := []interface{}{
100                 uint8(42),
101                 uint16(42),
102                 uint32(42),
103                 uint64(42),
104                 uint(42),
105         }
106
107         for _, value := range values {
108                 output, err := converter{}.ConvertValue(value)
109                 if err != nil {
110                         t.Fatalf("%T type not convertible %s", value, err)
111                 }
112
113                 if output != int64(42) {
114                         t.Fatalf("%T type not converted, got %#v %T", value, output, output)
115                 }
116         }
117
118         output, err := converter{}.ConvertValue(^uint64(0))
119         if err != nil {
120                 t.Fatal("uint64 high-bit not convertible", err)
121         }
122
123         if output != "18446744073709551615" {
124                 t.Fatalf("uint64 high-bit not converted, got %#v %T", output, output)
125         }
126 }