root / trunk / extensions / extSymbology / src-test / org / gvsig / symbology / fmap / labeling / parse / TestLabelExpressionParser.java @ 22511
History | View | Annotate | Download (21.3 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 |
|
45 |
import junit.framework.TestCase; |
46 |
|
47 |
import org.gvsig.symbology.fmap.labeling.lang.functions.SubstringFunction; |
48 |
import org.gvsig.symbology.fmap.rendering.filter.operations.Expression; |
49 |
import org.gvsig.symbology.fmap.rendering.filter.operations.ExpressionException; |
50 |
import org.gvsig.symbology.fmap.rendering.filter.operations.OperatorsFactory; |
51 |
|
52 |
import com.hardcode.gdbms.engine.values.BooleanValue; |
53 |
import com.hardcode.gdbms.engine.values.DoubleValue; |
54 |
import com.hardcode.gdbms.engine.values.IntValue; |
55 |
import com.hardcode.gdbms.engine.values.NullValue; |
56 |
import com.hardcode.gdbms.engine.values.StringValue; |
57 |
import com.hardcode.gdbms.engine.values.Value; |
58 |
import com.hardcode.gdbms.engine.values.ValueFactory; |
59 |
|
60 |
public class TestLabelExpressionParser extends TestCase { |
61 |
LabelExpressionParser parser; |
62 |
|
63 |
protected void setUp() throws Exception { |
64 |
super.setUp();
|
65 |
} |
66 |
|
67 |
private class Symbol { |
68 |
private String id; |
69 |
private Value val;
|
70 |
|
71 |
public Symbol(String id, Value val) { |
72 |
this.id = id;
|
73 |
this.val = val;
|
74 |
} |
75 |
} |
76 |
private Symbol[] symbols = new Symbol[] { |
77 |
// 0
|
78 |
new Symbol(
|
79 |
"A_DOUBLE_VALUE",
|
80 |
ValueFactory.createValue(4.0)
|
81 |
), |
82 |
// 1
|
83 |
new Symbol(
|
84 |
"ANOTHER_DOUBLE_VALUE",
|
85 |
ValueFactory.createValue(Math.PI)
|
86 |
), |
87 |
// 2
|
88 |
new Symbol(
|
89 |
"A_INTEGER_VALUE",
|
90 |
ValueFactory.createValue(12)
|
91 |
), |
92 |
// 3
|
93 |
new Symbol(
|
94 |
"A_STRING_VALUE",
|
95 |
ValueFactory.createValue("this is a String")
|
96 |
), |
97 |
// 4
|
98 |
new Symbol(
|
99 |
"A_BOOLEAN_VALUE",
|
100 |
ValueFactory.createValue(true)
|
101 |
), |
102 |
// 5
|
103 |
new Symbol(
|
104 |
"ANOTHER_BOOLEAN_VALUE",
|
105 |
ValueFactory.createValue(false)
|
106 |
), |
107 |
// 6
|
108 |
new Symbol(
|
109 |
"A_NULL_VALUE",
|
110 |
ValueFactory.createNullValue() |
111 |
), |
112 |
// 7
|
113 |
new Symbol(
|
114 |
"XX",
|
115 |
ValueFactory.createValue(2)),
|
116 |
// 8
|
117 |
new Symbol(
|
118 |
"Y",
|
119 |
ValueFactory.createValue(2.0)),
|
120 |
}; |
121 |
|
122 |
private String[] ArgumentsExpressions = new String[] { |
123 |
"(754)",
|
124 |
"(754, \"blah\")",
|
125 |
"(-9.68, [A_DOUBLE_VALUE]) ",
|
126 |
"(false, true) ",
|
127 |
}; |
128 |
private Object[][] ArgumentsExpressionsValue = new Object[][] { |
129 |
new Object[] { 754 }, |
130 |
new Object[] { 754, "blah" }, |
131 |
new Object[] { -9.68, 4.0 }, |
132 |
new Object[] { false, true }, |
133 |
}; |
134 |
|
135 |
public void testArguments() throws ExpressionException { |
136 |
|
137 |
String[] expressions = ArgumentsExpressions; |
138 |
Object[][] expectedValues = ArgumentsExpressionsValue; |
139 |
System.out.println("\nTestLabelExpressionParser.testArgumens()"); |
140 |
|
141 |
for (int i = 0; i < expressions.length; i++) { |
142 |
String expr = expressions[i];
|
143 |
parser = new LabelExpressionParser(new CharArrayReader(expr.toCharArray())); |
144 |
|
145 |
for (int j = 0; j < symbols.length; j++) { |
146 |
parser.putSymbol(symbols[j].id,symbols[j].val); |
147 |
} |
148 |
System.out.print("Parsing '"+expr+"'"); |
149 |
try {
|
150 |
|
151 |
int amount = parser.Arguments();
|
152 |
|
153 |
System.out.print(": [ parsed ]. Evaluating: "); |
154 |
Object[] expected = expectedValues[i]; |
155 |
assertTrue("Failed detecting argument number. Expected "+expected.length+", but got "+amount+".", amount == expected.length); |
156 |
|
157 |
for (int j = expected.length-1; j >= 0; j--) { // <- Last in first out |
158 |
Object value = parser.pop();
|
159 |
assertTrue("Parsed text '"+expr+"' evaluated to ("+value+") when expecting ["+expected[j]+"]", value.equals(expected[j])); |
160 |
System.out.print(value+" [ Ok! ]\t"); |
161 |
} |
162 |
|
163 |
|
164 |
} catch (ParseException e) { |
165 |
System.err.println(":\t [ Fail! ]"); |
166 |
fail("Failed parsing text '"+expr+"'\n"+e.getMessage()); |
167 |
} |
168 |
System.out.println();
|
169 |
} |
170 |
} |
171 |
|
172 |
private String[] LiteralExpressions = new String[] { |
173 |
"true",
|
174 |
"false",
|
175 |
" 43564356435.234",
|
176 |
" 12455 ",
|
177 |
" \"a string\"",
|
178 |
}; |
179 |
private Object[] LiteralExpressionsValue = new Object[] { |
180 |
true ,
|
181 |
false,
|
182 |
43564356435.234,
|
183 |
12455,
|
184 |
"a string"
|
185 |
}; |
186 |
|
187 |
public void testLiteral() throws ExpressionException { |
188 |
String[] expressions = LiteralExpressions; |
189 |
Object[] expectedValues = LiteralExpressionsValue; |
190 |
System.out.println("\nTestLabelExpressionParser.testLiteral()"); |
191 |
|
192 |
for (int i = 0; i < expressions.length; i++) { |
193 |
String expr = expressions[i];
|
194 |
parser = new LabelExpressionParser(new CharArrayReader(expr.toCharArray())); |
195 |
for (int j = 0; j < symbols.length; j++) { |
196 |
parser.putSymbol(symbols[j].id,symbols[j].val); |
197 |
} |
198 |
System.out.print("Parsing '"+expr+"'"); |
199 |
try {
|
200 |
parser.UnaryElement(); |
201 |
System.out.print(": [ parsed ]. Evaluating: "); |
202 |
Object expected = expectedValues[i];
|
203 |
|
204 |
Object value = parser.pop();
|
205 |
assertTrue("Parsed text '"+expr+"' evaluated to ("+value+") when expecting ["+expected+"]", value.equals(expected)); |
206 |
System.out.print(value+" [ Ok! ]\t"); |
207 |
|
208 |
|
209 |
} catch (ParseException e) { |
210 |
System.err.println(":\t [ Fail! ]"); |
211 |
fail("Failed parsing text '"+expr+"'\n"+e.getMessage()); |
212 |
} |
213 |
System.out.println();
|
214 |
} |
215 |
} |
216 |
|
217 |
private String[] FunctionExpressions = new String[] { |
218 |
new SubstringFunction().getName()+"(\"My taylor is rich!\", 1)", |
219 |
new SubstringFunction().getName()+"(\"My taylor is rich!\", 3, 9)", |
220 |
new SubstringFunction().getName()+"("+new SubstringFunction().getName()+"(\"My taylor is rich!\", 3, 9), 2,3)", |
221 |
}; |
222 |
private Object[] FunctionExpressionsValue = new Object[] { |
223 |
"y taylor is rich!" ,
|
224 |
"taylor" ,
|
225 |
"y",
|
226 |
}; |
227 |
public void testFunction() throws ExpressionException { |
228 |
OperatorsFactory operators = OperatorsFactory.getInstance(); |
229 |
operators.addOperator(SubstringFunction.class); |
230 |
|
231 |
String[] expressions = FunctionExpressions; |
232 |
Object[] expectedValues = FunctionExpressionsValue; |
233 |
System.out.println("\nTestLabelExpressionParser.testFunction()"); |
234 |
|
235 |
|
236 |
for (int i = 0; i < expressions.length; i++) { |
237 |
String expr = expressions[i];
|
238 |
parser = new LabelExpressionParser(new CharArrayReader(expr.toCharArray())); |
239 |
parser.setOperatorsFactory(operators); |
240 |
|
241 |
for (int j = 0; j < symbols.length; j++) { |
242 |
parser.putSymbol(symbols[j].id,symbols[j].val); |
243 |
} |
244 |
System.out.print("Parsing '"+expr+"'"); |
245 |
try {
|
246 |
parser.function(); |
247 |
System.out.print(": [ parsed ]. Evaluating: "); |
248 |
Object expected = expectedValues[i];
|
249 |
|
250 |
Object value = parser.pop();
|
251 |
assertTrue("Parsed text '"+expr+"' evaluated to ("+value+") when expecting ["+expected+"]", value.equals(expected)); |
252 |
System.out.print(value+" [ Ok! ]\t"); |
253 |
|
254 |
|
255 |
} catch (ParseException e) { |
256 |
System.err.println(":\t [ Fail! ]"); |
257 |
fail("Failed parsing text '"+expr+"'\n"+e.getMessage()); |
258 |
} |
259 |
System.out.println();
|
260 |
} |
261 |
} |
262 |
|
263 |
public void testPrimitiveExpression() throws ExpressionException { |
264 |
String[] PrimitiveExpressions = new String[symbols.length]; |
265 |
Object[] PrimitiveExpressionsValue = new Object[symbols.length]; |
266 |
for (int i = 0; i < symbols.length; i++) { |
267 |
PrimitiveExpressions[i] = "["+symbols[i].id+"]"; |
268 |
PrimitiveExpressionsValue[i] = symbols[i].val; |
269 |
} |
270 |
|
271 |
String[] expressions = PrimitiveExpressions; |
272 |
Object[] expectedValues = PrimitiveExpressionsValue; |
273 |
|
274 |
System.out.println("\nTestLabelExpressionParser.testPrimitiveExpression()"); |
275 |
|
276 |
for (int i = 0; i < expressions.length; i++) { |
277 |
String expr = expressions[i];
|
278 |
parser = new LabelExpressionParser(new CharArrayReader(expr.toCharArray())); |
279 |
for (int j = 0; j < symbols.length; j++) { |
280 |
parser.putSymbol(symbols[j].id,symbols[j].val); |
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 CharArrayReader(expr.toCharArray())); |
342 |
for (int j = 0; j < symbols.length; j++) { |
343 |
parser.putSymbol(symbols[j].id,symbols[j].val); |
344 |
} |
345 |
System.out.print("Parsing '"+expr+"'"); |
346 |
try {
|
347 |
parser.UnaryElement(); |
348 |
System.out.print(": [ parsed ]. Evaluating: "); |
349 |
Object expected = expectedValues[i];
|
350 |
|
351 |
Object value = parser.pop();
|
352 |
assertTrue("Parsed text '"+expr+"' evaluated to ("+value+") when expecting ["+expected+"]", value.equals(expected)); |
353 |
System.out.print(value+" [ Ok! ]\t"); |
354 |
|
355 |
|
356 |
} catch (ParseException e) { |
357 |
System.err.println(":\t [ Fail! ]"); |
358 |
fail("Failed parsing text '"+expr+"'\n"+e.getMessage()); |
359 |
} |
360 |
System.out.println();
|
361 |
} |
362 |
} |
363 |
|
364 |
|
365 |
private String[] UnaryArithmeticExpressions = new String[] { |
366 |
"+65",
|
367 |
"-5.5",
|
368 |
"+-+-[A_DOUBLE_VALUE]",
|
369 |
"--+[ANOTHER_DOUBLE_VALUE]",
|
370 |
}; |
371 |
private Object[] UnaryArithmeticExpressionsValue = new Object[] { |
372 |
65,
|
373 |
-5.5,
|
374 |
((DoubleValue) symbols[0].val).getValue(),
|
375 |
((DoubleValue) symbols[1].val).getValue(),
|
376 |
}; |
377 |
public void testArithmeticUnaryExpression() throws ExpressionException { |
378 |
String[] expressions = UnaryArithmeticExpressions; |
379 |
Object[] expectedValues = UnaryArithmeticExpressionsValue; |
380 |
System.out.println("\nTestLabelExpressionParser.testArithmeticUnaryExpression()"); |
381 |
|
382 |
for (int i = 0; i < expressions.length; i++) { |
383 |
String expr = expressions[i];
|
384 |
parser = new LabelExpressionParser(new CharArrayReader(expr.toCharArray())); |
385 |
for (int j = 0; j < symbols.length; j++) { |
386 |
parser.putSymbol(symbols[j].id,symbols[j].val); |
387 |
} |
388 |
System.out.print("Parsing '"+expr+"'"); |
389 |
try {
|
390 |
parser.MultiplicativeExpression(); |
391 |
System.out.print(": [ parsed ]. Evaluating: "); |
392 |
Object expected = expectedValues[i];
|
393 |
|
394 |
Object value = parser.pop();
|
395 |
assertTrue("Parsed text '"+expr+"' evaluated to ("+value+") when expecting ["+expected+"]", value.equals(expected)); |
396 |
System.out.print(value+" [ Ok! ]\t"); |
397 |
|
398 |
|
399 |
} catch (ParseException e) { |
400 |
System.err.println(":\t [ Fail! ]"); |
401 |
fail("Failed parsing text '"+expr+"'\n"+e.getMessage()); |
402 |
} |
403 |
System.out.println();
|
404 |
} |
405 |
} |
406 |
|
407 |
private String[] MultiplicativeArithmeticExpressions = new String[] { |
408 |
"3*4356.234",
|
409 |
"15*10",
|
410 |
"15/10",
|
411 |
"8768758/2432432",
|
412 |
"[A_DOUBLE_VALUE]*[ANOTHER_DOUBLE_VALUE]",
|
413 |
"[A_DOUBLE_VALUE]/[ANOTHER_DOUBLE_VALUE]",
|
414 |
"[A_DOUBLE_VALUE]*16",
|
415 |
}; |
416 |
private Object[] MultiplicativeArithmeticExpressionsValue = new Object[] { |
417 |
3*4356.234, |
418 |
15*10, |
419 |
15/10, |
420 |
8768758/2432432, |
421 |
((DoubleValue) symbols[0].val).getValue()*((DoubleValue) symbols[1].val).getValue(), |
422 |
((DoubleValue) symbols[0].val).getValue()/((DoubleValue) symbols[1].val).getValue(), |
423 |
((DoubleValue) symbols[0].val).getValue() * 16, |
424 |
}; |
425 |
public void testMultiplicativeExpression() throws ExpressionException { |
426 |
String[] expressions = MultiplicativeArithmeticExpressions; |
427 |
Object[] expectedValues = MultiplicativeArithmeticExpressionsValue; |
428 |
System.out.println("\nTestLabelExpressionParser.testMultiplicativeExpression()"); |
429 |
|
430 |
for (int i = 0; i < expressions.length; i++) { |
431 |
String expr = expressions[i];
|
432 |
parser = new LabelExpressionParser(new CharArrayReader(expr.toCharArray())); |
433 |
for (int j = 0; j < symbols.length; j++) { |
434 |
parser.putSymbol(symbols[j].id,symbols[j].val); |
435 |
} |
436 |
System.out.print("Parsing '"+expr+"'"); |
437 |
try {
|
438 |
parser.MultiplicativeExpression(); |
439 |
System.out.print(": [ parsed ]. Evaluating: "); |
440 |
Object expected = expectedValues[i];
|
441 |
|
442 |
Object value = parser.pop();
|
443 |
assertTrue("Parsed text '"+expr+"' evaluated to ("+value+") when expecting ["+expected+"]", value.equals(expected)); |
444 |
System.out.print(value+" [ Ok! ]\t"); |
445 |
|
446 |
|
447 |
} catch (ParseException e) { |
448 |
System.err.println(":\t [ Fail! ]"); |
449 |
fail("Failed parsing text '"+expr+"'\n"+e.getMessage()); |
450 |
} |
451 |
System.out.println();
|
452 |
} |
453 |
} |
454 |
|
455 |
private String[] AdditiveArithmeticExpressions = new String[] { |
456 |
"3-4356.234",
|
457 |
"8768758+2432432",
|
458 |
"[A_DOUBLE_VALUE]+[ANOTHER_DOUBLE_VALUE]",
|
459 |
"[A_DOUBLE_VALUE]-[ANOTHER_DOUBLE_VALUE]",
|
460 |
}; |
461 |
private Object[] AdditiveArithmeticExpressionsValue = new Object[] { |
462 |
3-4356.234, |
463 |
8768758+2432432, |
464 |
((DoubleValue) symbols[0].val).getValue()+((DoubleValue) symbols[1].val).getValue(), |
465 |
((DoubleValue) symbols[0].val).getValue()-((DoubleValue) symbols[1].val).getValue(), |
466 |
}; |
467 |
public void testAdditiveExpression() throws ExpressionException { |
468 |
String[] expressions = AdditiveArithmeticExpressions; |
469 |
Object[] expectedValues = AdditiveArithmeticExpressionsValue; |
470 |
System.out.println("\nTestLabelExpressionParser.testAdditiveExpression()"); |
471 |
|
472 |
for (int i = 0; i < expressions.length; i++) { |
473 |
String expr = expressions[i];
|
474 |
parser = new LabelExpressionParser(new CharArrayReader(expr.toCharArray())); |
475 |
for (int j = 0; j < symbols.length; j++) { |
476 |
parser.putSymbol(symbols[j].id,symbols[j].val); |
477 |
} |
478 |
System.out.print("Parsing '"+expr+"'"); |
479 |
try {
|
480 |
parser.AdditiveExpression(); |
481 |
System.out.print(": [ parsed ]. Evaluating: "); |
482 |
Object expected = expectedValues[i];
|
483 |
|
484 |
Object value = parser.pop();
|
485 |
assertTrue("Parsed text '"+expr+"' evaluated to ("+value+") when expecting ["+expected+"]", value.equals(expected)); |
486 |
System.out.print(value+" [ Ok! ]\t"); |
487 |
|
488 |
|
489 |
} catch (ParseException e) { |
490 |
System.err.println(":\t [ Fail! ]"); |
491 |
fail("Failed parsing text '"+expr+"'\n"+e.getMessage()); |
492 |
} |
493 |
System.out.println();
|
494 |
} |
495 |
} |
496 |
|
497 |
|
498 |
|
499 |
private String EOField = LabelExpressionParser.tokenFor(LabelExpressionParser.EOFIELD); |
500 |
private String EOExpression = LabelExpressionParser.tokenFor(LabelExpressionParser.EOEXPR); |
501 |
private String DOUBLEQUOTE = "\""; |
502 |
|
503 |
private String[] FieldExpressionStrings = new String[] { |
504 |
"km" +"25", |
505 |
DOUBLEQUOTE+"km"+DOUBLEQUOTE+" "+DOUBLEQUOTE+" 25"+DOUBLEQUOTE, |
506 |
"[A_STRING_VALUE] "+DOUBLEQUOTE+" 25"+DOUBLEQUOTE, |
507 |
"[A_INTEGER_VALUE] "+DOUBLEQUOTE+" 25"+DOUBLEQUOTE, |
508 |
"[A_DOUBLE_VALUE] "+DOUBLEQUOTE+" 25"+DOUBLEQUOTE, |
509 |
"2+3"+"km", |
510 |
}; |
511 |
private Object[] FieldExpressionValue = new Object[] { |
512 |
"km25",
|
513 |
"km 25",
|
514 |
((StringValue) symbols[3].val).getValue()+" 25", |
515 |
((IntValue) symbols[2].val).getValue()+" 25", |
516 |
((DoubleValue) symbols[0].val).getValue()+" 25", |
517 |
"5km"
|
518 |
}; |
519 |
|
520 |
public void testFieldExpressionStrings() throws ExpressionException { |
521 |
|
522 |
String[] expressions = FieldExpressionStrings; |
523 |
Object[] expectedValues = FieldExpressionValue; |
524 |
System.out.println("\nTestLabelExpressionParser.testConcatExpressions()"); |
525 |
|
526 |
for (int i = 0; i < expressions.length; i++) { |
527 |
String expr = expressions[i];
|
528 |
parser = new LabelExpressionParser(new CharArrayReader(expr.toCharArray())); |
529 |
|
530 |
for (int j = 0; j < symbols.length; j++) { |
531 |
parser.putSymbol(symbols[j].id,symbols[j].val); |
532 |
} |
533 |
|
534 |
|
535 |
System.out.print("Parsing '"+expr+"'"); |
536 |
try {
|
537 |
|
538 |
parser.LabelExpression(); |
539 |
|
540 |
System.out.print(": [ parsed ]. Evaluating: "); |
541 |
Object[] expected = expectedValues; |
542 |
String myValues = ((Expression)parser.getStack().pop()).evaluate(parser.getSymbols()).toString(); |
543 |
|
544 |
|
545 |
Object value = myValues;
|
546 |
assertTrue("Parsed text '"+expr+"' evaluated to ("+value+") when expecting ["+expected[i]+"]", value.equals(expected[i].toString())); |
547 |
System.out.print(value+" [ Ok! ]\t"); |
548 |
|
549 |
|
550 |
|
551 |
} catch (ParseException e) { |
552 |
System.err.println(":\t [ Fail! ]"); |
553 |
fail("Failed parsing text '"+expr+"'\n"+e.getMessage()); |
554 |
} |
555 |
System.out.println();
|
556 |
} |
557 |
} |
558 |
|
559 |
|
560 |
private String[] LabelExpressions = new String[] { |
561 |
"1+2"+EOField+"true"+EOField+"2<3", |
562 |
"300+454"+EOField+"false", |
563 |
"1+2"+EOField+"1+5"+EOField+"2<3", |
564 |
"[A_DOUBLE_VALUE]/[ANOTHER_DOUBLE_VALUE]"+EOField+"Km", |
565 |
"km" +"25"+EOField+"1+5", |
566 |
DOUBLEQUOTE+"km"+DOUBLEQUOTE+" "+DOUBLEQUOTE+" 25"+DOUBLEQUOTE+EOField+"1+2"+EOField+"true"+EOField+"2<3", |
567 |
|
568 |
}; |
569 |
private Object[][] LabelExpressionsValue = new Object[][] { |
570 |
new Object[] {3,true,true }, |
571 |
new Object[] { 754, false }, |
572 |
new Object[] { 3,6,true }, |
573 |
new Object[] {((DoubleValue) symbols[0].val).getValue()/((DoubleValue) symbols[1].val).getValue(),"Km"}, |
574 |
new Object[] {"km25",6 }, |
575 |
new Object[] {"km 25",3,true,true }, |
576 |
|
577 |
}; |
578 |
|
579 |
public void testLabelExpressions() throws ExpressionException { |
580 |
|
581 |
String[] expressions = LabelExpressions; |
582 |
Object[][] expectedValues = LabelExpressionsValue; |
583 |
System.out.println("\nTestLabelExpressionParser.testLabelExpressions()"); |
584 |
|
585 |
for (int i = 0; i < expressions.length; i++) { |
586 |
String expr = expressions[i];
|
587 |
parser = new LabelExpressionParser(new CharArrayReader(expr.toCharArray())); |
588 |
|
589 |
for (int j = 0; j < symbols.length; j++) { |
590 |
parser.putSymbol(symbols[j].id,symbols[j].val); |
591 |
} |
592 |
|
593 |
|
594 |
System.out.print("Parsing '"+expr+"'"); |
595 |
try {
|
596 |
|
597 |
parser.LabelExpression(); |
598 |
|
599 |
System.out.print(": [ parsed ]. Evaluating: "); |
600 |
Object[] expected = expectedValues[i]; |
601 |
Object[] myValues = (Object[]) ((Expression)parser.getStack().pop()).evaluate(parser.getSymbols()); |
602 |
|
603 |
for (int j = 0; j < myValues.length; j++) { // <- Last in first out |
604 |
Object value = myValues[j];
|
605 |
assertTrue("Parsed text '"+expr+"' evaluated to ("+value+") when expecting ["+expected[j]+"]", value.equals(expected[j].toString())); |
606 |
System.out.print(value+" [ Ok! ]\t"); |
607 |
} |
608 |
|
609 |
|
610 |
} catch (ParseException e) { |
611 |
System.err.println(":\t [ Fail! ]"); |
612 |
fail("Failed parsing text '"+expr+"'\n"+e.getMessage()); |
613 |
} |
614 |
System.out.println();
|
615 |
} |
616 |
} |
617 |
|
618 |
|
619 |
|
620 |
private String[] SolvedBugsExpressions = new String[] { |
621 |
"([Y] + 3) * 5;",
|
622 |
"([Y] + 3) * 5"+EOField+"([Y] + 3) * 5", |
623 |
}; |
624 |
private Object[][] SolvedBugsExpressionsValue = new Object[][] { |
625 |
new Object[] { ((((DoubleValue) symbols[8].val ).getValue() + 3 ) *5) }, |
626 |
new Object[] { |
627 |
""+((((DoubleValue) symbols[8].val ).getValue() + 3 ) *5), |
628 |
""+((((DoubleValue) symbols[8].val ).getValue() + 3 ) *5) }, |
629 |
}; |
630 |
/**
|
631 |
* Tests several buggy expressions detected by testers and users
|
632 |
* @throws ExpressionException
|
633 |
*/
|
634 |
public void testSolvedBugsExpressions() throws ExpressionException { |
635 |
|
636 |
String[] expressions = SolvedBugsExpressions; |
637 |
Object[][] expectedValues = SolvedBugsExpressionsValue; |
638 |
System.out.println("\nTestLabelExpressionParser.testSolvedBugsExpressions()"); |
639 |
|
640 |
for (int i = 0; i < expressions.length; i++) { |
641 |
String expr = expressions[i];
|
642 |
parser = new LabelExpressionParser(new CharArrayReader(expr.toCharArray())); |
643 |
|
644 |
for (int j = 0; j < symbols.length; j++) { |
645 |
parser.putSymbol(symbols[j].id,symbols[j].val); |
646 |
} |
647 |
|
648 |
|
649 |
System.out.print("Parsing '"+expr+"'"); |
650 |
try {
|
651 |
|
652 |
parser.LabelExpression(); |
653 |
|
654 |
System.out.print(": [ parsed ]. Evaluating: "); |
655 |
Object[] expected = expectedValues[i]; |
656 |
Object value = ((Expression)parser.getStack().pop()).evaluate(parser.getSymbols()); |
657 |
if (value.getClass().isArray()) {
|
658 |
Object[] myValues = (Object[]) value; |
659 |
|
660 |
for (int j = 0; j < myValues.length; j++) { // <- Last in first out |
661 |
Object aValue = myValues[j];
|
662 |
assertTrue("Parsed text '"+expr+"' evaluated to ("+aValue+") when expecting ["+expected[j]+"]", aValue.equals(expected[j].toString())); |
663 |
System.out.print(aValue+" [ Ok! ]\t"); |
664 |
} |
665 |
} else {
|
666 |
assertTrue("Parsed text '"+expr+"' evaluated to ("+value+") when expecting ["+expected+"]", value.equals(expected[0])); |
667 |
System.out.print(value+" [ Ok! ]\t"); |
668 |
} |
669 |
|
670 |
} catch (ParseException e) { |
671 |
System.err.println(":\t [ Fail! ]"); |
672 |
fail("Failed parsing text '"+expr+"'\n"+e.getMessage()); |
673 |
} |
674 |
System.out.println();
|
675 |
} |
676 |
} |
677 |
|
678 |
} |