1 package query
2
3 import (
4 "github.com/pelletier/go-toml"
5 "testing"
6 )
7
8 func testQLFlow(t *testing.T, input string, expectedFlow []token) {
9 ch := lexQuery(input)
10 for idx, expected := range expectedFlow {
11 token := <-ch
12 if token != expected {
13 t.Log("While testing #", idx, ":", input)
14 t.Log("compared (got)", token, "to (expected)", expected)
15 t.Log("\tvalue:", token.val, "<->", expected.val)
16 t.Log("\tvalue as bytes:", []byte(token.val), "<->", []byte(expected.val))
17 t.Log("\ttype:", token.typ.String(), "<->", expected.typ.String())
18 t.Log("\tline:", token.Line, "<->", expected.Line)
19 t.Log("\tcolumn:", token.Col, "<->", expected.Col)
20 t.Log("compared", token, "to", expected)
21 t.FailNow()
22 }
23 }
24
25 tok, ok := <-ch
26 if ok {
27 t.Log("channel is not closed!")
28 t.Log(len(ch)+1, "tokens remaining:")
29
30 t.Log("token ->", tok)
31 for token := range ch {
32 t.Log("token ->", token)
33 }
34 t.FailNow()
35 }
36 }
37
38 func TestLexSpecialChars(t *testing.T) {
39 testQLFlow(t, " .$[]..()?*", []token{
40 {toml.Position{1, 2}, tokenDot, "."},
41 {toml.Position{1, 3}, tokenDollar, "$"},
42 {toml.Position{1, 4}, tokenLeftBracket, "["},
43 {toml.Position{1, 5}, tokenRightBracket, "]"},
44 {toml.Position{1, 6}, tokenDotDot, ".."},
45 {toml.Position{1, 8}, tokenLeftParen, "("},
46 {toml.Position{1, 9}, tokenRightParen, ")"},
47 {toml.Position{1, 10}, tokenQuestion, "?"},
48 {toml.Position{1, 11}, tokenStar, "*"},
49 {toml.Position{1, 12}, tokenEOF, ""},
50 })
51 }
52
53 func TestLexString(t *testing.T) {
54 testQLFlow(t, "'foo\n'", []token{
55 {toml.Position{1, 2}, tokenString, "foo\n"},
56 {toml.Position{2, 2}, tokenEOF, ""},
57 })
58 }
59
60 func TestLexDoubleString(t *testing.T) {
61 testQLFlow(t, `"bar"`, []token{
62 {toml.Position{1, 2}, tokenString, "bar"},
63 {toml.Position{1, 6}, tokenEOF, ""},
64 })
65 }
66
67 func TestLexStringEscapes(t *testing.T) {
68 testQLFlow(t, `"foo \" \' \b \f \/ \t \r \\ \u03A9 \U00012345 \n bar"`, []token{
69 {toml.Position{1, 2}, tokenString, "foo \" ' \b \f / \t \r \\ \u03A9 \U00012345 \n bar"},
70 {toml.Position{1, 55}, tokenEOF, ""},
71 })
72 }
73
74 func TestLexStringUnfinishedUnicode4(t *testing.T) {
75 testQLFlow(t, `"\u000"`, []token{
76 {toml.Position{1, 2}, tokenError, "unfinished unicode escape"},
77 })
78 }
79
80 func TestLexStringUnfinishedUnicode8(t *testing.T) {
81 testQLFlow(t, `"\U0000"`, []token{
82 {toml.Position{1, 2}, tokenError, "unfinished unicode escape"},
83 })
84 }
85
86 func TestLexStringInvalidEscape(t *testing.T) {
87 testQLFlow(t, `"\x"`, []token{
88 {toml.Position{1, 2}, tokenError, "invalid escape sequence: \\x"},
89 })
90 }
91
92 func TestLexStringUnfinished(t *testing.T) {
93 testQLFlow(t, `"bar`, []token{
94 {toml.Position{1, 2}, tokenError, "unclosed string"},
95 })
96 }
97
98 func TestLexKey(t *testing.T) {
99 testQLFlow(t, "foo", []token{
100 {toml.Position{1, 1}, tokenKey, "foo"},
101 {toml.Position{1, 4}, tokenEOF, ""},
102 })
103 }
104
105 func TestLexRecurse(t *testing.T) {
106 testQLFlow(t, "$..*", []token{
107 {toml.Position{1, 1}, tokenDollar, "$"},
108 {toml.Position{1, 2}, tokenDotDot, ".."},
109 {toml.Position{1, 4}, tokenStar, "*"},
110 {toml.Position{1, 5}, tokenEOF, ""},
111 })
112 }
113
114 func TestLexBracketKey(t *testing.T) {
115 testQLFlow(t, "$[foo]", []token{
116 {toml.Position{1, 1}, tokenDollar, "$"},
117 {toml.Position{1, 2}, tokenLeftBracket, "["},
118 {toml.Position{1, 3}, tokenKey, "foo"},
119 {toml.Position{1, 6}, tokenRightBracket, "]"},
120 {toml.Position{1, 7}, tokenEOF, ""},
121 })
122 }
123
124 func TestLexSpace(t *testing.T) {
125 testQLFlow(t, "foo bar baz", []token{
126 {toml.Position{1, 1}, tokenKey, "foo"},
127 {toml.Position{1, 5}, tokenKey, "bar"},
128 {toml.Position{1, 9}, tokenKey, "baz"},
129 {toml.Position{1, 12}, tokenEOF, ""},
130 })
131 }
132
133 func TestLexInteger(t *testing.T) {
134 testQLFlow(t, "100 +200 -300", []token{
135 {toml.Position{1, 1}, tokenInteger, "100"},
136 {toml.Position{1, 5}, tokenInteger, "+200"},
137 {toml.Position{1, 10}, tokenInteger, "-300"},
138 {toml.Position{1, 14}, tokenEOF, ""},
139 })
140 }
141
142 func TestLexFloat(t *testing.T) {
143 testQLFlow(t, "100.0 +200.0 -300.0", []token{
144 {toml.Position{1, 1}, tokenFloat, "100.0"},
145 {toml.Position{1, 7}, tokenFloat, "+200.0"},
146 {toml.Position{1, 14}, tokenFloat, "-300.0"},
147 {toml.Position{1, 20}, tokenEOF, ""},
148 })
149 }
150
151 func TestLexFloatWithMultipleDots(t *testing.T) {
152 testQLFlow(t, "4.2.", []token{
153 {toml.Position{1, 1}, tokenError, "cannot have two dots in one float"},
154 })
155 }
156
157 func TestLexFloatLeadingDot(t *testing.T) {
158 testQLFlow(t, "+.1", []token{
159 {toml.Position{1, 1}, tokenError, "cannot start float with a dot"},
160 })
161 }
162
163 func TestLexFloatWithTrailingDot(t *testing.T) {
164 testQLFlow(t, "42.", []token{
165 {toml.Position{1, 1}, tokenError, "float cannot end with a dot"},
166 })
167 }
168
169 func TestLexNumberWithoutDigit(t *testing.T) {
170 testQLFlow(t, "+", []token{
171 {toml.Position{1, 1}, tokenError, "no digit in that number"},
172 })
173 }
174
175 func TestLexUnknown(t *testing.T) {
176 testQLFlow(t, "^", []token{
177 {toml.Position{1, 1}, tokenError, "unexpected char: '94'"},
178 })
179 }
180
View as plain text