root / trunk / extensions / extSymbology / src-test / org / gvsig / symbology / fmap / labeling / parse / TestLabelExpressionParser.java @ 22511
History | View | Annotate | Download (21.3 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 | |||
| 45 | import junit.framework.TestCase; |
||
| 46 | |||
| 47 | 22218 | jdominguez | 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 | 20768 | jdominguez | |
| 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 | 22218 | jdominguez | import com.hardcode.gdbms.engine.values.Value; |
| 58 | 20768 | jdominguez | import com.hardcode.gdbms.engine.values.ValueFactory; |
| 59 | |||
| 60 | public class TestLabelExpressionParser extends TestCase { |
||
| 61 | LabelExpressionParser parser; |
||
| 62 | 22511 | jdominguez | |
| 63 | 20768 | jdominguez | protected void setUp() throws Exception { |
| 64 | super.setUp();
|
||
| 65 | } |
||
| 66 | 22218 | jdominguez | |
| 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 | 20768 | jdominguez | private Symbol[] symbols = new Symbol[] { |
| 77 | 22495 | jdominguez | // 0
|
| 78 | 20768 | jdominguez | new Symbol(
|
| 79 | "A_DOUBLE_VALUE",
|
||
| 80 | ValueFactory.createValue(4.0)
|
||
| 81 | ), |
||
| 82 | 22495 | jdominguez | // 1
|
| 83 | 20768 | jdominguez | new Symbol(
|
| 84 | "ANOTHER_DOUBLE_VALUE",
|
||
| 85 | ValueFactory.createValue(Math.PI)
|
||
| 86 | ), |
||
| 87 | 22495 | jdominguez | // 2
|
| 88 | 20768 | jdominguez | new Symbol(
|
| 89 | "A_INTEGER_VALUE",
|
||
| 90 | ValueFactory.createValue(12)
|
||
| 91 | ), |
||
| 92 | 22495 | jdominguez | // 3
|
| 93 | 20768 | jdominguez | new Symbol(
|
| 94 | "A_STRING_VALUE",
|
||
| 95 | ValueFactory.createValue("this is a String")
|
||
| 96 | ), |
||
| 97 | 22495 | jdominguez | // 4
|
| 98 | 20768 | jdominguez | new Symbol(
|
| 99 | "A_BOOLEAN_VALUE",
|
||
| 100 | ValueFactory.createValue(true)
|
||
| 101 | ), |
||
| 102 | 22495 | jdominguez | // 5
|
| 103 | 20768 | jdominguez | new Symbol(
|
| 104 | "ANOTHER_BOOLEAN_VALUE",
|
||
| 105 | ValueFactory.createValue(false)
|
||
| 106 | ), |
||
| 107 | 22495 | jdominguez | // 6
|
| 108 | 20768 | jdominguez | new Symbol(
|
| 109 | "A_NULL_VALUE",
|
||
| 110 | ValueFactory.createNullValue() |
||
| 111 | ), |
||
| 112 | 22495 | jdominguez | // 7
|
| 113 | new Symbol(
|
||
| 114 | "XX",
|
||
| 115 | ValueFactory.createValue(2)),
|
||
| 116 | // 8
|
||
| 117 | new Symbol(
|
||
| 118 | "Y",
|
||
| 119 | ValueFactory.createValue(2.0)),
|
||
| 120 | 20768 | jdominguez | }; |
| 121 | 22218 | jdominguez | |
| 122 | 20768 | jdominguez | 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 | 22218 | jdominguez | |
| 135 | public void testArguments() throws ExpressionException { |
||
| 136 | |||
| 137 | 20768 | jdominguez | String[] expressions = ArgumentsExpressions; |
| 138 | Object[][] expectedValues = ArgumentsExpressionsValue; |
||
| 139 | System.out.println("\nTestLabelExpressionParser.testArgumens()"); |
||
| 140 | 22218 | jdominguez | |
| 141 | 20768 | jdominguez | for (int i = 0; i < expressions.length; i++) { |
| 142 | String expr = expressions[i];
|
||
| 143 | parser = new LabelExpressionParser(new CharArrayReader(expr.toCharArray())); |
||
| 144 | 22218 | jdominguez | |
| 145 | 20768 | jdominguez | for (int j = 0; j < symbols.length; j++) { |
| 146 | 22218 | jdominguez | parser.putSymbol(symbols[j].id,symbols[j].val); |
| 147 | 20768 | jdominguez | } |
| 148 | System.out.print("Parsing '"+expr+"'"); |
||
| 149 | try {
|
||
| 150 | 22279 | jvidal | |
| 151 | 20768 | jdominguez | int amount = parser.Arguments();
|
| 152 | 22279 | jvidal | |
| 153 | 20768 | jdominguez | 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 | 22218 | jdominguez | |
| 157 | 20768 | jdominguez | 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 | 22218 | jdominguez | |
| 164 | 20768 | jdominguez | } 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 | 22279 | jvidal | |
| 172 | 20768 | jdominguez | 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 | 22279 | jvidal | true ,
|
| 181 | false,
|
||
| 182 | 43564356435.234,
|
||
| 183 | 12455,
|
||
| 184 | "a string"
|
||
| 185 | 20768 | jdominguez | }; |
| 186 | 22279 | jvidal | |
| 187 | 22218 | jdominguez | public void testLiteral() throws ExpressionException { |
| 188 | 20768 | jdominguez | String[] expressions = LiteralExpressions; |
| 189 | Object[] expectedValues = LiteralExpressionsValue; |
||
| 190 | System.out.println("\nTestLabelExpressionParser.testLiteral()"); |
||
| 191 | 22279 | jvidal | |
| 192 | 20768 | jdominguez | for (int i = 0; i < expressions.length; i++) { |
| 193 | String expr = expressions[i];
|
||
| 194 | 22218 | jdominguez | parser = new LabelExpressionParser(new CharArrayReader(expr.toCharArray())); |
| 195 | 20768 | jdominguez | for (int j = 0; j < symbols.length; j++) { |
| 196 | 22218 | jdominguez | parser.putSymbol(symbols[j].id,symbols[j].val); |
| 197 | 20768 | jdominguez | } |
| 198 | System.out.print("Parsing '"+expr+"'"); |
||
| 199 | try {
|
||
| 200 | 22218 | jdominguez | parser.UnaryElement(); |
| 201 | 20768 | jdominguez | 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 | 22279 | jvidal | |
| 217 | 20768 | jdominguez | private String[] FunctionExpressions = new String[] { |
| 218 | 22218 | jdominguez | 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 | 20768 | jdominguez | }; |
| 222 | private Object[] FunctionExpressionsValue = new Object[] { |
||
| 223 | 22218 | jdominguez | "y taylor is rich!" ,
|
| 224 | 22279 | jvidal | "taylor" ,
|
| 225 | "y",
|
||
| 226 | 20768 | jdominguez | }; |
| 227 | 22218 | jdominguez | public void testFunction() throws ExpressionException { |
| 228 | OperatorsFactory operators = OperatorsFactory.getInstance(); |
||
| 229 | 22279 | jvidal | operators.addOperator(SubstringFunction.class); |
| 230 | |||
| 231 | 20768 | jdominguez | String[] expressions = FunctionExpressions; |
| 232 | Object[] expectedValues = FunctionExpressionsValue; |
||
| 233 | System.out.println("\nTestLabelExpressionParser.testFunction()"); |
||
| 234 | 22279 | jvidal | |
| 235 | |||
| 236 | 20768 | jdominguez | for (int i = 0; i < expressions.length; i++) { |
| 237 | String expr = expressions[i];
|
||
| 238 | 22218 | jdominguez | parser = new LabelExpressionParser(new CharArrayReader(expr.toCharArray())); |
| 239 | 22279 | jvidal | parser.setOperatorsFactory(operators); |
| 240 | |||
| 241 | 20768 | jdominguez | for (int j = 0; j < symbols.length; j++) { |
| 242 | 22218 | jdominguez | parser.putSymbol(symbols[j].id,symbols[j].val); |
| 243 | 20768 | jdominguez | } |
| 244 | System.out.print("Parsing '"+expr+"'"); |
||
| 245 | try {
|
||
| 246 | 22218 | jdominguez | parser.function(); |
| 247 | 20768 | jdominguez | 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 | 22218 | jdominguez | public void testPrimitiveExpression() throws ExpressionException { |
| 264 | 20768 | jdominguez | String[] PrimitiveExpressions = new String[symbols.length]; |
| 265 | Object[] PrimitiveExpressionsValue = new Object[symbols.length]; |
||
| 266 | for (int i = 0; i < symbols.length; i++) { |
||
| 267 | 22218 | jdominguez | PrimitiveExpressions[i] = "["+symbols[i].id+"]"; |
| 268 | PrimitiveExpressionsValue[i] = symbols[i].val; |
||
| 269 | 20768 | jdominguez | } |
| 270 | 22279 | jvidal | |
| 271 | 20768 | jdominguez | String[] expressions = PrimitiveExpressions; |
| 272 | Object[] expectedValues = PrimitiveExpressionsValue; |
||
| 273 | 22279 | jvidal | |
| 274 | 20768 | jdominguez | System.out.println("\nTestLabelExpressionParser.testPrimitiveExpression()"); |
| 275 | 22279 | jvidal | |
| 276 | 20768 | jdominguez | 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 | 22218 | jdominguez | parser.putSymbol(symbols[j].id,symbols[j].val); |
| 281 | 20768 | jdominguez | } |
| 282 | 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 | 22218 | jdominguez | } |
| 296 | 22279 | jvidal | |
| 297 | 22218 | jdominguez | // else if (expected instanceof DateValue) {
|
| 298 | 22279 | jvidal | // expected = ((DateValue) expected).getValue();
|
| 299 | 22218 | jdominguez | // }
|
| 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 | 22495 | jdominguez | |
| 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 | 20768 | jdominguez | }; |
| 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 | parser = new LabelExpressionParser(new CharArrayReader(expr.toCharArray())); |
||
| 342 | for (int j = 0; j < symbols.length; j++) { |
||
| 343 | 22218 | jdominguez | parser.putSymbol(symbols[j].id,symbols[j].val); |
| 344 | 20768 | jdominguez | } |
| 345 | System.out.print("Parsing '"+expr+"'"); |
||
| 346 | try {
|
||
| 347 | 22218 | jdominguez | parser.UnaryElement(); |
| 348 | 20768 | jdominguez | 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 | 22279 | jvidal | |
| 364 | |||
| 365 | 20768 | jdominguez | 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 | 22218 | jdominguez | ((DoubleValue) symbols[0].val).getValue(),
|
| 375 | ((DoubleValue) symbols[1].val).getValue(),
|
||
| 376 | 20768 | jdominguez | }; |
| 377 | 22218 | jdominguez | public void testArithmeticUnaryExpression() throws ExpressionException { |
| 378 | 20768 | jdominguez | String[] expressions = UnaryArithmeticExpressions; |
| 379 | Object[] expectedValues = UnaryArithmeticExpressionsValue; |
||
| 380 | System.out.println("\nTestLabelExpressionParser.testArithmeticUnaryExpression()"); |
||
| 381 | 22279 | jvidal | |
| 382 | 20768 | jdominguez | 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 | 22218 | jdominguez | parser.putSymbol(symbols[j].id,symbols[j].val); |
| 387 | 20768 | jdominguez | } |
| 388 | System.out.print("Parsing '"+expr+"'"); |
||
| 389 | try {
|
||
| 390 | 22218 | jdominguez | parser.MultiplicativeExpression(); |
| 391 | 20768 | jdominguez | 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 | 22279 | jvidal | |
| 407 | 20768 | jdominguez | private String[] MultiplicativeArithmeticExpressions = new String[] { |
| 408 | "3*4356.234",
|
||
| 409 | 22218 | jdominguez | "15*10",
|
| 410 | "15/10",
|
||
| 411 | 20768 | jdominguez | "8768758/2432432",
|
| 412 | "[A_DOUBLE_VALUE]*[ANOTHER_DOUBLE_VALUE]",
|
||
| 413 | "[A_DOUBLE_VALUE]/[ANOTHER_DOUBLE_VALUE]",
|
||
| 414 | 22495 | jdominguez | "[A_DOUBLE_VALUE]*16",
|
| 415 | 20768 | jdominguez | }; |
| 416 | private Object[] MultiplicativeArithmeticExpressionsValue = new Object[] { |
||
| 417 | 3*4356.234, |
||
| 418 | 22218 | jdominguez | 15*10, |
| 419 | 15/10, |
||
| 420 | 20768 | jdominguez | 8768758/2432432, |
| 421 | 22218 | jdominguez | ((DoubleValue) symbols[0].val).getValue()*((DoubleValue) symbols[1].val).getValue(), |
| 422 | ((DoubleValue) symbols[0].val).getValue()/((DoubleValue) symbols[1].val).getValue(), |
||
| 423 | 22495 | jdominguez | ((DoubleValue) symbols[0].val).getValue() * 16, |
| 424 | 20768 | jdominguez | }; |
| 425 | 22218 | jdominguez | public void testMultiplicativeExpression() throws ExpressionException { |
| 426 | 20768 | jdominguez | String[] expressions = MultiplicativeArithmeticExpressions; |
| 427 | Object[] expectedValues = MultiplicativeArithmeticExpressionsValue; |
||
| 428 | System.out.println("\nTestLabelExpressionParser.testMultiplicativeExpression()"); |
||
| 429 | 22279 | jvidal | |
| 430 | 20768 | jdominguez | 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 | 22218 | jdominguez | parser.putSymbol(symbols[j].id,symbols[j].val); |
| 435 | 20768 | jdominguez | } |
| 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 | 22279 | jvidal | |
| 455 | 20768 | jdominguez | 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 | 22218 | jdominguez | ((DoubleValue) symbols[0].val).getValue()+((DoubleValue) symbols[1].val).getValue(), |
| 465 | ((DoubleValue) symbols[0].val).getValue()-((DoubleValue) symbols[1].val).getValue(), |
||
| 466 | 20768 | jdominguez | }; |
| 467 | 22218 | jdominguez | public void testAdditiveExpression() throws ExpressionException { |
| 468 | 20768 | jdominguez | String[] expressions = AdditiveArithmeticExpressions; |
| 469 | Object[] expectedValues = AdditiveArithmeticExpressionsValue; |
||
| 470 | System.out.println("\nTestLabelExpressionParser.testAdditiveExpression()"); |
||
| 471 | 22279 | jvidal | |
| 472 | 20768 | jdominguez | 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 | 22218 | jdominguez | parser.putSymbol(symbols[j].id,symbols[j].val); |
| 477 | 20768 | jdominguez | } |
| 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 | 22279 | jvidal | |
| 498 | 22218 | jdominguez | |
| 499 | 22279 | jvidal | private String EOField = LabelExpressionParser.tokenFor(LabelExpressionParser.EOFIELD); |
| 500 | private String EOExpression = LabelExpressionParser.tokenFor(LabelExpressionParser.EOEXPR); |
||
| 501 | private String DOUBLEQUOTE = "\""; |
||
| 502 | |||
| 503 | 22421 | jdominguez | private String[] FieldExpressionStrings = new String[] { |
| 504 | 22279 | jvidal | "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 | 22421 | jdominguez | private Object[] FieldExpressionValue = new Object[] { |
| 512 | 22279 | jvidal | "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 | 22421 | jdominguez | public void testFieldExpressionStrings() throws ExpressionException { |
| 521 | 22279 | jvidal | |
| 522 | 22421 | jdominguez | String[] expressions = FieldExpressionStrings; |
| 523 | Object[] expectedValues = FieldExpressionValue; |
||
| 524 | 22279 | jvidal | 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 | 22218 | jdominguez | |
| 568 | }; |
||
| 569 | 22279 | jvidal | private Object[][] LabelExpressionsValue = new Object[][] { |
| 570 | new Object[] {3,true,true }, |
||
| 571 | 22218 | jdominguez | new Object[] { 754, false }, |
| 572 | 22279 | jvidal | 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 | 22218 | jdominguez | }; |
| 578 | |||
| 579 | 22279 | jvidal | public void testLabelExpressions() throws ExpressionException { |
| 580 | 22218 | jdominguez | |
| 581 | 22279 | jvidal | String[] expressions = LabelExpressions; |
| 582 | Object[][] expectedValues = LabelExpressionsValue; |
||
| 583 | System.out.println("\nTestLabelExpressionParser.testLabelExpressions()"); |
||
| 584 | |||
| 585 | 22218 | jdominguez | 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 | 22279 | jvidal | |
| 593 | |||
| 594 | 22218 | jdominguez | System.out.print("Parsing '"+expr+"'"); |
| 595 | try {
|
||
| 596 | 22279 | jvidal | |
| 597 | 22218 | jdominguez | parser.LabelExpression(); |
| 598 | 22279 | jvidal | |
| 599 | 22218 | jdominguez | System.out.print(": [ parsed ]. Evaluating: "); |
| 600 | Object[] expected = expectedValues[i]; |
||
| 601 | Object[] myValues = (Object[]) ((Expression)parser.getStack().pop()).evaluate(parser.getSymbols()); |
||
| 602 | 22279 | jvidal | |
| 603 | for (int j = 0; j < myValues.length; j++) { // <- Last in first out |
||
| 604 | Object value = myValues[j];
|
||
| 605 | 22218 | jdominguez | 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 | 20768 | jdominguez | } |
| 617 | |||
| 618 | 22279 | jvidal | |
| 619 | |||
| 620 | 22495 | jdominguez | private String[] SolvedBugsExpressions = new String[] { |
| 621 | 22510 | jdominguez | "([Y] + 3) * 5;",
|
| 622 | "([Y] + 3) * 5"+EOField+"([Y] + 3) * 5", |
||
| 623 | 22495 | jdominguez | }; |
| 624 | private Object[][] SolvedBugsExpressionsValue = new Object[][] { |
||
| 625 | 22510 | jdominguez | 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 | 22495 | jdominguez | }; |
| 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 | 22510 | jdominguez | Object value = ((Expression)parser.getStack().pop()).evaluate(parser.getSymbols()); |
| 657 | if (value.getClass().isArray()) {
|
||
| 658 | Object[] myValues = (Object[]) value; |
||
| 659 | 22495 | jdominguez | |
| 660 | 22510 | jdominguez | 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 | 22495 | jdominguez | 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 | 20768 | jdominguez | } |