1 package pgtype
2
3 import (
4 "bytes"
5 "testing"
6 )
7
8 func TestParseUntypedTextRange(t *testing.T) {
9 tests := []struct {
10 src string
11 result untypedTextRange
12 err error
13 }{
14 {
15 src: `[1,2)`,
16 result: untypedTextRange{Lower: "1", Upper: "2", LowerType: Inclusive, UpperType: Exclusive},
17 err: nil,
18 },
19 {
20 src: `[1,2]`,
21 result: untypedTextRange{Lower: "1", Upper: "2", LowerType: Inclusive, UpperType: Inclusive},
22 err: nil,
23 },
24 {
25 src: `(1,3)`,
26 result: untypedTextRange{Lower: "1", Upper: "3", LowerType: Exclusive, UpperType: Exclusive},
27 err: nil,
28 },
29 {
30 src: ` [1,2) `,
31 result: untypedTextRange{Lower: "1", Upper: "2", LowerType: Inclusive, UpperType: Exclusive},
32 err: nil,
33 },
34 {
35 src: `[ foo , bar )`,
36 result: untypedTextRange{Lower: " foo ", Upper: " bar ", LowerType: Inclusive, UpperType: Exclusive},
37 err: nil,
38 },
39 {
40 src: `["foo","bar")`,
41 result: untypedTextRange{Lower: "foo", Upper: "bar", LowerType: Inclusive, UpperType: Exclusive},
42 err: nil,
43 },
44 {
45 src: `["f""oo","b""ar")`,
46 result: untypedTextRange{Lower: `f"oo`, Upper: `b"ar`, LowerType: Inclusive, UpperType: Exclusive},
47 err: nil,
48 },
49 {
50 src: `["f""oo","b""ar")`,
51 result: untypedTextRange{Lower: `f"oo`, Upper: `b"ar`, LowerType: Inclusive, UpperType: Exclusive},
52 err: nil,
53 },
54 {
55 src: `["","bar")`,
56 result: untypedTextRange{Lower: ``, Upper: `bar`, LowerType: Inclusive, UpperType: Exclusive},
57 err: nil,
58 },
59 {
60 src: `[f\"oo\,,b\\ar\))`,
61 result: untypedTextRange{Lower: `f"oo,`, Upper: `b\ar)`, LowerType: Inclusive, UpperType: Exclusive},
62 err: nil,
63 },
64 {
65 src: `empty`,
66 result: untypedTextRange{Lower: "", Upper: "", LowerType: Empty, UpperType: Empty},
67 err: nil,
68 },
69 }
70
71 for i, tt := range tests {
72 r, err := parseUntypedTextRange(tt.src)
73 if err != tt.err {
74 t.Errorf("%d. `%v`: expected err %v, got %v", i, tt.src, tt.err, err)
75 continue
76 }
77
78 if r.LowerType != tt.result.LowerType {
79 t.Errorf("%d. `%v`: expected result lower type %v, got %v", i, tt.src, string(tt.result.LowerType), string(r.LowerType))
80 }
81
82 if r.UpperType != tt.result.UpperType {
83 t.Errorf("%d. `%v`: expected result upper type %v, got %v", i, tt.src, string(tt.result.UpperType), string(r.UpperType))
84 }
85
86 if r.Lower != tt.result.Lower {
87 t.Errorf("%d. `%v`: expected result lower %v, got %v", i, tt.src, tt.result.Lower, r.Lower)
88 }
89
90 if r.Upper != tt.result.Upper {
91 t.Errorf("%d. `%v`: expected result upper %v, got %v", i, tt.src, tt.result.Upper, r.Upper)
92 }
93 }
94 }
95
96 func TestParseUntypedBinaryRange(t *testing.T) {
97 tests := []struct {
98 src []byte
99 result untypedBinaryRange
100 err error
101 }{
102 {
103 src: []byte{0, 0, 0, 0, 2, 0, 4, 0, 0, 0, 2, 0, 5},
104 result: untypedBinaryRange{Lower: []byte{0, 4}, Upper: []byte{0, 5}, LowerType: Exclusive, UpperType: Exclusive},
105 err: nil,
106 },
107 {
108 src: []byte{1},
109 result: untypedBinaryRange{Lower: nil, Upper: nil, LowerType: Empty, UpperType: Empty},
110 err: nil,
111 },
112 {
113 src: []byte{2, 0, 0, 0, 2, 0, 4, 0, 0, 0, 2, 0, 5},
114 result: untypedBinaryRange{Lower: []byte{0, 4}, Upper: []byte{0, 5}, LowerType: Inclusive, UpperType: Exclusive},
115 err: nil,
116 },
117 {
118 src: []byte{4, 0, 0, 0, 2, 0, 4, 0, 0, 0, 2, 0, 5},
119 result: untypedBinaryRange{Lower: []byte{0, 4}, Upper: []byte{0, 5}, LowerType: Exclusive, UpperType: Inclusive},
120 err: nil,
121 },
122 {
123 src: []byte{6, 0, 0, 0, 2, 0, 4, 0, 0, 0, 2, 0, 5},
124 result: untypedBinaryRange{Lower: []byte{0, 4}, Upper: []byte{0, 5}, LowerType: Inclusive, UpperType: Inclusive},
125 err: nil,
126 },
127 {
128 src: []byte{8, 0, 0, 0, 2, 0, 5},
129 result: untypedBinaryRange{Lower: nil, Upper: []byte{0, 5}, LowerType: Unbounded, UpperType: Exclusive},
130 err: nil,
131 },
132 {
133 src: []byte{12, 0, 0, 0, 2, 0, 5},
134 result: untypedBinaryRange{Lower: nil, Upper: []byte{0, 5}, LowerType: Unbounded, UpperType: Inclusive},
135 err: nil,
136 },
137 {
138 src: []byte{16, 0, 0, 0, 2, 0, 4},
139 result: untypedBinaryRange{Lower: []byte{0, 4}, Upper: nil, LowerType: Exclusive, UpperType: Unbounded},
140 err: nil,
141 },
142 {
143 src: []byte{18, 0, 0, 0, 2, 0, 4},
144 result: untypedBinaryRange{Lower: []byte{0, 4}, Upper: nil, LowerType: Inclusive, UpperType: Unbounded},
145 err: nil,
146 },
147 {
148 src: []byte{24},
149 result: untypedBinaryRange{Lower: nil, Upper: nil, LowerType: Unbounded, UpperType: Unbounded},
150 err: nil,
151 },
152 }
153
154 for i, tt := range tests {
155 r, err := parseUntypedBinaryRange(tt.src)
156 if err != tt.err {
157 t.Errorf("%d. `%v`: expected err %v, got %v", i, tt.src, tt.err, err)
158 continue
159 }
160
161 if r.LowerType != tt.result.LowerType {
162 t.Errorf("%d. `%v`: expected result lower type %v, got %v", i, tt.src, string(tt.result.LowerType), string(r.LowerType))
163 }
164
165 if r.UpperType != tt.result.UpperType {
166 t.Errorf("%d. `%v`: expected result upper type %v, got %v", i, tt.src, string(tt.result.UpperType), string(r.UpperType))
167 }
168
169 if !bytes.Equal(r.Lower, tt.result.Lower) {
170 t.Errorf("%d. `%v`: expected result lower %v, got %v", i, tt.src, tt.result.Lower, r.Lower)
171 }
172
173 if !bytes.Equal(r.Upper, tt.result.Upper) {
174 t.Errorf("%d. `%v`: expected result upper %v, got %v", i, tt.src, tt.result.Upper, r.Upper)
175 }
176 }
177 }
178
View as plain text