1   package org.codehaus.groovy.syntax;
2   
3   
4   import groovy.util.GroovyTestCase;
5   
6   public class TokenTest
7       extends GroovyTestCase
8   {
9   
10      public void testNothing()
11      {
12      }
13  
14  /*
15      private static final int LINE = 11;
16      private static final int COLUMN = 33;
17  
18      public void testConstruct()
19      {
20          Token token = new Token( 42,
21                                   "forty-two",
22                                   11,
23                                   22 );
24  
25          assertEquals( 42,
26                        token.getType() );
27  
28          assertEquals( "forty-two",
29                        token.getText() );
30  
31          assertEquals( 11,
32                        token.getStartLine() );
33  
34          assertEquals( 22,
35                        token.getStartColumn() );
36      }
37  
38      public void testLeftCurlyBrace()
39      {
40          Token token = Token.leftCurlyBrace( LINE,
41                                              COLUMN );
42  
43          assertToken( token,
44                       Token.LEFT_CURLY_BRACE,
45                       "{" );
46      }
47  
48      public void testRightCurlyBrace()
49      {
50          Token token = Token.rightCurlyBrace( LINE,
51                                               COLUMN );
52  
53          assertToken( token,
54                       Token.RIGHT_CURLY_BRACE,
55                       "}" );
56      }
57  
58      public void testLeftSquareBracket()
59      {
60          Token token = Token.leftSquareBracket( LINE,
61                                                 COLUMN );
62  
63          assertToken( token,
64                       Token.LEFT_SQUARE_BRACKET,
65                       "[" );
66      }
67  
68      public void testRightSquareBracket()
69      {
70          Token token = Token.rightSquareBracket( LINE,
71                                                  COLUMN );
72  
73          assertToken( token,
74                       Token.RIGHT_SQUARE_BRACKET,
75                       "]" );
76      }
77  
78      public void testLeftParenthesis()
79      {
80          Token token = Token.leftParenthesis( LINE,
81                                               COLUMN );
82  
83          assertToken( token,
84                       Token.LEFT_PARENTHESIS,
85                       "(" );
86      }
87  
88      public void testRightParenthesis()
89      {
90          Token token = Token.rightParenthesis( LINE,
91                                                COLUMN );
92  
93          assertToken( token,
94                       Token.RIGHT_PARENTHESIS,
95                       ")" );
96      }
97  
98      public void testDot()
99      {
100         Token token = Token.dot( LINE,
101                                  COLUMN );
102 
103         assertToken( token,
104                      Token.DOT,
105                      "." );
106     }
107 
108     public void testDotDot()
109     {
110         Token token = Token.dotDot( LINE,
111                                     COLUMN );
112 
113         assertToken( token,
114                      Token.DOT_DOT,
115                      ".." );
116     }
117 
118     public void testNot()
119     {
120         Token token = Token.not( LINE,
121                                  COLUMN );
122 
123         assertToken( token,
124                      Token.NOT,
125                      "!" );
126     }
127 
128     public void testCompareNotEqual()
129     {
130         Token token = Token.compareNotEqual( LINE,
131                                              COLUMN );
132 
133         assertToken( token,
134                      Token.COMPARE_NOT_EQUAL,
135                      "!=" );
136     }
137 
138     public void testEqual()
139     {
140         Token token = Token.equal( LINE,
141                                    COLUMN );
142 
143         assertToken( token,
144                      Token.EQUAL,
145                      "=" );
146     }
147 
148     public void testCompareIdentical()
149     {
150         Token token = Token.compareIdentical( LINE,
151                                               COLUMN );
152 
153         assertToken( token,
154                      Token.COMPARE_IDENTICAL,
155                      "===" );
156     }
157 
158     public void testCompareEqual()
159     {
160         Token token = Token.compareEqual( LINE,
161                                           COLUMN );
162 
163         assertToken( token,
164                      Token.COMPARE_EQUAL,
165                      "==" );
166     }
167 
168     public void testCompareLessThan()
169     {
170         Token token = Token.compareLessThan( LINE,
171                                              COLUMN );
172 
173         assertToken( token,
174                      Token.COMPARE_LESS_THAN,
175                      "<" );
176     }
177 
178     public void testCompareLessThanEqual()
179     {
180         Token token = Token.compareLessThanEqual( LINE,
181                                                   COLUMN );
182 
183         assertToken( token,
184                      Token.COMPARE_LESS_THAN_EQUAL,
185                      "<=" );
186     }
187 
188     public void testCompareGreaterThan()
189     {
190         Token token = Token.compareGreaterThan( LINE,
191                                                 COLUMN );
192 
193         assertToken( token,
194                      Token.COMPARE_GREATER_THAN,
195                      ">" );
196     }
197 
198     public void testCompareGreaterThanEqual()
199     {
200         Token token = Token.compareGreaterThanEqual( LINE,
201                                                      COLUMN );
202 
203         assertToken( token,
204                      Token.COMPARE_GREATER_THAN_EQUAL,
205                      ">=" );
206     }
207 
208     public void testLogicalOr()
209     {
210         Token token = Token.logicalOr( LINE,
211                                        COLUMN );
212 
213         assertToken( token,
214                      Token.LOGICAL_OR,
215                      "||" );
216     }
217 
218     public void testLogicalAnd()
219     {
220         Token token = Token.logicalAnd( LINE,
221                                         COLUMN );
222 
223         assertToken( token,
224                      Token.LOGICAL_AND,
225                      "&&" );
226     }
227 
228     public void testPlus()
229     {
230         Token token = Token.plus( LINE,
231                                   COLUMN );
232 
233         assertToken( token,
234                      Token.PLUS,
235                      "+" );
236     }
237 
238     public void testPlusPlus()
239     {
240         Token token = Token.plusPlus( LINE,
241                                       COLUMN );
242 
243         assertToken( token,
244                      Token.PLUS_PLUS,
245                      "++" );
246     }
247 
248     public void testPlusEqual()
249     {
250         Token token = Token.plusEqual( LINE,
251                                        COLUMN );
252 
253         assertToken( token,
254                      Token.PLUS_EQUAL,
255                      "+=" );
256     }
257 
258     public void testMinus()
259     {
260         Token token = Token.minus( LINE,
261                                    COLUMN );
262 
263         assertToken( token,
264                      Token.MINUS,
265                      "-" );
266     }
267 
268     public void testMinusMinus()
269     {
270         Token token = Token.minusMinus( LINE,
271                                         COLUMN );
272 
273         assertToken( token,
274                      Token.MINUS_MINUS,
275                      "--" );
276     }
277 
278     public void testMinusEqual()
279     {
280         Token token = Token.minusEqual( LINE,
281                                         COLUMN );
282 
283         assertToken( token,
284                      Token.MINUS_EQUAL,
285                      "-=" );
286     }
287 
288     public void testDivide()
289     {
290         Token token = Token.divide( LINE,
291                                     COLUMN );
292 
293         assertToken( token,
294                      Token.DIVIDE,
295                      "/" );
296     }
297 
298     public void testDivideEqual()
299     {
300         Token token = Token.divideEqual( LINE,
301                                          COLUMN );
302 
303         assertToken( token,
304                      Token.DIVIDE_EQUAL,
305                      "/=" );
306     }
307 
308     public void testMod()
309     {
310         Token token = Token.mod( LINE,
311                                  COLUMN );
312 
313         assertToken( token,
314                      Token.MOD,
315                      "%" );
316     }
317 
318     public void testModEqual()
319     {
320         Token token = Token.modEqual( LINE,
321                                       COLUMN );
322 
323         assertToken( token,
324                      Token.MOD_EQUAL,
325                      "%=" );
326     }
327 
328     public void testMultiply()
329     {
330         Token token = Token.multiply( LINE,
331                                       COLUMN );
332 
333         assertToken( token,
334                      Token.MULTIPLY,
335                      "*" );
336     }
337 
338     public void testMultiplyEqual()
339     {
340         Token token = Token.multiplyEqual( LINE,
341                                            COLUMN );
342 
343         assertToken( token,
344                      Token.MULTIPLY_EQUAL,
345                      "*=" );
346     }
347 
348     public void testComma()
349     {
350         Token token = Token.comma( LINE,
351                                    COLUMN );
352 
353         assertToken( token,
354                      Token.COMMA,
355                      "," );
356     }
357 
358     public void testColon()
359     {
360         Token token = Token.colon( LINE,
361                                    COLUMN );
362 
363         assertToken( token,
364                      Token.COLON,
365                      ":" );
366     }
367 
368     public void testSemicolon()
369     {
370         Token token = Token.semicolon( LINE,
371                                        COLUMN );
372 
373         assertToken( token,
374                      Token.SEMICOLON,
375                      ";" );
376     }
377 
378     public void testQuestion()
379     {
380         Token token = Token.question( LINE,
381                                       COLUMN );
382 
383         assertToken( token,
384                      Token.QUESTION,
385                      "?" );
386     }
387 
388     public void testPipe()
389     {
390         Token token = Token.pipe( LINE,
391                                   COLUMN );
392 
393         assertToken( token,
394                      Token.PIPE,
395                      "|" );
396     }
397 
398     public void testDoubleQuoteString()
399     {
400         Token token = Token.doubleQuoteString( LINE,
401                                                COLUMN,
402                                                "cheese" );
403 
404         assertToken( token,
405                      Token.DOUBLE_QUOTE_STRING,
406                      "cheese",
407                      "<string literal>");
408     }
409 
410     public void testSingleQuoteString()
411     {
412         Token token = Token.singleQuoteString( LINE,
413                                                COLUMN,
414                                                "cheese" );
415 
416         assertToken( token,
417                      Token.SINGLE_QUOTE_STRING,
418                      "cheese",
419                      "<string literal>" );
420     }
421 
422     public void testIdentifier()
423     {
424         Token token = Token.identifier( LINE,
425                                         COLUMN,
426                                         "cheese" );
427 
428         assertToken( token,
429                      Token.IDENTIFIER,
430                      "cheese",
431                      "<identifier>" );
432     }
433 
434     public void testIntegerNumber()
435     {
436         Token token = Token.integerNumber( LINE,
437                                            COLUMN,
438                                            "42" );
439 
440         assertToken( token,
441                      Token.INTEGER_NUMBER,
442                      "42",
443                      "<number>" );
444     }
445 
446     public void testFloatNumber()
447     {
448         Token token = Token.floatNumber( LINE,
449                                          COLUMN,
450                                          "42.84" );
451 
452         assertToken( token,
453                      Token.FLOAT_NUMBER,
454                      "42.84",
455                      "<number>" );
456     }
457 
458     // ----------------------------------------------------------------------
459     // ----------------------------------------------------------------------
460 
461     public void testKeyword_As()
462     {
463         assertKeywordToken( "as",
464                             Token.KEYWORD_AS );
465     }
466 
467     public void testKeyword_Abstract()
468     {
469         assertKeywordToken( "abstract",
470                             Token.KEYWORD_ABSTRACT );
471     }
472 
473     public void testKeyword_Break()
474     {
475         assertKeywordToken( "break",
476                             Token.KEYWORD_BREAK );
477     }
478 
479     public void testKeyword_Case()
480     {
481         assertKeywordToken( "case",
482                             Token.KEYWORD_CASE );
483     }
484 
485     public void testKeyword_Catch()
486     {
487         assertKeywordToken( "catch",
488                             Token.KEYWORD_CATCH );
489     }
490 
491     public void testKeyword_Class()
492     {
493         assertKeywordToken( "class",
494                             Token.KEYWORD_CLASS );
495     }
496 
497     public void testKeyword_Const()
498     {
499         assertKeywordToken( "const",
500                             Token.KEYWORD_CONST );
501     }
502 
503     public void testKeyword_Continue()
504     {
505         assertKeywordToken( "continue",
506                             Token.KEYWORD_CONTINUE );
507     }
508 
509     public void testKeyword_Default()
510     {
511         assertKeywordToken( "default",
512                             Token.KEYWORD_DEFAULT );
513     }
514 
515     public void testKeyword_Do()
516     {
517         assertKeywordToken( "do",
518                             Token.KEYWORD_DO );
519     }
520 
521     public void testKeyword_Else()
522     {
523         assertKeywordToken( "else",
524                             Token.KEYWORD_ELSE );
525     }
526 
527     public void testKeyword_Extends()
528     {
529         assertKeywordToken( "extends",
530                             Token.KEYWORD_EXTENDS );
531     }
532 
533     public void testKeyword_Final()
534     {
535         assertKeywordToken( "final",
536                             Token.KEYWORD_FINAL );
537     }
538 
539     public void testKeyword_Finally()
540     {
541         assertKeywordToken( "finally",
542                             Token.KEYWORD_FINALLY );
543     }
544 
545     public void testKeyword_For()
546     {
547         assertKeywordToken( "for",
548                             Token.KEYWORD_FOR );
549     }
550 
551     public void testKeyword_Goto()
552     {
553         assertKeywordToken( "goto",
554                             Token.KEYWORD_GOTO );
555     }
556 
557     public void testKeyword_If()
558     {
559         assertKeywordToken( "if",
560                             Token.KEYWORD_IF );
561     }
562 
563     public void testKeyword_Implements()
564     {
565         assertKeywordToken( "implements",
566                             Token.KEYWORD_IMPLEMENTS );
567     }
568 
569     public void testKeyword_Import()
570     {
571         assertKeywordToken( "import",
572                             Token.KEYWORD_IMPORT );
573     }
574 
575     public void testKeyword_Instanceof()
576     {
577         assertKeywordToken( "instanceof",
578                             Token.KEYWORD_INSTANCEOF );
579     }
580 
581     public void testKeyword_Interface()
582     {
583         assertKeywordToken( "interface",
584                             Token.KEYWORD_INTERFACE );
585     }
586 
587     public void testKeyword_Native()
588     {
589         assertKeywordToken( "native",
590                             Token.KEYWORD_NATIVE );
591     }
592 
593     public void testKeyword_New()
594     {
595         assertKeywordToken( "new",
596                             Token.KEYWORD_NEW );
597     }
598 
599     public void testKeyword_Package()
600     {
601         assertKeywordToken( "package",
602                             Token.KEYWORD_PACKAGE );
603     }
604 
605     public void testKeyword_Private()
606     {
607         assertKeywordToken( "private",
608                             Token.KEYWORD_PRIVATE );
609     }
610 
611     public void testKeyword_Property()
612     {
613         assertKeywordToken( "property",
614                             Token.KEYWORD_PROPERTY );
615     }
616 
617     public void testKeyword_Protected()
618     {
619         assertKeywordToken( "protected",
620                             Token.KEYWORD_PROTECTED );
621     }
622 
623     public void testKeyword_Public()
624     {
625         assertKeywordToken( "public",
626                             Token.KEYWORD_PUBLIC );
627     }
628 
629     public void testKeyword_Return()
630     {
631         assertKeywordToken( "return",
632                             Token.KEYWORD_RETURN );
633     }
634 
635     public void testKeyword_Static()
636     {
637         assertKeywordToken( "static",
638                             Token.KEYWORD_STATIC );
639     }
640 
641     public void testKeyword_Super()
642     {
643         assertKeywordToken( "super",
644                             Token.KEYWORD_SUPER );
645     }
646 
647     public void testKeyword_Switch()
648     {
649         assertKeywordToken( "switch",
650                             Token.KEYWORD_SWITCH );
651     }
652 
653     public void testKeyword_Synchronized()
654     {
655         assertKeywordToken( "synchronized",
656                             Token.KEYWORD_SYNCHRONIZED );
657     }
658 
659     public void testKeyword_This()
660     {
661         assertKeywordToken( "this",
662                             Token.KEYWORD_THIS );
663     }
664 
665     public void testKeyword_Throw()
666     {
667         assertKeywordToken( "throw",
668                             Token.KEYWORD_THROW );
669     }
670 
671     public void testKeyword_Throws()
672     {
673         assertKeywordToken( "throws",
674                             Token.KEYWORD_THROWS );
675     }
676 
677     public void testKeyword_Try()
678     {
679         assertKeywordToken( "try",
680                             Token.KEYWORD_TRY );
681     }
682 
683     public void testKeyword_While()
684     {
685         assertKeywordToken( "while",
686                             Token.KEYWORD_WHILE );
687     }
688 
689     public void testUniqueKeywordTypes()
690     {
691         Map keywords = Token.getKeywordMap();
692 
693         Set types = new HashSet();
694 
695         types.addAll( keywords.values() );
696 
697         assertEquals( types.size(),
698                       keywords.size() );
699     }
700 
701     public void testUnknownTokenType()
702     {
703         assertEquals( "<unknown>",
704                       Token.getTokenDescription( 6666 ) );
705     }
706 
707     // ----------------------------------------------------------------------
708     // ----------------------------------------------------------------------
709 
710     protected void assertKeywordToken(String text,
711                                       int expectedType)
712     {
713         Token token = Token.keyword( LINE,
714                                      COLUMN,
715                                      text );
716 
717         assertToken( token,
718                      expectedType,
719                      text );
720     }
721 
722     protected void assertToken(Token token,
723                                int type,
724                                String text)
725     {
726         assertToken( token,
727                      type,
728                      text,
729                      '"' + text + '"' );
730     }
731 
732     protected void assertToken(Token token,
733                                int type,
734                                String text,
735                                String description)
736     {
737         assertEquals( type,
738                       token.getType() );
739 
740         assertEquals( text,
741                       token.getText() );
742 
743         assertEquals( description,
744                       token.getDescription() );
745 
746         assertEquals( LINE,
747                       token.getStartLine() );
748 
749         assertEquals( COLUMN,
750                       token.getStartColumn() );
751     }
752     
753 */
754 }