Revision 44139 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/TestInterpreter.java
TestInterpreter.java | ||
---|---|---|
1 | 1 |
package org.gvsig.expresionevaluator.impl; |
2 | 2 |
|
3 |
import org.gvsig.expressionevaluator.impl.DefaultInterpreter; |
|
4 |
import org.gvsig.expressionevaluator.impl.DefaultSymbolTable; |
|
5 |
import org.gvsig.expressionevaluator.impl.SQLLexicalAnalyzer; |
|
6 |
import org.gvsig.expressionevaluator.impl.DefaultCompiler; |
|
7 | 3 |
import junit.framework.TestCase; |
8 | 4 |
import org.gvsig.expressionevaluator.LexicalAnalyzer; |
9 | 5 |
import org.gvsig.expressionevaluator.Compiler; |
10 | 6 |
import org.gvsig.expressionevaluator.SymbolTable; |
11 | 7 |
import org.gvsig.expressionevaluator.Interpreter; |
12 | 8 |
import org.gvsig.expressionevaluator.Code; |
9 |
import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator; |
|
10 |
import org.gvsig.expressionevaluator.ExpressionEvaluatorManager; |
|
11 |
import org.gvsig.expressionevaluator.MutableSymbolTable; |
|
13 | 12 |
import org.gvsig.tools.library.impl.DefaultLibrariesInitializer; |
14 | 13 |
|
15 | 14 |
public class TestInterpreter extends TestCase { |
... | ... | |
32 | 31 |
// TODO add test methods here. The name must begin with 'test'. For example: |
33 | 32 |
// public void testHello() {} |
34 | 33 |
|
34 |
|
|
35 | 35 |
protected LexicalAnalyzer createLexicalAnalyzer() { |
36 |
SQLLexicalAnalyzer lexer = new SQLLexicalAnalyzer(); |
|
36 |
ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager(); |
|
37 |
LexicalAnalyzer lexer = manager.createLexicalAnalyzer(); |
|
37 | 38 |
return lexer; |
38 | 39 |
} |
39 |
|
|
40 |
protected Compiler createCompiler() { |
|
41 |
Compiler compiler = new DefaultCompiler(); |
|
40 |
|
|
41 |
protected org.gvsig.expressionevaluator.Compiler createCompiler() { |
|
42 |
ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager(); |
|
43 |
Compiler compiler = manager.createCompiler(); |
|
42 | 44 |
compiler.setLexicalAnalyzer(createLexicalAnalyzer()); |
43 | 45 |
return compiler; |
44 | 46 |
} |
47 |
|
|
45 | 48 |
|
46 | 49 |
protected SymbolTable createSymbolTable() { |
47 |
DefaultSymbolTable symbolTable = new DefaultSymbolTable(); |
|
50 |
ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager(); |
|
51 |
MutableSymbolTable symbolTable = manager.createSymbolTable(); |
|
48 | 52 |
symbolTable.setVar("precio", 200); |
49 | 53 |
symbolTable.setVar("1990", 0.168873933773767); |
50 | 54 |
return symbolTable; |
51 | 55 |
} |
52 | 56 |
|
53 | 57 |
protected Interpreter createInterpreter(SymbolTable symbolTable) { |
54 |
Interpreter interpreter = new DefaultInterpreter(); |
|
58 |
ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager(); |
|
59 |
Interpreter interpreter = manager.createInterpreter(); |
|
55 | 60 |
interpreter.setSymbolTable(symbolTable); |
56 | 61 |
return interpreter; |
57 | 62 |
} |
58 | 63 |
|
59 | 64 |
public void testIdentifier1() { |
60 |
String source = "precio"; |
|
61 |
|
|
62 | 65 |
SymbolTable symbolTable = createSymbolTable(); |
63 | 66 |
Compiler compiler = createCompiler(); |
64 | 67 |
Interpreter interpreter = createInterpreter(symbolTable); |
65 | 68 |
|
69 |
String source = "precio"; |
|
70 |
|
|
66 | 71 |
Code code = compiler.compileExpression(source); |
67 | 72 |
Object v = interpreter.run(code); |
68 | 73 |
assertEquals(200, ((Number)v).intValue()); |
69 | 74 |
} |
70 | 75 |
|
71 | 76 |
public void testInteger() { |
72 |
String source = "23"; |
|
73 |
|
|
74 | 77 |
SymbolTable symbolTable = createSymbolTable(); |
75 | 78 |
Compiler compiler = createCompiler(); |
76 | 79 |
Interpreter interpreter = createInterpreter(symbolTable); |
77 | 80 |
|
81 |
String source = "23"; |
|
82 |
|
|
78 | 83 |
Code code = compiler.compileExpression(source); |
79 | 84 |
Object v = interpreter.run(code); |
80 | 85 |
assertEquals(23, ((Number)v).intValue()); |
81 | 86 |
} |
82 | 87 |
|
83 | 88 |
public void testTrue() { |
84 |
String source = "true"; |
|
85 |
|
|
86 | 89 |
SymbolTable symbolTable = createSymbolTable(); |
87 | 90 |
Compiler compiler = createCompiler(); |
88 | 91 |
Interpreter interpreter = createInterpreter(symbolTable); |
89 | 92 |
|
93 |
String source = "true"; |
|
94 |
|
|
90 | 95 |
Code code = compiler.compileExpression(source); |
91 | 96 |
assertEquals(Boolean.TRUE, interpreter.run(code)); |
92 | 97 |
} |
93 | 98 |
|
94 | 99 |
public void testFalse() { |
95 |
String source = "false"; |
|
96 |
|
|
97 | 100 |
SymbolTable symbolTable = createSymbolTable(); |
98 | 101 |
Compiler compiler = createCompiler(); |
99 | 102 |
Interpreter interpreter = createInterpreter(symbolTable); |
100 | 103 |
|
104 |
String source = "false"; |
|
105 |
|
|
101 | 106 |
Code code = compiler.compileExpression(source); |
102 | 107 |
assertEquals(Boolean.FALSE, interpreter.run(code)); |
103 | 108 |
} |
104 | 109 |
|
105 | 110 |
public void testNull() { |
106 |
String source = "null"; |
|
107 |
|
|
108 | 111 |
SymbolTable symbolTable = createSymbolTable(); |
109 | 112 |
Compiler compiler = createCompiler(); |
110 | 113 |
Interpreter interpreter = createInterpreter(symbolTable); |
111 | 114 |
|
115 |
String source = "null"; |
|
116 |
|
|
112 | 117 |
Code code = compiler.compileExpression(source); |
113 | 118 |
assertEquals(null, interpreter.run(code)); |
114 | 119 |
} |
115 | 120 |
|
116 | 121 |
public void testAdd1() { |
117 |
String source = "precio + 10"; |
|
118 |
|
|
119 | 122 |
SymbolTable symbolTable = createSymbolTable(); |
120 | 123 |
Compiler compiler = createCompiler(); |
121 | 124 |
Interpreter interpreter = createInterpreter(symbolTable); |
122 | 125 |
|
126 |
String source = "precio + 10"; |
|
127 |
|
|
123 | 128 |
Code code = compiler.compileExpression(source); |
124 | 129 |
Object v = interpreter.run(code); |
125 | 130 |
assertEquals(210, ((Number)v).intValue()); |
126 | 131 |
} |
127 | 132 |
|
128 | 133 |
public void testSimpleAdd1() { |
129 |
String source = "5+10"; |
|
130 |
|
|
131 | 134 |
SymbolTable symbolTable = createSymbolTable(); |
132 | 135 |
Compiler compiler = createCompiler(); |
133 | 136 |
Interpreter interpreter = createInterpreter(symbolTable); |
134 | 137 |
|
138 |
String source = "5+10"; |
|
139 |
|
|
135 | 140 |
Code code = compiler.compileExpression(source); |
136 | 141 |
Object v = interpreter.run(code); |
137 | 142 |
assertEquals(15, ((Number)v).intValue()); |
138 | 143 |
} |
139 | 144 |
|
140 | 145 |
public void testSimpleAdd2() { |
141 |
String source = "5 + 10"; |
|
142 |
|
|
143 | 146 |
SymbolTable symbolTable = createSymbolTable(); |
144 | 147 |
Compiler compiler = createCompiler(); |
145 | 148 |
Interpreter interpreter = createInterpreter(symbolTable); |
146 | 149 |
|
150 |
String source = "5 + 10"; |
|
151 |
|
|
147 | 152 |
Code code = compiler.compileExpression(source); |
148 | 153 |
Object v = interpreter.run(code); |
149 | 154 |
assertEquals(15, ((Number)v).intValue()); |
150 | 155 |
} |
151 | 156 |
|
152 | 157 |
public void testSimpleAdd3() { |
153 |
String source = "10+-5"; |
|
154 |
|
|
155 | 158 |
SymbolTable symbolTable = createSymbolTable(); |
156 | 159 |
Compiler compiler = createCompiler(); |
157 | 160 |
Interpreter interpreter = createInterpreter(symbolTable); |
158 | 161 |
|
162 |
String source = "10+-5"; |
|
163 |
|
|
159 | 164 |
Code code = compiler.compileExpression(source); |
160 | 165 |
Object v = interpreter.run(code); |
161 | 166 |
assertEquals(5, ((Number)v).intValue()); |
162 | 167 |
} |
163 | 168 |
|
164 | 169 |
public void testSimpleSub1() { |
165 |
String source = "10-5"; |
|
166 |
|
|
167 | 170 |
SymbolTable symbolTable = createSymbolTable(); |
168 | 171 |
Compiler compiler = createCompiler(); |
169 | 172 |
Interpreter interpreter = createInterpreter(symbolTable); |
170 | 173 |
|
174 |
String source = "10-5"; |
|
175 |
|
|
171 | 176 |
Code code = compiler.compileExpression(source); |
172 | 177 |
Object v = interpreter.run(code); |
173 | 178 |
assertEquals(5, ((Number)v).intValue()); |
174 | 179 |
} |
175 | 180 |
|
176 | 181 |
public void testSimpleSub2() { |
177 |
String source = "10 - 5"; |
|
178 |
|
|
179 | 182 |
SymbolTable symbolTable = createSymbolTable(); |
180 | 183 |
Compiler compiler = createCompiler(); |
181 | 184 |
Interpreter interpreter = createInterpreter(symbolTable); |
182 | 185 |
|
186 |
String source = "10 - 5"; |
|
187 |
|
|
183 | 188 |
Code code = compiler.compileExpression(source); |
184 | 189 |
Object v = interpreter.run(code); |
185 | 190 |
assertEquals(5, ((Number)v).intValue()); |
186 | 191 |
} |
187 | 192 |
|
188 | 193 |
public void testSimpleNumber() { |
189 |
String source = "23"; |
|
190 |
|
|
191 | 194 |
SymbolTable symbolTable = createSymbolTable(); |
192 | 195 |
Compiler compiler = createCompiler(); |
193 | 196 |
Interpreter interpreter = createInterpreter(symbolTable); |
194 | 197 |
|
198 |
String source = "23"; |
|
199 |
|
|
195 | 200 |
Code code = compiler.compileExpression(source); |
196 | 201 |
Object v = interpreter.run(code); |
197 | 202 |
assertEquals(23, ((Number)v).intValue()); |
198 | 203 |
} |
199 | 204 |
|
200 | 205 |
public void testSimpleNegativeNumber() { |
201 |
String source = "-23"; |
|
202 |
|
|
203 | 206 |
SymbolTable symbolTable = createSymbolTable(); |
204 | 207 |
Compiler compiler = createCompiler(); |
205 | 208 |
Interpreter interpreter = createInterpreter(symbolTable); |
206 | 209 |
|
210 |
String source = "-23"; |
|
211 |
|
|
207 | 212 |
Code code = compiler.compileExpression(source); |
208 | 213 |
Object v = interpreter.run(code); |
209 | 214 |
assertEquals(-23, ((Number)v).intValue()); |
210 | 215 |
} |
211 | 216 |
|
212 | 217 |
public void testNegateFunction() { |
213 |
String source = "-PI()"; |
|
214 |
|
|
215 | 218 |
SymbolTable symbolTable = createSymbolTable(); |
216 | 219 |
Compiler compiler = createCompiler(); |
217 | 220 |
Interpreter interpreter = createInterpreter(symbolTable); |
218 | 221 |
|
222 |
String source = "-PI()"; |
|
223 |
|
|
219 | 224 |
Code code = compiler.compileExpression(source); |
220 | 225 |
Object v = interpreter.run(code); |
221 | 226 |
assertEquals(-Math.PI, ((Number)v).doubleValue()); |
222 | 227 |
} |
223 | 228 |
|
224 | 229 |
public void testSub1() { |
225 |
String source = "precio - 10"; |
|
226 |
|
|
227 | 230 |
SymbolTable symbolTable = createSymbolTable(); |
228 | 231 |
Compiler compiler = createCompiler(); |
229 | 232 |
Interpreter interpreter = createInterpreter(symbolTable); |
230 | 233 |
|
234 |
String source = "precio - 10"; |
|
235 |
|
|
231 | 236 |
Code code = compiler.compileExpression(source); |
232 | 237 |
Object v = interpreter.run(code); |
233 | 238 |
assertEquals(190, ((Number)v).intValue()); |
234 | 239 |
} |
235 | 240 |
|
236 | 241 |
public void testMul1() { |
237 |
String source = "precio * 10"; |
|
238 |
|
|
239 | 242 |
SymbolTable symbolTable = createSymbolTable(); |
240 | 243 |
Compiler compiler = createCompiler(); |
241 | 244 |
Interpreter interpreter = createInterpreter(symbolTable); |
242 | 245 |
|
246 |
String source = "precio * 10"; |
|
247 |
|
|
243 | 248 |
Code code = compiler.compileExpression(source); |
244 | 249 |
Object v = interpreter.run(code); |
245 | 250 |
assertEquals(2000, ((Number)v).intValue()); |
246 | 251 |
} |
247 | 252 |
|
248 | 253 |
public void testDiv1() { |
249 |
String source = "precio / 10"; |
|
250 |
|
|
251 | 254 |
SymbolTable symbolTable = createSymbolTable(); |
252 | 255 |
Compiler compiler = createCompiler(); |
253 | 256 |
Interpreter interpreter = createInterpreter(symbolTable); |
254 | 257 |
|
258 |
String source = "precio / 10"; |
|
259 |
|
|
255 | 260 |
Code code = compiler.compileExpression(source); |
256 | 261 |
Object v = interpreter.run(code); |
257 | 262 |
assertEquals(20, ((Number)v).intValue()); |
258 | 263 |
} |
259 | 264 |
|
260 | 265 |
public void testAdd2() { |
261 |
String source = "precio + 10 + 20 + 30"; |
|
262 |
|
|
263 | 266 |
SymbolTable symbolTable = createSymbolTable(); |
264 | 267 |
Compiler compiler = createCompiler(); |
265 | 268 |
Interpreter interpreter = createInterpreter(symbolTable); |
266 | 269 |
|
270 |
String source = "precio + 10 + 20 + 30"; |
|
271 |
|
|
267 | 272 |
Code code = compiler.compileExpression(source); |
268 | 273 |
Object v = interpreter.run(code); |
269 | 274 |
assertEquals(260, ((Number)v).intValue()); |
270 | 275 |
} |
271 | 276 |
|
272 | 277 |
public void testAddMul() { |
273 |
String source = "precio + 10 * 2 + 20 + 30"; |
|
274 |
|
|
275 | 278 |
SymbolTable symbolTable = createSymbolTable(); |
276 | 279 |
Compiler compiler = createCompiler(); |
277 | 280 |
Interpreter interpreter = createInterpreter(symbolTable); |
278 | 281 |
|
282 |
String source = "precio + 10 * 2 + 20 + 30"; |
|
283 |
|
|
279 | 284 |
Code code = compiler.compileExpression(source); |
280 | 285 |
Object v = interpreter.run(code); |
281 | 286 |
assertEquals(270, ((Number)v).intValue()); |
282 | 287 |
} |
283 | 288 |
|
284 | 289 |
public void testAddMulPar() { |
285 |
String source = "(precio + 10) * 2 + 20 + 30"; |
|
286 |
|
|
287 | 290 |
SymbolTable symbolTable = createSymbolTable(); |
288 | 291 |
Compiler compiler = createCompiler(); |
289 | 292 |
Interpreter interpreter = createInterpreter(symbolTable); |
290 | 293 |
|
294 |
String source = "(precio + 10) * 2 + 20 + 30"; |
|
295 |
|
|
291 | 296 |
Code code = compiler.compileExpression(source); |
292 | 297 |
Object v = interpreter.run(code); |
293 | 298 |
assertEquals(470, ((Number)v).intValue()); |
294 | 299 |
} |
295 | 300 |
|
296 | 301 |
public void testAbs() { |
297 |
String source = "precio + abs(10)"; |
|
298 |
|
|
299 | 302 |
SymbolTable symbolTable = createSymbolTable(); |
300 | 303 |
Compiler compiler = createCompiler(); |
301 | 304 |
Interpreter interpreter = createInterpreter(symbolTable); |
302 | 305 |
|
306 |
String source = "precio + abs(10)"; |
|
307 |
|
|
303 | 308 |
Code code = compiler.compileExpression(source); |
304 | 309 |
Object v = interpreter.run(code); |
305 | 310 |
assertEquals(210, ((Number)v).intValue()); |
306 | 311 |
} |
307 | 312 |
|
308 | 313 |
public void testAbs2() { |
309 |
String source = "precio + abs(-10)"; |
|
310 |
|
|
311 | 314 |
SymbolTable symbolTable = createSymbolTable(); |
312 | 315 |
Compiler compiler = createCompiler(); |
313 | 316 |
Interpreter interpreter = createInterpreter(symbolTable); |
314 | 317 |
|
318 |
String source = "precio + abs(-10)"; |
|
319 |
|
|
315 | 320 |
Code code = compiler.compileExpression(source); |
316 | 321 |
Object v = interpreter.run(code); |
317 | 322 |
assertEquals(210, ((Number)v).intValue()); |
318 | 323 |
} |
319 | 324 |
|
320 | 325 |
public void testCeil() { |
321 |
String source = "precio + CEIL(PI())"; |
|
322 |
|
|
323 | 326 |
SymbolTable symbolTable = createSymbolTable(); |
324 | 327 |
Compiler compiler = createCompiler(); |
325 | 328 |
Interpreter interpreter = createInterpreter(symbolTable); |
326 | 329 |
|
330 |
String source = "precio + CEIL(PI())"; |
|
331 |
|
|
327 | 332 |
Code code = compiler.compileExpression(source); |
328 | 333 |
Object v = interpreter.run(code); |
329 | 334 |
assertEquals(204, ((Number)v).intValue()); |
330 | 335 |
} |
331 | 336 |
|
332 | 337 |
public void testConcat() { |
333 |
String source = "CONCAT(precio,' euros')"; |
|
334 |
|
|
335 | 338 |
SymbolTable symbolTable = createSymbolTable(); |
336 | 339 |
Compiler compiler = createCompiler(); |
337 | 340 |
Interpreter interpreter = createInterpreter(symbolTable); |
338 | 341 |
|
342 |
String source = "CONCAT(precio,' euros')"; |
|
343 |
|
|
339 | 344 |
Code code = compiler.compileExpression(source); |
340 | 345 |
Object v = interpreter.run(code); |
341 | 346 |
assertEquals("200 euros", (String)v); |
... | ... | |
349 | 354 |
Code code; |
350 | 355 |
Object v; |
351 | 356 |
|
357 |
compiler.getLexicalAnalyzer().setUseBracketsForIdentifiers(true); |
|
358 |
|
|
352 | 359 |
code = compiler.compileExpression("[1990] = 0.168873933773767"); |
353 | 360 |
v = interpreter.run(code); |
354 | 361 |
assertEquals(true, ((Boolean)v).booleanValue()); |
... | ... | |
363 | 370 |
} |
364 | 371 |
|
365 | 372 |
public void test2fields() { |
366 |
String source = "[1990] = [precio]"; |
|
367 |
|
|
368 | 373 |
SymbolTable symbolTable = createSymbolTable(); |
369 | 374 |
Compiler compiler = createCompiler(); |
370 | 375 |
Interpreter interpreter = createInterpreter(symbolTable); |
371 | 376 |
|
377 |
compiler.getLexicalAnalyzer().setUseBracketsForIdentifiers(true); |
|
378 |
|
|
379 |
String source = "[1990] = [precio]"; |
|
380 |
|
|
381 |
compiler.getLexicalAnalyzer().setUseBracketsForIdentifiers(true); |
|
372 | 382 |
Code code = compiler.compileExpression(source); |
373 | 383 |
Object v = interpreter.run(code); |
374 | 384 |
assertEquals(false, ((Boolean)v).booleanValue()); |
... | ... | |
376 | 386 |
|
377 | 387 |
|
378 | 388 |
public void testInvokeMethod1() { |
379 |
String source = "'hola'.length()"; |
|
380 |
|
|
381 | 389 |
SymbolTable symbolTable = createSymbolTable(); |
382 | 390 |
Compiler compiler = createCompiler(); |
383 | 391 |
Interpreter interpreter = createInterpreter(symbolTable); |
384 | 392 |
|
393 |
String source = "'hola'.length()"; |
|
394 |
|
|
385 | 395 |
Code code = compiler.compileExpression(source); |
386 | 396 |
Object v = interpreter.run(code); |
387 | 397 |
|
... | ... | |
390 | 400 |
|
391 | 401 |
|
392 | 402 |
public void testInvokeMethod2() { |
403 |
SymbolTable symbolTable = createSymbolTable(); |
|
404 |
Compiler compiler = createCompiler(); |
|
405 |
Interpreter interpreter = createInterpreter(symbolTable); |
|
406 |
|
|
393 | 407 |
String source = "'hola'.indexOf('l')"; |
394 | 408 |
|
409 |
Code code = compiler.compileExpression(source); |
|
410 |
Object v = interpreter.run(code); |
|
411 |
|
|
412 |
assertEquals(2, ((Number)v).intValue()); |
|
413 |
} |
|
414 |
|
|
415 |
public void testAlias() { |
|
395 | 416 |
SymbolTable symbolTable = createSymbolTable(); |
396 | 417 |
Compiler compiler = createCompiler(); |
397 | 418 |
Interpreter interpreter = createInterpreter(symbolTable); |
398 | 419 |
|
420 |
String source = "UPPER('hola')"; |
|
399 | 421 |
Code code = compiler.compileExpression(source); |
400 | 422 |
Object v = interpreter.run(code); |
423 |
assertEquals("HOLA", (String)v); |
|
401 | 424 |
|
402 |
assertEquals(2, ((Number)v).intValue()); |
|
425 |
|
|
426 |
source = "UCASE('hola')"; |
|
427 |
code = compiler.compileExpression(source); |
|
428 |
v = interpreter.run(code); |
|
429 |
assertEquals("HOLA", (String)v); |
|
403 | 430 |
} |
431 |
|
|
432 |
public void testRegexp1() { |
|
433 |
SymbolTable symbolTable = createSymbolTable(); |
|
434 |
Compiler compiler = createCompiler(); |
|
435 |
Interpreter interpreter = createInterpreter(symbolTable); |
|
436 |
|
|
437 |
String source = "'Hola' ~ '[Hh]ola'" ; |
|
438 |
Code code = compiler.compileExpression(source); |
|
439 |
Object v = interpreter.run(code); |
|
440 |
assertTrue((Boolean)v); |
|
441 |
} |
|
404 | 442 |
|
443 |
public void testGetitem1() { |
|
444 |
SymbolTable symbolTable = createSymbolTable(); |
|
445 |
Compiler compiler = createCompiler(); |
|
446 |
Interpreter interpreter = createInterpreter(symbolTable); |
|
447 |
compiler.getLexicalAnalyzer().setUseBracketsForIdentifiers(false); |
|
448 |
|
|
449 |
String source = "LIST('uno','dos','tres')[1]" ; |
|
450 |
|
|
451 |
Code code = compiler.compileExpression(source); |
|
452 |
Object v = interpreter.run(code); |
|
453 |
assertEquals("dos", (String)v); |
|
454 |
} |
|
405 | 455 |
|
406 | 456 |
} |
Also available in: Unified diff