tokentest.java

来自「Groovy动态语言 运行在JVM中的动态语言 可以方便的处理业务逻辑变化大的业」· Java 代码 · 共 755 行 · 第 1/2 页

    {
        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() );
    }
    
*/
}