ReVanced/smali
1
0
Fork 0
mirror of https://github.com/revanced/smali.git synced 2025-05-10 19:34:28 +02:00
Code Issues Packages Projects Releases Wiki Activity

Add a framework for lexer tests, plus a preliminary (incomplete) set of tests

Browse Source 
git-svn-id: https://smali.googlecode.com/svn/trunk@744 55b6fa8a-2a1e-11de-a435-ffa8d773f76a
This commit is contained in:
JesusFreke@JesusFreke.com 2010-06-13 20:33:00 +00:00
parent 4c872e9a7c
commit 9f2671f5ff
15 changed files with 1334 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
smali/pom.xml
View File

@ -62,6 +62,20 @@
</includes> </includes>
</configuration> </configuration>
</execution> </execution>
<execution>
<id>expectedTokensTestGrammar</id>
<phase>generate-test-sources</phase>
<goals>
<goal>antlr</goal>
</goals>
<configuration>
<sourceDirectory>src/test/antlr3</sourceDirectory>
<outputDirectory>target/generated-test-sources/antlr3</outputDirectory>
<includes>
<include>org/jf/smali/expectedTokensTestGrammar.g</include>
</includes>
</configuration>
</execution>
</executions> </executions>
</plugin> </plugin>
<plugin> <plugin>
@ -77,6 +91,25 @@
</archive> </archive>
</configuration> </configuration>
</plugin> </plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>build-helper-maven-plugin</artifactId>
<version>1.2</version>
<executions>
<execution>
<id>add generated test sources</id>
<phase>generate-sources</phase>
<goals>
<goal>add-test-source</goal>
</goals>
<configuration>
<sources>
<source>target/generated-test-sources</source>
</sources>
</configuration>
</execution>
</executions>
</plugin>
</plugins> </plugins>
<resources> <resources>
<resource> <resource>

153
smali/src/test/antlr3/org/jf/smali/expectedTokensTestGrammar.g Normal file
View File

@ -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<ExpectedToken> expectedTokens = new ArrayList<ExpectedToken>();
public List<ExpectedToken> 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()));
};

167
smali/src/test/java/LexerTest.java Normal file
View File

@ -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<String, Integer> tokenTypesByName;
static {
tokenTypesByName = new HashMap<String, Integer>();
for (int i=0; i<smaliParser.tokenNames.length; i++) {
tokenTypesByName.put(smaliParser.tokenNames[i], i);
}
}
@Test
public void DirectiveTest() {
runTest("DirectiveTest");
}
@Test
public void ByteLiteralTest() {
runTest("ByteLiteralTest");
}
@Test
public void ShortLiteralTest() {
runTest("ShortLiteralTest");
}
@Test
public void IntegerLiteralTest() {
runTest("IntegerLiteralTest");
}
@Test
public void LongLiteralTest() {
runTest("LongLiteralTest");
}
@Test
public void FloatLiteralTest() {
runTest("FloatLiteralTest");
}
public void runTest(String test) {
String smaliFile = String.format("LexerTest%s%s.smali", File.separatorChar, test);
String tokensFile = String.format("LexerTest%s%s.tokens", File.separatorChar, test);
expectedTokensTestGrammarLexer expectedTokensLexer = null;
try {
expectedTokensLexer = new expectedTokensTestGrammarLexer(new ANTLRInputStream(
LexerTest.class.getClassLoader().getResourceAsStream(tokensFile)));
} catch (IOException ex) {
throw new RuntimeException(ex);
}
CommonTokenStream expectedTokensStream = new CommonTokenStream(expectedTokensLexer);
expectedTokensTestGrammarParser expectedTokensParser =
new expectedTokensTestGrammarParser(expectedTokensStream);
try {
expectedTokensParser.top();
} catch (RecognitionException ex) {
throw new RuntimeException(ex);
}
List<ExpectedToken> 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<tokens.size(); i++) {
token = (CommonToken)tokens.get(i);
if (token.getChannel() == smaliLexer.HIDDEN) {
continue;
}
if (expectedTokenIndex >= 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];
}
}

47
smali/src/test/resources/LexerTest/ByteLiteralTest.smali Normal file
View File

@ -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

47
smali/src/test/resources/LexerTest/ByteLiteralTest.tokens Normal file
View File

@ -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")

56
smali/src/test/resources/LexerTest/DirectiveTest.smali Normal file
View File

@ -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
.

64
smali/src/test/resources/LexerTest/DirectiveTest.tokens Normal file
View File

@ -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(".")

242
smali/src/test/resources/LexerTest/FloatLiteralTest.smali Normal file
View File

@ -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

241
smali/src/test/resources/LexerTest/FloatLiteralTest.tokens Normal file
View File

@ -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")

45
smali/src/test/resources/LexerTest/IntegerLiteralTest.smali Normal file
View File

@ -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

45
smali/src/test/resources/LexerTest/IntegerLiteralTest.tokens Normal file
View File

@ -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")

48
smali/src/test/resources/LexerTest/LongLiteralTest.smali Normal file
View File

@ -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

48
smali/src/test/resources/LexerTest/LongLiteralTest.tokens Normal file
View File

@ -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")

49
smali/src/test/resources/LexerTest/ShortLiteralTest.smali Normal file
View File

@ -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

49
smali/src/test/resources/LexerTest/ShortLiteralTest.tokens Normal file
View File

@ -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")