    1   /*
    2    * $Id: ASTBuilderTest.java,v 1.30 2004/07/13 14:37:49 jstrachan Exp $
    3    *
    4    * Copyright 2003 (C) James Strachan and Bob Mcwhirter. All Rights Reserved.
    5    *
    6    * Redistribution and use of this software and associated documentation
    7    * ("Software"), with or without modification, are permitted provided that the
    8    * following conditions are met: 1. Redistributions of source code must retain
    9    * copyright statements and notices. Redistributions must also contain a copy
    10   * of this document. 2. Redistributions in binary form must reproduce the above
    11   * copyright notice, this list of conditions and the following disclaimer in
    12   * the documentation and/or other materials provided with the distribution. 3.
    13   * The name "groovy" must not be used to endorse or promote products derived
    14   * from this Software without prior written permission of The Codehaus. For
    15   * written permission, please contact info@codehaus.org. 4. Products derived
    16   * from this Software may not be called "groovy" nor may "groovy" appear in
    17   * their names without prior written permission of The Codehaus. "groovy" is a
    18   * registered trademark of The Codehaus. 5. Due credit should be given to The
    19   * Codehaus - http://groovy.codehaus.org/
    20   *
    21   * THIS SOFTWARE IS PROVIDED BY THE CODEHAUS AND CONTRIBUTORS ``AS IS'' AND ANY
    22   * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
    23   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
    24   * DISCLAIMED. IN NO EVENT SHALL THE CODEHAUS OR ITS CONTRIBUTORS BE LIABLE FOR
    25   * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
    26   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
    27   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
    28   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    29   * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
    30   * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
    31   * DAMAGE.
    32   *
    33   */
    34  package org.codehaus.groovy.syntax.parser;
    35
    36  import java.util.Iterator;
    37  import java.util.List;
    38
    39  import org.codehaus.groovy.ast.ClassNode;
    40  import org.codehaus.groovy.ast.MethodNode;
    41  import org.codehaus.groovy.ast.ModuleNode;
    42  import org.codehaus.groovy.ast.expr.BinaryExpression;
    43  import org.codehaus.groovy.ast.expr.ClassExpression;
    44  import org.codehaus.groovy.ast.expr.ClosureExpression;
    45  import org.codehaus.groovy.ast.expr.ConstantExpression;
    46  import org.codehaus.groovy.ast.expr.Expression;
    47  import org.codehaus.groovy.ast.expr.MapEntryExpression;
    48  import org.codehaus.groovy.ast.expr.MapExpression;
    49  import org.codehaus.groovy.ast.expr.VariableExpression;
    50  import org.codehaus.groovy.ast.stmt.BlockStatement;
    51  import org.codehaus.groovy.ast.stmt.ExpressionStatement;
    52  import org.codehaus.groovy.ast.stmt.ForStatement;
    53  import org.codehaus.groovy.ast.stmt.IfStatement;
    54  import org.codehaus.groovy.ast.stmt.ReturnStatement;
    55  import org.codehaus.groovy.control.CompilationFailedException;
    56  import org.codehaus.groovy.runtime.InvokerHelper;
    57  import org.codehaus.groovy.syntax.SyntaxException;
    58  import org.codehaus.groovy.syntax.Types;
    59  import org.codehaus.groovy.syntax.lexer.UnexpectedCharacterException;
    60
    61  /***
    62   * Test case for the AST builder
    63   *
    64   * @author <a href="mailto:james@coredevelopers.net">James Strachan</a>
    65   * @version $Revision: 1.30 $
    66   */
    67  public class ASTBuilderTest extends TestParserSupport {
    68
    69      public void testStatementParsing() throws Exception {
    70          ModuleNode module =
    71              parse("import cheddar.cheese.Toast as Bread\n x = [1, 2, 3]; System.out.println(x)", "foo/Cheese.groovy");
    72
    73          BlockStatement block = module.getStatementBlock();
    74          assertTrue("Contains some statements", !block.getStatements().isEmpty());
    75
    76          //System.out.println("Statements: " + block.getStatements());
    77      }
    78
    79      public void testBlock() throws Exception {
    80          ModuleNode module =
    81              parse("class Foo { void testMethod() { x = someMethod(); callMethod(x) } }", "Dummy.groovy");
    82          BlockStatement statement = getCode(module, "testMethod");
    83
    84          assertEquals("Statements size: " + statement.getStatements(), 2, statement.getStatements().size());
    85
    86          System.out.println(statement.getStatements());
    87      }
    88
    89      public void testSubscript() throws Exception {
    90          ModuleNode module =
    91              parse("class Foo { void testMethod() { x = 1\n [1].each { println(it) }} }", "Dummy.groovy");
    92          BlockStatement statement = getCode(module, "testMethod");
    93
    94          assertEquals("Statements size: " + statement.getStatements(), 2, statement.getStatements().size());
    95
    96          for (Iterator iter = statement.getStatements().iterator(); iter.hasNext();) {
    97              System.out.println(iter.next());
    98          }
    99      }
    100
    101     public void testNewlinesInsideExpresssions() throws Exception {
    102         ModuleNode module = parse("class Foo { void testMethod() { x = 1 +\n 5 * \n 2 / \n 5 } }", "Dummy.groovy");
    103         BlockStatement statement = getCode(module, "testMethod");
    104
    105         assertEquals("Statements size: " + statement.getStatements(), 1, statement.getStatements().size());
    106
    107         for (Iterator iter = statement.getStatements().iterator(); iter.hasNext();) {
    108             System.out.println(iter.next());
    109         }
    110     }
    111
    112     public void testMethodCalls() throws Exception {
    113         ModuleNode module =
    114             parse(
    115                 "class Foo { void testMethod() { array = getMockArguments()\n \n dummyMethod(array) } }",
    116                 "Dummy.groovy");
    117         BlockStatement statement = getCode(module, "testMethod");
    118
    119         assertEquals("Statements size: " + statement.getStatements(), 2, statement.getStatements().size());
    120
    121         for (Iterator iter = statement.getStatements().iterator(); iter.hasNext();) {
    122             System.out.println(iter.next());
    123         }
    124     }
    125
    126     public void testJdk15ForLoop() throws Exception {
    127         ModuleNode module = parse("class Foo { void testMethod() { for (x : foo) { println x } } }", "Dummy.groovy");
    128         BlockStatement statement = getCode(module, "testMethod");
    129
    130         assertEquals("Statements size: " + statement.getStatements(), 1, statement.getStatements().size());
    131
    132         ForStatement stmt = (ForStatement) statement.getStatements().get(0);
    133         assertEquals("x", stmt.getVariable());
    134         assertTrue(stmt.getVariableType().isDynamic());
    135         System.out.println(stmt);
    136     }
    137
    138     public void testJdk15ForLoopWithType() throws Exception {
    139         ModuleNode module = parse("class Foo { void testMethod() { for (Integer x : foo) { println x } } }", "Dummy.groovy");
    140         BlockStatement statement = getCode(module, "testMethod");
    141
    142         assertEquals("Statements size: " + statement.getStatements(), 1, statement.getStatements().size());
    143
    144         ForStatement stmt = (ForStatement) statement.getStatements().get(0);
    145         assertEquals("x", stmt.getVariable());
    146         System.out.println( stmt.getVariableType().getName() );
    147         assertEquals("java.lang.Integer", stmt.getVariableType().getName());
    148         assertFalse(stmt.getVariableType().isDynamic());
    149         System.out.println(stmt);
    150     }
    151
    152     public void testForLoopWithType() throws Exception {
    153         ModuleNode module = parse("class Foo { void testMethod() { for (Foo x in foo) { println x } } }", "Dummy.groovy");
    154         BlockStatement statement = getCode(module, "testMethod");
    155
    156         assertEquals("Statements size: " + statement.getStatements(), 1, statement.getStatements().size());
    157
    158         ForStatement stmt = (ForStatement) statement.getStatements().get(0);
    159         assertEquals("x", stmt.getVariable());
    160         assertEquals("Foo", stmt.getVariableType().getName());
    161         assertFalse(stmt.getVariableType().isDynamic());
    162         System.out.println(stmt);
    163     }
    164
    165     public void testSubscriptAssignment() throws Exception {
    166         ModuleNode module = parse("class Foo { void testMethod() { x[12] = 'abc' } }", "Dummy.groovy");
    167         BlockStatement statement = getCode(module, "testMethod");
    168
    169         assertEquals("Statements size: " + statement.getStatements(), 1, statement.getStatements().size());
    170
    171         ExpressionStatement exprStmt = (ExpressionStatement) statement.getStatements().get(0);
    172         Expression exp = exprStmt.getExpression();
    173         System.out.println(exp);
    174
    175         assertTrue(exp instanceof BinaryExpression);
    176         BinaryExpression binExpr = (BinaryExpression) exp;
    177         assertTrue("RHS is constant", binExpr.getRightExpression() instanceof ConstantExpression);
    178
    179         Expression lhs = binExpr.getLeftExpression();
    180         assertTrue("LHS is binary expression", lhs instanceof BinaryExpression);
    181
    182         BinaryExpression lhsBinExpr = (BinaryExpression) lhs;
    183         assertEquals(Types.LEFT_SQUARE_BRACKET, lhsBinExpr.getOperation().getType());
    184
    185         assertTrue("Left of LHS is a variable", lhsBinExpr.getLeftExpression() instanceof VariableExpression);
    186         assertTrue("Right of LHS is a constant", lhsBinExpr.getRightExpression() instanceof ConstantExpression);
    187
    188     }
    189
    190     public void testNoReturn() throws Exception {
    191         ModuleNode module = parse("class Foo { void testMethod() { x += 5 } }", "Dummy.groovy");
    192         BlockStatement statement = getCode(module, "testMethod");
    193
    194         assertEquals("Statements size: " + statement.getStatements(), 1, statement.getStatements().size());
    195
    196         System.out.println(statement.getStatements());
    197
    198         ExpressionStatement exprStmt = (ExpressionStatement) statement.getStatements().get(0);
    199         Expression exp = exprStmt.getExpression();
    200
    201         System.out.println("expr: " + exp);
    202     }
    203
    204     public void testCastExpression() throws Exception {
    205         ModuleNode module = parse("class Foo { void testMethod() { x = (Short) 5 } }", "Dummy.groovy");
    206         BlockStatement statement = getCode(module, "testMethod");
    207
    208         assertEquals("Statements size: " + statement.getStatements(), 1, statement.getStatements().size());
    209
    210         System.out.println(statement.getStatements());
    211
    212         ExpressionStatement exprStmt = (ExpressionStatement) statement.getStatements().get(0);
    213         Expression exp = exprStmt.getExpression();
    214
    215         System.out.println("expr: " + exp);
    216     }
    217
    218     public void testTernaryExpression() throws Exception {
    219         ModuleNode module = parse("class Foo { void testMethod() { foo() ? 'a' : 'b' } }", "Dummy.groovy");
    220         BlockStatement statement = getCode(module, "testMethod");
    221
    222         assertEquals("Statements size: " + statement.getStatements(), 1, statement.getStatements().size());
    223
    224         System.out.println(statement.getStatements());
    225
    226         ExpressionStatement exprStmt = (ExpressionStatement) statement.getStatements().get(0);
    227         Expression exp = exprStmt.getExpression();
    228
    229         System.out.println("expr: " + exp);
    230     }
    231
    232     public void testClosureWithJustIdentifierBug() throws Exception {
    233         ModuleNode module = parse("class Foo { void testMethod() { return {a} } }", "Dummy.groovy");
    234         BlockStatement statement = getCode(module, "testMethod");
    235
    236         assertEquals("Statements size: " + statement.getStatements(), 1, statement.getStatements().size());
    237
    238         System.out.println(statement.getStatements());
    239
    240         ReturnStatement returnStmt = (ReturnStatement)statement.getStatements().get(0);
    241         Expression exp = returnStmt.getExpression();
    242
    243         System.out.println("expr: " + exp);
    244     }
    245
    246     public void testClosureWithJustIdentifierInMapBug() throws Exception {
    247         ModuleNode module = parse("class Foo { void testMethod() { ['x':{a}, 'd':123] } }", "Dummy.groovy");
    248         BlockStatement statement = getCode(module, "testMethod");
    249
    250         assertEquals("Statements size: " + statement.getStatements(), 1, statement.getStatements().size());
    251
    252         System.out.println(statement.getStatements());
    253
    254         ExpressionStatement exprStmt = (ExpressionStatement) statement.getStatements().get(0);
    255
    256         MapExpression mapExp = (MapExpression) exprStmt.getExpression();
    257         MapEntryExpression entryExp = (MapEntryExpression) mapExp.getMapEntryExpressions().get(0);
    258         ClosureExpression closureExp = (ClosureExpression) entryExp.getValueExpression();
    259         assertEquals("Parameters on closure", 0, closureExp.getParameters().length);
    260         System.out.println("expr: " + closureExp);
    261     }
    262
    263     public void testArrayExpression() throws Exception {
    264         ModuleNode module = parse("class Foo { void testMethod() { foo = new String[] { 'a', 'b', 'c' }\n assert foo != null } }", "Dummy.groovy");
    265         BlockStatement statement = getCode(module, "testMethod");
    266
    267         assertEquals("Statements size: " + statement.getStatements(), 2, statement.getStatements().size());
    268
    269         System.out.println(statement.getStatements());
    270
    271         ExpressionStatement exprStmt = (ExpressionStatement) statement.getStatements().get(0);
    272         Expression exp = exprStmt.getExpression();
    273
    274         System.out.println("expr: " + exp);
    275     }
    276
    277     public void testTypedVariableExpression() throws Exception {
    278         ModuleNode module = parse("class Foo { void testMethod() { Short x = 5 } }", "Dummy.groovy");
    279         BlockStatement statement = getCode(module, "testMethod");
    280
    281         assertEquals("Statements size: " + statement.getStatements(), 1, statement.getStatements().size());
    282
    283         System.out.println(statement.getStatements());
    284
    285         ExpressionStatement exprStmt = (ExpressionStatement) statement.getStatements().get(0);
    286         Expression exp = exprStmt.getExpression();
    287
    288         System.out.println("expr: " + exp);
    289     }
    290
    291     public void testFullyQualifiedType() throws Exception {
    292         ModuleNode module = parse("class Foo { void testMethod() { com.acme.Foo } }", "Dummy.groovy");
    293         BlockStatement statement = getCode(module, "testMethod");
    294
    295         assertEquals("Statements size: " + statement.getStatements(), 1, statement.getStatements().size());
    296
    297         System.out.println(statement.getStatements());
    298
    299         ExpressionStatement exprStmt = (ExpressionStatement) statement.getStatements().get(0);
    300         Expression exp = exprStmt.getExpression();
    301
    302         System.out.println("expr: " + exp);
    303
    304         System.out.println("text: " + exp.getText());
    305     }
    306
    307     public void testDoubleSubscript() throws Exception {
    308         ModuleNode module = parse("class Foo { void testMethod() { x = foo[0][0] } }", "Dummy.groovy");
    309         BlockStatement statement = getCode(module, "testMethod");
    310
    311         assertEquals("Statements size: " + statement.getStatements(), 1, statement.getStatements().size());
    312
    313         System.out.println(statement.getStatements());
    314
    315         ExpressionStatement exprStmt = (ExpressionStatement) statement.getStatements().get(0);
    316         Expression exp = exprStmt.getExpression();
    317
    318         System.out.println("expr: " + exp);
    319
    320         System.out.println("text: " + exp.getText());
    321     }
    322
    323     public void testMethodCallWithDotAndNoParenthesis() throws Exception {
    324         ModuleNode module = parse("class Foo { void testMethod() { foo.someMethod 1 } }", "Dummy.groovy");
    325         BlockStatement statement = getCode(module, "testMethod");
    326
    327         assertEquals("Statements size: " + statement.getStatements(), 1, statement.getStatements().size());
    328
    329         System.out.println(statement.getStatements());
    330
    331         ExpressionStatement exprStmt = (ExpressionStatement) statement.getStatements().get(0);
    332         Expression exp = exprStmt.getExpression();
    333
    334         System.out.println("expr: " + exp);
    335
    336         System.out.println("text: " + exp.getText());
    337     }
    338
    339     public void testMethodCallWithNoParenthesis() throws Exception {
    340         ModuleNode module = parse("class Foo { void testMethod() { someMethod 1 } }", "Dummy.groovy");
    341         BlockStatement statement = getCode(module, "testMethod");
    342
    343         assertEquals("Statements size: " + statement.getStatements(), 1, statement.getStatements().size());
    344
    345         System.out.println(statement.getStatements());
    346
    347         ExpressionStatement exprStmt = (ExpressionStatement) statement.getStatements().get(0);
    348         Expression exp = exprStmt.getExpression();
    349
    350         System.out.println("expr: " + exp);
    351
    352         System.out.println("text: " + exp.getText());
    353     }
    354
    355     public void testScriptMethodCallWithNoParenthesis() throws Exception {
    356         ModuleNode module = parse("someMethod 1", "Dummy.groovy");
    357         BlockStatement statement = getCode(module, "run");
    358
    359         assertEquals("Statements size: " + statement.getStatements(), 1, statement.getStatements().size());
    360
    361         System.out.println(statement.getStatements());
    362
    363         ExpressionStatement exprStmt = (ExpressionStatement) statement.getStatements().get(0);
    364         Expression exp = exprStmt.getExpression();
    365
    366         System.out.println("expr: " + exp);
    367
    368         System.out.println("text: " + exp.getText());
    369     }
    370
    371     public void testScriptWithMethodDeclaration() throws Exception {
    372         ModuleNode module = parse("def foo(a) { return a + 1}\n foo(123)", "Dummy.groovy");
    373         BlockStatement statement = getCode(module, "run");
    374
    375         assertEquals("Statements size: " + statement.getStatements(), 1, statement.getStatements().size());
    376
    377         System.out.println(statement.getStatements());
    378
    379         ExpressionStatement exprStmt = (ExpressionStatement) statement.getStatements().get(0);
    380         Expression exp = exprStmt.getExpression();
    381
    382         System.out.println("expr: " + exp);
    383
    384         System.out.println("text: " + exp.getText());
    385     }
    386
    387     public void testSubscriptThenMethod() throws Exception {
    388         ModuleNode module = parse("class Foo { void testMethod() { x = foo[0].foo() } }", "Dummy.groovy");
    389         BlockStatement statement = getCode(module, "testMethod");
    390
    391         assertEquals("Statements size: " + statement.getStatements(), 1, statement.getStatements().size());
    392
    393         System.out.println(statement.getStatements());
    394
    395         ExpressionStatement exprStmt = (ExpressionStatement) statement.getStatements().get(0);
    396         Expression exp = exprStmt.getExpression();
    397
    398         System.out.println("expr: " + exp);
    399
    400         System.out.println("text: " + exp.getText());
    401     }
    402
    403     public void testSubscriptThenOperation() throws Exception {
    404         ModuleNode module = parse("class Foo { void testMethod() { foo[0] += 5 } }", "Dummy.groovy");
    405         BlockStatement statement = getCode(module, "testMethod");
    406
    407         assertEquals("Statements size: " + statement.getStatements(), 1, statement.getStatements().size());
    408
    409         System.out.println(statement.getStatements());
    410
    411         ExpressionStatement exprStmt = (ExpressionStatement) statement.getStatements().get(0);
    412         Expression exp = exprStmt.getExpression();
    413
    414         System.out.println("expr: " + exp);
    415
    416         System.out.println("text: " + exp.getText());
    417     }
    418
    419
    420     public void testRodsBug() throws Exception {
    421         ModuleNode module = parse("class Foo { void testMethod() { if (x) { String n = 'foo' } } }", "Dummy.groovy");
    422         BlockStatement statement = getCode(module, "testMethod");
    423
    424         assertEquals("Statements size: " + statement.getStatements(), 1, statement.getStatements().size());
    425
    426         System.out.println(statement.getStatements());
    427
    428         IfStatement ifStmt = (IfStatement) statement.getStatements().get(0);
    429         BlockStatement trueStmt = (BlockStatement) ifStmt.getIfBlock();
    430
    431         System.out.println("trueStmt: " + trueStmt);
    432
    433         // ideally there would be 1 statement; though we're handling that in the verifier
    434         assertEquals(1, trueStmt.getStatements().size());
    435     }
    436
    437     public void testStaticMethodCallBug() throws Exception {
    438         ModuleNode module =
    439             parse("class Foo { void testMethod() { ASTBuilderTest.mockHelperMethod() } }", "Dummy.groovy");
    440         BlockStatement statement = getCode(module, "testMethod");
    441
    442         assertEquals("Statements size: " + statement.getStatements(), 1, statement.getStatements().size());
    443
    444         System.out.println(statement.getStatements());
    445     }
    446
    447     public void testInstanceofBug() throws Exception {
    448         ModuleNode module =
    449         parse("class Foo { void testMethod() { if (foo instanceof java.util.List) { println('hello') } } }", "Dummy.groovy");
    450         BlockStatement statement = getCode(module, "testMethod");
    451
    452         assertEquals("Statements size: " + statement.getStatements(), 1, statement.getStatements().size());
    453
    454         System.out.println(statement.getStatements());
    455
    456         IfStatement ifStmt = (IfStatement) statement.getStatements().get(0);
    457         BinaryExpression exp = (BinaryExpression) ifStmt.getBooleanExpression().getExpression();
    458
    459         System.out.println("exp: " + exp);
    460
    461         Expression rhs = exp.getRightExpression();
    462         assertTrue("RHS should be a class expression", rhs instanceof ClassExpression);
    463
    464         ClassExpression classExp = (ClassExpression) rhs;
    465         assertEquals("java.util.List", classExp.getType());
    466     }
    467
    468     public void testMethodCallWithoutParensBug() throws Exception {
    469         ModuleNode module = parse("class Foo { void testMethod() { println 3, 5 } }", "Dummy.groovy");
    470         BlockStatement statement = getCode(module, "testMethod");
    471
    472         assertEquals("Statements size: " + statement.getStatements(), 1, statement.getStatements().size());
    473
    474         System.out.println(statement.getStatements());
    475     }
    476
    477     public void testReturnMethodClosure() throws Exception {
    478         ModuleNode module = parse("class Foo { void testMethod() { System.out.println\n}}", "Dummy.groovy");
    479         BlockStatement statement = getCode(module, "testMethod");
    480
    481         assertEquals("Statements size: " + statement.getStatements(), 1, statement.getStatements().size());
    482
    483         System.out.println(statement.getStatements());
    484     }
    485
    486     public void testDionsTypo() throws Exception {
    487         ModuleNode module = parse("class Foo { void testMethod() { println ${foo}\n}}", "Dummy.groovy");
    488         BlockStatement statement = getCode(module, "testMethod");
    489
    490         assertEquals("Statements size: " + statement.getStatements(), 1, statement.getStatements().size());
    491
    492         System.out.println(statement.getStatements());
    493     }
    494
    495     public void testMethodWithArrayTypeParam() throws Exception {
    496         ModuleNode module = parse("class Foo { void main(String[] args) { println(args) } }", "Dummy.groovy");
    497
    498         MethodNode method = getMethod(module, "main");
    499
    500         System.out.println("Parameters: " + InvokerHelper.toString(method.getParameters()));
    501     }
    502
    503     private void ensureOutOfRange(String script) throws Exception {
    504         try {
    505             ModuleNode module = parse(script, "Dummy.groovy");
    506         } catch (CompilationFailedException e) {
    507             SyntaxException cause = e.getUnit().getSyntaxError(0);
    508             if( cause != null && cause instanceof ParserException && cause.getMessage().indexOf("out of range") >= 0) {
    509                 return;
    510             }
    511             fail (script+" should fail with a ParserException: "+e.getMessage());
    512         }
    513         fail(script+" should fail because the number is out of range.");
    514     }
    515
    516     private void ensureInRange(String script) throws Exception {
    517         ModuleNode module = parse(script, "Dummy.groovy");
    518     }
    519
    520     public void testLiteralIntegerRange() throws Exception {
    521         ensureInRange(   "x =  2147483647I;");
    522         ensureOutOfRange("x =  2147483648I;");
    523
    524         ensureInRange(   "x = -2147483648I;");
    525         ensureOutOfRange("x = -2147483649I;");
    526     }
    527
    528     public void testLiteralLongRange() throws Exception {
    529         ensureInRange(   "x =  9223372036854775807L;");
    530         ensureOutOfRange("x =  9223372036854775808L;");
    531
    532         ensureInRange(   "x = -9223372036854775808L;");
    533         ensureOutOfRange("x = -9223372036854775809L;");
    534     }
    535
    536     public void testLiteralDoubleRange() throws Exception {
    537         ensureInRange(   "x =  1.7976931348623157E308D;");
    538         ensureOutOfRange("x =  1.7976931348623167E308D;");
    539
    540         ensureInRange(   "x = -1.7976931348623157E308D;");
    541         ensureOutOfRange("x = -1.7976931348623167E308D;");
    542     }
    543
    544     public void testLiteralFloatRange() throws Exception {
    545         ensureInRange(   "x =  3.4028235e+38f;");
    546         ensureOutOfRange("x =  3.4028236e+38f;");
    547
    548         ensureInRange(   "x = -3.4028235e+38f;");
    549         ensureOutOfRange("x = -3.4028236e+38f;");
    550     }
    551
    552     public void testLiteralIntegerBadSuffix() throws Exception {
    553         try {
    554             ModuleNode module = parse("x = 2147483648J;", "Dummy.groovy");
    555         } catch (CompilationFailedException e) {
    556             SyntaxException cause = e.getUnit().getSyntaxError(0);
    557             if (cause instanceof UnexpectedCharacterException) {
    558                 return;
    559             }
    560             fail ("x = 2147483648J should fail with an UnexpectedCharacterException");
    561         }
    562         fail("x = 2147483648J, should fail because J is an invalid numeric literal suffix.");
    563     }
    564
    565     public void testLiteralBadExponent() throws Exception {
    566         try {
    567             ModuleNode module = parse("x = 2.3e;", "Dummy.groovy");
    568         } catch (CompilationFailedException e) {
    569             SyntaxException cause = e.getUnit().getSyntaxError(0);
    570             if (cause instanceof UnexpectedCharacterException) {
    571                 return;
    572             }
    573             fail ("x = 2.3e should fail with an UnexpectedCharacterException");
    574         }
    575         fail("x = 2.3e, should fail because no exponent is specified.");
    576     }
    577
    578     public static Object mockHelperMethod() {
    579         return "cheese";
    580     }
    581
    582     protected BlockStatement getCode(ModuleNode module, String name) {
    583         MethodNode method = getMethod(module, name);
    584
    585         BlockStatement statement = (BlockStatement) method.getCode();
    586         assertNotNull(statement);
    587         return statement;
    588     }
    589
    590     protected MethodNode getMethod(ModuleNode module, String name) {
    591         assertEquals("class count", 1, module.getClasses().size());
    592
    593         ClassNode node = (ClassNode) module.getClasses().get(0);
    594
    595         assertNotNull(node);
    596
    597         List methods = node.getDeclaredMethods(name);
    598         assertTrue(methods.size() > 0);
    599         return (MethodNode) methods.get(0);
    600     }
    601 }