svn-gvsig-desktop / trunk / org.gvsig.desktop / org.gvsig.desktop.library / org.gvsig.expressionevaluator / org.gvsig.expressionevaluator.lib / org.gvsig.expressionevaluator.lib.impl / src / test / java / org / gvsig / expresionevaluator / impl / TestSQLLexer.java @ 44421
History | View | Annotate | Download (8.71 KB)
1 |
package org.gvsig.expresionevaluator.impl; |
---|---|
2 |
|
3 |
import org.gvsig.expressionevaluator.impl.SQLLexicalAnalyzer; |
4 |
import junit.framework.TestCase; |
5 |
import org.gvsig.expressionevaluator.LexicalAnalyzer; |
6 |
import org.gvsig.expressionevaluator.LexicalAnalyzer.Token; |
7 |
import org.gvsig.tools.library.impl.DefaultLibrariesInitializer; |
8 |
|
9 |
public class TestSQLLexer extends TestCase { |
10 |
|
11 |
public TestSQLLexer(String testName) { |
12 |
super(testName);
|
13 |
} |
14 |
|
15 |
@Override
|
16 |
protected void setUp() throws Exception { |
17 |
super.setUp();
|
18 |
new DefaultLibrariesInitializer().fullInitialize();
|
19 |
} |
20 |
|
21 |
@Override
|
22 |
protected void tearDown() throws Exception { |
23 |
super.tearDown();
|
24 |
} |
25 |
|
26 |
// TODO add test methods here. The name must begin with 'test'. For example:
|
27 |
// public void testHello() {}
|
28 |
|
29 |
protected LexicalAnalyzer createLexicalAnalyzer(String expression) { |
30 |
SQLLexicalAnalyzer lex = new SQLLexicalAnalyzer(expression);
|
31 |
return lex;
|
32 |
} |
33 |
|
34 |
public void testIdentifier1() { |
35 |
String expression = "precio"; |
36 |
|
37 |
LexicalAnalyzer lex = createLexicalAnalyzer(expression); |
38 |
Token t1 = lex.next(); |
39 |
assertEquals(Token.IDENTIFIER, t1.getType()); |
40 |
assertEquals("precio", t1.getLiteral());
|
41 |
} |
42 |
|
43 |
public void testIdentifier2() { |
44 |
String expression = "\"precio\""; |
45 |
|
46 |
LexicalAnalyzer lex = createLexicalAnalyzer(expression); |
47 |
Token t1 = lex.next(); |
48 |
assertEquals(Token.IDENTIFIER, t1.getType()); |
49 |
assertEquals("precio", t1.getLiteral());
|
50 |
} |
51 |
|
52 |
public void testIdentifier3() { |
53 |
String expression = "[precio]"; |
54 |
|
55 |
LexicalAnalyzer lex = createLexicalAnalyzer(expression); |
56 |
lex.setUseBracketsForIdentifiers(true);
|
57 |
|
58 |
Token t1 = lex.next(); |
59 |
assertEquals(Token.IDENTIFIER, t1.getType()); |
60 |
assertEquals("precio", t1.getLiteral());
|
61 |
} |
62 |
|
63 |
public void testTrue() { |
64 |
String expression = "true"; |
65 |
|
66 |
LexicalAnalyzer lex = createLexicalAnalyzer(expression); |
67 |
Token t1 = lex.next(); |
68 |
assertEquals(Token.TRUE, t1.getType()); |
69 |
assertEquals("true", t1.getLiteral());
|
70 |
} |
71 |
|
72 |
public void testFalse() { |
73 |
String expression = "false"; |
74 |
|
75 |
LexicalAnalyzer lex = createLexicalAnalyzer(expression); |
76 |
Token t1 = lex.next(); |
77 |
assertEquals(Token.FALSE, t1.getType()); |
78 |
assertEquals("false", t1.getLiteral());
|
79 |
} |
80 |
|
81 |
public void testNull() { |
82 |
String expression = "null"; |
83 |
|
84 |
LexicalAnalyzer lex = createLexicalAnalyzer(expression); |
85 |
Token t1 = lex.next(); |
86 |
assertEquals(Token.NULL, t1.getType()); |
87 |
assertEquals("null", t1.getLiteral());
|
88 |
assertNotNull(t1.getValue()); |
89 |
} |
90 |
|
91 |
public void testIsNull() { |
92 |
String expression = "isnull"; |
93 |
|
94 |
LexicalAnalyzer lex = createLexicalAnalyzer(expression); |
95 |
Token t1 = lex.next(); |
96 |
assertEquals(Token.ISNULL, t1.getType()); |
97 |
assertEquals("isnull", t1.getLiteral());
|
98 |
assertNotNull(t1.getValue()); |
99 |
} |
100 |
|
101 |
public void testNotNull() { |
102 |
String expression = "notnull"; |
103 |
|
104 |
LexicalAnalyzer lex = createLexicalAnalyzer(expression); |
105 |
Token t1 = lex.next(); |
106 |
assertEquals(Token.NOTNULL, t1.getType()); |
107 |
assertEquals("notnull", t1.getLiteral());
|
108 |
assertNotNull(t1.getValue()); |
109 |
} |
110 |
|
111 |
public void testNotTrue() { |
112 |
String expression = "not true"; |
113 |
|
114 |
LexicalAnalyzer lex = createLexicalAnalyzer(expression); |
115 |
Token t1 = lex.next(); |
116 |
assertEquals(Token.OP_NOT, t1.getType()); |
117 |
assertEquals("not", t1.getLiteral());
|
118 |
t1 = lex.next(); |
119 |
assertEquals(Token.TRUE, t1.getType()); |
120 |
assertEquals("true", t1.getLiteral());
|
121 |
} |
122 |
|
123 |
public void testInteger() { |
124 |
String expression = "23"; |
125 |
|
126 |
LexicalAnalyzer lex = createLexicalAnalyzer(expression); |
127 |
Token t1 = lex.next(); |
128 |
assertEquals(Token.INTEGER_LITERAL, t1.getType()); |
129 |
assertEquals("23", t1.getLiteral());
|
130 |
assertEquals((Integer)23, t1.getValue()); |
131 |
} |
132 |
|
133 |
public void testDecimal() { |
134 |
String expression = "23.1"; |
135 |
|
136 |
LexicalAnalyzer lex = createLexicalAnalyzer(expression); |
137 |
Token t1 = lex.next(); |
138 |
assertEquals(Token.FLOATING_POINT_LITERAL, t1.getType()); |
139 |
assertEquals("23.1", t1.getLiteral());
|
140 |
assertEquals(new Double(23.1), t1.getValue()); |
141 |
} |
142 |
|
143 |
public void testStringLiteral1() { |
144 |
String expression = "'hola macu'"; |
145 |
|
146 |
LexicalAnalyzer lex = createLexicalAnalyzer(expression); |
147 |
Token t1 = lex.next(); |
148 |
assertEquals(Token.STRING_LITERAL, t1.getType()); |
149 |
assertEquals("hola macu", t1.getLiteral());
|
150 |
assertEquals("hola macu", t1.getValue());
|
151 |
} |
152 |
|
153 |
public void testStringLiteral2() { |
154 |
String expression = "'hola''s macu'"; |
155 |
|
156 |
LexicalAnalyzer lex = createLexicalAnalyzer(expression); |
157 |
Token t1 = lex.next(); |
158 |
assertEquals(Token.STRING_LITERAL, t1.getType()); |
159 |
assertEquals("hola's macu", t1.getLiteral());
|
160 |
assertEquals("hola's macu", t1.getValue());
|
161 |
} |
162 |
|
163 |
public void operator(String operatorName, int operatorId) { |
164 |
String expression = "precio " + operatorName + " 23"; |
165 |
|
166 |
LexicalAnalyzer lex = createLexicalAnalyzer(expression); |
167 |
Token t1 = lex.next(); |
168 |
assertEquals(Token.IDENTIFIER, t1.getType()); |
169 |
assertEquals("precio", t1.getLiteral());
|
170 |
|
171 |
Token t2 = lex.next(); |
172 |
assertEquals(operatorId, t2.getType()); |
173 |
assertEquals(operatorName, t2.getLiteral()); |
174 |
|
175 |
Token t3 = lex.next(); |
176 |
assertEquals(Token.INTEGER_LITERAL, t3.getType()); |
177 |
assertEquals("23", t3.getLiteral());
|
178 |
assertEquals((Integer)23, t3.getValue()); |
179 |
} |
180 |
|
181 |
public void testOperators() { |
182 |
|
183 |
operator("=", Token.OP_EQ);
|
184 |
operator("<>", Token.OP_NE);
|
185 |
operator(">", Token.OP_GT);
|
186 |
operator(">=", Token.OP_GE);
|
187 |
operator("<", Token.OP_LT);
|
188 |
operator("<=", Token.OP_LE);
|
189 |
operator("like", Token.PRED_LIKE);
|
190 |
operator("ilike", Token.PRED_ILIKE);
|
191 |
operator("+", Token.OP_ADD);
|
192 |
operator("-", Token.OP_SUBST);
|
193 |
operator("*", Token.OP_MULT);
|
194 |
// operator("^", Token.OP_POW);
|
195 |
operator("or", Token.OP_OR);
|
196 |
operator("and", Token.OP_AND);
|
197 |
operator("%", Token.OP_MOD);
|
198 |
operator("is", Token.PRED_IS);
|
199 |
operator("->", Token.OP_GETATTR);
|
200 |
operator(".", Token.OP_GETATTR);
|
201 |
|
202 |
} |
203 |
|
204 |
public void testPar() { |
205 |
String expression = "precio = ( 23 + 5 )"; |
206 |
|
207 |
LexicalAnalyzer lex = createLexicalAnalyzer(expression); |
208 |
Token t1 = lex.next(); |
209 |
assertEquals(Token.IDENTIFIER, t1.getType()); |
210 |
assertEquals("precio", t1.getLiteral());
|
211 |
|
212 |
t1 = lex.next(); |
213 |
assertEquals(Token.OP_EQ, t1.getType()); |
214 |
assertEquals("=", t1.getLiteral());
|
215 |
|
216 |
t1 = lex.next(); |
217 |
assertEquals(Token.PARENTHESIS_OPEN, t1.getType()); |
218 |
assertEquals("(", t1.getLiteral());
|
219 |
|
220 |
t1 = lex.next(); |
221 |
assertEquals(Token.INTEGER_LITERAL, t1.getType()); |
222 |
assertEquals("23", t1.getLiteral());
|
223 |
assertEquals((Integer)23, t1.getValue()); |
224 |
|
225 |
t1 = lex.next(); |
226 |
assertEquals(Token.OP_ADD, t1.getType()); |
227 |
assertEquals("+", t1.getLiteral());
|
228 |
|
229 |
t1 = lex.next(); |
230 |
assertEquals(Token.INTEGER_LITERAL, t1.getType()); |
231 |
assertEquals("5", t1.getLiteral());
|
232 |
assertEquals((Integer)5, t1.getValue()); |
233 |
|
234 |
t1 = lex.next(); |
235 |
assertEquals(Token.PARENTHESIS_CLOSE, t1.getType()); |
236 |
assertEquals(")", t1.getLiteral());
|
237 |
} |
238 |
|
239 |
public void testFuncWithArgs() { |
240 |
String expression = "precio = add(23, 5)"; |
241 |
|
242 |
LexicalAnalyzer lex = createLexicalAnalyzer(expression); |
243 |
Token t1 = lex.next(); |
244 |
assertEquals(Token.IDENTIFIER, t1.getType()); |
245 |
assertEquals("precio", t1.getLiteral());
|
246 |
|
247 |
t1 = lex.next(); |
248 |
assertEquals(Token.OP_EQ, t1.getType()); |
249 |
assertEquals("=", t1.getLiteral());
|
250 |
|
251 |
t1 = lex.next(); |
252 |
assertEquals(Token.IDENTIFIER, t1.getType()); |
253 |
assertEquals("add", t1.getLiteral());
|
254 |
|
255 |
t1 = lex.next(); |
256 |
assertEquals(Token.PARENTHESIS_OPEN, t1.getType()); |
257 |
assertEquals("(", t1.getLiteral());
|
258 |
|
259 |
t1 = lex.next(); |
260 |
assertEquals(Token.INTEGER_LITERAL, t1.getType()); |
261 |
assertEquals("23", t1.getLiteral());
|
262 |
assertEquals((Integer)23, t1.getValue()); |
263 |
|
264 |
t1 = lex.next(); |
265 |
assertEquals(Token.COMA, t1.getType()); |
266 |
assertEquals(",", t1.getLiteral());
|
267 |
|
268 |
t1 = lex.next(); |
269 |
assertEquals(Token.INTEGER_LITERAL, t1.getType()); |
270 |
assertEquals("5", t1.getLiteral());
|
271 |
assertEquals((Integer)5, t1.getValue()); |
272 |
|
273 |
t1 = lex.next(); |
274 |
assertEquals(Token.PARENTHESIS_CLOSE, t1.getType()); |
275 |
assertEquals(")", t1.getLiteral());
|
276 |
} |
277 |
} |