From 959cb5fd4f9586ec3bd265b452fe25fe1db82e3f Mon Sep 17 00:00:00 2001 From: jeff Date: Tue, 13 Jan 2015 23:25:04 -0500 Subject: source format change don't hate me too much if you were planning a big merge. =P --- test/cuchaz/enigma/EntryFactory.java | 44 ++-- test/cuchaz/enigma/TestDeobfuscator.java | 34 ++- test/cuchaz/enigma/TestInnerClasses.java | 48 ++-- .../enigma/TestJarIndexConstructorReferences.java | 160 ++++++------- .../cuchaz/enigma/TestJarIndexInheritanceTree.java | 254 ++++++++++----------- test/cuchaz/enigma/TestJarIndexLoneClass.java | 168 ++++++-------- test/cuchaz/enigma/TestSourceIndex.java | 36 ++- test/cuchaz/enigma/TestTokensConstructors.java | 137 +++++------ test/cuchaz/enigma/TokenChecker.java | 46 ++-- test/cuchaz/enigma/inputs/Keep.java | 8 +- .../enigma/inputs/constructors/BaseClass.java | 16 +- test/cuchaz/enigma/inputs/constructors/Caller.java | 49 ++-- .../inputs/constructors/DefaultConstructable.java | 3 +- .../enigma/inputs/constructors/SubClass.java | 20 +- .../enigma/inputs/constructors/SubSubClass.java | 9 +- .../enigma/inputs/inheritanceTree/BaseClass.java | 12 +- .../enigma/inputs/inheritanceTree/SubclassA.java | 9 +- .../enigma/inputs/inheritanceTree/SubclassB.java | 19 +- .../inputs/inheritanceTree/SubsubclassAA.java | 17 +- .../enigma/inputs/innerClasses/Anonymous.java | 13 +- .../innerClasses/AnonymousWithScopeArgs.java | 15 +- .../inputs/innerClasses/ConstructorArgs.java | 18 +- test/cuchaz/enigma/inputs/innerClasses/Simple.java | 7 +- test/cuchaz/enigma/inputs/loneClass/LoneClass.java | 10 +- 24 files changed, 510 insertions(+), 642 deletions(-) (limited to 'test') diff --git a/test/cuchaz/enigma/EntryFactory.java b/test/cuchaz/enigma/EntryFactory.java index 5a8a427..d9317ef 100644 --- a/test/cuchaz/enigma/EntryFactory.java +++ b/test/cuchaz/enigma/EntryFactory.java @@ -18,45 +18,37 @@ import cuchaz.enigma.mapping.ConstructorEntry; import cuchaz.enigma.mapping.FieldEntry; import cuchaz.enigma.mapping.MethodEntry; -public class EntryFactory -{ - public static ClassEntry newClass( String name ) - { - return new ClassEntry( name ); +public class EntryFactory { + + public static ClassEntry newClass(String name) { + return new ClassEntry(name); } - public static FieldEntry newField( String className, String fieldName ) - { - return new FieldEntry( newClass( className ), fieldName ); + public static FieldEntry newField(String className, String fieldName) { + return new FieldEntry(newClass(className), fieldName); } - public static MethodEntry newMethod( String className, String methodName, String methodSignature ) - { - return new MethodEntry( newClass( className ), methodName, methodSignature ); + public static MethodEntry newMethod(String className, String methodName, String methodSignature) { + return new MethodEntry(newClass(className), methodName, methodSignature); } - public static ConstructorEntry newConstructor( String className, String signature ) - { - return new ConstructorEntry( newClass( className ), signature ); + public static ConstructorEntry newConstructor(String className, String signature) { + return new ConstructorEntry(newClass(className), signature); } - public static EntryReference newFieldReferenceByMethod( FieldEntry fieldEntry, String callerClassName, String callerName, String callerSignature ) - { - return new EntryReference( fieldEntry, "", newMethod( callerClassName, callerName, callerSignature ) ); + public static EntryReference newFieldReferenceByMethod(FieldEntry fieldEntry, String callerClassName, String callerName, String callerSignature) { + return new EntryReference(fieldEntry, "", newMethod(callerClassName, callerName, callerSignature)); } - public static EntryReference newFieldReferenceByConstructor( FieldEntry fieldEntry, String callerClassName, String callerSignature ) - { - return new EntryReference( fieldEntry, "", newConstructor( callerClassName, callerSignature ) ); + public static EntryReference newFieldReferenceByConstructor(FieldEntry fieldEntry, String callerClassName, String callerSignature) { + return new EntryReference(fieldEntry, "", newConstructor(callerClassName, callerSignature)); } - public static EntryReference newBehaviorReferenceByMethod( BehaviorEntry behaviorEntry, String callerClassName, String callerName, String callerSignature ) - { - return new EntryReference( behaviorEntry, "", newMethod( callerClassName, callerName, callerSignature ) ); + public static EntryReference newBehaviorReferenceByMethod(BehaviorEntry behaviorEntry, String callerClassName, String callerName, String callerSignature) { + return new EntryReference(behaviorEntry, "", newMethod(callerClassName, callerName, callerSignature)); } - public static EntryReference newBehaviorReferenceByConstructor( BehaviorEntry behaviorEntry, String callerClassName, String callerSignature ) - { - return new EntryReference( behaviorEntry, "", newConstructor( callerClassName, callerSignature ) ); + public static EntryReference newBehaviorReferenceByConstructor(BehaviorEntry behaviorEntry, String callerClassName, String callerSignature) { + return new EntryReference(behaviorEntry, "", newConstructor(callerClassName, callerSignature)); } } diff --git a/test/cuchaz/enigma/TestDeobfuscator.java b/test/cuchaz/enigma/TestDeobfuscator.java index 71de24a..45d27c4 100644 --- a/test/cuchaz/enigma/TestDeobfuscator.java +++ b/test/cuchaz/enigma/TestDeobfuscator.java @@ -23,40 +23,32 @@ import com.google.common.collect.Lists; import cuchaz.enigma.mapping.ClassEntry; -public class TestDeobfuscator -{ - private Deobfuscator getDeobfuscator( ) - throws IOException - { - return new Deobfuscator( new File( "build/libs/testLoneClass.obf.jar" ) ); +public class TestDeobfuscator { + + private Deobfuscator getDeobfuscator() throws IOException { + return new Deobfuscator(new File("build/libs/testLoneClass.obf.jar")); } @Test - public void loadJar( ) - throws Exception - { + public void loadJar() throws Exception { getDeobfuscator(); } @Test - public void getClasses( ) - throws Exception - { + public void getClasses() throws Exception { Deobfuscator deobfuscator = getDeobfuscator(); List obfClasses = Lists.newArrayList(); List deobfClasses = Lists.newArrayList(); - deobfuscator.getSeparatedClasses( obfClasses, deobfClasses ); - assertEquals( 1, obfClasses.size() ); - assertEquals( "none/a", obfClasses.get( 0 ).getName() ); - assertEquals( 1, deobfClasses.size() ); - assertEquals( "cuchaz/enigma/inputs/Keep", deobfClasses.get( 0 ).getName() ); + deobfuscator.getSeparatedClasses(obfClasses, deobfClasses); + assertEquals(1, obfClasses.size()); + assertEquals("none/a", obfClasses.get(0).getName()); + assertEquals(1, deobfClasses.size()); + assertEquals("cuchaz/enigma/inputs/Keep", deobfClasses.get(0).getName()); } @Test - public void decompileClass( ) - throws Exception - { + public void decompileClass() throws Exception { Deobfuscator deobfuscator = getDeobfuscator(); - deobfuscator.getSource( deobfuscator.getSourceTree( "none/a" ) ); + deobfuscator.getSource(deobfuscator.getSourceTree("none/a")); } } diff --git a/test/cuchaz/enigma/TestInnerClasses.java b/test/cuchaz/enigma/TestInnerClasses.java index a7ee0b6..c84d755 100644 --- a/test/cuchaz/enigma/TestInnerClasses.java +++ b/test/cuchaz/enigma/TestInnerClasses.java @@ -20,8 +20,8 @@ import org.junit.Test; import cuchaz.enigma.analysis.JarIndex; -public class TestInnerClasses -{ +public class TestInnerClasses { + private JarIndex m_index; private static final String AnonymousOuter = "none/a"; @@ -33,42 +33,36 @@ public class TestInnerClasses private static final String AnonymousWithScopeArgsOuter = "none/c"; private static final String AnonymousWithScopeArgsInner = "d"; - public TestInnerClasses( ) - throws Exception - { + public TestInnerClasses() throws Exception { m_index = new JarIndex(); - m_index.indexJar( new JarFile( "build/libs/testInnerClasses.obf.jar" ), true ); + m_index.indexJar(new JarFile("build/libs/testInnerClasses.obf.jar"), true); } @Test - public void simple( ) - { - assertThat( m_index.getOuterClass( SimpleInner ), is( SimpleOuter ) ); - assertThat( m_index.getInnerClasses( SimpleOuter ), containsInAnyOrder( SimpleInner ) ); - assertThat( m_index.isAnonymousClass( SimpleInner ), is( false ) ); + public void simple() { + assertThat(m_index.getOuterClass(SimpleInner), is(SimpleOuter)); + assertThat(m_index.getInnerClasses(SimpleOuter), containsInAnyOrder(SimpleInner)); + assertThat(m_index.isAnonymousClass(SimpleInner), is(false)); } @Test - public void anonymous( ) - { - assertThat( m_index.getOuterClass( AnonymousInner ), is( AnonymousOuter ) ); - assertThat( m_index.getInnerClasses( AnonymousOuter ), containsInAnyOrder( AnonymousInner ) ); - assertThat( m_index.isAnonymousClass( AnonymousInner ), is( true ) ); + public void anonymous() { + assertThat(m_index.getOuterClass(AnonymousInner), is(AnonymousOuter)); + assertThat(m_index.getInnerClasses(AnonymousOuter), containsInAnyOrder(AnonymousInner)); + assertThat(m_index.isAnonymousClass(AnonymousInner), is(true)); } - + @Test - public void constructorArgs( ) - { - assertThat( m_index.getOuterClass( ConstructorArgsInner ), is( ConstructorArgsOuter ) ); - assertThat( m_index.getInnerClasses( ConstructorArgsOuter ), containsInAnyOrder( ConstructorArgsInner ) ); - assertThat( m_index.isAnonymousClass( ConstructorArgsInner ), is( false ) ); + public void constructorArgs() { + assertThat(m_index.getOuterClass(ConstructorArgsInner), is(ConstructorArgsOuter)); + assertThat(m_index.getInnerClasses(ConstructorArgsOuter), containsInAnyOrder(ConstructorArgsInner)); + assertThat(m_index.isAnonymousClass(ConstructorArgsInner), is(false)); } @Test - public void anonymousWithScopeArgs( ) - { - assertThat( m_index.getOuterClass( AnonymousWithScopeArgsInner ), is( AnonymousWithScopeArgsOuter ) ); - assertThat( m_index.getInnerClasses( AnonymousWithScopeArgsOuter ), containsInAnyOrder( AnonymousWithScopeArgsInner ) ); - assertThat( m_index.isAnonymousClass( AnonymousWithScopeArgsInner ), is( true ) ); + public void anonymousWithScopeArgs() { + assertThat(m_index.getOuterClass(AnonymousWithScopeArgsInner), is(AnonymousWithScopeArgsOuter)); + assertThat(m_index.getInnerClasses(AnonymousWithScopeArgsOuter), containsInAnyOrder(AnonymousWithScopeArgsInner)); + assertThat(m_index.isAnonymousClass(AnonymousWithScopeArgsInner), is(true)); } } diff --git a/test/cuchaz/enigma/TestJarIndexConstructorReferences.java b/test/cuchaz/enigma/TestJarIndexConstructorReferences.java index 0238171..b5f4c7f 100644 --- a/test/cuchaz/enigma/TestJarIndexConstructorReferences.java +++ b/test/cuchaz/enigma/TestJarIndexConstructorReferences.java @@ -26,117 +26,99 @@ import cuchaz.enigma.mapping.BehaviorEntry; import cuchaz.enigma.mapping.ClassEntry; import cuchaz.enigma.mapping.ConstructorEntry; -public class TestJarIndexConstructorReferences -{ +public class TestJarIndexConstructorReferences { + private JarIndex m_index; - - private ClassEntry m_baseClass = new ClassEntry( "none/a" ); - private ClassEntry m_subClass = new ClassEntry( "none/d" ); - private ClassEntry m_subsubClass = new ClassEntry( "none/e" ); - private ClassEntry m_defaultClass = new ClassEntry( "none/c" ); - private ClassEntry m_callerClass = new ClassEntry( "none/b" ); - - public TestJarIndexConstructorReferences( ) - throws Exception - { - File jarFile = new File( "build/libs/testConstructors.obf.jar" ); + + private ClassEntry m_baseClass = new ClassEntry("none/a"); + private ClassEntry m_subClass = new ClassEntry("none/d"); + private ClassEntry m_subsubClass = new ClassEntry("none/e"); + private ClassEntry m_defaultClass = new ClassEntry("none/c"); + private ClassEntry m_callerClass = new ClassEntry("none/b"); + + public TestJarIndexConstructorReferences() throws Exception { + File jarFile = new File("build/libs/testConstructors.obf.jar"); m_index = new JarIndex(); - m_index.indexJar( new JarFile( jarFile ), false ); + m_index.indexJar(new JarFile(jarFile), false); } @Test - public void obfEntries( ) - { - assertThat( m_index.getObfClassEntries(), containsInAnyOrder( - newClass( "cuchaz/enigma/inputs/Keep" ), - m_baseClass, - m_subClass, - m_subsubClass, - m_defaultClass, - m_callerClass - ) ); + public void obfEntries() { + assertThat(m_index.getObfClassEntries(), containsInAnyOrder(newClass("cuchaz/enigma/inputs/Keep"), m_baseClass, m_subClass, m_subsubClass, m_defaultClass, m_callerClass)); } @Test - @SuppressWarnings( "unchecked" ) - public void baseDefault( ) - { - BehaviorEntry source = new ConstructorEntry( m_baseClass, "()V" ); - Collection> references = m_index.getBehaviorReferences( source ); - assertThat( references, containsInAnyOrder( - newBehaviorReferenceByMethod( source, m_callerClass.getName(), "a", "()V" ), - newBehaviorReferenceByConstructor( source, m_subClass.getName(), "()V" ), - newBehaviorReferenceByConstructor( source, m_subClass.getName(), "(III)V" ) - ) ); + @SuppressWarnings("unchecked") + public void baseDefault() { + BehaviorEntry source = new ConstructorEntry(m_baseClass, "()V"); + Collection> references = m_index.getBehaviorReferences(source); + assertThat(references, containsInAnyOrder( + newBehaviorReferenceByMethod(source, m_callerClass.getName(), "a", "()V"), + newBehaviorReferenceByConstructor(source, m_subClass.getName(), "()V"), + newBehaviorReferenceByConstructor(source, m_subClass.getName(), "(III)V") + )); } @Test - @SuppressWarnings( "unchecked" ) - public void baseInt( ) - { - BehaviorEntry source = new ConstructorEntry( m_baseClass, "(I)V" ); - assertThat( m_index.getBehaviorReferences( source ), containsInAnyOrder( - newBehaviorReferenceByMethod( source, m_callerClass.getName(), "b", "()V" ) - ) ); + @SuppressWarnings("unchecked") + public void baseInt() { + BehaviorEntry source = new ConstructorEntry(m_baseClass, "(I)V"); + assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder( + newBehaviorReferenceByMethod(source, m_callerClass.getName(), "b", "()V") + )); } - + @Test - @SuppressWarnings( "unchecked" ) - public void subDefault( ) - { - BehaviorEntry source = new ConstructorEntry( m_subClass, "()V" ); - assertThat( m_index.getBehaviorReferences( source ), containsInAnyOrder( - newBehaviorReferenceByMethod( source, m_callerClass.getName(), "c", "()V" ), - newBehaviorReferenceByConstructor( source, m_subClass.getName(), "(I)V" ) - ) ); + @SuppressWarnings("unchecked") + public void subDefault() { + BehaviorEntry source = new ConstructorEntry(m_subClass, "()V"); + assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder( + newBehaviorReferenceByMethod(source, m_callerClass.getName(), "c", "()V"), + newBehaviorReferenceByConstructor(source, m_subClass.getName(), "(I)V") + )); } - + @Test - @SuppressWarnings( "unchecked" ) - public void subInt( ) - { - BehaviorEntry source = new ConstructorEntry( m_subClass, "(I)V" ); - assertThat( m_index.getBehaviorReferences( source ), containsInAnyOrder( - newBehaviorReferenceByMethod( source, m_callerClass.getName(), "d", "()V" ), - newBehaviorReferenceByConstructor( source, m_subClass.getName(), "(II)V" ), - newBehaviorReferenceByConstructor( source, m_subsubClass.getName(), "(I)V" ) - ) ); + @SuppressWarnings("unchecked") + public void subInt() { + BehaviorEntry source = new ConstructorEntry(m_subClass, "(I)V"); + assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder( + newBehaviorReferenceByMethod(source, m_callerClass.getName(), "d", "()V"), + newBehaviorReferenceByConstructor(source, m_subClass.getName(), "(II)V"), + newBehaviorReferenceByConstructor(source, m_subsubClass.getName(), "(I)V") + )); } - + @Test - @SuppressWarnings( "unchecked" ) - public void subIntInt( ) - { - BehaviorEntry source = new ConstructorEntry( m_subClass, "(II)V" ); - assertThat( m_index.getBehaviorReferences( source ), containsInAnyOrder( - newBehaviorReferenceByMethod( source, m_callerClass.getName(), "e", "()V" ) - ) ); + @SuppressWarnings("unchecked") + public void subIntInt() { + BehaviorEntry source = new ConstructorEntry(m_subClass, "(II)V"); + assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder( + newBehaviorReferenceByMethod(source, m_callerClass.getName(), "e", "()V") + )); } - + @Test - public void subIntIntInt( ) - { - BehaviorEntry source = new ConstructorEntry( m_subClass, "(III)V" ); - assertThat( m_index.getBehaviorReferences( source ), is( empty() ) ); + public void subIntIntInt() { + BehaviorEntry source = new ConstructorEntry(m_subClass, "(III)V"); + assertThat(m_index.getBehaviorReferences(source), is(empty())); } - + @Test - @SuppressWarnings( "unchecked" ) - public void subsubInt( ) - { - BehaviorEntry source = new ConstructorEntry( m_subsubClass, "(I)V" ); - assertThat( m_index.getBehaviorReferences( source ), containsInAnyOrder( - newBehaviorReferenceByMethod( source, m_callerClass.getName(), "f", "()V" ) - ) ); + @SuppressWarnings("unchecked") + public void subsubInt() { + BehaviorEntry source = new ConstructorEntry(m_subsubClass, "(I)V"); + assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder( + newBehaviorReferenceByMethod(source, m_callerClass.getName(), "f", "()V") + )); } - + @Test - @SuppressWarnings( "unchecked" ) - public void defaultConstructable( ) - { - BehaviorEntry source = new ConstructorEntry( m_defaultClass, "()V" ); - assertThat( m_index.getBehaviorReferences( source ), containsInAnyOrder( - newBehaviorReferenceByMethod( source, m_callerClass.getName(), "g", "()V" ) - ) ); + @SuppressWarnings("unchecked") + public void defaultConstructable() { + BehaviorEntry source = new ConstructorEntry(m_defaultClass, "()V"); + assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder( + newBehaviorReferenceByMethod(source, m_callerClass.getName(), "g", "()V") + )); } } diff --git a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java index 50c2282..caf6578 100644 --- a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java +++ b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java @@ -30,209 +30,199 @@ import cuchaz.enigma.mapping.ConstructorEntry; import cuchaz.enigma.mapping.FieldEntry; import cuchaz.enigma.mapping.MethodEntry; -public class TestJarIndexInheritanceTree -{ +public class TestJarIndexInheritanceTree { + private JarIndex m_index; - private ClassEntry m_baseClass = new ClassEntry( "none/a" ); - private ClassEntry m_subClassA = new ClassEntry( "none/b" ); - private ClassEntry m_subClassAA = new ClassEntry( "none/d" ); - private ClassEntry m_subClassB = new ClassEntry( "none/c" ); - private FieldEntry m_nameField = new FieldEntry( m_baseClass, "a" ); - private FieldEntry m_numThingsField = new FieldEntry( m_subClassB, "a" ); + private ClassEntry m_baseClass = new ClassEntry("none/a"); + private ClassEntry m_subClassA = new ClassEntry("none/b"); + private ClassEntry m_subClassAA = new ClassEntry("none/d"); + private ClassEntry m_subClassB = new ClassEntry("none/c"); + private FieldEntry m_nameField = new FieldEntry(m_baseClass, "a"); + private FieldEntry m_numThingsField = new FieldEntry(m_subClassB, "a"); - public TestJarIndexInheritanceTree( ) - throws Exception - { + public TestJarIndexInheritanceTree() throws Exception { m_index = new JarIndex(); - m_index.indexJar( new JarFile( "build/libs/testInheritanceTree.obf.jar" ), false ); + m_index.indexJar(new JarFile("build/libs/testInheritanceTree.obf.jar"), false); } @Test - public void obfEntries( ) - { - assertThat( m_index.getObfClassEntries(), containsInAnyOrder( - newClass( "cuchaz/enigma/inputs/Keep" ), + public void obfEntries() { + assertThat(m_index.getObfClassEntries(), containsInAnyOrder( + newClass("cuchaz/enigma/inputs/Keep"), m_baseClass, m_subClassA, m_subClassAA, m_subClassB - ) ); + )); } @Test - public void translationIndex( ) - { + public void translationIndex() { + TranslationIndex index = m_index.getTranslationIndex(); // base class - assertThat( index.getSuperclassName( m_baseClass.getName() ), is( nullValue() ) ); - assertThat( index.getAncestry( m_baseClass.getName() ), is( empty() ) ); - assertThat( index.getSubclassNames( m_baseClass.getName() ), containsInAnyOrder( + assertThat(index.getSuperclassName(m_baseClass.getName()), is(nullValue())); + assertThat(index.getAncestry(m_baseClass.getName()), is(empty())); + assertThat(index.getSubclassNames(m_baseClass.getName()), containsInAnyOrder( m_subClassA.getName(), m_subClassB.getName() - ) ); + )); // subclass a - assertThat( index.getSuperclassName( m_subClassA.getName() ), is( m_baseClass.getName() ) ); - assertThat( index.getAncestry( m_subClassA.getName() ), contains( m_baseClass.getName() ) ); - assertThat( index.getSubclassNames( m_subClassA.getName() ), contains( m_subClassAA.getName() ) ); + assertThat(index.getSuperclassName(m_subClassA.getName()), is(m_baseClass.getName())); + assertThat(index.getAncestry(m_subClassA.getName()), contains(m_baseClass.getName())); + assertThat(index.getSubclassNames(m_subClassA.getName()), contains(m_subClassAA.getName())); // subclass aa - assertThat( index.getSuperclassName( m_subClassAA.getName() ), is( m_subClassA.getName() ) ); - assertThat( index.getAncestry( m_subClassAA.getName() ), contains( - m_subClassA.getName(), - m_baseClass.getName() - ) ); - assertThat( index.getSubclassNames( m_subClassAA.getName() ), is( empty() ) ); + assertThat(index.getSuperclassName(m_subClassAA.getName()), is(m_subClassA.getName())); + assertThat(index.getAncestry(m_subClassAA.getName()), contains(m_subClassA.getName(), m_baseClass.getName())); + assertThat(index.getSubclassNames(m_subClassAA.getName()), is(empty())); // subclass b - assertThat( index.getSuperclassName( m_subClassB.getName() ), is( m_baseClass.getName() ) ); - assertThat( index.getAncestry( m_subClassB.getName() ), contains( m_baseClass.getName() ) ); - assertThat( index.getSubclassNames( m_subClassB.getName() ), is( empty() ) ); + assertThat(index.getSuperclassName(m_subClassB.getName()), is(m_baseClass.getName())); + assertThat(index.getAncestry(m_subClassB.getName()), contains(m_baseClass.getName())); + assertThat(index.getSubclassNames(m_subClassB.getName()), is(empty())); } @Test - public void access( ) - { - assertThat( m_index.getAccess( m_nameField ), is( Access.Private ) ); - assertThat( m_index.getAccess( m_numThingsField ), is( Access.Private ) ); + public void access() { + assertThat(m_index.getAccess(m_nameField), is(Access.Private)); + assertThat(m_index.getAccess(m_numThingsField), is(Access.Private)); } @Test - public void relatedMethodImplementations( ) - { + public void relatedMethodImplementations() { + Set entries; // getName() - entries = m_index.getRelatedMethodImplementations( new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ) ); - assertThat( entries, containsInAnyOrder( - new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ), - new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ) - ) ); - entries = m_index.getRelatedMethodImplementations( new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ) ); - assertThat( entries, containsInAnyOrder( - new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ), - new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ) - ) ); + entries = m_index.getRelatedMethodImplementations(new MethodEntry(m_baseClass, "a", "()Ljava/lang/String;")); + assertThat(entries, containsInAnyOrder( + new MethodEntry(m_baseClass, "a", "()Ljava/lang/String;"), + new MethodEntry(m_subClassAA, "a", "()Ljava/lang/String;") + )); + entries = m_index.getRelatedMethodImplementations(new MethodEntry(m_subClassAA, "a", "()Ljava/lang/String;")); + assertThat(entries, containsInAnyOrder( + new MethodEntry(m_baseClass, "a", "()Ljava/lang/String;"), + new MethodEntry(m_subClassAA, "a", "()Ljava/lang/String;") + )); // doBaseThings() - entries = m_index.getRelatedMethodImplementations( new MethodEntry( m_baseClass, "a", "()V" ) ); - assertThat( entries, containsInAnyOrder( - new MethodEntry( m_baseClass, "a", "()V" ), - new MethodEntry( m_subClassAA, "a", "()V" ), - new MethodEntry( m_subClassB, "a", "()V" ) - ) ); - entries = m_index.getRelatedMethodImplementations( new MethodEntry( m_subClassAA, "a", "()V" ) ); - assertThat( entries, containsInAnyOrder( - new MethodEntry( m_baseClass, "a", "()V" ), - new MethodEntry( m_subClassAA, "a", "()V" ), - new MethodEntry( m_subClassB, "a", "()V" ) - ) ); - entries = m_index.getRelatedMethodImplementations( new MethodEntry( m_subClassB, "a", "()V" ) ); - assertThat( entries, containsInAnyOrder( - new MethodEntry( m_baseClass, "a", "()V" ), - new MethodEntry( m_subClassAA, "a", "()V" ), - new MethodEntry( m_subClassB, "a", "()V" ) - ) ); + entries = m_index.getRelatedMethodImplementations(new MethodEntry(m_baseClass, "a", "()V")); + assertThat(entries, containsInAnyOrder( + new MethodEntry(m_baseClass, "a", "()V"), + new MethodEntry(m_subClassAA, "a", "()V"), + new MethodEntry(m_subClassB, "a", "()V") + )); + entries = m_index.getRelatedMethodImplementations(new MethodEntry(m_subClassAA, "a", "()V")); + assertThat(entries, containsInAnyOrder( + new MethodEntry(m_baseClass, "a", "()V"), + new MethodEntry(m_subClassAA, "a", "()V"), + new MethodEntry(m_subClassB, "a", "()V") + )); + entries = m_index.getRelatedMethodImplementations(new MethodEntry(m_subClassB, "a", "()V")); + assertThat(entries, containsInAnyOrder( + new MethodEntry(m_baseClass, "a", "()V"), + new MethodEntry(m_subClassAA, "a", "()V"), + new MethodEntry(m_subClassB, "a", "()V") + )); // doBThings - entries = m_index.getRelatedMethodImplementations( new MethodEntry( m_subClassB, "b", "()V" ) ); - assertThat( entries, containsInAnyOrder( - new MethodEntry( m_subClassB, "b", "()V" ) - ) ); + entries = m_index.getRelatedMethodImplementations(new MethodEntry(m_subClassB, "b", "()V")); + assertThat(entries, containsInAnyOrder(new MethodEntry(m_subClassB, "b", "()V"))); } @Test - @SuppressWarnings( "unchecked" ) - public void fieldReferences( ) - { + @SuppressWarnings("unchecked") + public void fieldReferences() { Collection> references; // name - references = m_index.getFieldReferences( m_nameField ); - assertThat( references, containsInAnyOrder( - newFieldReferenceByConstructor( m_nameField, m_baseClass.getName(), "(Ljava/lang/String;)V" ), - newFieldReferenceByMethod( m_nameField, m_baseClass.getName(), "a", "()Ljava/lang/String;" ) - ) ); + references = m_index.getFieldReferences(m_nameField); + assertThat(references, containsInAnyOrder( + newFieldReferenceByConstructor(m_nameField, m_baseClass.getName(), "(Ljava/lang/String;)V"), + newFieldReferenceByMethod(m_nameField, m_baseClass.getName(), "a", "()Ljava/lang/String;") + )); // numThings - references = m_index.getFieldReferences( m_numThingsField ); - assertThat( references, containsInAnyOrder( - newFieldReferenceByConstructor( m_numThingsField, m_subClassB.getName(), "()V" ), - newFieldReferenceByMethod( m_numThingsField, m_subClassB.getName(), "b", "()V" ) - ) ); + references = m_index.getFieldReferences(m_numThingsField); + assertThat(references, containsInAnyOrder( + newFieldReferenceByConstructor(m_numThingsField, m_subClassB.getName(), "()V"), + newFieldReferenceByMethod(m_numThingsField, m_subClassB.getName(), "b", "()V") + )); } @Test - @SuppressWarnings( "unchecked" ) - public void behaviorReferences( ) - { + @SuppressWarnings("unchecked") + public void behaviorReferences() { + BehaviorEntry source; Collection> references; // baseClass constructor - source = new ConstructorEntry( m_baseClass, "(Ljava/lang/String;)V" ); - references = m_index.getBehaviorReferences( source ); - assertThat( references, containsInAnyOrder( - newBehaviorReferenceByConstructor( source, m_subClassA.getName(), "(Ljava/lang/String;)V" ), - newBehaviorReferenceByConstructor( source, m_subClassB.getName(), "()V" ) - ) ); + source = new ConstructorEntry(m_baseClass, "(Ljava/lang/String;)V"); + references = m_index.getBehaviorReferences(source); + assertThat(references, containsInAnyOrder( + newBehaviorReferenceByConstructor(source, m_subClassA.getName(), "(Ljava/lang/String;)V"), + newBehaviorReferenceByConstructor(source, m_subClassB.getName(), "()V") + )); // subClassA constructor - source = new ConstructorEntry( m_subClassA, "(Ljava/lang/String;)V" ); - references = m_index.getBehaviorReferences( source ); - assertThat( references, containsInAnyOrder( - newBehaviorReferenceByConstructor( source, m_subClassAA.getName(), "()V" ) - ) ); + source = new ConstructorEntry(m_subClassA, "(Ljava/lang/String;)V"); + references = m_index.getBehaviorReferences(source); + assertThat(references, containsInAnyOrder( + newBehaviorReferenceByConstructor(source, m_subClassAA.getName(), "()V") + )); // baseClass.getName() - source = new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ); - references = m_index.getBehaviorReferences( source ); - assertThat( references, containsInAnyOrder( - newBehaviorReferenceByMethod( source, m_subClassAA.getName(), "a", "()Ljava/lang/String;" ), - newBehaviorReferenceByMethod( source, m_subClassB.getName(), "a", "()V" ) - ) ); + source = new MethodEntry(m_baseClass, "a", "()Ljava/lang/String;"); + references = m_index.getBehaviorReferences(source); + assertThat(references, containsInAnyOrder( + newBehaviorReferenceByMethod(source, m_subClassAA.getName(), "a", "()Ljava/lang/String;"), + newBehaviorReferenceByMethod(source, m_subClassB.getName(), "a", "()V") + )); // subclassAA.getName() - source = new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ); - references = m_index.getBehaviorReferences( source ); - assertThat( references, containsInAnyOrder( - newBehaviorReferenceByMethod( source, m_subClassAA.getName(), "a", "()V" ) - ) ); + source = new MethodEntry(m_subClassAA, "a", "()Ljava/lang/String;"); + references = m_index.getBehaviorReferences(source); + assertThat(references, containsInAnyOrder( + newBehaviorReferenceByMethod(source, m_subClassAA.getName(), "a", "()V") + )); } @Test - public void containsEntries( ) - { + public void containsEntries() { + // classes - assertThat( m_index.containsObfClass( m_baseClass ), is( true ) ); - assertThat( m_index.containsObfClass( m_subClassA ), is( true ) ); - assertThat( m_index.containsObfClass( m_subClassAA ), is( true ) ); - assertThat( m_index.containsObfClass( m_subClassB ), is( true ) ); + assertThat(m_index.containsObfClass(m_baseClass), is(true)); + assertThat(m_index.containsObfClass(m_subClassA), is(true)); + assertThat(m_index.containsObfClass(m_subClassAA), is(true)); + assertThat(m_index.containsObfClass(m_subClassB), is(true)); // fields - assertThat( m_index.containsObfField( m_nameField ), is( true ) ); - assertThat( m_index.containsObfField( m_numThingsField ), is( true ) ); + assertThat(m_index.containsObfField(m_nameField), is(true)); + assertThat(m_index.containsObfField(m_numThingsField), is(true)); // methods // getName() - assertThat( m_index.containsObfBehavior( new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ) ), is( true ) ); - assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassA, "a", "()Ljava/lang/String;" ) ), is( false ) ); - assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ) ), is( true ) ); - assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassB, "a", "()Ljava/lang/String;" ) ), is( false ) ); + assertThat(m_index.containsObfBehavior(new MethodEntry(m_baseClass, "a", "()Ljava/lang/String;")), is(true)); + assertThat(m_index.containsObfBehavior(new MethodEntry(m_subClassA, "a", "()Ljava/lang/String;")), is(false)); + assertThat(m_index.containsObfBehavior(new MethodEntry(m_subClassAA, "a", "()Ljava/lang/String;")), is(true)); + assertThat(m_index.containsObfBehavior(new MethodEntry(m_subClassB, "a", "()Ljava/lang/String;")), is(false)); // doBaseThings() - assertThat( m_index.containsObfBehavior( new MethodEntry( m_baseClass, "a", "()V" ) ), is( true ) ); - assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassA, "a", "()V" ) ), is( false ) ); - assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassAA, "a", "()V" ) ), is( true ) ); - assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassB, "a", "()V" ) ), is( true ) ); + assertThat(m_index.containsObfBehavior(new MethodEntry(m_baseClass, "a", "()V")), is(true)); + assertThat(m_index.containsObfBehavior(new MethodEntry(m_subClassA, "a", "()V")), is(false)); + assertThat(m_index.containsObfBehavior(new MethodEntry(m_subClassAA, "a", "()V")), is(true)); + assertThat(m_index.containsObfBehavior(new MethodEntry(m_subClassB, "a", "()V")), is(true)); // doBThings() - assertThat( m_index.containsObfBehavior( new MethodEntry( m_baseClass, "b", "()V" ) ), is( false ) ); - assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassA, "b", "()V" ) ), is( false ) ); - assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassAA, "b", "()V" ) ), is( false ) ); - assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassB, "b", "()V" ) ), is( true ) ); - + assertThat(m_index.containsObfBehavior(new MethodEntry(m_baseClass, "b", "()V")), is(false)); + assertThat(m_index.containsObfBehavior(new MethodEntry(m_subClassA, "b", "()V")), is(false)); + assertThat(m_index.containsObfBehavior(new MethodEntry(m_subClassAA, "b", "()V")), is(false)); + assertThat(m_index.containsObfBehavior(new MethodEntry(m_subClassB, "b", "()V")), is(true)); + } } diff --git a/test/cuchaz/enigma/TestJarIndexLoneClass.java b/test/cuchaz/enigma/TestJarIndexLoneClass.java index e2a87d0..0575eec 100644 --- a/test/cuchaz/enigma/TestJarIndexLoneClass.java +++ b/test/cuchaz/enigma/TestJarIndexLoneClass.java @@ -33,154 +33,136 @@ import cuchaz.enigma.mapping.FieldEntry; import cuchaz.enigma.mapping.MethodEntry; import cuchaz.enigma.mapping.Translator; -public class TestJarIndexLoneClass -{ +public class TestJarIndexLoneClass { + private JarIndex m_index; - public TestJarIndexLoneClass( ) - throws Exception - { + public TestJarIndexLoneClass() throws Exception { m_index = new JarIndex(); - m_index.indexJar( new JarFile( "build/libs/testLoneClass.obf.jar" ), false ); + m_index.indexJar(new JarFile("build/libs/testLoneClass.obf.jar"), false); } @Test - public void obfEntries( ) - { - assertThat( m_index.getObfClassEntries(), containsInAnyOrder( - newClass( "cuchaz/enigma/inputs/Keep" ), - newClass( "none/a" ) - ) ); + public void obfEntries() { + assertThat(m_index.getObfClassEntries(), containsInAnyOrder( + newClass("cuchaz/enigma/inputs/Keep"), + newClass("none/a") + )); } @Test - public void translationIndex( ) - { - assertThat( m_index.getTranslationIndex().getSuperclassName( "none/a" ), is( nullValue() ) ); - assertThat( m_index.getTranslationIndex().getSuperclassName( "cuchaz/enigma/inputs/Keep" ), is( nullValue() ) ); - assertThat( m_index.getTranslationIndex().getAncestry( "none/a" ), is( empty() ) ); - assertThat( m_index.getTranslationIndex().getAncestry( "cuchaz/enigma/inputs/Keep" ), is( empty() ) ); - assertThat( m_index.getTranslationIndex().getSubclassNames( "none/a" ), is( empty() ) ); - assertThat( m_index.getTranslationIndex().getSubclassNames( "cuchaz/enigma/inputs/Keep" ), is( empty() ) ); + public void translationIndex() { + assertThat(m_index.getTranslationIndex().getSuperclassName("none/a"), is(nullValue())); + assertThat(m_index.getTranslationIndex().getSuperclassName("cuchaz/enigma/inputs/Keep"), is(nullValue())); + assertThat(m_index.getTranslationIndex().getAncestry("none/a"), is(empty())); + assertThat(m_index.getTranslationIndex().getAncestry("cuchaz/enigma/inputs/Keep"), is(empty())); + assertThat(m_index.getTranslationIndex().getSubclassNames("none/a"), is(empty())); + assertThat(m_index.getTranslationIndex().getSubclassNames("cuchaz/enigma/inputs/Keep"), is(empty())); } @Test - public void access( ) - { - assertThat( m_index.getAccess( newField( "none/a", "a" ) ), is( Access.Private ) ); - assertThat( m_index.getAccess( newMethod( "none/a", "a", "()Ljava/lang/String;" ) ), is( Access.Public ) ); - assertThat( m_index.getAccess( newField( "none/a", "b" ) ), is( nullValue() ) ); + public void access() { + assertThat(m_index.getAccess(newField("none/a", "a")), is(Access.Private)); + assertThat(m_index.getAccess(newMethod("none/a", "a", "()Ljava/lang/String;")), is(Access.Public)); + assertThat(m_index.getAccess(newField("none/a", "b")), is(nullValue())); } @Test - public void classInheritance( ) - { - ClassInheritanceTreeNode node = m_index.getClassInheritance( new Translator(), newClass( "none/a" ) ); - assertThat( node, is( not( nullValue() ) ) ); - assertThat( node.getObfClassName(), is( "none/a" ) ); - assertThat( node.getChildCount(), is( 0 ) ); + public void classInheritance() { + ClassInheritanceTreeNode node = m_index.getClassInheritance(new Translator(), newClass("none/a")); + assertThat(node, is(not(nullValue()))); + assertThat(node.getObfClassName(), is("none/a")); + assertThat(node.getChildCount(), is(0)); } - + @Test - public void methodInheritance( ) - { - MethodEntry source = newMethod( "none/a", "a", "()Ljava/lang/String;" ); - MethodInheritanceTreeNode node = m_index.getMethodInheritance( new Translator(), source ); - assertThat( node, is( not( nullValue() ) ) ); - assertThat( node.getMethodEntry(), is( source ) ); - assertThat( node.getChildCount(), is( 0 ) ); + public void methodInheritance() { + MethodEntry source = newMethod("none/a", "a", "()Ljava/lang/String;"); + MethodInheritanceTreeNode node = m_index.getMethodInheritance(new Translator(), source); + assertThat(node, is(not(nullValue()))); + assertThat(node.getMethodEntry(), is(source)); + assertThat(node.getChildCount(), is(0)); } @Test - public void classImplementations( ) - { - ClassImplementationsTreeNode node = m_index.getClassImplementations( new Translator(), newClass( "none/a" ) ); - assertThat( node, is( nullValue() ) ); + public void classImplementations() { + ClassImplementationsTreeNode node = m_index.getClassImplementations(new Translator(), newClass("none/a")); + assertThat(node, is(nullValue())); } @Test - public void methodImplementations( ) - { - MethodEntry source = newMethod( "none/a", "a", "()Ljava/lang/String;" ); - MethodImplementationsTreeNode node = m_index.getMethodImplementations( new Translator(), source ); - assertThat( node, is( nullValue() ) ); + public void methodImplementations() { + MethodEntry source = newMethod("none/a", "a", "()Ljava/lang/String;"); + MethodImplementationsTreeNode node = m_index.getMethodImplementations(new Translator(), source); + assertThat(node, is(nullValue())); } @Test - public void relatedMethodImplementations( ) - { - Set entries = m_index.getRelatedMethodImplementations( newMethod( "none/a", "a", "()Ljava/lang/String;" ) ); - assertThat( entries, containsInAnyOrder( newMethod( "none/a", "a", "()Ljava/lang/String;" ) ) ); + public void relatedMethodImplementations() { + Set entries = m_index.getRelatedMethodImplementations(newMethod("none/a", "a", "()Ljava/lang/String;")); + assertThat(entries, containsInAnyOrder( + newMethod("none/a", "a", "()Ljava/lang/String;") + )); } @Test - @SuppressWarnings( "unchecked" ) - public void fieldReferences( ) - { - FieldEntry source = newField( "none/a", "a" ); - Collection> references = m_index.getFieldReferences( source ); - assertThat( references, containsInAnyOrder( - newFieldReferenceByConstructor( source, "none/a", "(Ljava/lang/String;)V" ), - newFieldReferenceByMethod( source, "none/a", "a", "()Ljava/lang/String;" ) - ) ); + @SuppressWarnings("unchecked") + public void fieldReferences() { + FieldEntry source = newField("none/a", "a"); + Collection> references = m_index.getFieldReferences(source); + assertThat(references, containsInAnyOrder( + newFieldReferenceByConstructor(source, "none/a", "(Ljava/lang/String;)V"), + newFieldReferenceByMethod(source, "none/a", "a", "()Ljava/lang/String;") + )); } @Test - public void behaviorReferences( ) - { - assertThat( m_index.getBehaviorReferences( newMethod( "none/a", "a", "()Ljava/lang/String;" ) ), is( empty() ) ); + public void behaviorReferences() { + assertThat(m_index.getBehaviorReferences(newMethod("none/a", "a", "()Ljava/lang/String;")), is(empty())); } @Test - public void innerClasses( ) - { - assertThat( m_index.getInnerClasses( "none/a" ), is( empty() ) ); + public void innerClasses() { + assertThat(m_index.getInnerClasses("none/a"), is(empty())); } @Test - public void outerClass( ) - { - assertThat( m_index.getOuterClass( "a" ), is( nullValue() ) ); + public void outerClass() { + assertThat(m_index.getOuterClass("a"), is(nullValue())); } @Test - public void isAnonymousClass( ) - { - assertThat( m_index.isAnonymousClass( "none/a" ), is( false ) ); + public void isAnonymousClass() { + assertThat(m_index.isAnonymousClass("none/a"), is(false)); } @Test - public void interfaces( ) - { - assertThat( m_index.getInterfaces( "none/a" ), is( empty() ) ); + public void interfaces() { + assertThat(m_index.getInterfaces("none/a"), is(empty())); } @Test - public void implementingClasses( ) - { - assertThat( m_index.getImplementingClasses( "none/a" ), is( empty() ) ); + public void implementingClasses() { + assertThat(m_index.getImplementingClasses("none/a"), is(empty())); } @Test - public void isInterface( ) - { - assertThat( m_index.isInterface( "none/a" ), is( false ) ); + public void isInterface() { + assertThat(m_index.isInterface("none/a"), is(false)); } @Test - public void bridgeMethods( ) - { - assertThat( m_index.getBridgeMethod( newMethod( "none/a", "a", "()Ljava/lang/String;" ) ), is( nullValue() ) ); + public void bridgeMethods() { + assertThat(m_index.getBridgeMethod(newMethod("none/a", "a", "()Ljava/lang/String;")), is(nullValue())); } @Test - public void contains( ) - { - assertThat( m_index.containsObfClass( newClass( "none/a" ) ), is( true ) ); - assertThat( m_index.containsObfClass( newClass( "none/b" ) ), is( false ) ); - assertThat( m_index.containsObfField( newField( "none/a", "a" ) ), is( true ) ); - assertThat( m_index.containsObfField( newField( "none/a", "b" ) ), is( false ) ); - assertThat( m_index.containsObfBehavior( newMethod( "none/a", "a", "()Ljava/lang/String;" ) ), is( true ) ); - assertThat( m_index.containsObfBehavior( newMethod( "none/a", "b", "()Ljava/lang/String;" ) ), is( false ) ); + public void contains() { + assertThat(m_index.containsObfClass(newClass("none/a")), is(true)); + assertThat(m_index.containsObfClass(newClass("none/b")), is(false)); + assertThat(m_index.containsObfField(newField("none/a", "a")), is(true)); + assertThat(m_index.containsObfField(newField("none/a", "b")), is(false)); + assertThat(m_index.containsObfBehavior(newMethod("none/a", "a", "()Ljava/lang/String;")), is(true)); + assertThat(m_index.containsObfBehavior(newMethod("none/a", "b", "()Ljava/lang/String;")), is(false)); } } diff --git a/test/cuchaz/enigma/TestSourceIndex.java b/test/cuchaz/enigma/TestSourceIndex.java index dc6ca7e..fb385e0 100644 --- a/test/cuchaz/enigma/TestSourceIndex.java +++ b/test/cuchaz/enigma/TestSourceIndex.java @@ -21,35 +21,27 @@ import com.strobel.decompiler.languages.java.ast.CompilationUnit; import cuchaz.enigma.mapping.ClassEntry; -public class TestSourceIndex -{ +public class TestSourceIndex { + @Test - public void indexEverything( ) - throws Exception - { - Deobfuscator deobfuscator = new Deobfuscator( new File( "input/1.8.jar" ) ); + public void indexEverything() throws Exception { + Deobfuscator deobfuscator = new Deobfuscator(new File("input/1.8.jar")); // get all classes that aren't inner classes Set classEntries = Sets.newHashSet(); - for( ClassEntry obfClassEntry : deobfuscator.getJarIndex().getObfClassEntries() ) - { - if( !obfClassEntry.isInnerClass() ) - { - classEntries.add( obfClassEntry ); + for (ClassEntry obfClassEntry : deobfuscator.getJarIndex().getObfClassEntries()) { + if (!obfClassEntry.isInnerClass()) { + classEntries.add(obfClassEntry); } } - for( ClassEntry obfClassEntry : classEntries ) - { - try - { - CompilationUnit tree = deobfuscator.getSourceTree( obfClassEntry.getName() ); - String source = deobfuscator.getSource( tree ); - deobfuscator.getSourceIndex( tree, source ); - } - catch( Throwable t ) - { - throw new Error( "Unable to index " + obfClassEntry, t ); + for (ClassEntry obfClassEntry : classEntries) { + try { + CompilationUnit tree = deobfuscator.getSourceTree(obfClassEntry.getName()); + String source = deobfuscator.getSource(tree); + deobfuscator.getSourceIndex(tree, source); + } catch (Throwable t) { + throw new Error("Unable to index " + obfClassEntry, t); } } } diff --git a/test/cuchaz/enigma/TestTokensConstructors.java b/test/cuchaz/enigma/TestTokensConstructors.java index 2409153..f805a65 100644 --- a/test/cuchaz/enigma/TestTokensConstructors.java +++ b/test/cuchaz/enigma/TestTokensConstructors.java @@ -24,129 +24,116 @@ import org.junit.Test; import cuchaz.enigma.mapping.BehaviorEntry; -public class TestTokensConstructors extends TokenChecker -{ - public TestTokensConstructors( ) - throws Exception - { - super( new File( "build/libs/testConstructors.obf.jar" ) ); +public class TestTokensConstructors extends TokenChecker { + + public TestTokensConstructors() throws Exception { + super(new File("build/libs/testConstructors.obf.jar")); } @Test - public void baseDeclarations( ) - { - assertThat( getDeclarationToken( newConstructor( "none/a", "()V" ) ), is( "a" ) ); - assertThat( getDeclarationToken( newConstructor( "none/a", "(I)V" ) ), is( "a" ) ); + public void baseDeclarations() { + assertThat(getDeclarationToken(newConstructor("none/a", "()V")), is("a")); + assertThat(getDeclarationToken(newConstructor("none/a", "(I)V")), is("a")); } @Test - public void subDeclarations( ) - { - assertThat( getDeclarationToken( newConstructor( "none/d", "()V" ) ), is( "d" ) ); - assertThat( getDeclarationToken( newConstructor( "none/d", "(I)V" ) ), is( "d" ) ); - assertThat( getDeclarationToken( newConstructor( "none/d", "(II)V" ) ), is( "d" ) ); - assertThat( getDeclarationToken( newConstructor( "none/d", "(III)V" ) ), is( "d" ) ); + public void subDeclarations() { + assertThat(getDeclarationToken(newConstructor("none/d", "()V")), is("d")); + assertThat(getDeclarationToken(newConstructor("none/d", "(I)V")), is("d")); + assertThat(getDeclarationToken(newConstructor("none/d", "(II)V")), is("d")); + assertThat(getDeclarationToken(newConstructor("none/d", "(III)V")), is("d")); } @Test - public void subsubDeclarations( ) - { - assertThat( getDeclarationToken( newConstructor( "none/e", "(I)V" ) ), is( "e" ) ); + public void subsubDeclarations() { + assertThat(getDeclarationToken(newConstructor("none/e", "(I)V")), is("e")); } @Test - public void defaultDeclarations( ) - { - assertThat( getDeclarationToken( newConstructor( "none/c", "()V" ) ), nullValue() ); + public void defaultDeclarations() { + assertThat(getDeclarationToken(newConstructor("none/c", "()V")), nullValue()); } @Test - public void baseDefaultReferences( ) - { - BehaviorEntry source = newConstructor( "none/a", "()V" ); + public void baseDefaultReferences() { + BehaviorEntry source = newConstructor("none/a", "()V"); assertThat( - getReferenceTokens( newBehaviorReferenceByMethod( source, "none/b", "a", "()V" ) ), - containsInAnyOrder( "a" ) + getReferenceTokens(newBehaviorReferenceByMethod(source, "none/b", "a", "()V")), + containsInAnyOrder("a") ); assertThat( - getReferenceTokens( newBehaviorReferenceByConstructor( source, "none/d", "()V" ) ), - containsInAnyOrder( "super" ) // implicit call, decompiled to "super" + getReferenceTokens(newBehaviorReferenceByConstructor(source, "none/d", "()V")), + containsInAnyOrder("super") // implicit call, decompiled to "super" ); assertThat( - getReferenceTokens( newBehaviorReferenceByConstructor( source, "none/d", "(III)V" ) ), - containsInAnyOrder( "super" ) // implicit call, decompiled to "super" + getReferenceTokens(newBehaviorReferenceByConstructor(source, "none/d", "(III)V")), + containsInAnyOrder("super") // implicit call, decompiled to "super" ); } @Test - public void baseIntReferences( ) - { - BehaviorEntry source = newConstructor( "none/a", "(I)V" ); + public void baseIntReferences() { + BehaviorEntry source = newConstructor("none/a", "(I)V"); assertThat( - getReferenceTokens( newBehaviorReferenceByMethod( source, "none/b", "b", "()V" ) ), - containsInAnyOrder( "a" ) + getReferenceTokens(newBehaviorReferenceByMethod(source, "none/b", "b", "()V")), + containsInAnyOrder("a") ); } - + @Test - public void subDefaultReferences( ) - { - BehaviorEntry source = newConstructor( "none/d", "()V" ); + public void subDefaultReferences() { + BehaviorEntry source = newConstructor("none/d", "()V"); assertThat( - getReferenceTokens( newBehaviorReferenceByMethod( source, "none/b", "c", "()V" ) ), - containsInAnyOrder( "d" ) + getReferenceTokens(newBehaviorReferenceByMethod(source, "none/b", "c", "()V")), + containsInAnyOrder("d") ); assertThat( - getReferenceTokens( newBehaviorReferenceByConstructor( source, "none/d", "(I)V" ) ), - containsInAnyOrder( "this" ) + getReferenceTokens(newBehaviorReferenceByConstructor(source, "none/d", "(I)V")), + containsInAnyOrder("this") ); } - + @Test - public void subIntReferences( ) - { - BehaviorEntry source = newConstructor( "none/d", "(I)V" ); - assertThat( - getReferenceTokens( newBehaviorReferenceByMethod( source, "none/b", "d", "()V" ) ), - containsInAnyOrder( "d" ) + public void subIntReferences() { + BehaviorEntry source = newConstructor("none/d", "(I)V"); + assertThat(getReferenceTokens( + newBehaviorReferenceByMethod(source, "none/b", "d", "()V")), + containsInAnyOrder("d") ); - assertThat( - getReferenceTokens( newBehaviorReferenceByConstructor( source, "none/d", "(II)V" ) ), - containsInAnyOrder( "this" ) + assertThat(getReferenceTokens( + newBehaviorReferenceByConstructor(source, "none/d", "(II)V")), + containsInAnyOrder("this") ); - assertThat( - getReferenceTokens( newBehaviorReferenceByConstructor( source, "none/e", "(I)V" ) ), - containsInAnyOrder( "super" ) + assertThat(getReferenceTokens( + newBehaviorReferenceByConstructor(source, "none/e", "(I)V")), + containsInAnyOrder("super") ); } - + @Test - public void subIntIntReferences( ) - { - BehaviorEntry source = newConstructor( "none/d", "(II)V" ); + public void subIntIntReferences() { + BehaviorEntry source = newConstructor("none/d", "(II)V"); assertThat( - getReferenceTokens( newBehaviorReferenceByMethod( source, "none/b", "e", "()V" ) ), - containsInAnyOrder( "d" ) + getReferenceTokens(newBehaviorReferenceByMethod(source, "none/b", "e", "()V")), + containsInAnyOrder("d") ); } - + @Test - public void subsubIntReferences( ) - { - BehaviorEntry source = newConstructor( "none/e", "(I)V" ); + public void subsubIntReferences() { + BehaviorEntry source = newConstructor("none/e", "(I)V"); assertThat( - getReferenceTokens( newBehaviorReferenceByMethod( source, "none/b", "f", "()V" ) ), - containsInAnyOrder( "e" ) + getReferenceTokens(newBehaviorReferenceByMethod(source, "none/b", "f", "()V")), + containsInAnyOrder("e") ); } - + @Test - public void defaultConstructableReferences( ) - { - BehaviorEntry source = newConstructor( "none/c", "()V" ); + public void defaultConstructableReferences() { + BehaviorEntry source = newConstructor("none/c", "()V"); assertThat( - getReferenceTokens( newBehaviorReferenceByMethod( source, "none/b", "g", "()V" ) ), - containsInAnyOrder( "c" ) + getReferenceTokens(newBehaviorReferenceByMethod(source, "none/b", "g", "()V")), + containsInAnyOrder("c") ); } } diff --git a/test/cuchaz/enigma/TokenChecker.java b/test/cuchaz/enigma/TokenChecker.java index c0852f3..524c5ec 100644 --- a/test/cuchaz/enigma/TokenChecker.java +++ b/test/cuchaz/enigma/TokenChecker.java @@ -23,47 +23,41 @@ import cuchaz.enigma.analysis.SourceIndex; import cuchaz.enigma.analysis.Token; import cuchaz.enigma.mapping.Entry; -public class TokenChecker -{ +public class TokenChecker { + private Deobfuscator m_deobfuscator; - - protected TokenChecker( File jarFile ) - throws IOException - { - m_deobfuscator = new Deobfuscator( jarFile ); + + protected TokenChecker(File jarFile) throws IOException { + m_deobfuscator = new Deobfuscator(jarFile); } - protected String getDeclarationToken( Entry entry ) - { + protected String getDeclarationToken(Entry entry) { // decompile the class - CompilationUnit tree = m_deobfuscator.getSourceTree( entry.getClassName() ); + CompilationUnit tree = m_deobfuscator.getSourceTree(entry.getClassName()); // DEBUG - //tree.acceptVisitor( new TreeDumpVisitor( new File( "tree." + entry.getClassName().replace( '/', '.' ) + ".txt" ) ), null ); - String source = m_deobfuscator.getSource( tree ); - SourceIndex index = m_deobfuscator.getSourceIndex( tree, source ); + // tree.acceptVisitor( new TreeDumpVisitor( new File( "tree." + entry.getClassName().replace( '/', '.' ) + ".txt" ) ), null ); + String source = m_deobfuscator.getSource(tree); + SourceIndex index = m_deobfuscator.getSourceIndex(tree, source); // get the token value - Token token = index.getDeclarationToken( entry ); - if( token == null ) - { + Token token = index.getDeclarationToken(entry); + if (token == null) { return null; } - return source.substring( token.start, token.end ); + return source.substring(token.start, token.end); } - @SuppressWarnings( "unchecked" ) - protected Collection getReferenceTokens( EntryReference reference ) - { + @SuppressWarnings("unchecked") + protected Collection getReferenceTokens(EntryReference reference) { // decompile the class - CompilationUnit tree = m_deobfuscator.getSourceTree( reference.context.getClassName() ); - String source = m_deobfuscator.getSource( tree ); - SourceIndex index = m_deobfuscator.getSourceIndex( tree, source ); + CompilationUnit tree = m_deobfuscator.getSourceTree(reference.context.getClassName()); + String source = m_deobfuscator.getSource(tree); + SourceIndex index = m_deobfuscator.getSourceIndex(tree, source); // get the token values List values = Lists.newArrayList(); - for( Token token : index.getReferenceTokens( (EntryReference)reference ) ) - { - values.add( source.substring( token.start, token.end ) ); + for (Token token : index.getReferenceTokens((EntryReference)reference)) { + values.add(source.substring(token.start, token.end)); } return values; } diff --git a/test/cuchaz/enigma/inputs/Keep.java b/test/cuchaz/enigma/inputs/Keep.java index 3c12bae..390e82f 100644 --- a/test/cuchaz/enigma/inputs/Keep.java +++ b/test/cuchaz/enigma/inputs/Keep.java @@ -1,9 +1,7 @@ package cuchaz.enigma.inputs; -public class Keep -{ - public static void main( String[] args ) - { - System.out.println( "Keep me!" ); +public class Keep { + public static void main(String[] args) { + System.out.println("Keep me!"); } } diff --git a/test/cuchaz/enigma/inputs/constructors/BaseClass.java b/test/cuchaz/enigma/inputs/constructors/BaseClass.java index e6d8768..9345308 100644 --- a/test/cuchaz/enigma/inputs/constructors/BaseClass.java +++ b/test/cuchaz/enigma/inputs/constructors/BaseClass.java @@ -1,17 +1,15 @@ package cuchaz.enigma.inputs.constructors; // none/a -public class BaseClass -{ +public class BaseClass { + // ()V - public BaseClass( ) - { - System.out.println( "Default constructor" ); + public BaseClass() { + System.out.println("Default constructor"); } - + // (I)V - public BaseClass( int i ) - { - System.out.println( "Int constructor " + i ); + public BaseClass(int i) { + System.out.println("Int constructor " + i); } } diff --git a/test/cuchaz/enigma/inputs/constructors/Caller.java b/test/cuchaz/enigma/inputs/constructors/Caller.java index b218619..5727875 100644 --- a/test/cuchaz/enigma/inputs/constructors/Caller.java +++ b/test/cuchaz/enigma/inputs/constructors/Caller.java @@ -1,54 +1,47 @@ package cuchaz.enigma.inputs.constructors; // none/b -public class Caller -{ +public class Caller { + // a()V - public void callBaseDefault( ) - { + public void callBaseDefault() { // none/a.()V - System.out.println( new BaseClass() ); + System.out.println(new BaseClass()); } - + // b()V - public void callBaseInt( ) - { + public void callBaseInt() { // none/a.(I)V - System.out.println( new BaseClass( 5 ) ); + System.out.println(new BaseClass(5)); } - + // c()V - public void callSubDefault( ) - { + public void callSubDefault() { // none/d.()V - System.out.println( new SubClass() ); + System.out.println(new SubClass()); } - + // d()V - public void callSubInt( ) - { + public void callSubInt() { // none/d.(I)V - System.out.println( new SubClass( 6 ) ); + System.out.println(new SubClass(6)); } - + // e()V - public void callSubIntInt( ) - { + public void callSubIntInt() { // none/d.(II)V - System.out.println( new SubClass( 4, 2 ) ); + System.out.println(new SubClass(4, 2)); } - + // f()V - public void callSubSubInt( ) - { + public void callSubSubInt() { // none/e.(I)V - System.out.println( new SubSubClass( 3 ) ); + System.out.println(new SubSubClass(3)); } // g()V - public void callDefaultConstructable() - { + public void callDefaultConstructable() { // none/c.()V - System.out.println( new DefaultConstructable() ); + System.out.println(new DefaultConstructable()); } } diff --git a/test/cuchaz/enigma/inputs/constructors/DefaultConstructable.java b/test/cuchaz/enigma/inputs/constructors/DefaultConstructable.java index 6cfd35e..26a3ddb 100644 --- a/test/cuchaz/enigma/inputs/constructors/DefaultConstructable.java +++ b/test/cuchaz/enigma/inputs/constructors/DefaultConstructable.java @@ -1,6 +1,5 @@ package cuchaz.enigma.inputs.constructors; -public class DefaultConstructable -{ +public class DefaultConstructable { // only default constructor } diff --git a/test/cuchaz/enigma/inputs/constructors/SubClass.java b/test/cuchaz/enigma/inputs/constructors/SubClass.java index 6ef7732..fecfa2b 100644 --- a/test/cuchaz/enigma/inputs/constructors/SubClass.java +++ b/test/cuchaz/enigma/inputs/constructors/SubClass.java @@ -1,32 +1,28 @@ package cuchaz.enigma.inputs.constructors; // none/d extends none/a -public class SubClass extends BaseClass -{ +public class SubClass extends BaseClass { + // ()V - public SubClass( ) - { + public SubClass() { // none/a.()V } // (I)V - public SubClass( int num ) - { + public SubClass(int num) { // ()V this(); - System.out.println( "SubClass " + num ); + System.out.println("SubClass " + num); } // (II)V - public SubClass( int a, int b ) - { + public SubClass(int a, int b) { // (I)V - this( a + b ); + this(a + b); } // (III)V - public SubClass( int a, int b, int c ) - { + public SubClass(int a, int b, int c) { // none/a.()V } } diff --git a/test/cuchaz/enigma/inputs/constructors/SubSubClass.java b/test/cuchaz/enigma/inputs/constructors/SubSubClass.java index 76a0f1f..ab84161 100644 --- a/test/cuchaz/enigma/inputs/constructors/SubSubClass.java +++ b/test/cuchaz/enigma/inputs/constructors/SubSubClass.java @@ -1,12 +1,11 @@ package cuchaz.enigma.inputs.constructors; // none/e extends none/d -public class SubSubClass extends SubClass -{ +public class SubSubClass extends SubClass { + // (I)V - public SubSubClass( int i ) - { + public SubSubClass(int i) { // none/c.(I)V - super( i ); + super(i); } } diff --git a/test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java b/test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java index 8402dde..5b416c4 100644 --- a/test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java +++ b/test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java @@ -1,23 +1,21 @@ package cuchaz.enigma.inputs.inheritanceTree; // none/a -public abstract class BaseClass -{ +public abstract class BaseClass { + // a private String m_name; // (Ljava/lang/String;)V - protected BaseClass( String name ) - { + protected BaseClass(String name) { m_name = name; } // a()Ljava/lang/String; - public String getName( ) - { + public String getName() { return m_name; } // a()V - public abstract void doBaseThings( ); + public abstract void doBaseThings(); } diff --git a/test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java index ed50709..7a99d51 100644 --- a/test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java +++ b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java @@ -1,12 +1,11 @@ package cuchaz.enigma.inputs.inheritanceTree; // none/b extends none/a -public abstract class SubclassA extends BaseClass -{ +public abstract class SubclassA extends BaseClass { + // (Ljava/lang/String;)V - protected SubclassA( String name ) - { + protected SubclassA(String name) { // call to none/a.(Ljava/lang/String)V - super( name ); + super(name); } } diff --git a/test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java index fc4c8ee..c9485d3 100644 --- a/test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java +++ b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java @@ -1,16 +1,15 @@ package cuchaz.enigma.inputs.inheritanceTree; // none/c extends none/a -public class SubclassB extends BaseClass -{ +public class SubclassB extends BaseClass { + // a private int m_numThings; // ()V - protected SubclassB( ) - { + protected SubclassB() { // none/a.(Ljava/lang/String;)V - super( "B" ); + super("B"); // access to a m_numThings = 4; @@ -18,16 +17,14 @@ public class SubclassB extends BaseClass @Override // a()V - public void doBaseThings( ) - { + public void doBaseThings() { // call to none/a.a()Ljava/lang/String; - System.out.println( "Base things by B! " + getName() ); + System.out.println("Base things by B! " + getName()); } // b()V - public void doBThings( ) - { + public void doBThings() { // access to a - System.out.println( "" + m_numThings + " B things!" ); + System.out.println("" + m_numThings + " B things!"); } } diff --git a/test/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java b/test/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java index b3b8342..afd03ac 100644 --- a/test/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java +++ b/test/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java @@ -1,27 +1,24 @@ package cuchaz.enigma.inputs.inheritanceTree; // none/d extends none/b -public class SubsubclassAA extends SubclassA -{ - protected SubsubclassAA( ) - { +public class SubsubclassAA extends SubclassA { + + protected SubsubclassAA() { // call to none/b.(Ljava/lang/String;)V - super( "AA" ); + super("AA"); } @Override // a()Ljava/lang/String; - public String getName( ) - { + public String getName() { // call to none/b.a()Ljava/lang/String; return "subsub" + super.getName(); } @Override // a()V - public void doBaseThings( ) - { + public void doBaseThings() { // call to none/d.a()Ljava/lang/String; - System.out.println( "Base things by " + getName() ); + System.out.println("Base things by " + getName()); } } diff --git a/test/cuchaz/enigma/inputs/innerClasses/Anonymous.java b/test/cuchaz/enigma/inputs/innerClasses/Anonymous.java index d36a514..f5d9d1c 100644 --- a/test/cuchaz/enigma/inputs/innerClasses/Anonymous.java +++ b/test/cuchaz/enigma/inputs/innerClasses/Anonymous.java @@ -1,14 +1,11 @@ package cuchaz.enigma.inputs.innerClasses; -public class Anonymous -{ - public void foo( ) - { - Runnable runnable = new Runnable( ) - { +public class Anonymous { + + public void foo() { + Runnable runnable = new Runnable() { @Override - public void run( ) - { + public void run() { // don't care } }; diff --git a/test/cuchaz/enigma/inputs/innerClasses/AnonymousWithScopeArgs.java b/test/cuchaz/enigma/inputs/innerClasses/AnonymousWithScopeArgs.java index e0a65e2..b3ba1af 100644 --- a/test/cuchaz/enigma/inputs/innerClasses/AnonymousWithScopeArgs.java +++ b/test/cuchaz/enigma/inputs/innerClasses/AnonymousWithScopeArgs.java @@ -1,16 +1,13 @@ package cuchaz.enigma.inputs.innerClasses; -public class AnonymousWithScopeArgs -{ - public static void foo( final Simple arg ) - { - System.out.println( new Object( ) - { +public class AnonymousWithScopeArgs { + + public static void foo(final Simple arg) { + System.out.println(new Object() { @Override - public String toString( ) - { + public String toString() { return arg.toString(); } - } ); + }); } } diff --git a/test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java b/test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java index e24395c..08135fe 100644 --- a/test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java +++ b/test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java @@ -1,22 +1,20 @@ package cuchaz.enigma.inputs.innerClasses; -@SuppressWarnings( "unused" ) -public class ConstructorArgs -{ - class Inner - { +@SuppressWarnings("unused") +public class ConstructorArgs { + + class Inner { + private int a; - public Inner( int a ) - { + public Inner(int a) { this.a = a; } } Inner i; - public void foo( ) - { - i = new Inner( 5 ); + public void foo() { + i = new Inner(5); } } diff --git a/test/cuchaz/enigma/inputs/innerClasses/Simple.java b/test/cuchaz/enigma/inputs/innerClasses/Simple.java index 405c639..cb536fa 100644 --- a/test/cuchaz/enigma/inputs/innerClasses/Simple.java +++ b/test/cuchaz/enigma/inputs/innerClasses/Simple.java @@ -1,9 +1,8 @@ package cuchaz.enigma.inputs.innerClasses; -public class Simple -{ - class Inner - { +public class Simple { + + class Inner { // nothing to do } } diff --git a/test/cuchaz/enigma/inputs/loneClass/LoneClass.java b/test/cuchaz/enigma/inputs/loneClass/LoneClass.java index 961b012..18c716e 100644 --- a/test/cuchaz/enigma/inputs/loneClass/LoneClass.java +++ b/test/cuchaz/enigma/inputs/loneClass/LoneClass.java @@ -1,16 +1,14 @@ package cuchaz.enigma.inputs.loneClass; -public class LoneClass -{ +public class LoneClass { + private String m_name; - public LoneClass( String name ) - { + public LoneClass(String name) { m_name = name; } - public String getName( ) - { + public String getName() { return m_name; } } -- cgit v1.2.3