    1   package org.codehaus.groovy.syntax;
    2
    3
    4   import groovy.util.GroovyTestCase;
    5   import org.codehaus.groovy.GroovyBugError;
    6
    7
    8   public class AbstractTokenStreamTest
    9       extends GroovyTestCase
    10  {
    11      public static class MockTokenStream
    12          extends AbstractTokenStream
    13      {
    14          private int cur;
    15          private int checkpoint;
    16          private Token[] tokens;
    17
    18          public MockTokenStream(Token[] tokens)
    19          {
    20              this.tokens = tokens;
    21              this.cur  = 0;
    22          }
    23
    24          public Token nextToken()
    25              throws ReadException, SyntaxException
    26          {
    27              if ( this.cur >= this.tokens.length )
    28              {
    29                  return null;
    30              }
    31
    32              Token token = this.tokens[ this.cur ];
    33
    34              ++this.cur;
    35
    36              return token;
    37          }
    38
    39          public void checkpoint() {
    40              checkpoint = cur;
    41          }
    42
    43          public void restore() {
    44              cur = checkpoint;
    45          }
    46      }
    47
    48      public void testNextToken()
    49          throws Exception
    50      {
    51          Token[] tokens = new Token[]
    52              {
    53                  Token.newSymbol( "(", 1, 1 ),
    54                  Token.newSymbol( ")", 1, 2 )
    55              };
    56
    57          MockTokenStream in = new MockTokenStream( tokens );
    58
    59
    60          assertSame( tokens[0],
    61                      in.nextToken() );
    62
    63          assertSame( tokens[1],
    64                      in.nextToken() );
    65
    66          assertNull( in.nextToken() );
    67
    68      }
    69
    70      public void testLa()
    71          throws Exception
    72      {
    73          Token[] tokens = new Token[]
    74              {
    75                  Token.newSymbol( "(", 1, 1 ),
    76                  Token.newSymbol( ")", 1, 2 )
    77              };
    78
    79          MockTokenStream in = new MockTokenStream( tokens );
    80
    81
    82          assertSame( tokens[0],
    83                      in.la() );
    84
    85          assertSame( tokens[0],
    86                      in.la() );
    87
    88          assertSame( tokens[0],
    89                      in.la( 1 ) );
    90
    91          assertSame( tokens[0],
    92                      in.la( 1 ) );
    93
    94          assertSame( tokens[1],
    95                      in.la( 2 ) );
    96
    97          assertSame( tokens[1],
    98                      in.la( 2 ) );
    99      }
    100
    101     public void testLaAndConsume()
    102         throws Exception
    103     {
    104         Token[] tokens = new Token[]
    105             {
    106                 Token.newSymbol( "(", 1, 1 ),
    107                 Token.newSymbol( ")", 1, 2 )
    108             };
    109
    110         MockTokenStream in = new MockTokenStream( tokens );
    111
    112         assertSame( tokens[0],
    113                     in.la() );
    114
    115         assertSame( tokens[0],
    116                     in.la() );
    117
    118         assertSame( tokens[0],
    119                     in.la( 1 ) );
    120
    121         assertSame( tokens[0],
    122                     in.la( 1 ) );
    123
    124         assertSame( tokens[1],
    125                     in.la( 2 ) );
    126
    127         in.consume( Types.LEFT_PARENTHESIS );
    128
    129         assertSame( tokens[1],
    130                     in.la() );
    131
    132         assertSame( tokens[1],
    133                     in.la() );
    134
    135         assertSame( tokens[1],
    136                     in.la( 1 ) );
    137
    138         assertSame( tokens[1],
    139                     in.la( 1 ) );
    140     }
    141
    142     public void testLaOutOfOrder()
    143         throws Exception
    144     {
    145         Token[] tokens = new Token[]
    146             {
    147                 Token.newIdentifier( "cheeseIt", 1, 1 ),
    148                 Token.newSymbol( "(", 1, 10 ),
    149                 Token.newSymbol( ")", 1, 11 )
    150             };
    151
    152         MockTokenStream in = new MockTokenStream( tokens );
    153
    154         assertSame( tokens[2],
    155                     in.la( 3 ) );
    156
    157         assertSame( tokens[1],
    158                     in.la( 2 ) );
    159
    160         assertSame( tokens[0],
    161                     in.la( 1 ) );
    162     }
    163
    164     public void testLaAtEnd()
    165         throws Exception
    166     {
    167         Token[] tokens = new Token[]
    168             {
    169             };
    170
    171         MockTokenStream in = new MockTokenStream( tokens );
    172
    173         assertNull( in.la() );
    174
    175         assertNull( in.la() );
    176
    177         assertNull( in.la() );
    178     }
    179
    180     /***
    181      * this test is broken as we have a large look-ahead token buffer now
    182      * to handle newlines. if we supported mid-stream consumption
    183      * (e.g. consumeAtIndex(3) then we could avoid such a large buffer
    184      */
    185     public void DISABLED_testExhaustLookAhead()
    186         throws Exception
    187     {
    188         Token[] tokens = new Token[]
    189             {
    190                 Token.newSymbol( "(", 1, 1 ),
    191                 Token.newSymbol( ")", 1, 2 ),
    192                 Token.newSymbol( "[", 1, 3 ),
    193                 Token.newSymbol( "]", 1, 4 ),
    194                 Token.newSymbol( "{", 1, 5 ),
    195                 Token.newSymbol( "}", 1, 6 )
    196             };
    197
    198         MockTokenStream in = new MockTokenStream( tokens );
    199
    200         assertSame( tokens[0],
    201                     in.la() );
    202
    203         assertSame( tokens[1],
    204                     in.la( 2 ) );
    205
    206         assertSame( tokens[2],
    207                     in.la( 3 ) );
    208
    209         assertSame( tokens[3],
    210                     in.la( 4 ) );
    211
    212         assertSame( tokens[4],
    213                     in.la( 5 ) );
    214         try
    215         {
    216             in.la( 6 );
    217             fail( "should have thrown GroovyBugError" );
    218         }
    219         catch (GroovyBugError e)
    220         {
    221             // expected and correct
    222 //            assertEquals( 6,
    223 //                          e.getLookAhead() );
    224         }
    225     }
    226
    227     public void testTokenMismatch()
    228         throws Exception
    229     {
    230         Token[] tokens = new Token[]
    231             {
    232                 Token.newSymbol( "(", 1, 1 ),
    233                 Token.newSymbol( ")", 1, 2 )
    234             };
    235
    236         MockTokenStream in = new MockTokenStream( tokens );
    237
    238         try
    239         {
    240             in.consume( Types.RIGHT_PARENTHESIS );
    241             fail( "should have thrown TokenMismatchException" );
    242         }
    243         catch (TokenMismatchException e)
    244         {
    245             // expected and correct
    246
    247             assertSame( tokens[0],
    248                         e.getUnexpectedToken() );
    249
    250             assertEquals( Types.RIGHT_PARENTHESIS,
    251                           e.getExpectedType() );
    252         }
    253     }
    254 }