home | career | drupal | java | mac | mysql | perl | scala | uml | unix

Groovy example source code file (TokenTest.java)

This example Groovy source code file (TokenTest.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.

Java - Groovy tags/keywords

groovytestcase, groovytestcase, tokentest, tokentest

The Groovy TokenTest.java source code

package org.codehaus.groovy.syntax;


import groovy.util.GroovyTestCase;

public class TokenTest
        extends GroovyTestCase {

    public void testNothing() {
    }

/*
    private static final int LINE = 11;
    private static final int COLUMN = 33;

    public void testConstruct()
    {
        Token token = new Token( 42,
                                 "forty-two",
                                 11,
                                 22 );

        assertEquals( 42,
                      token.getType() );

        assertEquals( "forty-two",
                      token.getText() );

        assertEquals( 11,
                      token.getStartLine() );

        assertEquals( 22,
                      token.getStartColumn() );
    }

    public void testLeftCurlyBrace()
    {
        Token token = Token.leftCurlyBrace( LINE,
                                            COLUMN );

        assertToken( token,
                     Token.LEFT_CURLY_BRACE,
                     "{" );
    }

    public void testRightCurlyBrace()
    {
        Token token = Token.rightCurlyBrace( LINE,
                                             COLUMN );

        assertToken( token,
                     Token.RIGHT_CURLY_BRACE,
                     "}" );
    }

    public void testLeftSquareBracket()
    {
        Token token = Token.leftSquareBracket( LINE,
                                               COLUMN );

        assertToken( token,
                     Token.LEFT_SQUARE_BRACKET,
                     "[" );
    }

    public void testRightSquareBracket()
    {
        Token token = Token.rightSquareBracket( LINE,
                                                COLUMN );

        assertToken( token,
                     Token.RIGHT_SQUARE_BRACKET,
                     "]" );
    }

    public void testLeftParenthesis()
    {
        Token token = Token.leftParenthesis( LINE,
                                             COLUMN );

        assertToken( token,
                     Token.LEFT_PARENTHESIS,
                     "(" );
    }

    public void testRightParenthesis()
    {
        Token token = Token.rightParenthesis( LINE,
                                              COLUMN );

        assertToken( token,
                     Token.RIGHT_PARENTHESIS,
                     ")" );
    }

    public void testDot()
    {
        Token token = Token.dot( LINE,
                                 COLUMN );

        assertToken( token,
                     Token.DOT,
                     "." );
    }

    public void testDotDot()
    {
        Token token = Token.dotDot( LINE,
                                    COLUMN );

        assertToken( token,
                     Token.DOT_DOT,
                     ".." );
    }

    public void testNot()
    {
        Token token = Token.not( LINE,
                                 COLUMN );

        assertToken( token,
                     Token.NOT,
                     "!" );
    }

    public void testCompareNotEqual()
    {
        Token token = Token.compareNotEqual( LINE,
                                             COLUMN );

        assertToken( token,
                     Token.COMPARE_NOT_EQUAL,
                     "!=" );
    }

    public void testEqual()
    {
        Token token = Token.equal( LINE,
                                   COLUMN );

        assertToken( token,
                     Token.EQUAL,
                     "=" );
    }

    public void testCompareIdentical()
    {
        Token token = Token.compareIdentical( LINE,
                                              COLUMN );

        assertToken( token,
                     Token.COMPARE_IDENTICAL,
                     "===" );
    }

    public void testCompareEqual()
    {
        Token token = Token.compareEqual( LINE,
                                          COLUMN );

        assertToken( token,
                     Token.COMPARE_EQUAL,
                     "==" );
    }

    public void testCompareLessThan()
    {
        Token token = Token.compareLessThan( LINE,
                                             COLUMN );

        assertToken( token,
                     Token.COMPARE_LESS_THAN,
                     "<" );
    }

    public void testCompareLessThanEqual()
    {
        Token token = Token.compareLessThanEqual( LINE,
                                                  COLUMN );

        assertToken( token,
                     Token.COMPARE_LESS_THAN_EQUAL,
                     "<=" );
    }

    public void testCompareGreaterThan()
    {
        Token token = Token.compareGreaterThan( LINE,
                                                COLUMN );

        assertToken( token,
                     Token.COMPARE_GREATER_THAN,
                     ">" );
    }

    public void testCompareGreaterThanEqual()
    {
        Token token = Token.compareGreaterThanEqual( LINE,
                                                     COLUMN );

        assertToken( token,
                     Token.COMPARE_GREATER_THAN_EQUAL,
                     ">=" );
    }

    public void testLogicalOr()
    {
        Token token = Token.logicalOr( LINE,
                                       COLUMN );

        assertToken( token,
                     Token.LOGICAL_OR,
                     "||" );
    }

    public void testLogicalAnd()
    {
        Token token = Token.logicalAnd( LINE,
                                        COLUMN );

        assertToken( token,
                     Token.LOGICAL_AND,
                     "&&" );
    }

    public void testPlus()
    {
        Token token = Token.plus( LINE,
                                  COLUMN );

        assertToken( token,
                     Token.PLUS,
                     "+" );
    }

    public void testPlusPlus()
    {
        Token token = Token.plusPlus( LINE,
                                      COLUMN );

        assertToken( token,
                     Token.PLUS_PLUS,
                     "++" );
    }

    public void testPlusEqual()
    {
        Token token = Token.plusEqual( LINE,
                                       COLUMN );

        assertToken( token,
                     Token.PLUS_EQUAL,
                     "+=" );
    }

    public void testMinus()
    {
        Token token = Token.minus( LINE,
                                   COLUMN );

        assertToken( token,
                     Token.MINUS,
                     "-" );
    }

    public void testMinusMinus()
    {
        Token token = Token.minusMinus( LINE,
                                        COLUMN );

        assertToken( token,
                     Token.MINUS_MINUS,
                     "--" );
    }

    public void testMinusEqual()
    {
        Token token = Token.minusEqual( LINE,
                                        COLUMN );

        assertToken( token,
                     Token.MINUS_EQUAL,
                     "-=" );
    }

    public void testDivide()
    {
        Token token = Token.divide( LINE,
                                    COLUMN );

        assertToken( token,
                     Token.DIVIDE,
                     "/" );
    }

    public void testDivideEqual()
    {
        Token token = Token.divideEqual( LINE,
                                         COLUMN );

        assertToken( token,
                     Token.DIVIDE_EQUAL,
                     "/=" );
    }

    public void testMod()
    {
        Token token = Token.mod( LINE,
                                 COLUMN );

        assertToken( token,
                     Token.MOD,
                     "%" );
    }

    public void testModEqual()
    {
        Token token = Token.modEqual( LINE,
                                      COLUMN );

        assertToken( token,
                     Token.MOD_EQUAL,
                     "%=" );
    }

    public void testMultiply()
    {
        Token token = Token.multiply( LINE,
                                      COLUMN );

        assertToken( token,
                     Token.MULTIPLY,
                     "*" );
    }

    public void testMultiplyEqual()
    {
        Token token = Token.multiplyEqual( LINE,
                                           COLUMN );

        assertToken( token,
                     Token.MULTIPLY_EQUAL,
                     "*=" );
    }

    public void testComma()
    {
        Token token = Token.comma( LINE,
                                   COLUMN );

        assertToken( token,
                     Token.COMMA,
                     "," );
    }

    public void testColon()
    {
        Token token = Token.colon( LINE,
                                   COLUMN );

        assertToken( token,
                     Token.COLON,
                     ":" );
    }

    public void testSemicolon()
    {
        Token token = Token.semicolon( LINE,
                                       COLUMN );

        assertToken( token,
                     Token.SEMICOLON,
                     ";" );
    }

    public void testQuestion()
    {
        Token token = Token.question( LINE,
                                      COLUMN );

        assertToken( token,
                     Token.QUESTION,
                     "?" );
    }

    public void testPipe()
    {
        Token token = Token.pipe( LINE,
                                  COLUMN );

        assertToken( token,
                     Token.PIPE,
                     "|" );
    }

    public void testDoubleQuoteString()
    {
        Token token = Token.doubleQuoteString( LINE,
                                               COLUMN,
                                               "cheese" );

        assertToken( token,
                     Token.DOUBLE_QUOTE_STRING,
                     "cheese",
                     "<string literal>");
    }

    public void testSingleQuoteString()
    {
        Token token = Token.singleQuoteString( LINE,
                                               COLUMN,
                                               "cheese" );

        assertToken( token,
                     Token.SINGLE_QUOTE_STRING,
                     "cheese",
                     "<string literal>" );
    }

    public void testIdentifier()
    {
        Token token = Token.identifier( LINE,
                                        COLUMN,
                                        "cheese" );

        assertToken( token,
                     Token.IDENTIFIER,
                     "cheese",
                     "<identifier>" );
    }

    public void testIntegerNumber()
    {
        Token token = Token.integerNumber( LINE,
                                           COLUMN,
                                           "42" );

        assertToken( token,
                     Token.INTEGER_NUMBER,
                     "42",
                     "<number>" );
    }

    public void testFloatNumber()
    {
        Token token = Token.floatNumber( LINE,
                                         COLUMN,
                                         "42.84" );

        assertToken( token,
                     Token.FLOAT_NUMBER,
                     "42.84",
                     "<number>" );
    }

    // ----------------------------------------------------------------------
    // ----------------------------------------------------------------------

    public void testKeyword_As()
    {
        assertKeywordToken( "as",
                            Token.KEYWORD_AS );
    }

    public void testKeyword_Abstract()
    {
        assertKeywordToken( "abstract",
                            Token.KEYWORD_ABSTRACT );
    }

    public void testKeyword_Break()
    {
        assertKeywordToken( "break",
                            Token.KEYWORD_BREAK );
    }

    public void testKeyword_Case()
    {
        assertKeywordToken( "case",
                            Token.KEYWORD_CASE );
    }

    public void testKeyword_Catch()
    {
        assertKeywordToken( "catch",
                            Token.KEYWORD_CATCH );
    }

    public void testKeyword_Class()
    {
        assertKeywordToken( "class",
                            Token.KEYWORD_CLASS );
    }

    public void testKeyword_Const()
    {
        assertKeywordToken( "const",
                            Token.KEYWORD_CONST );
    }

    public void testKeyword_Continue()
    {
        assertKeywordToken( "continue",
                            Token.KEYWORD_CONTINUE );
    }

    public void testKeyword_Default()
    {
        assertKeywordToken( "default",
                            Token.KEYWORD_DEFAULT );
    }

    public void testKeyword_Do()
    {
        assertKeywordToken( "do",
                            Token.KEYWORD_DO );
    }

    public void testKeyword_Else()
    {
        assertKeywordToken( "else",
                            Token.KEYWORD_ELSE );
    }

    public void testKeyword_Extends()
    {
        assertKeywordToken( "extends",
                            Token.KEYWORD_EXTENDS );
    }

    public void testKeyword_Final()
    {
        assertKeywordToken( "final",
                            Token.KEYWORD_FINAL );
    }

    public void testKeyword_Finally()
    {
        assertKeywordToken( "finally",
                            Token.KEYWORD_FINALLY );
    }

    public void testKeyword_For()
    {
        assertKeywordToken( "for",
                            Token.KEYWORD_FOR );
    }

    public void testKeyword_Goto()
    {
        assertKeywordToken( "goto",
                            Token.KEYWORD_GOTO );
    }

    public void testKeyword_If()
    {
        assertKeywordToken( "if",
                            Token.KEYWORD_IF );
    }

    public void testKeyword_Implements()
    {
        assertKeywordToken( "implements",
                            Token.KEYWORD_IMPLEMENTS );
    }

    public void testKeyword_Import()
    {
        assertKeywordToken( "import",
                            Token.KEYWORD_IMPORT );
    }

    public void testKeyword_Instanceof()
    {
        assertKeywordToken( "instanceof",
                            Token.KEYWORD_INSTANCEOF );
    }

    public void testKeyword_Interface()
    {
        assertKeywordToken( "interface",
                            Token.KEYWORD_INTERFACE );
    }

    public void testKeyword_Native()
    {
        assertKeywordToken( "native",
                            Token.KEYWORD_NATIVE );
    }

    public void testKeyword_New()
    {
        assertKeywordToken( "new",
                            Token.KEYWORD_NEW );
    }

    public void testKeyword_Package()
    {
        assertKeywordToken( "package",
                            Token.KEYWORD_PACKAGE );
    }

    public void testKeyword_Private()
    {
        assertKeywordToken( "private",
                            Token.KEYWORD_PRIVATE );
    }

    public void testKeyword_Property()
    {
        assertKeywordToken( "property",
                            Token.KEYWORD_PROPERTY );
    }

    public void testKeyword_Protected()
    {
        assertKeywordToken( "protected",
                            Token.KEYWORD_PROTECTED );
    }

    public void testKeyword_Public()
    {
        assertKeywordToken( "public",
                            Token.KEYWORD_PUBLIC );
    }

    public void testKeyword_Return()
    {
        assertKeywordToken( "return",
                            Token.KEYWORD_RETURN );
    }

    public void testKeyword_Static()
    {
        assertKeywordToken( "static",
                            Token.KEYWORD_STATIC );
    }

    public void testKeyword_Super()
    {
        assertKeywordToken( "super",
                            Token.KEYWORD_SUPER );
    }

    public void testKeyword_Switch()
    {
        assertKeywordToken( "switch",
                            Token.KEYWORD_SWITCH );
    }

    public void testKeyword_Synchronized()
    {
        assertKeywordToken( "synchronized",
                            Token.KEYWORD_SYNCHRONIZED );
    }

    public void testKeyword_This()
    {
        assertKeywordToken( "this",
                            Token.KEYWORD_THIS );
    }

    public void testKeyword_Throw()
    {
        assertKeywordToken( "throw",
                            Token.KEYWORD_THROW );
    }

    public void testKeyword_Throws()
    {
        assertKeywordToken( "throws",
                            Token.KEYWORD_THROWS );
    }

    public void testKeyword_Try()
    {
        assertKeywordToken( "try",
                            Token.KEYWORD_TRY );
    }

    public void testKeyword_While()
    {
        assertKeywordToken( "while",
                            Token.KEYWORD_WHILE );
    }

    public void testUniqueKeywordTypes()
    {
        Map keywords = Token.getKeywordMap();

        Set types = new HashSet();

        types.addAll( keywords.values() );

        assertEquals( types.size(),
                      keywords.size() );
    }

    public void testUnknownTokenType()
    {
        assertEquals( "<unknown>",
                      Token.getTokenDescription( 6666 ) );
    }

    // ----------------------------------------------------------------------
    // ----------------------------------------------------------------------

    protected void assertKeywordToken(String text,
                                      int expectedType)
    {
        Token token = Token.keyword( LINE,
                                     COLUMN,
                                     text );

        assertToken( token,
                     expectedType,
                     text );
    }

    protected void assertToken(Token token,
                               int type,
                               String text)
    {
        assertToken( token,
                     type,
                     text,
                     '"' + text + '"' );
    }

    protected void assertToken(Token token,
                               int type,
                               String text,
                               String description)
    {
        assertEquals( type,
                      token.getType() );

        assertEquals( text,
                      token.getText() );

        assertEquals( description,
                      token.getDescription() );

        assertEquals( LINE,
                      token.getStartLine() );

        assertEquals( COLUMN,
                      token.getStartColumn() );
    }
    
*/
}

Other Groovy examples (source code examples)

Here is a short list of links related to this Groovy TokenTest.java source code file:

new blog posts

 

Copyright 1998-2013 Alvin Alexander, alvinalexander.com
All Rights Reserved.