root / trunk / extensions / extSymbology / src-test / org / gvsig / symbology / fmap / labeling / parse / TestLabelExpressionParser.java @ 22517
History | View | Annotate | Download (20.4 KB)
| 1 | 22218 | jdominguez | /* 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 | 20768 | jdominguez | package org.gvsig.symbology.fmap.labeling.parse; |
| 42 | |||
| 43 | import java.io.CharArrayReader; |
||
| 44 | 22517 | jvidal | import java.io.StringReader; |
| 45 | import java.util.Hashtable; |
||
| 46 | 20768 | jdominguez | |
| 47 | import junit.framework.TestCase; |
||
| 48 | |||
| 49 | 22517 | jvidal | |
| 50 | 22218 | jdominguez | 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 | 20768 | jdominguez | |
| 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 | 22218 | jdominguez | import com.hardcode.gdbms.engine.values.Value; |
| 61 | 20768 | jdominguez | import com.hardcode.gdbms.engine.values.ValueFactory; |
| 62 | |||
| 63 | public class TestLabelExpressionParser extends TestCase { |
||
| 64 | LabelExpressionParser parser; |
||
| 65 | 22517 | jvidal | Hashtable<String, Value> symbols_table = new Hashtable<String, Value>(); |
| 66 | |||
| 67 | 20768 | jdominguez | protected void setUp() throws Exception { |
| 68 | super.setUp();
|
||
| 69 | 22517 | jvidal | |
| 70 | for (int j = 0; j < symbols.length; j++) { |
||
| 71 | symbols_table.put(symbols[j].id,symbols[j].val); |
||
| 72 | } |
||
| 73 | 20768 | jdominguez | } |
| 74 | 22218 | jdominguez | |
| 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 | 20768 | jdominguez | private Symbol[] symbols = new Symbol[] { |
| 85 | 22495 | jdominguez | // 0
|
| 86 | 20768 | jdominguez | new Symbol(
|
| 87 | 22517 | jvidal | "A_DOUBLE_VALUE",
|
| 88 | 20768 | jdominguez | ValueFactory.createValue(4.0)
|
| 89 | ), |
||
| 90 | 22495 | jdominguez | // 1
|
| 91 | 20768 | jdominguez | new Symbol(
|
| 92 | 22517 | jvidal | "ANOTHER_DOUBLE_VALUE",
|
| 93 | 20768 | jdominguez | ValueFactory.createValue(Math.PI)
|
| 94 | ), |
||
| 95 | 22495 | jdominguez | // 2
|
| 96 | 20768 | jdominguez | new Symbol(
|
| 97 | 22517 | jvidal | "A_INTEGER_VALUE",
|
| 98 | 20768 | jdominguez | ValueFactory.createValue(12)
|
| 99 | ), |
||
| 100 | 22495 | jdominguez | // 3
|
| 101 | 20768 | jdominguez | new Symbol(
|
| 102 | 22517 | jvidal | "A_STRING_VALUE",
|
| 103 | 20768 | jdominguez | ValueFactory.createValue("this is a String")
|
| 104 | ), |
||
| 105 | 22495 | jdominguez | // 4
|
| 106 | 20768 | jdominguez | new Symbol(
|
| 107 | 22517 | jvidal | "A_BOOLEAN_VALUE",
|
| 108 | 20768 | jdominguez | ValueFactory.createValue(true)
|
| 109 | ), |
||
| 110 | 22495 | jdominguez | // 5
|
| 111 | 20768 | jdominguez | new Symbol(
|
| 112 | 22517 | jvidal | "ANOTHER_BOOLEAN_VALUE",
|
| 113 | 20768 | jdominguez | ValueFactory.createValue(false)
|
| 114 | ), |
||
| 115 | 22495 | jdominguez | // 6
|
| 116 | 20768 | jdominguez | new Symbol(
|
| 117 | 22517 | jvidal | "A_NULL_VALUE",
|
| 118 | 20768 | jdominguez | ValueFactory.createNullValue() |
| 119 | ), |
||
| 120 | 22517 | jvidal | |
| 121 | 22495 | jdominguez | // 7
|
| 122 | new Symbol(
|
||
| 123 | "XX",
|
||
| 124 | ValueFactory.createValue(2)),
|
||
| 125 | // 8
|
||
| 126 | new Symbol(
|
||
| 127 | "Y",
|
||
| 128 | ValueFactory.createValue(2.0)),
|
||
| 129 | 22517 | jvidal | |
| 130 | 20768 | jdominguez | }; |
| 131 | 22218 | jdominguez | |
| 132 | 20768 | jdominguez | 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 | 22517 | jvidal | }; |
| 144 | 22218 | jdominguez | |
| 145 | public void testArguments() throws ExpressionException { |
||
| 146 | |||
| 147 | 20768 | jdominguez | String[] expressions = ArgumentsExpressions; |
| 148 | Object[][] expectedValues = ArgumentsExpressionsValue; |
||
| 149 | System.out.println("\nTestLabelExpressionParser.testArgumens()"); |
||
| 150 | 22218 | jdominguez | |
| 151 | 20768 | jdominguez | for (int i = 0; i < expressions.length; i++) { |
| 152 | String expr = expressions[i];
|
||
| 153 | 22517 | jvidal | parser = new LabelExpressionParser(new StringReader(expr),symbols_table); |
| 154 | 22218 | jdominguez | |
| 155 | 20768 | jdominguez | System.out.print("Parsing '"+expr+"'"); |
| 156 | try {
|
||
| 157 | 22279 | jvidal | |
| 158 | 20768 | jdominguez | int amount = parser.Arguments();
|
| 159 | 22279 | jvidal | |
| 160 | 20768 | jdominguez | 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 | 22218 | jdominguez | |
| 164 | 20768 | jdominguez | 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 | 22218 | jdominguez | |
| 171 | 20768 | jdominguez | } 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 | 22279 | jvidal | |
| 179 | 20768 | jdominguez | 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 | 22279 | jvidal | true ,
|
| 188 | false,
|
||
| 189 | 43564356435.234,
|
||
| 190 | 12455,
|
||
| 191 | "a string"
|
||
| 192 | 22517 | jvidal | }; |
| 193 | 22279 | jvidal | |
| 194 | 22218 | jdominguez | public void testLiteral() throws ExpressionException { |
| 195 | 20768 | jdominguez | String[] expressions = LiteralExpressions; |
| 196 | Object[] expectedValues = LiteralExpressionsValue; |
||
| 197 | System.out.println("\nTestLabelExpressionParser.testLiteral()"); |
||
| 198 | 22279 | jvidal | |
| 199 | 20768 | jdominguez | for (int i = 0; i < expressions.length; i++) { |
| 200 | String expr = expressions[i];
|
||
| 201 | 22517 | jvidal | parser = new LabelExpressionParser(new StringReader(expr),symbols_table); |
| 202 | |||
| 203 | 20768 | jdominguez | System.out.print("Parsing '"+expr+"'"); |
| 204 | try {
|
||
| 205 | 22218 | jdominguez | parser.UnaryElement(); |
| 206 | 20768 | jdominguez | 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 | 22279 | jvidal | |
| 222 | 20768 | jdominguez | private String[] FunctionExpressions = new String[] { |
| 223 | 22517 | jvidal | 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 | 20768 | jdominguez | }; |
| 227 | private Object[] FunctionExpressionsValue = new Object[] { |
||
| 228 | 22218 | jdominguez | "y taylor is rich!" ,
|
| 229 | 22279 | jvidal | "taylor" ,
|
| 230 | "y",
|
||
| 231 | 22517 | jvidal | }; |
| 232 | 22218 | jdominguez | public void testFunction() throws ExpressionException { |
| 233 | OperatorsFactory operators = OperatorsFactory.getInstance(); |
||
| 234 | 22279 | jvidal | operators.addOperator(SubstringFunction.class); |
| 235 | |||
| 236 | 20768 | jdominguez | String[] expressions = FunctionExpressions; |
| 237 | Object[] expectedValues = FunctionExpressionsValue; |
||
| 238 | System.out.println("\nTestLabelExpressionParser.testFunction()"); |
||
| 239 | 22279 | jvidal | |
| 240 | |||
| 241 | 20768 | jdominguez | for (int i = 0; i < expressions.length; i++) { |
| 242 | String expr = expressions[i];
|
||
| 243 | 22517 | jvidal | parser = new LabelExpressionParser(new StringReader(expr),symbols_table); |
| 244 | 22279 | jvidal | parser.setOperatorsFactory(operators); |
| 245 | |||
| 246 | 20768 | jdominguez | System.out.print("Parsing '"+expr+"'"); |
| 247 | try {
|
||
| 248 | 22218 | jdominguez | parser.function(); |
| 249 | 20768 | jdominguez | 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 | 22218 | jdominguez | public void testPrimitiveExpression() throws ExpressionException { |
| 266 | 20768 | jdominguez | String[] PrimitiveExpressions = new String[symbols.length]; |
| 267 | Object[] PrimitiveExpressionsValue = new Object[symbols.length]; |
||
| 268 | for (int i = 0; i < symbols.length; i++) { |
||
| 269 | 22218 | jdominguez | PrimitiveExpressions[i] = "["+symbols[i].id+"]"; |
| 270 | PrimitiveExpressionsValue[i] = symbols[i].val; |
||
| 271 | 20768 | jdominguez | } |
| 272 | 22279 | jvidal | |
| 273 | 20768 | jdominguez | String[] expressions = PrimitiveExpressions; |
| 274 | Object[] expectedValues = PrimitiveExpressionsValue; |
||
| 275 | 22279 | jvidal | |
| 276 | 20768 | jdominguez | System.out.println("\nTestLabelExpressionParser.testPrimitiveExpression()"); |
| 277 | 22279 | jvidal | |
| 278 | 20768 | jdominguez | for (int i = 0; i < expressions.length; i++) { |
| 279 | String expr = expressions[i];
|
||
| 280 | 22517 | jvidal | parser = new LabelExpressionParser(new StringReader(expr),symbols_table); |
| 281 | |||
| 282 | 20768 | jdominguez | System.out.print("Parsing '"+expr+"'"); |
| 283 | try {
|
||
| 284 | 22218 | jdominguez | parser.Element(); |
| 285 | 20768 | jdominguez | System.out.print(": [ parsed ]. Evaluating: "); |
| 286 | Object expected = expectedValues[i];
|
||
| 287 | 22279 | jvidal | |
| 288 | 20768 | jdominguez | // 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 | 22517 | jvidal | } |
| 296 | 22279 | jvidal | |
| 297 | 22218 | jdominguez | // else if (expected instanceof DateValue) {
|
| 298 | 22279 | jvidal | // expected = ((DateValue) expected).getValue();
|
| 299 | 22517 | jvidal | // }
|
| 300 | 22279 | jvidal | |
| 301 | 22218 | jdominguez | else if (expected instanceof BooleanValue) { |
| 302 | 20768 | jdominguez | expected = ((BooleanValue) expected).getValue(); |
| 303 | } else if (expected instanceof NullValue) { |
||
| 304 | expected = null;
|
||
| 305 | } |
||
| 306 | |||
| 307 | 22279 | jvidal | |
| 308 | 20768 | jdominguez | 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 | 22517 | jvidal | |
| 321 | |||
| 322 | 20768 | jdominguez | 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 | 22279 | jvidal | !false,
|
| 330 | !true,
|
||
| 331 | !((BooleanValue) symbols[4].val).getValue(),
|
||
| 332 | !((BooleanValue) symbols[5].val).getValue(),
|
||
| 333 | 22517 | jvidal | }; |
| 334 | 22218 | jdominguez | public void testBooleanUnaryExpression() throws ExpressionException { |
| 335 | 20768 | jdominguez | String[] expressions = UnaryBooleanExpressions; |
| 336 | Object[] expectedValues = UnaryBooleanExpressionsValue; |
||
| 337 | System.out.println("\nTestLabelExpressionParser.testBooleanUnaryExpression()"); |
||
| 338 | 22279 | jvidal | |
| 339 | 20768 | jdominguez | for (int i = 0; i < expressions.length; i++) { |
| 340 | String expr = expressions[i];
|
||
| 341 | 22517 | jvidal | parser = new LabelExpressionParser(new StringReader(expr),symbols_table); |
| 342 | |||
| 343 | 20768 | jdominguez | System.out.print("Parsing '"+expr+"'"); |
| 344 | try {
|
||
| 345 | 22218 | jdominguez | parser.UnaryElement(); |
| 346 | 20768 | jdominguez | 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 | 22279 | jvidal | |
| 362 | |||
| 363 | 20768 | jdominguez | 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 | 22218 | jdominguez | ((DoubleValue) symbols[0].val).getValue(),
|
| 373 | ((DoubleValue) symbols[1].val).getValue(),
|
||
| 374 | 22517 | jvidal | }; |
| 375 | 22218 | jdominguez | public void testArithmeticUnaryExpression() throws ExpressionException { |
| 376 | 20768 | jdominguez | String[] expressions = UnaryArithmeticExpressions; |
| 377 | Object[] expectedValues = UnaryArithmeticExpressionsValue; |
||
| 378 | System.out.println("\nTestLabelExpressionParser.testArithmeticUnaryExpression()"); |
||
| 379 | 22279 | jvidal | |
| 380 | 20768 | jdominguez | for (int i = 0; i < expressions.length; i++) { |
| 381 | String expr = expressions[i];
|
||
| 382 | 22517 | jvidal | parser = new LabelExpressionParser(new StringReader(expr),symbols_table); |
| 383 | |||
| 384 | 20768 | jdominguez | System.out.print("Parsing '"+expr+"'"); |
| 385 | try {
|
||
| 386 | 22218 | jdominguez | parser.MultiplicativeExpression(); |
| 387 | 20768 | jdominguez | 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 | 22279 | jvidal | |
| 403 | 20768 | jdominguez | private String[] MultiplicativeArithmeticExpressions = new String[] { |
| 404 | "3*4356.234",
|
||
| 405 | 22218 | jdominguez | "15*10",
|
| 406 | "15/10",
|
||
| 407 | 20768 | jdominguez | "8768758/2432432",
|
| 408 | "[A_DOUBLE_VALUE]*[ANOTHER_DOUBLE_VALUE]",
|
||
| 409 | "[A_DOUBLE_VALUE]/[ANOTHER_DOUBLE_VALUE]",
|
||
| 410 | 22495 | jdominguez | "[A_DOUBLE_VALUE]*16",
|
| 411 | 20768 | jdominguez | }; |
| 412 | private Object[] MultiplicativeArithmeticExpressionsValue = new Object[] { |
||
| 413 | 3*4356.234, |
||
| 414 | 22218 | jdominguez | 15*10, |
| 415 | 15/10, |
||
| 416 | 20768 | jdominguez | 8768758/2432432, |
| 417 | 22218 | jdominguez | ((DoubleValue) symbols[0].val).getValue()*((DoubleValue) symbols[1].val).getValue(), |
| 418 | ((DoubleValue) symbols[0].val).getValue()/((DoubleValue) symbols[1].val).getValue(), |
||
| 419 | 22495 | jdominguez | ((DoubleValue) symbols[0].val).getValue() * 16, |
| 420 | 22517 | jvidal | }; |
| 421 | |||
| 422 | 22218 | jdominguez | public void testMultiplicativeExpression() throws ExpressionException { |
| 423 | 20768 | jdominguez | String[] expressions = MultiplicativeArithmeticExpressions; |
| 424 | Object[] expectedValues = MultiplicativeArithmeticExpressionsValue; |
||
| 425 | System.out.println("\nTestLabelExpressionParser.testMultiplicativeExpression()"); |
||
| 426 | 22279 | jvidal | |
| 427 | 20768 | jdominguez | for (int i = 0; i < expressions.length; i++) { |
| 428 | String expr = expressions[i];
|
||
| 429 | 22517 | jvidal | parser = new LabelExpressionParser(new StringReader(expr),symbols_table); |
| 430 | |||
| 431 | 20768 | jdominguez | 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 | 22279 | jvidal | |
| 450 | 20768 | jdominguez | 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 | 22218 | jdominguez | ((DoubleValue) symbols[0].val).getValue()+((DoubleValue) symbols[1].val).getValue(), |
| 460 | ((DoubleValue) symbols[0].val).getValue()-((DoubleValue) symbols[1].val).getValue(), |
||
| 461 | 20768 | jdominguez | }; |
| 462 | 22218 | jdominguez | public void testAdditiveExpression() throws ExpressionException { |
| 463 | 20768 | jdominguez | String[] expressions = AdditiveArithmeticExpressions; |
| 464 | Object[] expectedValues = AdditiveArithmeticExpressionsValue; |
||
| 465 | System.out.println("\nTestLabelExpressionParser.testAdditiveExpression()"); |
||
| 466 | 22279 | jvidal | |
| 467 | 20768 | jdominguez | for (int i = 0; i < expressions.length; i++) { |
| 468 | String expr = expressions[i];
|
||
| 469 | 22517 | jvidal | parser = new LabelExpressionParser(new StringReader(expr),symbols_table); |
| 470 | |||
| 471 | 20768 | jdominguez | 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 | 22279 | jvidal | |
| 491 | 22517 | jvidal | |
| 492 | 22279 | jvidal | private String EOField = LabelExpressionParser.tokenFor(LabelExpressionParser.EOFIELD); |
| 493 | private String EOExpression = LabelExpressionParser.tokenFor(LabelExpressionParser.EOEXPR); |
||
| 494 | private String DOUBLEQUOTE = "\""; |
||
| 495 | 22517 | jvidal | |
| 496 | 22421 | jdominguez | private String[] FieldExpressionStrings = new String[] { |
| 497 | 22279 | jvidal | "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 | 22421 | jdominguez | private Object[] FieldExpressionValue = new Object[] { |
| 505 | 22279 | jvidal | "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 | 22421 | jdominguez | public void testFieldExpressionStrings() throws ExpressionException { |
| 514 | 22279 | jvidal | |
| 515 | 22421 | jdominguez | String[] expressions = FieldExpressionStrings; |
| 516 | Object[] expectedValues = FieldExpressionValue; |
||
| 517 | 22279 | jvidal | System.out.println("\nTestLabelExpressionParser.testConcatExpressions()"); |
| 518 | |||
| 519 | for (int i = 0; i < expressions.length; i++) { |
||
| 520 | String expr = expressions[i];
|
||
| 521 | 22517 | jvidal | parser = new LabelExpressionParser(new StringReader(expr),symbols_table); |
| 522 | 22279 | jvidal | |
| 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 | 22517 | jvidal | String myValues = ((Expression)parser.getStack().pop()).evaluate().toString(); |
| 532 | 22279 | jvidal | |
| 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 | 22517 | jvidal | |
| 549 | 22279 | jvidal | 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 | 22517 | jvidal | |
| 557 | 22218 | jdominguez | }; |
| 558 | 22279 | jvidal | private Object[][] LabelExpressionsValue = new Object[][] { |
| 559 | new Object[] {3,true,true }, |
||
| 560 | 22218 | jdominguez | new Object[] { 754, false }, |
| 561 | 22279 | jvidal | 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 | 22517 | jvidal | |
| 566 | 22218 | jdominguez | }; |
| 567 | |||
| 568 | 22279 | jvidal | public void testLabelExpressions() throws ExpressionException { |
| 569 | 22218 | jdominguez | |
| 570 | 22279 | jvidal | String[] expressions = LabelExpressions; |
| 571 | Object[][] expectedValues = LabelExpressionsValue; |
||
| 572 | System.out.println("\nTestLabelExpressionParser.testLabelExpressions()"); |
||
| 573 | |||
| 574 | 22218 | jdominguez | for (int i = 0; i < expressions.length; i++) { |
| 575 | String expr = expressions[i];
|
||
| 576 | 22517 | jvidal | parser = new LabelExpressionParser(new StringReader(expr),symbols_table); |
| 577 | 22218 | jdominguez | |
| 578 | 22279 | jvidal | |
| 579 | 22218 | jdominguez | System.out.print("Parsing '"+expr+"'"); |
| 580 | try {
|
||
| 581 | 22279 | jvidal | |
| 582 | 22218 | jdominguez | parser.LabelExpression(); |
| 583 | 22279 | jvidal | |
| 584 | 22218 | jdominguez | System.out.print(": [ parsed ]. Evaluating: "); |
| 585 | Object[] expected = expectedValues[i]; |
||
| 586 | 22517 | jvidal | Object[] myValues = (Object[]) ((Expression)parser.getStack().pop()).evaluate(); |
| 587 | 22279 | jvidal | |
| 588 | for (int j = 0; j < myValues.length; j++) { // <- Last in first out |
||
| 589 | Object value = myValues[j];
|
||
| 590 | 22218 | jdominguez | 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 | 20768 | jdominguez | } |
| 602 | |||
| 603 | 22279 | jvidal | |
| 604 | |||
| 605 | 22495 | jdominguez | private String[] SolvedBugsExpressions = new String[] { |
| 606 | 22510 | jdominguez | "([Y] + 3) * 5;",
|
| 607 | "([Y] + 3) * 5"+EOField+"([Y] + 3) * 5", |
||
| 608 | 22495 | jdominguez | }; |
| 609 | private Object[][] SolvedBugsExpressionsValue = new Object[][] { |
||
| 610 | 22510 | jdominguez | new Object[] { ((((DoubleValue) symbols[8].val ).getValue() + 3 ) *5) }, |
| 611 | 22517 | jvidal | new Object[] { |
| 612 | 22510 | jdominguez | ""+((((DoubleValue) symbols[8].val ).getValue() + 3 ) *5), |
| 613 | ""+((((DoubleValue) symbols[8].val ).getValue() + 3 ) *5) }, |
||
| 614 | 22495 | jdominguez | }; |
| 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 | 22517 | jvidal | parser = new LabelExpressionParser(new StringReader(expr),symbols_table); |
| 628 | 22495 | jdominguez | |
| 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 | 22517 | jvidal | Object value = ((Expression)parser.getStack().pop()).evaluate(); |
| 638 | 22510 | jdominguez | if (value.getClass().isArray()) {
|
| 639 | Object[] myValues = (Object[]) value; |
||
| 640 | 22495 | jdominguez | |
| 641 | 22510 | jdominguez | 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 | 22495 | jdominguez | 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 | 20768 | jdominguez | } |