root / trunk / extensions / extSymbology / src-test / org / gvsig / symbology / fmap / labeling / parse / TestLabelExpressionParser.java @ 22517
History | View | Annotate | Download (20.4 KB)
1 |
/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana
|
---|---|
2 |
*
|
3 |
* Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.
|
4 |
*
|
5 |
* This program is free software; you can redistribute it and/or
|
6 |
* modify it under the terms of the GNU General Public License
|
7 |
* as published by the Free Software Foundation; either version 2
|
8 |
* of the License, or (at your option) any later version.
|
9 |
*
|
10 |
* This program is distributed in the hope that it will be useful,
|
11 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
12 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
13 |
* GNU General Public License for more details.
|
14 |
*
|
15 |
* You should have received a copy of the GNU General Public License
|
16 |
* along with this program; if not, write to the Free Software
|
17 |
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,USA.
|
18 |
*
|
19 |
* For more information, contact:
|
20 |
*
|
21 |
* Generalitat Valenciana
|
22 |
* Conselleria d'Infraestructures i Transport
|
23 |
* Av. Blasco Ib??ez, 50
|
24 |
* 46010 VALENCIA
|
25 |
* SPAIN
|
26 |
*
|
27 |
* +34 963862235
|
28 |
* gvsig@gva.es
|
29 |
* www.gvsig.gva.es
|
30 |
*
|
31 |
* or
|
32 |
*
|
33 |
* IVER T.I. S.A
|
34 |
* Salamanca 50
|
35 |
* 46005 Valencia
|
36 |
* Spain
|
37 |
*
|
38 |
* +34 963163400
|
39 |
* dac@iver.es
|
40 |
*/
|
41 |
package org.gvsig.symbology.fmap.labeling.parse; |
42 |
|
43 |
import java.io.CharArrayReader; |
44 |
import java.io.StringReader; |
45 |
import java.util.Hashtable; |
46 |
|
47 |
import junit.framework.TestCase; |
48 |
|
49 |
|
50 |
import org.gvsig.symbology.fmap.labeling.lang.functions.SubstringFunction; |
51 |
import org.gvsig.symbology.fmap.rendering.filter.operations.Expression; |
52 |
import org.gvsig.symbology.fmap.rendering.filter.operations.ExpressionException; |
53 |
import org.gvsig.symbology.fmap.rendering.filter.operations.OperatorsFactory; |
54 |
|
55 |
import com.hardcode.gdbms.engine.values.BooleanValue; |
56 |
import com.hardcode.gdbms.engine.values.DoubleValue; |
57 |
import com.hardcode.gdbms.engine.values.IntValue; |
58 |
import com.hardcode.gdbms.engine.values.NullValue; |
59 |
import com.hardcode.gdbms.engine.values.StringValue; |
60 |
import com.hardcode.gdbms.engine.values.Value; |
61 |
import com.hardcode.gdbms.engine.values.ValueFactory; |
62 |
|
63 |
public class TestLabelExpressionParser extends TestCase { |
64 |
LabelExpressionParser parser; |
65 |
Hashtable<String, Value> symbols_table = new Hashtable<String, Value>(); |
66 |
|
67 |
protected void setUp() throws Exception { |
68 |
super.setUp();
|
69 |
|
70 |
for (int j = 0; j < symbols.length; j++) { |
71 |
symbols_table.put(symbols[j].id,symbols[j].val); |
72 |
} |
73 |
} |
74 |
|
75 |
private class Symbol { |
76 |
private String id; |
77 |
private Value val;
|
78 |
|
79 |
public Symbol(String id, Value val) { |
80 |
this.id = id;
|
81 |
this.val = val;
|
82 |
} |
83 |
} |
84 |
private Symbol[] symbols = new Symbol[] { |
85 |
// 0
|
86 |
new Symbol(
|
87 |
"A_DOUBLE_VALUE",
|
88 |
ValueFactory.createValue(4.0)
|
89 |
), |
90 |
// 1
|
91 |
new Symbol(
|
92 |
"ANOTHER_DOUBLE_VALUE",
|
93 |
ValueFactory.createValue(Math.PI)
|
94 |
), |
95 |
// 2
|
96 |
new Symbol(
|
97 |
"A_INTEGER_VALUE",
|
98 |
ValueFactory.createValue(12)
|
99 |
), |
100 |
// 3
|
101 |
new Symbol(
|
102 |
"A_STRING_VALUE",
|
103 |
ValueFactory.createValue("this is a String")
|
104 |
), |
105 |
// 4
|
106 |
new Symbol(
|
107 |
"A_BOOLEAN_VALUE",
|
108 |
ValueFactory.createValue(true)
|
109 |
), |
110 |
// 5
|
111 |
new Symbol(
|
112 |
"ANOTHER_BOOLEAN_VALUE",
|
113 |
ValueFactory.createValue(false)
|
114 |
), |
115 |
// 6
|
116 |
new Symbol(
|
117 |
"A_NULL_VALUE",
|
118 |
ValueFactory.createNullValue() |
119 |
), |
120 |
|
121 |
// 7
|
122 |
new Symbol(
|
123 |
"XX",
|
124 |
ValueFactory.createValue(2)),
|
125 |
// 8
|
126 |
new Symbol(
|
127 |
"Y",
|
128 |
ValueFactory.createValue(2.0)),
|
129 |
|
130 |
}; |
131 |
|
132 |
private String[] ArgumentsExpressions = new String[] { |
133 |
"(754)",
|
134 |
"(754, \"blah\")",
|
135 |
"(-9.68, [A_DOUBLE_VALUE]) ",
|
136 |
"(false, true) ",
|
137 |
}; |
138 |
private Object[][] ArgumentsExpressionsValue = new Object[][] { |
139 |
new Object[] { 754 }, |
140 |
new Object[] { 754, "blah" }, |
141 |
new Object[] { -9.68, 4.0 }, |
142 |
new Object[] { false, true }, |
143 |
}; |
144 |
|
145 |
public void testArguments() throws ExpressionException { |
146 |
|
147 |
String[] expressions = ArgumentsExpressions; |
148 |
Object[][] expectedValues = ArgumentsExpressionsValue; |
149 |
System.out.println("\nTestLabelExpressionParser.testArgumens()"); |
150 |
|
151 |
for (int i = 0; i < expressions.length; i++) { |
152 |
String expr = expressions[i];
|
153 |
parser = new LabelExpressionParser(new StringReader(expr),symbols_table); |
154 |
|
155 |
System.out.print("Parsing '"+expr+"'"); |
156 |
try {
|
157 |
|
158 |
int amount = parser.Arguments();
|
159 |
|
160 |
System.out.print(": [ parsed ]. Evaluating: "); |
161 |
Object[] expected = expectedValues[i]; |
162 |
assertTrue("Failed detecting argument number. Expected "+expected.length+", but got "+amount+".", amount == expected.length); |
163 |
|
164 |
for (int j = expected.length-1; j >= 0; j--) { // <- Last in first out |
165 |
Object value = parser.pop();
|
166 |
assertTrue("Parsed text '"+expr+"' evaluated to ("+value+") when expecting ["+expected[j]+"]", value.equals(expected[j])); |
167 |
System.out.print(value+" [ Ok! ]\t"); |
168 |
} |
169 |
|
170 |
|
171 |
} catch (ParseException e) { |
172 |
System.err.println(":\t [ Fail! ]"); |
173 |
fail("Failed parsing text '"+expr+"'\n"+e.getMessage()); |
174 |
} |
175 |
System.out.println();
|
176 |
} |
177 |
} |
178 |
|
179 |
private String[] LiteralExpressions = new String[] { |
180 |
"true",
|
181 |
"false",
|
182 |
" 43564356435.234",
|
183 |
" 12455 ",
|
184 |
" \"a string\"",
|
185 |
}; |
186 |
private Object[] LiteralExpressionsValue = new Object[] { |
187 |
true ,
|
188 |
false,
|
189 |
43564356435.234,
|
190 |
12455,
|
191 |
"a string"
|
192 |
}; |
193 |
|
194 |
public void testLiteral() throws ExpressionException { |
195 |
String[] expressions = LiteralExpressions; |
196 |
Object[] expectedValues = LiteralExpressionsValue; |
197 |
System.out.println("\nTestLabelExpressionParser.testLiteral()"); |
198 |
|
199 |
for (int i = 0; i < expressions.length; i++) { |
200 |
String expr = expressions[i];
|
201 |
parser = new LabelExpressionParser(new StringReader(expr),symbols_table); |
202 |
|
203 |
System.out.print("Parsing '"+expr+"'"); |
204 |
try {
|
205 |
parser.UnaryElement(); |
206 |
System.out.print(": [ parsed ]. Evaluating: "); |
207 |
Object expected = expectedValues[i];
|
208 |
|
209 |
Object value = parser.pop();
|
210 |
assertTrue("Parsed text '"+expr+"' evaluated to ("+value+") when expecting ["+expected+"]", value.equals(expected)); |
211 |
System.out.print(value+" [ Ok! ]\t"); |
212 |
|
213 |
|
214 |
} catch (ParseException e) { |
215 |
System.err.println(":\t [ Fail! ]"); |
216 |
fail("Failed parsing text '"+expr+"'\n"+e.getMessage()); |
217 |
} |
218 |
System.out.println();
|
219 |
} |
220 |
} |
221 |
|
222 |
private String[] FunctionExpressions = new String[] { |
223 |
new SubstringFunction(symbols_table).getName()+"(\"My taylor is rich!\", 1)", |
224 |
new SubstringFunction(symbols_table).getName()+"(\"My taylor is rich!\", 3, 9)", |
225 |
new SubstringFunction(symbols_table).getName()+"("+new SubstringFunction(symbols_table).getName()+"(\"My taylor is rich!\", 3, 9), 2,3)", |
226 |
}; |
227 |
private Object[] FunctionExpressionsValue = new Object[] { |
228 |
"y taylor is rich!" ,
|
229 |
"taylor" ,
|
230 |
"y",
|
231 |
}; |
232 |
public void testFunction() throws ExpressionException { |
233 |
OperatorsFactory operators = OperatorsFactory.getInstance(); |
234 |
operators.addOperator(SubstringFunction.class); |
235 |
|
236 |
String[] expressions = FunctionExpressions; |
237 |
Object[] expectedValues = FunctionExpressionsValue; |
238 |
System.out.println("\nTestLabelExpressionParser.testFunction()"); |
239 |
|
240 |
|
241 |
for (int i = 0; i < expressions.length; i++) { |
242 |
String expr = expressions[i];
|
243 |
parser = new LabelExpressionParser(new StringReader(expr),symbols_table); |
244 |
parser.setOperatorsFactory(operators); |
245 |
|
246 |
System.out.print("Parsing '"+expr+"'"); |
247 |
try {
|
248 |
parser.function(); |
249 |
System.out.print(": [ parsed ]. Evaluating: "); |
250 |
Object expected = expectedValues[i];
|
251 |
|
252 |
Object value = parser.pop();
|
253 |
assertTrue("Parsed text '"+expr+"' evaluated to ("+value+") when expecting ["+expected+"]", value.equals(expected)); |
254 |
System.out.print(value+" [ Ok! ]\t"); |
255 |
|
256 |
|
257 |
} catch (ParseException e) { |
258 |
System.err.println(":\t [ Fail! ]"); |
259 |
fail("Failed parsing text '"+expr+"'\n"+e.getMessage()); |
260 |
} |
261 |
System.out.println();
|
262 |
} |
263 |
} |
264 |
|
265 |
public void testPrimitiveExpression() throws ExpressionException { |
266 |
String[] PrimitiveExpressions = new String[symbols.length]; |
267 |
Object[] PrimitiveExpressionsValue = new Object[symbols.length]; |
268 |
for (int i = 0; i < symbols.length; i++) { |
269 |
PrimitiveExpressions[i] = "["+symbols[i].id+"]"; |
270 |
PrimitiveExpressionsValue[i] = symbols[i].val; |
271 |
} |
272 |
|
273 |
String[] expressions = PrimitiveExpressions; |
274 |
Object[] expectedValues = PrimitiveExpressionsValue; |
275 |
|
276 |
System.out.println("\nTestLabelExpressionParser.testPrimitiveExpression()"); |
277 |
|
278 |
for (int i = 0; i < expressions.length; i++) { |
279 |
String expr = expressions[i];
|
280 |
parser = new LabelExpressionParser(new StringReader(expr),symbols_table); |
281 |
|
282 |
System.out.print("Parsing '"+expr+"'"); |
283 |
try {
|
284 |
parser.Element(); |
285 |
System.out.print(": [ parsed ]. Evaluating: "); |
286 |
Object expected = expectedValues[i];
|
287 |
|
288 |
// GDBMS values are evaluated as java primitives
|
289 |
if (expected instanceof DoubleValue) { |
290 |
expected = ((DoubleValue) expected).getValue(); |
291 |
} else if (expected instanceof IntValue) { |
292 |
expected = ((IntValue) expected).getValue(); |
293 |
} else if (expected instanceof StringValue) { |
294 |
expected = ((StringValue) expected).getValue(); |
295 |
} |
296 |
|
297 |
// else if (expected instanceof DateValue) {
|
298 |
// expected = ((DateValue) expected).getValue();
|
299 |
// }
|
300 |
|
301 |
else if (expected instanceof BooleanValue) { |
302 |
expected = ((BooleanValue) expected).getValue(); |
303 |
} else if (expected instanceof NullValue) { |
304 |
expected = null;
|
305 |
} |
306 |
|
307 |
|
308 |
Object value = parser.pop();
|
309 |
assertTrue("Parsed text '"+expr+"' evaluated to ("+value+") when expecting ["+expected+"]", value == null ? value == expected : value.equals(expected)); |
310 |
System.out.print(value+" [ Ok! ]\t"); |
311 |
|
312 |
|
313 |
} catch (ParseException e) { |
314 |
System.err.println(":\t [ Fail! ]"); |
315 |
fail("Failed parsing text '"+expr+"'\n"+e.getMessage()); |
316 |
} |
317 |
System.out.println();
|
318 |
} |
319 |
} |
320 |
|
321 |
|
322 |
private String[] UnaryBooleanExpressions = new String[] { |
323 |
"!false",
|
324 |
"!true",
|
325 |
"![A_BOOLEAN_VALUE]",
|
326 |
"![ANOTHER_BOOLEAN_VALUE]",
|
327 |
}; |
328 |
private Object[] UnaryBooleanExpressionsValue = new Object[] { |
329 |
!false,
|
330 |
!true,
|
331 |
!((BooleanValue) symbols[4].val).getValue(),
|
332 |
!((BooleanValue) symbols[5].val).getValue(),
|
333 |
}; |
334 |
public void testBooleanUnaryExpression() throws ExpressionException { |
335 |
String[] expressions = UnaryBooleanExpressions; |
336 |
Object[] expectedValues = UnaryBooleanExpressionsValue; |
337 |
System.out.println("\nTestLabelExpressionParser.testBooleanUnaryExpression()"); |
338 |
|
339 |
for (int i = 0; i < expressions.length; i++) { |
340 |
String expr = expressions[i];
|
341 |
parser = new LabelExpressionParser(new StringReader(expr),symbols_table); |
342 |
|
343 |
System.out.print("Parsing '"+expr+"'"); |
344 |
try {
|
345 |
parser.UnaryElement(); |
346 |
System.out.print(": [ parsed ]. Evaluating: "); |
347 |
Object expected = expectedValues[i];
|
348 |
|
349 |
Object value = parser.pop();
|
350 |
assertTrue("Parsed text '"+expr+"' evaluated to ("+value+") when expecting ["+expected+"]", value.equals(expected)); |
351 |
System.out.print(value+" [ Ok! ]\t"); |
352 |
|
353 |
|
354 |
} catch (ParseException e) { |
355 |
System.err.println(":\t [ Fail! ]"); |
356 |
fail("Failed parsing text '"+expr+"'\n"+e.getMessage()); |
357 |
} |
358 |
System.out.println();
|
359 |
} |
360 |
} |
361 |
|
362 |
|
363 |
private String[] UnaryArithmeticExpressions = new String[] { |
364 |
"+65",
|
365 |
"-5.5",
|
366 |
"+-+-[A_DOUBLE_VALUE]",
|
367 |
"--+[ANOTHER_DOUBLE_VALUE]",
|
368 |
}; |
369 |
private Object[] UnaryArithmeticExpressionsValue = new Object[] { |
370 |
65,
|
371 |
-5.5,
|
372 |
((DoubleValue) symbols[0].val).getValue(),
|
373 |
((DoubleValue) symbols[1].val).getValue(),
|
374 |
}; |
375 |
public void testArithmeticUnaryExpression() throws ExpressionException { |
376 |
String[] expressions = UnaryArithmeticExpressions; |
377 |
Object[] expectedValues = UnaryArithmeticExpressionsValue; |
378 |
System.out.println("\nTestLabelExpressionParser.testArithmeticUnaryExpression()"); |
379 |
|
380 |
for (int i = 0; i < expressions.length; i++) { |
381 |
String expr = expressions[i];
|
382 |
parser = new LabelExpressionParser(new StringReader(expr),symbols_table); |
383 |
|
384 |
System.out.print("Parsing '"+expr+"'"); |
385 |
try {
|
386 |
parser.MultiplicativeExpression(); |
387 |
System.out.print(": [ parsed ]. Evaluating: "); |
388 |
Object expected = expectedValues[i];
|
389 |
|
390 |
Object value = parser.pop();
|
391 |
assertTrue("Parsed text '"+expr+"' evaluated to ("+value+") when expecting ["+expected+"]", value.equals(expected)); |
392 |
System.out.print(value+" [ Ok! ]\t"); |
393 |
|
394 |
|
395 |
} catch (ParseException e) { |
396 |
System.err.println(":\t [ Fail! ]"); |
397 |
fail("Failed parsing text '"+expr+"'\n"+e.getMessage()); |
398 |
} |
399 |
System.out.println();
|
400 |
} |
401 |
} |
402 |
|
403 |
private String[] MultiplicativeArithmeticExpressions = new String[] { |
404 |
"3*4356.234",
|
405 |
"15*10",
|
406 |
"15/10",
|
407 |
"8768758/2432432",
|
408 |
"[A_DOUBLE_VALUE]*[ANOTHER_DOUBLE_VALUE]",
|
409 |
"[A_DOUBLE_VALUE]/[ANOTHER_DOUBLE_VALUE]",
|
410 |
"[A_DOUBLE_VALUE]*16",
|
411 |
}; |
412 |
private Object[] MultiplicativeArithmeticExpressionsValue = new Object[] { |
413 |
3*4356.234, |
414 |
15*10, |
415 |
15/10, |
416 |
8768758/2432432, |
417 |
((DoubleValue) symbols[0].val).getValue()*((DoubleValue) symbols[1].val).getValue(), |
418 |
((DoubleValue) symbols[0].val).getValue()/((DoubleValue) symbols[1].val).getValue(), |
419 |
((DoubleValue) symbols[0].val).getValue() * 16, |
420 |
}; |
421 |
|
422 |
public void testMultiplicativeExpression() throws ExpressionException { |
423 |
String[] expressions = MultiplicativeArithmeticExpressions; |
424 |
Object[] expectedValues = MultiplicativeArithmeticExpressionsValue; |
425 |
System.out.println("\nTestLabelExpressionParser.testMultiplicativeExpression()"); |
426 |
|
427 |
for (int i = 0; i < expressions.length; i++) { |
428 |
String expr = expressions[i];
|
429 |
parser = new LabelExpressionParser(new StringReader(expr),symbols_table); |
430 |
|
431 |
System.out.print("Parsing '"+expr+"'"); |
432 |
try {
|
433 |
parser.MultiplicativeExpression(); |
434 |
System.out.print(": [ parsed ]. Evaluating: "); |
435 |
Object expected = expectedValues[i];
|
436 |
|
437 |
Object value = parser.pop();
|
438 |
assertTrue("Parsed text '"+expr+"' evaluated to ("+value+") when expecting ["+expected+"]", value.equals(expected)); |
439 |
System.out.print(value+" [ Ok! ]\t"); |
440 |
|
441 |
|
442 |
} catch (ParseException e) { |
443 |
System.err.println(":\t [ Fail! ]"); |
444 |
fail("Failed parsing text '"+expr+"'\n"+e.getMessage()); |
445 |
} |
446 |
System.out.println();
|
447 |
} |
448 |
} |
449 |
|
450 |
private String[] AdditiveArithmeticExpressions = new String[] { |
451 |
"3-4356.234",
|
452 |
"8768758+2432432",
|
453 |
"[A_DOUBLE_VALUE]+[ANOTHER_DOUBLE_VALUE]",
|
454 |
"[A_DOUBLE_VALUE]-[ANOTHER_DOUBLE_VALUE]",
|
455 |
}; |
456 |
private Object[] AdditiveArithmeticExpressionsValue = new Object[] { |
457 |
3-4356.234, |
458 |
8768758+2432432, |
459 |
((DoubleValue) symbols[0].val).getValue()+((DoubleValue) symbols[1].val).getValue(), |
460 |
((DoubleValue) symbols[0].val).getValue()-((DoubleValue) symbols[1].val).getValue(), |
461 |
}; |
462 |
public void testAdditiveExpression() throws ExpressionException { |
463 |
String[] expressions = AdditiveArithmeticExpressions; |
464 |
Object[] expectedValues = AdditiveArithmeticExpressionsValue; |
465 |
System.out.println("\nTestLabelExpressionParser.testAdditiveExpression()"); |
466 |
|
467 |
for (int i = 0; i < expressions.length; i++) { |
468 |
String expr = expressions[i];
|
469 |
parser = new LabelExpressionParser(new StringReader(expr),symbols_table); |
470 |
|
471 |
System.out.print("Parsing '"+expr+"'"); |
472 |
try {
|
473 |
parser.AdditiveExpression(); |
474 |
System.out.print(": [ parsed ]. Evaluating: "); |
475 |
Object expected = expectedValues[i];
|
476 |
|
477 |
Object value = parser.pop();
|
478 |
assertTrue("Parsed text '"+expr+"' evaluated to ("+value+") when expecting ["+expected+"]", value.equals(expected)); |
479 |
System.out.print(value+" [ Ok! ]\t"); |
480 |
|
481 |
|
482 |
} catch (ParseException e) { |
483 |
System.err.println(":\t [ Fail! ]"); |
484 |
fail("Failed parsing text '"+expr+"'\n"+e.getMessage()); |
485 |
} |
486 |
System.out.println();
|
487 |
} |
488 |
} |
489 |
|
490 |
|
491 |
|
492 |
private String EOField = LabelExpressionParser.tokenFor(LabelExpressionParser.EOFIELD); |
493 |
private String EOExpression = LabelExpressionParser.tokenFor(LabelExpressionParser.EOEXPR); |
494 |
private String DOUBLEQUOTE = "\""; |
495 |
|
496 |
private String[] FieldExpressionStrings = new String[] { |
497 |
"km" +"25", |
498 |
DOUBLEQUOTE+"km"+DOUBLEQUOTE+" "+DOUBLEQUOTE+" 25"+DOUBLEQUOTE, |
499 |
"[A_STRING_VALUE] "+DOUBLEQUOTE+" 25"+DOUBLEQUOTE, |
500 |
"[A_INTEGER_VALUE] "+DOUBLEQUOTE+" 25"+DOUBLEQUOTE, |
501 |
"[A_DOUBLE_VALUE] "+DOUBLEQUOTE+" 25"+DOUBLEQUOTE, |
502 |
"2+3"+"km", |
503 |
}; |
504 |
private Object[] FieldExpressionValue = new Object[] { |
505 |
"km25",
|
506 |
"km 25",
|
507 |
((StringValue) symbols[3].val).getValue()+" 25", |
508 |
((IntValue) symbols[2].val).getValue()+" 25", |
509 |
((DoubleValue) symbols[0].val).getValue()+" 25", |
510 |
"5km"
|
511 |
}; |
512 |
|
513 |
public void testFieldExpressionStrings() throws ExpressionException { |
514 |
|
515 |
String[] expressions = FieldExpressionStrings; |
516 |
Object[] expectedValues = FieldExpressionValue; |
517 |
System.out.println("\nTestLabelExpressionParser.testConcatExpressions()"); |
518 |
|
519 |
for (int i = 0; i < expressions.length; i++) { |
520 |
String expr = expressions[i];
|
521 |
parser = new LabelExpressionParser(new StringReader(expr),symbols_table); |
522 |
|
523 |
|
524 |
System.out.print("Parsing '"+expr+"'"); |
525 |
try {
|
526 |
|
527 |
parser.LabelExpression(); |
528 |
|
529 |
System.out.print(": [ parsed ]. Evaluating: "); |
530 |
Object[] expected = expectedValues; |
531 |
String myValues = ((Expression)parser.getStack().pop()).evaluate().toString(); |
532 |
|
533 |
|
534 |
Object value = myValues;
|
535 |
assertTrue("Parsed text '"+expr+"' evaluated to ("+value+") when expecting ["+expected[i]+"]", value.equals(expected[i].toString())); |
536 |
System.out.print(value+" [ Ok! ]\t"); |
537 |
|
538 |
|
539 |
|
540 |
} catch (ParseException e) { |
541 |
System.err.println(":\t [ Fail! ]"); |
542 |
fail("Failed parsing text '"+expr+"'\n"+e.getMessage()); |
543 |
} |
544 |
System.out.println();
|
545 |
} |
546 |
} |
547 |
|
548 |
|
549 |
private String[] LabelExpressions = new String[] { |
550 |
"1+2"+EOField+"true"+EOField+"2<3", |
551 |
"300+454"+EOField+"false", |
552 |
"1+2"+EOField+"1+5"+EOField+"2<3", |
553 |
"[A_DOUBLE_VALUE]/[ANOTHER_DOUBLE_VALUE]"+EOField+"Km", |
554 |
"km" +"25"+EOField+"1+5", |
555 |
DOUBLEQUOTE+"km"+DOUBLEQUOTE+" "+DOUBLEQUOTE+" 25"+DOUBLEQUOTE+EOField+"1+2"+EOField+"true"+EOField+"2<3", |
556 |
|
557 |
}; |
558 |
private Object[][] LabelExpressionsValue = new Object[][] { |
559 |
new Object[] {3,true,true }, |
560 |
new Object[] { 754, false }, |
561 |
new Object[] { 3,6,true }, |
562 |
new Object[] {((DoubleValue) symbols[0].val).getValue()/((DoubleValue) symbols[1].val).getValue(),"Km"}, |
563 |
new Object[] {"km25",6 }, |
564 |
new Object[] {"km 25",3,true,true }, |
565 |
|
566 |
}; |
567 |
|
568 |
public void testLabelExpressions() throws ExpressionException { |
569 |
|
570 |
String[] expressions = LabelExpressions; |
571 |
Object[][] expectedValues = LabelExpressionsValue; |
572 |
System.out.println("\nTestLabelExpressionParser.testLabelExpressions()"); |
573 |
|
574 |
for (int i = 0; i < expressions.length; i++) { |
575 |
String expr = expressions[i];
|
576 |
parser = new LabelExpressionParser(new StringReader(expr),symbols_table); |
577 |
|
578 |
|
579 |
System.out.print("Parsing '"+expr+"'"); |
580 |
try {
|
581 |
|
582 |
parser.LabelExpression(); |
583 |
|
584 |
System.out.print(": [ parsed ]. Evaluating: "); |
585 |
Object[] expected = expectedValues[i]; |
586 |
Object[] myValues = (Object[]) ((Expression)parser.getStack().pop()).evaluate(); |
587 |
|
588 |
for (int j = 0; j < myValues.length; j++) { // <- Last in first out |
589 |
Object value = myValues[j];
|
590 |
assertTrue("Parsed text '"+expr+"' evaluated to ("+value+") when expecting ["+expected[j]+"]", value.equals(expected[j].toString())); |
591 |
System.out.print(value+" [ Ok! ]\t"); |
592 |
} |
593 |
|
594 |
|
595 |
} catch (ParseException e) { |
596 |
System.err.println(":\t [ Fail! ]"); |
597 |
fail("Failed parsing text '"+expr+"'\n"+e.getMessage()); |
598 |
} |
599 |
System.out.println();
|
600 |
} |
601 |
} |
602 |
|
603 |
|
604 |
|
605 |
private String[] SolvedBugsExpressions = new String[] { |
606 |
"([Y] + 3) * 5;",
|
607 |
"([Y] + 3) * 5"+EOField+"([Y] + 3) * 5", |
608 |
}; |
609 |
private Object[][] SolvedBugsExpressionsValue = new Object[][] { |
610 |
new Object[] { ((((DoubleValue) symbols[8].val ).getValue() + 3 ) *5) }, |
611 |
new Object[] { |
612 |
""+((((DoubleValue) symbols[8].val ).getValue() + 3 ) *5), |
613 |
""+((((DoubleValue) symbols[8].val ).getValue() + 3 ) *5) }, |
614 |
}; |
615 |
/**
|
616 |
* Tests several buggy expressions detected by testers and users
|
617 |
* @throws ExpressionException
|
618 |
*/
|
619 |
public void testSolvedBugsExpressions() throws ExpressionException { |
620 |
|
621 |
String[] expressions = SolvedBugsExpressions; |
622 |
Object[][] expectedValues = SolvedBugsExpressionsValue; |
623 |
System.out.println("\nTestLabelExpressionParser.testSolvedBugsExpressions()"); |
624 |
|
625 |
for (int i = 0; i < expressions.length; i++) { |
626 |
String expr = expressions[i];
|
627 |
parser = new LabelExpressionParser(new StringReader(expr),symbols_table); |
628 |
|
629 |
|
630 |
System.out.print("Parsing '"+expr+"'"); |
631 |
try {
|
632 |
|
633 |
parser.LabelExpression(); |
634 |
|
635 |
System.out.print(": [ parsed ]. Evaluating: "); |
636 |
Object[] expected = expectedValues[i]; |
637 |
Object value = ((Expression)parser.getStack().pop()).evaluate(); |
638 |
if (value.getClass().isArray()) {
|
639 |
Object[] myValues = (Object[]) value; |
640 |
|
641 |
for (int j = 0; j < myValues.length; j++) { // <- Last in first out |
642 |
Object aValue = myValues[j];
|
643 |
assertTrue("Parsed text '"+expr+"' evaluated to ("+aValue+") when expecting ["+expected[j]+"]", aValue.equals(expected[j].toString())); |
644 |
System.out.print(aValue+" [ Ok! ]\t"); |
645 |
} |
646 |
} else {
|
647 |
assertTrue("Parsed text '"+expr+"' evaluated to ("+value+") when expecting ["+expected+"]", value.equals(expected[0])); |
648 |
System.out.print(value+" [ Ok! ]\t"); |
649 |
} |
650 |
|
651 |
} catch (ParseException e) { |
652 |
System.err.println(":\t [ Fail! ]"); |
653 |
fail("Failed parsing text '"+expr+"'\n"+e.getMessage()); |
654 |
} |
655 |
System.out.println();
|
656 |
} |
657 |
} |
658 |
|
659 |
} |