diff --git a/smali/pom.xml b/smali/pom.xml index 60623e51..723f02a3 100644 --- a/smali/pom.xml +++ b/smali/pom.xml @@ -62,6 +62,20 @@ + + expectedTokensTestGrammar + generate-test-sources + + antlr + + + src/test/antlr3 + target/generated-test-sources/antlr3 + + org/jf/smali/expectedTokensTestGrammar.g + + + @@ -77,6 +91,25 @@ + + org.codehaus.mojo + build-helper-maven-plugin + 1.2 + + + add generated test sources + generate-sources + + add-test-source + + + + target/generated-test-sources + + + + + diff --git a/smali/src/test/antlr3/org/jf/smali/expectedTokensTestGrammar.g b/smali/src/test/antlr3/org/jf/smali/expectedTokensTestGrammar.g new file mode 100644 index 00000000..8cc3cf14 --- /dev/null +++ b/smali/src/test/antlr3/org/jf/smali/expectedTokensTestGrammar.g @@ -0,0 +1,153 @@ +/* + * The string related lexical rules are derived from rules from the + * Java 1.6 grammar which can be found here: + * http://openjdk.java.net/projects/compiler-grammar/antlrworks/Java.g + * + * Specifically, these rules: + * + * HEX_PREFIX, HEX_DIGIT, ESCAPE_SEQUENCE, STRING_LITERAL, BASE_STRING_LITERAL + * + * These rules were originally copyrighted by Terence Parr, and are used here in + * accordance with the following license + * + * [The "BSD licence"] + * Copyright (c) 2007-2008 Terence Parr + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * + * The remainder of this grammar is released by me (Ben Gruver) under the + * following license: + * + * [The "BSD licence"] + * Copyright (c) 2010 Ben Gruver + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +grammar expectedTokensTestGrammar; + +@lexer::header { +package org.jf.smali; +} + +@parser::header { +package org.jf.smali; + +import java.util.Collections; +} + +@parser::members { + public static class ExpectedToken { + public final String tokenName; + public final String tokenText; + + public ExpectedToken(String tokenName, String tokenText) { + this.tokenName = tokenName; + this.tokenText = tokenText; + } + + public ExpectedToken(String tokenName) { + this.tokenName = tokenName; + this.tokenText = null; + } + } + + private final ArrayList expectedTokens = new ArrayList(); + + public List getExpectedTokens() { + return Collections.unmodifiableList(expectedTokens); + } +} + + +fragment HEX_DIGIT + : ('0'..'9')|('A'..'F')|('a'..'f'); + +fragment HEX_DIGITS + : HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT; + +fragment ESCAPE_SEQUENCE[StringBuilder sb] + : '\\' + ( + 'b' {sb.append("\b");} + | 't' {sb.append("\t");} + | 'n' {sb.append("\n");} + | 'f' {sb.append("\f");} + | 'r' {sb.append("\r");} + | '\"' {sb.append("\"");} + | '\'' {sb.append("'");} + | '\\' {sb.append("\\");} + | 'u' HEX_DIGITS {sb.append((char)Integer.parseInt($HEX_DIGITS.text, 16));} + ); + + +STRING_LITERAL + @init {StringBuilder sb = new StringBuilder();} + : BASE_STRING_LITERAL[sb] {setText(sb.toString());}; + +fragment BASE_STRING_LITERAL[StringBuilder sb] + : '"' + ( ESCAPE_SEQUENCE[sb] + | ~( '\\' | '"' | '\r' | '\n' ) {sb.append((char)input.LA(-1));} + )* + '"'; + +TOKEN_NAME + : (('a'..'z')|('A' .. 'Z')|'_')+; + +WHITE_SPACE + : (' '|'\t'|'\n'|'\r')+ {$channel = HIDDEN;}; + +top : token*; + +token : TOKEN_NAME ( '(' STRING_LITERAL ')' ) + { + expectedTokens.add(new ExpectedToken($TOKEN_NAME.getText(), $STRING_LITERAL.getText())); + } | + TOKEN_NAME + { + expectedTokens.add(new ExpectedToken($TOKEN_NAME.getText())); + }; \ No newline at end of file diff --git a/smali/src/test/java/LexerTest.java b/smali/src/test/java/LexerTest.java new file mode 100644 index 00000000..411f86e6 --- /dev/null +++ b/smali/src/test/java/LexerTest.java @@ -0,0 +1,167 @@ +/* + * [The "BSD licence"] + * Copyright (c) 2010 Ben Gruver + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +import org.antlr.runtime.ANTLRInputStream; +import org.antlr.runtime.CommonToken; +import org.antlr.runtime.CommonTokenStream; +import org.antlr.runtime.RecognitionException; +import org.jf.smali.*; +import static org.jf.smali.expectedTokensTestGrammarParser.ExpectedToken; +import org.junit.Assert; +import org.junit.Test; + +import java.io.*; +import java.util.HashMap; +import java.util.List; + +public class LexerTest { + private static final HashMap tokenTypesByName; + + static { + tokenTypesByName = new HashMap(); + + for (int i=0; i expectedTokens = expectedTokensParser.getExpectedTokens(); + + InputStream smaliStream = LexerTest.class.getClassLoader().getResourceAsStream(smaliFile); + if (smaliStream == null) { + Assert.fail("Could not load " + smaliFile); + } + smaliFlexLexer lexer = new smaliFlexLexer(smaliStream); + + CommonTokenStream tokenStream = new CommonTokenStream(lexer); + List tokens = tokenStream.getTokens(); + + int expectedTokenIndex = 0; + CommonToken token; + for (int i=0; i= expectedTokens.size()) { + Assert.fail("Too many tokens"); + } + + if (token.getType() == smaliParser.INVALID_TOKEN) { + Assert.assertTrue("Encountered an INVALID_TOKEN not on the error channel", + token.getChannel() == smaliLexer.ERROR_CHANNEL); + } + + ExpectedToken expectedToken = expectedTokens.get(expectedTokenIndex++); + if (!tokenTypesByName.containsKey(expectedToken.tokenName)) { + Assert.fail("Unknown token: " + expectedToken.tokenName); + } + int expectedTokenType = tokenTypesByName.get(expectedToken.tokenName); + + System.out.println(String.format("%s(%s) - %s(%s)", expectedToken.tokenName, expectedToken.tokenText, getTokenName(token.getType()), token.getText())); + + if (token.getType() != expectedTokenType) { + Assert.fail(String.format("Invalid token at index %d. Expecting %s, got %s", + expectedTokenIndex-1, expectedToken.tokenName, getTokenName(token.getType()))); + } + + if (expectedToken.tokenText != null) { + if (!expectedToken.tokenText.equals(token.getText())) { + Assert.fail( + String.format("Invalid token text at index %d. Expecting text \"%s\", got \"%s\"", + expectedTokenIndex - 1, expectedToken.tokenText, token.getText())); + } + } + } + + if (expectedTokenIndex < expectedTokens.size()) { + Assert.fail(String.format("Not enough tokens. Expecting %d tokens, but got %d", expectedTokens.size(), + expectedTokenIndex)); + } + } + + + + private static String getTokenName(int tokenType) { + return smaliParser.tokenNames[tokenType]; + } +} diff --git a/smali/src/test/resources/LexerTest/ByteLiteralTest.smali b/smali/src/test/resources/LexerTest/ByteLiteralTest.smali new file mode 100644 index 00000000..99ad38de --- /dev/null +++ b/smali/src/test/resources/LexerTest/ByteLiteralTest.smali @@ -0,0 +1,47 @@ +0x0T +0x00 +0x1T +0x12 +0x7fT +0x80t +0xFFt +-0x00 +-0x01 +-0x12 +-0x80 +-0x1f +-0x1fT +-0x81 +-0xFF +-0x100 +0 +1t +123 +127T +128 +255 +-0 +-1 +-123 +-123T +-127 +-128 +-129 +-255 +256 +260 +00 +01 +0123t +0177 +0200T +0377 +-00 +-01 +-0123 +-0123t +-177 +-0200 +-0201 +-0377 +-0400 \ No newline at end of file diff --git a/smali/src/test/resources/LexerTest/ByteLiteralTest.tokens b/smali/src/test/resources/LexerTest/ByteLiteralTest.tokens new file mode 100644 index 00000000..921247f7 --- /dev/null +++ b/smali/src/test/resources/LexerTest/ByteLiteralTest.tokens @@ -0,0 +1,47 @@ +BYTE_LITERAL("0x0T") +INTEGER_LITERAL("0x00") +BYTE_LITERAL("0x1T") +INTEGER_LITERAL("0x12") +BYTE_LITERAL("0x7fT") +BYTE_LITERAL("0x80t") +BYTE_LITERAL("0xFFt") +INTEGER_LITERAL("-0x00") +INTEGER_LITERAL("-0x01") +INTEGER_LITERAL("-0x12") +INTEGER_LITERAL("-0x80") +INTEGER_LITERAL("-0x1f") +BYTE_LITERAL("-0x1fT") +INTEGER_LITERAL("-0x81") +INTEGER_LITERAL("-0xFF") +INTEGER_LITERAL("-0x100") +INTEGER_LITERAL("0") +BYTE_LITERAL("1t") +INTEGER_LITERAL("123") +BYTE_LITERAL("127T") +INTEGER_LITERAL("128") +INTEGER_LITERAL("255") +INTEGER_LITERAL("-0") +INTEGER_LITERAL("-1") +INTEGER_LITERAL("-123") +BYTE_LITERAL("-123T") +INTEGER_LITERAL("-127") +INTEGER_LITERAL("-128") +INTEGER_LITERAL("-129") +INTEGER_LITERAL("-255") +INTEGER_LITERAL("256") +INTEGER_LITERAL("260") +INTEGER_LITERAL("00") +INTEGER_LITERAL("01") +BYTE_LITERAL("0123t") +INTEGER_LITERAL("0177") +BYTE_LITERAL("0200T") +INTEGER_LITERAL("0377") +INTEGER_LITERAL("-00") +INTEGER_LITERAL("-01") +INTEGER_LITERAL("-0123") +BYTE_LITERAL("-0123t") +INTEGER_LITERAL("-177") +INTEGER_LITERAL("-0200") +INTEGER_LITERAL("-0201") +INTEGER_LITERAL("-0377") +INTEGER_LITERAL("-0400") \ No newline at end of file diff --git a/smali/src/test/resources/LexerTest/DirectiveTest.smali b/smali/src/test/resources/LexerTest/DirectiveTest.smali new file mode 100644 index 00000000..5ec54d8b --- /dev/null +++ b/smali/src/test/resources/LexerTest/DirectiveTest.smali @@ -0,0 +1,56 @@ + +.class +.super +.implements +.source +.field +.end field +.subannotation +.end subannotation +.annotation +.end annotation +.enum +.method +.end method +.registers +.locals +.array-data +.end array-data +.packed-switch +.end packed-switch +.sparse-switch +.end sparse-switch +.catch +.catchall +.line +.parameter +.end parameter +.local +.end local +.restart local +.prologue +.epilogue + + +.class.super.implements +.class .super .implements +.class .super .implements +.class .super .implements + .class + .super + .implements + + +.blah1234 +.end blah +.local1234 +.super1234 +.super@ +.super.super +.supeer +.end +. +.1234.1234 +. + + diff --git a/smali/src/test/resources/LexerTest/DirectiveTest.tokens b/smali/src/test/resources/LexerTest/DirectiveTest.tokens new file mode 100644 index 00000000..0579ad1b --- /dev/null +++ b/smali/src/test/resources/LexerTest/DirectiveTest.tokens @@ -0,0 +1,64 @@ +CLASS_DIRECTIVE(".class") +SUPER_DIRECTIVE(".super") +IMPLEMENTS_DIRECTIVE(".implements") +SOURCE_DIRECTIVE(".source") +FIELD_DIRECTIVE(".field") +END_FIELD_DIRECTIVE(".end field") +SUBANNOTATION_DIRECTIVE(".subannotation") +END_SUBANNOTATION_DIRECTIVE(".end subannotation") +ANNOTATION_DIRECTIVE(".annotation") +END_ANNOTATION_DIRECTIVE(".end annotation") +ENUM_DIRECTIVE(".enum") +METHOD_DIRECTIVE(".method") +END_METHOD_DIRECTIVE(".end method") +REGISTERS_DIRECTIVE(".registers") +LOCALS_DIRECTIVE(".locals") +ARRAY_DATA_DIRECTIVE(".array-data") +END_ARRAY_DATA_DIRECTIVE(".end array-data") +PACKED_SWITCH_DIRECTIVE(".packed-switch") +END_PACKED_SWITCH_DIRECTIVE(".end packed-switch") +SPARSE_SWITCH_DIRECTIVE(".sparse-switch") +END_SPARSE_SWITCH_DIRECTIVE(".end sparse-switch") +CATCH_DIRECTIVE(".catch") +CATCHALL_DIRECTIVE(".catchall") +LINE_DIRECTIVE(".line") +PARAMETER_DIRECTIVE(".parameter") +END_PARAMETER_DIRECTIVE(".end parameter") +LOCAL_DIRECTIVE(".local") +END_LOCAL_DIRECTIVE(".end local") +RESTART_LOCAL_DIRECTIVE(".restart local") +PROLOGUE_DIRECTIVE(".prologue") +EPILOGUE_DIRECTIVE(".epilogue") + + +CLASS_DIRECTIVE(".class") +SUPER_DIRECTIVE(".super") +IMPLEMENTS_DIRECTIVE(".implements") +CLASS_DIRECTIVE(".class") +SUPER_DIRECTIVE(".super") +IMPLEMENTS_DIRECTIVE(".implements") +CLASS_DIRECTIVE(".class") +SUPER_DIRECTIVE(".super") +IMPLEMENTS_DIRECTIVE(".implements") +CLASS_DIRECTIVE(".class") +SUPER_DIRECTIVE(".super") +IMPLEMENTS_DIRECTIVE(".implements") +CLASS_DIRECTIVE(".class") +SUPER_DIRECTIVE(".super") +IMPLEMENTS_DIRECTIVE(".implements") + + +INVALID_TOKEN(".blah1234") +INVALID_TOKEN(".end blah") +INVALID_TOKEN(".local1234") +INVALID_TOKEN(".super1234") +SUPER_DIRECTIVE(".super") +INVALID_TOKEN("@") +SUPER_DIRECTIVE(".super") +SUPER_DIRECTIVE(".super") +INVALID_TOKEN(".supeer") +INVALID_TOKEN(".end") +INVALID_TOKEN(".") +DOUBLE_LITERAL(".1234") +DOUBLE_LITERAL(".1234") +INVALID_TOKEN(".") \ No newline at end of file diff --git a/smali/src/test/resources/LexerTest/FloatLiteralTest.smali b/smali/src/test/resources/LexerTest/FloatLiteralTest.smali new file mode 100644 index 00000000..71319ffd --- /dev/null +++ b/smali/src/test/resources/LexerTest/FloatLiteralTest.smali @@ -0,0 +1,242 @@ +1234E9 +1234e9 +1234e-9 +-1234e9 +-1234e-9 + +1234E9d +1234e9D +1234e-9d +-1234e9D +-1234e-9d + +1234E9F +1234e9F +1234e-9f +-1234e9F +-1234e-9f + +0x123ABCP1 +0x123ABCp1 +0x123ABCp-1 +-0x123ABCp1 +-0x123ABCp-1 + +0x123ABCP1D +0x123ABCp1D +0x123ABCp-1D +-0x123ABCp1d +-0x123ABCp-1d + +0x123ABCP1f +0x123ABCp1F +0x123ABCp-1f +-0x123ABCp1F +-0x123ABCp-1F + +infinity +-infinity +INFINITY +-INFINITY +InFiNiTy +-InFiNiTy + +infinityd +-infinityD +INFINITYD +-INFINITYD +InFiNiTyd +-InFiNiTyd + +infinityf +-infinityf +INFINITYF +-INFINITYF +InFiNiTyF +-InFiNiTyF + +nan +NAN +NaN +nAn + +nanD +NAND +NaND +nAnd + +nanf +NANf +NaNf +nAnF + +1234. +1234.e10 +1234.2 +1234.2e2 +1234.e-10 +-1234. +-1234.e10 +-1234.2 +-1234.2e2 +-1234.e-10 + +1234.d +1234.e10D +1234.2D +1234.2e2D +1234.e-10D +-1234.D +-1234.e10D +-1234.2d +-1234.2e2d +-1234.e-10D + +1234.F +1234.e10F +1234.2f +1234.2e2f +1234.e-10F +-1234.F +-1234.e10F +-1234.2f +-1234.2e2f +-1234.e-10F + + +.2 +.2e2 +.2e-2 +-.2 +-.2e2 +-.2e-2 + + +.2D +.2e2D +.2e-2D +-.2d +-.2e2d +-.2e-2d + +.2f +.2e2F +.2e-2f +-.2F +-.2e2F +-.2e-2F + +0x12AB.p10 +0x12AB.p-10 +0x12AB.12ABp10 +0x12AB.12ABp-10 +-0x12AB.p10 +-0x12AB.p-10 +-0x12AB.12ABp10 +-0x12AB.12ABp-10 + +0x12AB.p10D +0x12AB.p-10D +0x12AB.12ABp10d +0x12AB.12ABp-10D +-0x12AB.p10D +-0x12AB.p-10d +-0x12AB.12ABp10D +-0x12AB.12ABp-10D + +0x12AB.p10f +0x12AB.p-10f +0x12AB.12ABp10f +0x12AB.12ABp-10f +-0x12AB.p10f +-0x12AB.p-10f +-0x12AB.12ABp10f +-0x12AB.12ABp-10F + +0x.12ABp10 +0x.12ABp-10 +-0x.12ABp10 +-0x.12ABp-10 +0x.1234p10 + +0x.12ABp10d +0x.12ABp-10D +-0x.12ABp10D +-0x.12ABp-10D +0x.1234p10D + +0x.12ABp10F +0x.12ABp-10f +-0x.12ABp10f +-0x.12ABp-10f +0x.1234p10f + +1234F +1234f +-1234F +-1234f + + +1234D +1234d +-1234D +-1234d + + + + +1234e +1234eA +1234eZ +1234e- +1234e-A +1234e-Z +-1234e +-1234eA +-1234eZ +-1234e- +-1234e-A +-1234e-Z + +0x123ABCp +0x123ABCpA +0x123ABCpZ +0x123ABCp- +0x123ABCp-A +0x123ABCp-Z +-0x123ABCp +-0x123ABCpA +-0x123ABCpZ +-0x123ABCp- +-0x123ABCp-A +-0x123ABCp-Z +0x123ABCDE1 + +infinitye +-infinitye +infinityp +-infinityp + +nane +NANp +NaNE +nAnP + +1234.e +1234.1234e +1234.e- +-1234.e +-1234.e- +1234.p +1234.p- +-1234.p +-1234.p- + +.1234e +.e10 +.p10 + +1234abcf +1234abcF +1234abcd +1234abcD \ No newline at end of file diff --git a/smali/src/test/resources/LexerTest/FloatLiteralTest.tokens b/smali/src/test/resources/LexerTest/FloatLiteralTest.tokens new file mode 100644 index 00000000..0945971c --- /dev/null +++ b/smali/src/test/resources/LexerTest/FloatLiteralTest.tokens @@ -0,0 +1,241 @@ +DOUBLE_LITERAL_OR_ID("1234E9") +DOUBLE_LITERAL_OR_ID("1234e9") +DOUBLE_LITERAL_OR_ID("1234e-9") +DOUBLE_LITERAL_OR_ID("-1234e9") +DOUBLE_LITERAL_OR_ID("-1234e-9") + +DOUBLE_LITERAL_OR_ID("1234E9d") +DOUBLE_LITERAL_OR_ID("1234e9D") +DOUBLE_LITERAL_OR_ID("1234e-9d") +DOUBLE_LITERAL_OR_ID("-1234e9D") +DOUBLE_LITERAL_OR_ID("-1234e-9d") + +FLOAT_LITERAL_OR_ID("1234E9F") +FLOAT_LITERAL_OR_ID("1234e9F") +FLOAT_LITERAL_OR_ID("1234e-9f") +FLOAT_LITERAL_OR_ID("-1234e9F") +FLOAT_LITERAL_OR_ID("-1234e-9f") + +DOUBLE_LITERAL_OR_ID("0x123ABCP1") +DOUBLE_LITERAL_OR_ID("0x123ABCp1") +DOUBLE_LITERAL_OR_ID("0x123ABCp-1") +DOUBLE_LITERAL_OR_ID("-0x123ABCp1") +DOUBLE_LITERAL_OR_ID("-0x123ABCp-1") + +DOUBLE_LITERAL_OR_ID("0x123ABCP1D") +DOUBLE_LITERAL_OR_ID("0x123ABCp1D") +DOUBLE_LITERAL_OR_ID("0x123ABCp-1D") +DOUBLE_LITERAL_OR_ID("-0x123ABCp1d") +DOUBLE_LITERAL_OR_ID("-0x123ABCp-1d") + +FLOAT_LITERAL_OR_ID("0x123ABCP1f") +FLOAT_LITERAL_OR_ID("0x123ABCp1F") +FLOAT_LITERAL_OR_ID("0x123ABCp-1f") +FLOAT_LITERAL_OR_ID("-0x123ABCp1F") +FLOAT_LITERAL_OR_ID("-0x123ABCp-1F") + +DOUBLE_LITERAL_OR_ID("infinity") +DOUBLE_LITERAL_OR_ID("-infinity") +DOUBLE_LITERAL_OR_ID("INFINITY") +DOUBLE_LITERAL_OR_ID("-INFINITY") +DOUBLE_LITERAL_OR_ID("InFiNiTy") +DOUBLE_LITERAL_OR_ID("-InFiNiTy") + +DOUBLE_LITERAL_OR_ID("infinityd") +DOUBLE_LITERAL_OR_ID("-infinityD") +DOUBLE_LITERAL_OR_ID("INFINITYD") +DOUBLE_LITERAL_OR_ID("-INFINITYD") +DOUBLE_LITERAL_OR_ID("InFiNiTyd") +DOUBLE_LITERAL_OR_ID("-InFiNiTyd") + +FLOAT_LITERAL_OR_ID("infinityf") +FLOAT_LITERAL_OR_ID("-infinityf") +FLOAT_LITERAL_OR_ID("INFINITYF") +FLOAT_LITERAL_OR_ID("-INFINITYF") +FLOAT_LITERAL_OR_ID("InFiNiTyF") +FLOAT_LITERAL_OR_ID("-InFiNiTyF") + +DOUBLE_LITERAL_OR_ID("nan") +DOUBLE_LITERAL_OR_ID("NAN") +DOUBLE_LITERAL_OR_ID("NaN") +DOUBLE_LITERAL_OR_ID("nAn") + +DOUBLE_LITERAL_OR_ID("nanD") +DOUBLE_LITERAL_OR_ID("NAND") +DOUBLE_LITERAL_OR_ID("NaND") +DOUBLE_LITERAL_OR_ID("nAnd") + +FLOAT_LITERAL_OR_ID("nanf") +FLOAT_LITERAL_OR_ID("NANf") +FLOAT_LITERAL_OR_ID("NaNf") +FLOAT_LITERAL_OR_ID("nAnF") + +DOUBLE_LITERAL("1234.") +DOUBLE_LITERAL("1234.e10") +DOUBLE_LITERAL("1234.2") +DOUBLE_LITERAL("1234.2e2") +DOUBLE_LITERAL("1234.e-10") +DOUBLE_LITERAL("-1234.") +DOUBLE_LITERAL("-1234.e10") +DOUBLE_LITERAL("-1234.2") +DOUBLE_LITERAL("-1234.2e2") +DOUBLE_LITERAL("-1234.e-10") + +DOUBLE_LITERAL("1234.d") +DOUBLE_LITERAL("1234.e10D") +DOUBLE_LITERAL("1234.2D") +DOUBLE_LITERAL("1234.2e2D") +DOUBLE_LITERAL("1234.e-10D") +DOUBLE_LITERAL("-1234.D") +DOUBLE_LITERAL("-1234.e10D") +DOUBLE_LITERAL("-1234.2d") +DOUBLE_LITERAL("-1234.2e2d") +DOUBLE_LITERAL("-1234.e-10D") + +FLOAT_LITERAL("1234.F") +FLOAT_LITERAL("1234.e10F") +FLOAT_LITERAL("1234.2f") +FLOAT_LITERAL("1234.2e2f") +FLOAT_LITERAL("1234.e-10F") +FLOAT_LITERAL("-1234.F") +FLOAT_LITERAL("-1234.e10F") +FLOAT_LITERAL("-1234.2f") +FLOAT_LITERAL("-1234.2e2f") +FLOAT_LITERAL("-1234.e-10F") + + +DOUBLE_LITERAL(".2") +DOUBLE_LITERAL(".2e2") +DOUBLE_LITERAL(".2e-2") +DOUBLE_LITERAL("-.2") +DOUBLE_LITERAL("-.2e2") +DOUBLE_LITERAL("-.2e-2") + + +DOUBLE_LITERAL(".2D") +DOUBLE_LITERAL(".2e2D") +DOUBLE_LITERAL(".2e-2D") +DOUBLE_LITERAL("-.2d") +DOUBLE_LITERAL("-.2e2d") +DOUBLE_LITERAL("-.2e-2d") + +FLOAT_LITERAL(".2f") +FLOAT_LITERAL(".2e2F") +FLOAT_LITERAL(".2e-2f") +FLOAT_LITERAL("-.2F") +FLOAT_LITERAL("-.2e2F") +FLOAT_LITERAL("-.2e-2F") + +DOUBLE_LITERAL("0x12AB.p10") +DOUBLE_LITERAL("0x12AB.p-10") +DOUBLE_LITERAL("0x12AB.12ABp10") +DOUBLE_LITERAL("0x12AB.12ABp-10") +DOUBLE_LITERAL("-0x12AB.p10") +DOUBLE_LITERAL("-0x12AB.p-10") +DOUBLE_LITERAL("-0x12AB.12ABp10") +DOUBLE_LITERAL("-0x12AB.12ABp-10") + +DOUBLE_LITERAL("0x12AB.p10D") +DOUBLE_LITERAL("0x12AB.p-10D") +DOUBLE_LITERAL("0x12AB.12ABp10d") +DOUBLE_LITERAL("0x12AB.12ABp-10D") +DOUBLE_LITERAL("-0x12AB.p10D") +DOUBLE_LITERAL("-0x12AB.p-10d") +DOUBLE_LITERAL("-0x12AB.12ABp10D") +DOUBLE_LITERAL("-0x12AB.12ABp-10D") + +FLOAT_LITERAL("0x12AB.p10f") +FLOAT_LITERAL("0x12AB.p-10f") +FLOAT_LITERAL("0x12AB.12ABp10f") +FLOAT_LITERAL("0x12AB.12ABp-10f") +FLOAT_LITERAL("-0x12AB.p10f") +FLOAT_LITERAL("-0x12AB.p-10f") +FLOAT_LITERAL("-0x12AB.12ABp10f") +FLOAT_LITERAL("-0x12AB.12ABp-10F") + +DOUBLE_LITERAL("0x.12ABp10") +DOUBLE_LITERAL("0x.12ABp-10") +DOUBLE_LITERAL("-0x.12ABp10") +DOUBLE_LITERAL("-0x.12ABp-10") +DOUBLE_LITERAL("0x.1234p10") + +DOUBLE_LITERAL("0x.12ABp10d") +DOUBLE_LITERAL("0x.12ABp-10D") +DOUBLE_LITERAL("-0x.12ABp10D") +DOUBLE_LITERAL("-0x.12ABp-10D") +DOUBLE_LITERAL("0x.1234p10D") + +FLOAT_LITERAL("0x.12ABp10F") +FLOAT_LITERAL("0x.12ABp-10f") +FLOAT_LITERAL("-0x.12ABp10f") +FLOAT_LITERAL("-0x.12ABp-10f") +FLOAT_LITERAL("0x.1234p10f") + +FLOAT_LITERAL_OR_ID("1234F") +FLOAT_LITERAL_OR_ID("1234f") +FLOAT_LITERAL_OR_ID("-1234F") +FLOAT_LITERAL_OR_ID("-1234f") + +DOUBLE_LITERAL_OR_ID("1234D") +DOUBLE_LITERAL_OR_ID("1234d") +DOUBLE_LITERAL_OR_ID("-1234D") +DOUBLE_LITERAL_OR_ID("-1234d") + + + + +SIMPLE_NAME("1234e") +SIMPLE_NAME("1234eA") +SIMPLE_NAME("1234eZ") +SIMPLE_NAME("1234e-") +SIMPLE_NAME("1234e-A") +SIMPLE_NAME("1234e-Z") +SIMPLE_NAME("-1234e") +SIMPLE_NAME("-1234eA") +SIMPLE_NAME("-1234eZ") +SIMPLE_NAME("-1234e-") +SIMPLE_NAME("-1234e-A") +SIMPLE_NAME("-1234e-Z") + +SIMPLE_NAME("0x123ABCp") +SIMPLE_NAME("0x123ABCpA") +SIMPLE_NAME("0x123ABCpZ") +SIMPLE_NAME("0x123ABCp-") +SIMPLE_NAME("0x123ABCp-A") +SIMPLE_NAME("0x123ABCp-Z") +SIMPLE_NAME("-0x123ABCp") +SIMPLE_NAME("-0x123ABCpA") +SIMPLE_NAME("-0x123ABCpZ") +SIMPLE_NAME("-0x123ABCp-") +SIMPLE_NAME("-0x123ABCp-A") +SIMPLE_NAME("-0x123ABCp-Z") +INTEGER_LITERAL("0x123ABCDE1") + +SIMPLE_NAME("infinitye") +SIMPLE_NAME("-infinitye") +SIMPLE_NAME("infinityp") +SIMPLE_NAME("-infinityp") + +SIMPLE_NAME("nane") +SIMPLE_NAME("NANp") +SIMPLE_NAME("NaNE") +SIMPLE_NAME("nAnP") + +DOUBLE_LITERAL("1234.") SIMPLE_NAME("e") +DOUBLE_LITERAL("1234.1234") SIMPLE_NAME("e") +DOUBLE_LITERAL("1234.") SIMPLE_NAME("e-") +DOUBLE_LITERAL("-1234.") SIMPLE_NAME("e") +DOUBLE_LITERAL("-1234.") SIMPLE_NAME("e-") +DOUBLE_LITERAL("1234.") SIMPLE_NAME("p") +DOUBLE_LITERAL("1234.") SIMPLE_NAME("p-") +DOUBLE_LITERAL("-1234.") SIMPLE_NAME("p") +DOUBLE_LITERAL("-1234.") SIMPLE_NAME("p-") + +DOUBLE_LITERAL(".1234") SIMPLE_NAME("e") +INVALID_TOKEN(".e10") +INVALID_TOKEN(".p10") + +SIMPLE_NAME("1234abcf") +SIMPLE_NAME("1234abcF") +SIMPLE_NAME("1234abcd") +SIMPLE_NAME("1234abcD") \ No newline at end of file diff --git a/smali/src/test/resources/LexerTest/IntegerLiteralTest.smali b/smali/src/test/resources/LexerTest/IntegerLiteralTest.smali new file mode 100644 index 00000000..68eae042 --- /dev/null +++ b/smali/src/test/resources/LexerTest/IntegerLiteralTest.smali @@ -0,0 +1,45 @@ +0x0 +0x00 +0x1 +0x12345678 +0x7fffffff +0x80000000 +0xFFFFFFFF +-0x00 +-0x01 +-0x12345678 +-0x80000000 +-0x1FFFFFFF +-0x80000001 +-0xFFFFFFFF +-0x100000000 +0 +1 +1234567890 +2147483647 +2147483648 +4294967295 +-0 +-1 +-1234567890 +-2147483647 +-2147483648 +-2147483649 +-4294967295 +4294967295 +4294967300 +8589934592 +00 +01 +012345670123 +017777777777 +020000000000 +037777777777 +-00 +-01 +-012345670123 +-017777777777 +-020000000000 +-020000000001 +-037777777777 +0400000000000 \ No newline at end of file diff --git a/smali/src/test/resources/LexerTest/IntegerLiteralTest.tokens b/smali/src/test/resources/LexerTest/IntegerLiteralTest.tokens new file mode 100644 index 00000000..b829c396 --- /dev/null +++ b/smali/src/test/resources/LexerTest/IntegerLiteralTest.tokens @@ -0,0 +1,45 @@ +INTEGER_LITERAL("0x0") +INTEGER_LITERAL("0x00") +INTEGER_LITERAL("0x1") +INTEGER_LITERAL("0x12345678") +INTEGER_LITERAL("0x7fffffff") +INTEGER_LITERAL("0x80000000") +INTEGER_LITERAL("0xFFFFFFFF") +INTEGER_LITERAL("-0x00") +INTEGER_LITERAL("-0x01") +INTEGER_LITERAL("-0x12345678") +INTEGER_LITERAL("-0x80000000") +INTEGER_LITERAL("-0x1FFFFFFF") +INTEGER_LITERAL("-0x80000001") +INTEGER_LITERAL("-0xFFFFFFFF") +INTEGER_LITERAL("-0x100000000") +INTEGER_LITERAL("0") +INTEGER_LITERAL("1") +INTEGER_LITERAL("1234567890") +INTEGER_LITERAL("2147483647") +INTEGER_LITERAL("2147483648") +INTEGER_LITERAL("4294967295") +INTEGER_LITERAL("-0") +INTEGER_LITERAL("-1") +INTEGER_LITERAL("-1234567890") +INTEGER_LITERAL("-2147483647") +INTEGER_LITERAL("-2147483648") +INTEGER_LITERAL("-2147483649") +INTEGER_LITERAL("-4294967295") +INTEGER_LITERAL("4294967295") +INTEGER_LITERAL("4294967300") +INTEGER_LITERAL("8589934592") +INTEGER_LITERAL("00") +INTEGER_LITERAL("01") +INTEGER_LITERAL("012345670123") +INTEGER_LITERAL("017777777777") +INTEGER_LITERAL("020000000000") +INTEGER_LITERAL("037777777777") +INTEGER_LITERAL("-00") +INTEGER_LITERAL("-01") +INTEGER_LITERAL("-012345670123") +INTEGER_LITERAL("-017777777777") +INTEGER_LITERAL("-020000000000") +INTEGER_LITERAL("-020000000001") +INTEGER_LITERAL("-037777777777") +INTEGER_LITERAL("0400000000000") \ No newline at end of file diff --git a/smali/src/test/resources/LexerTest/LongLiteralTest.smali b/smali/src/test/resources/LexerTest/LongLiteralTest.smali new file mode 100644 index 00000000..0cde8545 --- /dev/null +++ b/smali/src/test/resources/LexerTest/LongLiteralTest.smali @@ -0,0 +1,48 @@ +0x0L +0x00L +0x1L +0x1234567890123456L +0x7fffffffffffffffL +0x8000000000000000L +0xFFFFFFFFFFFFFFFFL +-0x00L +-0x01L +-0x1234567890123456L +-0x8000000000000000L +-0x1fffffffffffffffL +-0x8000000000000001 +-0xFFFFFFFFFFFFFFFF +0x10000000000000000 +0L +1 +1234567890123456789 +1234567890123456789L +9223372036854775807 +9223372036854775808 +18446744073709551615L +-0 +-1 +-1234567890123456789 +-1234567890123456789L +-9223372036854775807 +-9223372036854775808 +-9223372036854775809 +-18446744073709551616 +18446744073709551617 +18446744073709551700 +00 +01 +0123456701234567012345 +0123456701234567012345L +0777777777777777777777 +0100000000000000000000 +0177777777777777777777 +-00 +-01 +-0123456701234567012345 +-0123456701234567012345L +-0777777777777777777777 +-0100000000000000000000 +-0100000000000000000001 +-0177777777777777777777 +-02000000000000000000000 \ No newline at end of file diff --git a/smali/src/test/resources/LexerTest/LongLiteralTest.tokens b/smali/src/test/resources/LexerTest/LongLiteralTest.tokens new file mode 100644 index 00000000..f8ab03e8 --- /dev/null +++ b/smali/src/test/resources/LexerTest/LongLiteralTest.tokens @@ -0,0 +1,48 @@ +LONG_LITERAL("0x0L") +LONG_LITERAL("0x00L") +LONG_LITERAL("0x1L") +LONG_LITERAL("0x1234567890123456L") +LONG_LITERAL("0x7fffffffffffffffL") +LONG_LITERAL("0x8000000000000000L") +LONG_LITERAL("0xFFFFFFFFFFFFFFFFL") +LONG_LITERAL("-0x00L") +LONG_LITERAL("-0x01L") +LONG_LITERAL("-0x1234567890123456L") +LONG_LITERAL("-0x8000000000000000L") +LONG_LITERAL("-0x1fffffffffffffffL") +INTEGER_LITERAL("-0x8000000000000001") +INTEGER_LITERAL("-0xFFFFFFFFFFFFFFFF") +INTEGER_LITERAL("0x10000000000000000") +LONG_LITERAL("0L") +INTEGER_LITERAL("1") +INTEGER_LITERAL("1234567890123456789") +LONG_LITERAL("1234567890123456789L") +INTEGER_LITERAL("9223372036854775807") +INTEGER_LITERAL("9223372036854775808") +LONG_LITERAL("18446744073709551615L") +INTEGER_LITERAL("-0") +INTEGER_LITERAL("-1") +INTEGER_LITERAL("-1234567890123456789") +LONG_LITERAL("-1234567890123456789L") +INTEGER_LITERAL("-9223372036854775807") +INTEGER_LITERAL("-9223372036854775808") +INTEGER_LITERAL("-9223372036854775809") +INTEGER_LITERAL("-18446744073709551616") +INTEGER_LITERAL("18446744073709551617") +INTEGER_LITERAL("18446744073709551700") +INTEGER_LITERAL("00") +INTEGER_LITERAL("01") +INTEGER_LITERAL("0123456701234567012345") +LONG_LITERAL("0123456701234567012345L") +INTEGER_LITERAL("0777777777777777777777") +INTEGER_LITERAL("0100000000000000000000") +INTEGER_LITERAL("0177777777777777777777") +INTEGER_LITERAL("-00") +INTEGER_LITERAL("-01") +INTEGER_LITERAL("-0123456701234567012345") +LONG_LITERAL("-0123456701234567012345L") +INTEGER_LITERAL("-0777777777777777777777") +INTEGER_LITERAL("-0100000000000000000000") +INTEGER_LITERAL("-0100000000000000000001") +INTEGER_LITERAL("-0177777777777777777777") +INTEGER_LITERAL("-02000000000000000000000") \ No newline at end of file diff --git a/smali/src/test/resources/LexerTest/ShortLiteralTest.smali b/smali/src/test/resources/LexerTest/ShortLiteralTest.smali new file mode 100644 index 00000000..b5bfbbf1 --- /dev/null +++ b/smali/src/test/resources/LexerTest/ShortLiteralTest.smali @@ -0,0 +1,49 @@ +0x0S +0x00 +0x1s +0x1234 +0x7fffS +0x8000s +0xFFFF +-0x00 +-0x01 +-01234 +-01234s +-0x8000 +-0x1fff +-0x1fffS +-0x8001 +-0xFFFF +-0x100000 +0 +1 +12345 +12345s +32767 +32678 +65535S +-0 +-1 +-12345S +-32767 +-32768s +-32679s +-65535s +65536 +65600 +00 +01 +012345 +012345s +077777 +0100000 +0177777 +-00 +-01 +-012345 +-012345S +-077777 +-0100000 +-0100001 +-0177777 +0200000 \ No newline at end of file diff --git a/smali/src/test/resources/LexerTest/ShortLiteralTest.tokens b/smali/src/test/resources/LexerTest/ShortLiteralTest.tokens new file mode 100644 index 00000000..d0a1fabf --- /dev/null +++ b/smali/src/test/resources/LexerTest/ShortLiteralTest.tokens @@ -0,0 +1,49 @@ +SHORT_LITERAL("0x0S") +INTEGER_LITERAL("0x00") +SHORT_LITERAL("0x1s") +INTEGER_LITERAL("0x1234") +SHORT_LITERAL("0x7fffS") +SHORT_LITERAL("0x8000s") +INTEGER_LITERAL("0xFFFF") +INTEGER_LITERAL("-0x00") +INTEGER_LITERAL("-0x01") +INTEGER_LITERAL("-01234") +SHORT_LITERAL("-01234s") +INTEGER_LITERAL("-0x8000") +INTEGER_LITERAL("-0x1fff") +SHORT_LITERAL("-0x1fffS") +INTEGER_LITERAL("-0x8001") +INTEGER_LITERAL("-0xFFFF") +INTEGER_LITERAL("-0x100000") +INTEGER_LITERAL("0") +INTEGER_LITERAL("1") +INTEGER_LITERAL("12345") +SHORT_LITERAL("12345s") +INTEGER_LITERAL("32767") +INTEGER_LITERAL("32678") +SHORT_LITERAL("65535S") +INTEGER_LITERAL("-0") +INTEGER_LITERAL("-1") +SHORT_LITERAL("-12345S") +INTEGER_LITERAL("-32767") +SHORT_LITERAL("-32768s") +SHORT_LITERAL("-32679s") +SHORT_LITERAL("-65535s") +INTEGER_LITERAL("65536") +INTEGER_LITERAL("65600") +INTEGER_LITERAL("00") +INTEGER_LITERAL("01") +INTEGER_LITERAL("012345") +SHORT_LITERAL("012345s") +INTEGER_LITERAL("077777") +INTEGER_LITERAL("0100000") +INTEGER_LITERAL("0177777") +INTEGER_LITERAL("-00") +INTEGER_LITERAL("-01") +INTEGER_LITERAL("-012345") +SHORT_LITERAL("-012345S") +INTEGER_LITERAL("-077777") +INTEGER_LITERAL("-0100000") +INTEGER_LITERAL("-0100001") +INTEGER_LITERAL("-0177777") +INTEGER_LITERAL("0200000") \ No newline at end of file