From e70573589c092b0d2474fa745b1346379cf8767b Mon Sep 17 00:00:00 2001 From: jeff Date: Fri, 5 Sep 2014 01:15:43 -0400 Subject: added proguard to the gradle config to create obfuscated jars for testing added simple tests for the deobufscator class --- test/cuchaz/enigma/TestDeobfuscator.java | 51 ++++++++++++++++++++++++++++++++ test/cuchaz/enigma/inputs/Keep.java | 9 ++++++ test/cuchaz/enigma/inputs/LoneClass.java | 16 ++++++++++ 3 files changed, 76 insertions(+) create mode 100644 test/cuchaz/enigma/TestDeobfuscator.java create mode 100644 test/cuchaz/enigma/inputs/Keep.java create mode 100644 test/cuchaz/enigma/inputs/LoneClass.java (limited to 'test') diff --git a/test/cuchaz/enigma/TestDeobfuscator.java b/test/cuchaz/enigma/TestDeobfuscator.java new file mode 100644 index 0000000..3310fbc --- /dev/null +++ b/test/cuchaz/enigma/TestDeobfuscator.java @@ -0,0 +1,51 @@ +package cuchaz.enigma; + +import static org.junit.Assert.*; + +import java.io.File; +import java.io.IOException; +import java.util.List; + +import org.junit.Test; + +import com.beust.jcommander.internal.Lists; + +import cuchaz.enigma.mapping.ClassEntry; + +public class TestDeobfuscator +{ + private Deobfuscator getDeobfuscator( ) + throws IOException + { + return new Deobfuscator( new File( "build/libs/testCases.obf.jar" ) ); + } + + @Test + public void loadJar( ) + throws Exception + { + getDeobfuscator(); + } + + @Test + 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() ); + } + + @Test + public void decompileClass( ) + throws Exception + { + Deobfuscator deobfuscator = getDeobfuscator(); + deobfuscator.getSource( deobfuscator.getSourceTree( "none/a" ) ); + } +} diff --git a/test/cuchaz/enigma/inputs/Keep.java b/test/cuchaz/enigma/inputs/Keep.java new file mode 100644 index 0000000..3c12bae --- /dev/null +++ b/test/cuchaz/enigma/inputs/Keep.java @@ -0,0 +1,9 @@ +package cuchaz.enigma.inputs; + +public class Keep +{ + public static void main( String[] args ) + { + System.out.println( "Keep me!" ); + } +} diff --git a/test/cuchaz/enigma/inputs/LoneClass.java b/test/cuchaz/enigma/inputs/LoneClass.java new file mode 100644 index 0000000..a3d8cde --- /dev/null +++ b/test/cuchaz/enigma/inputs/LoneClass.java @@ -0,0 +1,16 @@ +package cuchaz.enigma.inputs; + +public class LoneClass +{ + private String m_name; + + public LoneClass( String name ) + { + m_name = name; + } + + public String getName( ) + { + return m_name; + } +} -- cgit v1.2.3 From 730238f3bab1c680424e0ac74178c33b15b43eb5 Mon Sep 17 00:00:00 2001 From: jeff Date: Sun, 7 Sep 2014 22:30:28 -0400 Subject: added some basic tests for the deobufscator and the jar index --- test/cuchaz/enigma/EntryFactory.java | 52 ++++++ test/cuchaz/enigma/TestDeobfuscator.java | 13 +- test/cuchaz/enigma/TestJarIndexLoneClass.java | 201 +++++++++++++++++++++ test/cuchaz/enigma/inputs/LoneClass.java | 16 -- test/cuchaz/enigma/inputs/loneClass/LoneClass.java | 16 ++ 5 files changed, 281 insertions(+), 17 deletions(-) create mode 100644 test/cuchaz/enigma/EntryFactory.java create mode 100644 test/cuchaz/enigma/TestJarIndexLoneClass.java delete mode 100644 test/cuchaz/enigma/inputs/LoneClass.java create mode 100644 test/cuchaz/enigma/inputs/loneClass/LoneClass.java (limited to 'test') diff --git a/test/cuchaz/enigma/EntryFactory.java b/test/cuchaz/enigma/EntryFactory.java new file mode 100644 index 0000000..b275719 --- /dev/null +++ b/test/cuchaz/enigma/EntryFactory.java @@ -0,0 +1,52 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin.\ + * + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Public License v3.0 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/gpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ +package cuchaz.enigma; + +import cuchaz.enigma.analysis.EntryReference; +import cuchaz.enigma.mapping.BehaviorEntry; +import cuchaz.enigma.mapping.ClassEntry; +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 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 ConstructorEntry newConstructor( String className, String signature ) + { + return new ConstructorEntry( newClass( className ), signature ); + } + + public static EntryReference newFieldReferenceByMethod( String fieldClassName, String fieldName, String callerClassName, String callerName, String callerSignature ) + { + return new EntryReference( newField( fieldClassName, fieldName ), newMethod( callerClassName, callerName, callerSignature ) ); + } + + public static EntryReference newFieldReferenceByConstructor( String fieldClassName, String fieldName, String callerClassName, String callerSignature ) + { + return new EntryReference( newField( fieldClassName, fieldName ), newConstructor( callerClassName, callerSignature ) ); + } +} diff --git a/test/cuchaz/enigma/TestDeobfuscator.java b/test/cuchaz/enigma/TestDeobfuscator.java index 3310fbc..3e679fb 100644 --- a/test/cuchaz/enigma/TestDeobfuscator.java +++ b/test/cuchaz/enigma/TestDeobfuscator.java @@ -1,3 +1,14 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin.\ + * + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Public License v3.0 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/gpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ package cuchaz.enigma; import static org.junit.Assert.*; @@ -17,7 +28,7 @@ public class TestDeobfuscator private Deobfuscator getDeobfuscator( ) throws IOException { - return new Deobfuscator( new File( "build/libs/testCases.obf.jar" ) ); + return new Deobfuscator( new File( "build/libs/testLoneClass.obf.jar" ) ); } @Test diff --git a/test/cuchaz/enigma/TestJarIndexLoneClass.java b/test/cuchaz/enigma/TestJarIndexLoneClass.java new file mode 100644 index 0000000..56031dd --- /dev/null +++ b/test/cuchaz/enigma/TestJarIndexLoneClass.java @@ -0,0 +1,201 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin.\ + * + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Public License v3.0 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/gpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ +package cuchaz.enigma; + +import static cuchaz.enigma.EntryFactory.newClass; +import static cuchaz.enigma.EntryFactory.newField; +import static cuchaz.enigma.EntryFactory.newFieldReferenceByConstructor; +import static cuchaz.enigma.EntryFactory.newFieldReferenceByMethod; +import static cuchaz.enigma.EntryFactory.newMethod; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.containsInAnyOrder; +import static org.hamcrest.Matchers.empty; +import static org.hamcrest.Matchers.is; +import static org.hamcrest.Matchers.not; +import static org.hamcrest.Matchers.nullValue; + +import java.util.Collection; +import java.util.Set; +import java.util.jar.JarFile; + +import org.junit.Test; + +import cuchaz.enigma.analysis.Access; +import cuchaz.enigma.analysis.ClassImplementationsTreeNode; +import cuchaz.enigma.analysis.ClassInheritanceTreeNode; +import cuchaz.enigma.analysis.EntryReference; +import cuchaz.enigma.analysis.JarIndex; +import cuchaz.enigma.analysis.MethodImplementationsTreeNode; +import cuchaz.enigma.analysis.MethodInheritanceTreeNode; +import cuchaz.enigma.mapping.BehaviorEntry; +import cuchaz.enigma.mapping.FieldEntry; +import cuchaz.enigma.mapping.MethodEntry; +import cuchaz.enigma.mapping.Translator; + +public class TestJarIndexLoneClass +{ + private JarIndex m_index; + + public TestJarIndexLoneClass( ) + throws Exception + { + m_index = new JarIndex(); + 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" ) + ) ); + } + + @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() ) ); + } + + @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() ) ); + } + + @Test + public void isImplemented( ) + { + assertThat( m_index.isMethodImplemented( newMethod( "none/a", "a", "()Ljava/lang/String;" ) ), is( true ) ); + assertThat( m_index.isMethodImplemented( newMethod( "none/a", "b", "()Ljava/lang/String;" ) ), is( false ) ); + } + + @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 ) ); + } + + + @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 ) ); + } + + @Test + 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() ) ); + } + + @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;" ) ) ); + } + + @Test + @SuppressWarnings( "unchecked" ) + public void fieldReferences( ) + { + Collection> references = m_index.getFieldReferences( newField( "none/a", "a" ) ); + assertThat( references, containsInAnyOrder( + newFieldReferenceByConstructor( "none/a", "a", "none/a", "(Ljava/lang/String;)V" ), + newFieldReferenceByMethod( "none/a", "a", "none/a", "a", "()Ljava/lang/String;" ) + ) ); + } + + @Test + 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() ) ); + } + + @Test + public void outerClass( ) + { + assertThat( m_index.getOuterClass( "none/a" ), is( nullValue() ) ); + } + + @Test + public void isAnonymousClass( ) + { + assertThat( m_index.isAnonymousClass( "none/a" ), is( false ) ); + } + + @Test + public void interfaces( ) + { + assertThat( m_index.getInterfaces( "none/a" ), is( empty() ) ); + } + + @Test + public void implementingClasses( ) + { + assertThat( m_index.getImplementingClasses( "none/a" ), is( empty() ) ); + } + + @Test + 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() ) ); + } + + @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.containsObfMethod( newMethod( "none/a", "a", "()Ljava/lang/String;" ) ), is( true ) ); + assertThat( m_index.containsObfMethod( newMethod( "none/a", "b", "()Ljava/lang/String;" ) ), is( false ) ); + } +} diff --git a/test/cuchaz/enigma/inputs/LoneClass.java b/test/cuchaz/enigma/inputs/LoneClass.java deleted file mode 100644 index a3d8cde..0000000 --- a/test/cuchaz/enigma/inputs/LoneClass.java +++ /dev/null @@ -1,16 +0,0 @@ -package cuchaz.enigma.inputs; - -public class LoneClass -{ - private String m_name; - - public LoneClass( String name ) - { - m_name = name; - } - - public String getName( ) - { - return m_name; - } -} diff --git a/test/cuchaz/enigma/inputs/loneClass/LoneClass.java b/test/cuchaz/enigma/inputs/loneClass/LoneClass.java new file mode 100644 index 0000000..961b012 --- /dev/null +++ b/test/cuchaz/enigma/inputs/loneClass/LoneClass.java @@ -0,0 +1,16 @@ +package cuchaz.enigma.inputs.loneClass; + +public class LoneClass +{ + private String m_name; + + public LoneClass( String name ) + { + m_name = name; + } + + public String getName( ) + { + return m_name; + } +} -- cgit v1.2.3 From a68dc42b6a835bd513e9d617c9892e85f321ddb6 Mon Sep 17 00:00:00 2001 From: jeff Date: Mon, 8 Sep 2014 00:23:46 -0400 Subject: added some tests for a small inheritance hierarchy --- test/cuchaz/enigma/EntryFactory.java | 18 +- .../cuchaz/enigma/TestJarIndexInheritanceTree.java | 255 +++++++++++++++++++++ test/cuchaz/enigma/TestJarIndexLoneClass.java | 8 +- .../enigma/inputs/inheritanceTree/BaseClass.java | 18 ++ .../enigma/inputs/inheritanceTree/SubclassA.java | 9 + .../enigma/inputs/inheritanceTree/SubclassB.java | 24 ++ .../inputs/inheritanceTree/SubsubclassAA.java | 21 ++ 7 files changed, 345 insertions(+), 8 deletions(-) create mode 100644 test/cuchaz/enigma/TestJarIndexInheritanceTree.java create mode 100644 test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java create mode 100644 test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java create mode 100644 test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java create mode 100644 test/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java (limited to 'test') diff --git a/test/cuchaz/enigma/EntryFactory.java b/test/cuchaz/enigma/EntryFactory.java index b275719..66f83df 100644 --- a/test/cuchaz/enigma/EntryFactory.java +++ b/test/cuchaz/enigma/EntryFactory.java @@ -40,13 +40,23 @@ public class EntryFactory return new ConstructorEntry( newClass( className ), signature ); } - public static EntryReference newFieldReferenceByMethod( String fieldClassName, String fieldName, String callerClassName, String callerName, String callerSignature ) + public static EntryReference newFieldReferenceByMethod( FieldEntry fieldEntry, String callerClassName, String callerName, String callerSignature ) { - return new EntryReference( newField( fieldClassName, fieldName ), newMethod( callerClassName, callerName, callerSignature ) ); + return new EntryReference( fieldEntry, newMethod( callerClassName, callerName, callerSignature ) ); } - public static EntryReference newFieldReferenceByConstructor( String fieldClassName, String fieldName, String callerClassName, String callerSignature ) + public static EntryReference newFieldReferenceByConstructor( FieldEntry fieldEntry, String callerClassName, String callerSignature ) { - return new EntryReference( newField( fieldClassName, fieldName ), newConstructor( callerClassName, 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 newBehaviorReferenceByConstructor( BehaviorEntry behaviorEntry, String callerClassName, String callerSignature ) + { + return new EntryReference( behaviorEntry, newConstructor( callerClassName, callerSignature ) ); } } diff --git a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java new file mode 100644 index 0000000..5ded5df --- /dev/null +++ b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java @@ -0,0 +1,255 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Public License v3.0 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/gpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ +package cuchaz.enigma; + +import static cuchaz.enigma.EntryFactory.newBehaviorReferenceByConstructor; +import static cuchaz.enigma.EntryFactory.newBehaviorReferenceByMethod; +import static cuchaz.enigma.EntryFactory.newClass; +import static cuchaz.enigma.EntryFactory.newFieldReferenceByConstructor; +import static cuchaz.enigma.EntryFactory.newFieldReferenceByMethod; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.contains; +import static org.hamcrest.Matchers.containsInAnyOrder; +import static org.hamcrest.Matchers.empty; +import static org.hamcrest.Matchers.is; +import static org.hamcrest.Matchers.nullValue; + +import java.util.Collection; +import java.util.Set; +import java.util.jar.JarFile; + +import org.junit.Test; + +import cuchaz.enigma.analysis.Access; +import cuchaz.enigma.analysis.EntryReference; +import cuchaz.enigma.analysis.JarIndex; +import cuchaz.enigma.analysis.TranslationIndex; +import cuchaz.enigma.mapping.BehaviorEntry; +import cuchaz.enigma.mapping.ClassEntry; +import cuchaz.enigma.mapping.ConstructorEntry; +import cuchaz.enigma.mapping.FieldEntry; +import cuchaz.enigma.mapping.MethodEntry; + +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" ); + + public TestJarIndexInheritanceTree( ) + throws Exception + { + m_index = new JarIndex(); + 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" ), + m_baseClass, + m_subClassA, + m_subClassAA, + m_subClassB + ) ); + } + + @Test + 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( + 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() ) ); + + // 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() ) ); + + // 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() ) ); + } + + @Test + public void access( ) + { + assertThat( m_index.getAccess( m_nameField ), is( Access.Private ) ); + assertThat( m_index.getAccess( m_numThingsField ), is( Access.Private ) ); + } + + @Test + public void isImplemented( ) + { + // getName() + assertThat( m_index.isMethodImplemented( new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ) ), is( true ) ); + assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassA, "a", "()Ljava/lang/String;" ) ), is( false ) ); + assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ) ), is( true ) ); + assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassB, "a", "()Ljava/lang/String;" ) ), is( false ) ); + + // doBaseThings() + assertThat( m_index.isMethodImplemented( new MethodEntry( m_baseClass, "a", "()V" ) ), is( true ) ); + assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassA, "a", "()V" ) ), is( false ) ); + assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassAA, "a", "()V" ) ), is( true ) ); + assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassB, "a", "()V" ) ), is( true ) ); + + // doBThings() + assertThat( m_index.isMethodImplemented( new MethodEntry( m_baseClass, "b", "()V" ) ), is( false ) ); + assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassA, "b", "()V" ) ), is( false ) ); + assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassAA, "b", "()V" ) ), is( false ) ); + assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassB, "b", "()V" ) ), is( true ) ); + } + + @Test + 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;" ) + ) ); + + // 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" ) + ) ); + + // doBThings + 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( ) + { + 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;" ) + ) ); + + // 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" ) + ) ); + } + + @Test + @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" ) + ) ); + + // 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" ) + ) ); + + // 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;" ) + ) ); + + // 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" ) + ) ); + } + + @Test + 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 ) ); + + // fields + assertThat( m_index.containsObfField( m_nameField ), is( true ) ); + assertThat( m_index.containsObfField( m_numThingsField ), is( true ) ); + + // methods + assertThat( m_index.containsObfMethod( new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ) ), is( true ) ); + assertThat( m_index.containsObfMethod( new MethodEntry( m_baseClass, "a", "()V" ) ), is( true ) ); + assertThat( m_index.containsObfMethod( new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ) ), is( true ) ); + assertThat( m_index.containsObfMethod( new MethodEntry( m_subClassAA, "a", "()V" ) ), is( true ) ); + assertThat( m_index.containsObfMethod( new MethodEntry( m_subClassB, "a", "()V" ) ), is( true ) ); + assertThat( m_index.containsObfMethod( new MethodEntry( m_subClassB, "b", "()V" ) ), is( true ) ); + } +} diff --git a/test/cuchaz/enigma/TestJarIndexLoneClass.java b/test/cuchaz/enigma/TestJarIndexLoneClass.java index 56031dd..9236d0c 100644 --- a/test/cuchaz/enigma/TestJarIndexLoneClass.java +++ b/test/cuchaz/enigma/TestJarIndexLoneClass.java @@ -95,7 +95,6 @@ public class TestJarIndexLoneClass assertThat( node.getObfClassName(), is( "none/a" ) ); assertThat( node.getChildCount(), is( 0 ) ); } - @Test public void methodInheritance( ) @@ -133,10 +132,11 @@ public class TestJarIndexLoneClass @SuppressWarnings( "unchecked" ) public void fieldReferences( ) { - Collection> references = m_index.getFieldReferences( newField( "none/a", "a" ) ); + FieldEntry source = newField( "none/a", "a" ); + Collection> references = m_index.getFieldReferences( source ); assertThat( references, containsInAnyOrder( - newFieldReferenceByConstructor( "none/a", "a", "none/a", "(Ljava/lang/String;)V" ), - newFieldReferenceByMethod( "none/a", "a", "none/a", "a", "()Ljava/lang/String;" ) + newFieldReferenceByConstructor( source, "none/a", "(Ljava/lang/String;)V" ), + newFieldReferenceByMethod( source, "none/a", "a", "()Ljava/lang/String;" ) ) ); } diff --git a/test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java b/test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java new file mode 100644 index 0000000..a6b3845 --- /dev/null +++ b/test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java @@ -0,0 +1,18 @@ +package cuchaz.enigma.inputs.inheritanceTree; + +public abstract class BaseClass +{ + private String m_name; + + protected BaseClass( String name ) + { + m_name = name; + } + + public String getName( ) + { + return m_name; + } + + public abstract void doBaseThings( ); +} diff --git a/test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java new file mode 100644 index 0000000..f4780a2 --- /dev/null +++ b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java @@ -0,0 +1,9 @@ +package cuchaz.enigma.inputs.inheritanceTree; + +public abstract class SubclassA extends BaseClass +{ + protected SubclassA( String name ) + { + super( name ); + } +} diff --git a/test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java new file mode 100644 index 0000000..4001e7a --- /dev/null +++ b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java @@ -0,0 +1,24 @@ +package cuchaz.enigma.inputs.inheritanceTree; + +public class SubclassB extends BaseClass +{ + private int m_numThings; + + protected SubclassB( ) + { + super( "B" ); + + m_numThings = 4; + } + + @Override + public void doBaseThings( ) + { + System.out.println( "Base things by B!" ); + } + + public void doBThings( ) + { + 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 new file mode 100644 index 0000000..11196d1 --- /dev/null +++ b/test/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java @@ -0,0 +1,21 @@ +package cuchaz.enigma.inputs.inheritanceTree; + +public class SubsubclassAA extends SubclassA +{ + protected SubsubclassAA( ) + { + super( "AA" ); + } + + @Override + public String getName( ) + { + return "subsub" + super.getName(); + } + + @Override + public void doBaseThings( ) + { + System.out.println( "Base things by " + getName() ); + } +} -- cgit v1.2.3 From aa68099bb252dd1a1c275459f8babe537868bcaf Mon Sep 17 00:00:00 2001 From: jeff Date: Sun, 14 Sep 2014 19:06:55 -0400 Subject: fixed bug with method references pointing to wrong class --- test/cuchaz/enigma/TestJarIndexInheritanceTree.java | 3 ++- test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java | 5 +++++ test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java | 3 +++ test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java | 11 ++++++++++- test/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java | 6 ++++++ 5 files changed, 26 insertions(+), 2 deletions(-) (limited to 'test') diff --git a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java index 5ded5df..3d488ee 100644 --- a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java +++ b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java @@ -220,7 +220,8 @@ public class TestJarIndexInheritanceTree 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_subClassAA.getName(), "a", "()Ljava/lang/String;" ), + newBehaviorReferenceByMethod( source, m_subClassB.getName(), "a", "()V" ) ) ); // subclassAA.getName() diff --git a/test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java b/test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java index a6b3845..8402dde 100644 --- a/test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java +++ b/test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java @@ -1,18 +1,23 @@ package cuchaz.enigma.inputs.inheritanceTree; +// none/a public abstract class BaseClass { + // a private String m_name; + // (Ljava/lang/String;)V protected BaseClass( String name ) { m_name = name; } + // a()Ljava/lang/String; public String getName( ) { return m_name; } + // a()V public abstract void doBaseThings( ); } diff --git a/test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java index f4780a2..ed50709 100644 --- a/test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java +++ b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java @@ -1,9 +1,12 @@ package cuchaz.enigma.inputs.inheritanceTree; +// none/b extends none/a public abstract class SubclassA extends BaseClass { + // (Ljava/lang/String;)V protected SubclassA( String name ) { + // call to none/a.(Ljava/lang/String)V super( name ); } } diff --git a/test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java index 4001e7a..fc4c8ee 100644 --- a/test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java +++ b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java @@ -1,24 +1,33 @@ package cuchaz.enigma.inputs.inheritanceTree; +// none/c extends none/a public class SubclassB extends BaseClass { + // a private int m_numThings; + // ()V protected SubclassB( ) { + // none/a.(Ljava/lang/String;)V super( "B" ); + // access to a m_numThings = 4; } @Override + // a()V public void doBaseThings( ) { - System.out.println( "Base things by B!" ); + // call to none/a.a()Ljava/lang/String; + System.out.println( "Base things by B! " + getName() ); } + // b()V public void doBThings( ) { + // access to a 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 11196d1..b3b8342 100644 --- a/test/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java +++ b/test/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java @@ -1,21 +1,27 @@ package cuchaz.enigma.inputs.inheritanceTree; +// none/d extends none/b public class SubsubclassAA extends SubclassA { protected SubsubclassAA( ) { + // call to none/b.(Ljava/lang/String;)V super( "AA" ); } @Override + // a()Ljava/lang/String; public String getName( ) { + // call to none/b.a()Ljava/lang/String; return "subsub" + super.getName(); } @Override + // a()V public void doBaseThings( ) { + // call to none/d.a()Ljava/lang/String; System.out.println( "Base things by " + getName() ); } } -- cgit v1.2.3 From 6736d9aac3e7d1591cba33852126abf79dd18a57 Mon Sep 17 00:00:00 2001 From: jeff Date: Sun, 14 Sep 2014 21:54:58 -0400 Subject: added test to check constructor references --- .../enigma/TestJarIndexConstructorReferences.java | 129 +++++++++++++++++++++ .../enigma/inputs/constructors/BaseClass.java | 17 +++ test/cuchaz/enigma/inputs/constructors/Caller.java | 47 ++++++++ .../enigma/inputs/constructors/SubClass.java | 31 +++++ .../enigma/inputs/constructors/SubSubClass.java | 12 ++ 5 files changed, 236 insertions(+) create mode 100644 test/cuchaz/enigma/TestJarIndexConstructorReferences.java create mode 100644 test/cuchaz/enigma/inputs/constructors/BaseClass.java create mode 100644 test/cuchaz/enigma/inputs/constructors/Caller.java create mode 100644 test/cuchaz/enigma/inputs/constructors/SubClass.java create mode 100644 test/cuchaz/enigma/inputs/constructors/SubSubClass.java (limited to 'test') diff --git a/test/cuchaz/enigma/TestJarIndexConstructorReferences.java b/test/cuchaz/enigma/TestJarIndexConstructorReferences.java new file mode 100644 index 0000000..38882a0 --- /dev/null +++ b/test/cuchaz/enigma/TestJarIndexConstructorReferences.java @@ -0,0 +1,129 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Public License v3.0 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/gpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ +package cuchaz.enigma; + +import static cuchaz.enigma.EntryFactory.newBehaviorReferenceByConstructor; +import static cuchaz.enigma.EntryFactory.newBehaviorReferenceByMethod; +import static cuchaz.enigma.EntryFactory.newClass; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.containsInAnyOrder; +import static org.hamcrest.Matchers.empty; +import static org.hamcrest.Matchers.is; + +import java.util.jar.JarFile; + +import org.junit.Test; + +import cuchaz.enigma.analysis.JarIndex; +import cuchaz.enigma.mapping.BehaviorEntry; +import cuchaz.enigma.mapping.ClassEntry; +import cuchaz.enigma.mapping.ConstructorEntry; + +public class TestJarIndexConstructorReferences +{ + private JarIndex m_index; + + private ClassEntry m_baseClass = new ClassEntry( "none/a" ); + private ClassEntry m_subClass = new ClassEntry( "none/c" ); + private ClassEntry m_subsubClass = new ClassEntry( "none/d" ); + private ClassEntry m_callerClass = new ClassEntry( "none/b" ); + + public TestJarIndexConstructorReferences( ) + throws Exception + { + m_index = new JarIndex(); + m_index.indexJar( new JarFile( "build/libs/testConstructors.obf.jar" ), false ); + } + + @Test + public void obfEntries( ) + { + assertThat( m_index.getObfClassEntries(), containsInAnyOrder( + newClass( "cuchaz/enigma/inputs/Keep" ), + m_baseClass, + m_subClass, + m_subsubClass, + m_callerClass + ) ); + } + + @Test + @SuppressWarnings( "unchecked" ) + public void baseDefault( ) + { + BehaviorEntry source = new ConstructorEntry( m_baseClass, "()V" ); + assertThat( m_index.getBehaviorReferences( source ), 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" ) + ) ); + } + + @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" ) + ) ); + } + + @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" ) + ) ); + } + + @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" ) + ) ); + } + + @Test + 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" ) + ) ); + } +} diff --git a/test/cuchaz/enigma/inputs/constructors/BaseClass.java b/test/cuchaz/enigma/inputs/constructors/BaseClass.java new file mode 100644 index 0000000..e6d8768 --- /dev/null +++ b/test/cuchaz/enigma/inputs/constructors/BaseClass.java @@ -0,0 +1,17 @@ +package cuchaz.enigma.inputs.constructors; + +// none/a +public class BaseClass +{ + // ()V + public BaseClass( ) + { + System.out.println( "Default constructor" ); + } + + // (I)V + 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 new file mode 100644 index 0000000..f356b1b --- /dev/null +++ b/test/cuchaz/enigma/inputs/constructors/Caller.java @@ -0,0 +1,47 @@ +package cuchaz.enigma.inputs.constructors; + +// none/b +public class Caller +{ + // a()V + public void callBaseDefault( ) + { + // none/a.()V + System.out.println( new BaseClass() ); + } + + // b()V + public void callBaseInt( ) + { + // none/a.(I)V + System.out.println( new BaseClass( 5 ) ); + } + + // c()V + public void callSubDefault( ) + { + // none/c.()V + System.out.println( new SubClass() ); + } + + // d()V + public void callSubInt( ) + { + // none/c.(I)V + System.out.println( new SubClass( 6 ) ); + } + + // e()V + public void callSubIntInt( ) + { + // none/c.(II)V + System.out.println( new SubClass( 4, 2 ) ); + } + + // f()V + public void callSubSubInt( ) + { + // none/d.(I)V + System.out.println( new SubSubClass( 3 ) ); + } +} diff --git a/test/cuchaz/enigma/inputs/constructors/SubClass.java b/test/cuchaz/enigma/inputs/constructors/SubClass.java new file mode 100644 index 0000000..2235de3 --- /dev/null +++ b/test/cuchaz/enigma/inputs/constructors/SubClass.java @@ -0,0 +1,31 @@ +package cuchaz.enigma.inputs.constructors; + +// none/c extends none/a +public class SubClass extends BaseClass +{ + // ()V + public SubClass( ) + { + // none/a.()V + } + + // (I)V + public SubClass( int num ) + { + // ()V + this(); + System.out.println( "SubClass " + num ); + } + + // (II)V + public SubClass( int a, int b ) + { + // (I)V + this( a + b ); + } + + 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 new file mode 100644 index 0000000..a9445d8 --- /dev/null +++ b/test/cuchaz/enigma/inputs/constructors/SubSubClass.java @@ -0,0 +1,12 @@ +package cuchaz.enigma.inputs.constructors; + +// none/d extends none/c +public class SubSubClass extends SubClass +{ + // (I)V + public SubSubClass( int i ) + { + // none/c.(I)V + super( i ); + } +} -- cgit v1.2.3 From 72e918a5134c2bf747a476284bcfa1bd2ef2fa21 Mon Sep 17 00:00:00 2001 From: jeff Date: Sun, 14 Sep 2014 23:56:43 -0400 Subject: added tests to check constructor tokens fixed a bug with constructor tokens too --- .../enigma/TestJarIndexConstructorReferences.java | 29 +++- test/cuchaz/enigma/TestTokensConstructors.java | 152 +++++++++++++++++++++ test/cuchaz/enigma/TokenChecker.java | 71 ++++++++++ test/cuchaz/enigma/inputs/constructors/Caller.java | 15 +- .../inputs/constructors/DefaultConstructable.java | 6 + .../enigma/inputs/constructors/SubClass.java | 3 +- .../enigma/inputs/constructors/SubSubClass.java | 2 +- 7 files changed, 266 insertions(+), 12 deletions(-) create mode 100644 test/cuchaz/enigma/TestTokensConstructors.java create mode 100644 test/cuchaz/enigma/TokenChecker.java create mode 100644 test/cuchaz/enigma/inputs/constructors/DefaultConstructable.java (limited to 'test') diff --git a/test/cuchaz/enigma/TestJarIndexConstructorReferences.java b/test/cuchaz/enigma/TestJarIndexConstructorReferences.java index 38882a0..c069188 100644 --- a/test/cuchaz/enigma/TestJarIndexConstructorReferences.java +++ b/test/cuchaz/enigma/TestJarIndexConstructorReferences.java @@ -18,10 +18,13 @@ import static org.hamcrest.Matchers.containsInAnyOrder; import static org.hamcrest.Matchers.empty; import static org.hamcrest.Matchers.is; +import java.io.File; +import java.util.Collection; import java.util.jar.JarFile; import org.junit.Test; +import cuchaz.enigma.analysis.EntryReference; import cuchaz.enigma.analysis.JarIndex; import cuchaz.enigma.mapping.BehaviorEntry; import cuchaz.enigma.mapping.ClassEntry; @@ -30,17 +33,19 @@ import cuchaz.enigma.mapping.ConstructorEntry; public class TestJarIndexConstructorReferences { private JarIndex m_index; - + private ClassEntry m_baseClass = new ClassEntry( "none/a" ); - private ClassEntry m_subClass = new ClassEntry( "none/c" ); - private ClassEntry m_subsubClass = new ClassEntry( "none/d" ); + 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( "build/libs/testConstructors.obf.jar" ), false ); + m_index.indexJar( new JarFile( jarFile ), false ); } @Test @@ -51,6 +56,7 @@ public class TestJarIndexConstructorReferences m_baseClass, m_subClass, m_subsubClass, + m_defaultClass, m_callerClass ) ); } @@ -60,7 +66,8 @@ public class TestJarIndexConstructorReferences public void baseDefault( ) { BehaviorEntry source = new ConstructorEntry( m_baseClass, "()V" ); - assertThat( m_index.getBehaviorReferences( source ), containsInAnyOrder( + 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" ) @@ -126,4 +133,14 @@ public class TestJarIndexConstructorReferences 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" ) + ) ); + } } diff --git a/test/cuchaz/enigma/TestTokensConstructors.java b/test/cuchaz/enigma/TestTokensConstructors.java new file mode 100644 index 0000000..2409153 --- /dev/null +++ b/test/cuchaz/enigma/TestTokensConstructors.java @@ -0,0 +1,152 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Public License v3.0 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/gpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ +package cuchaz.enigma; + +import static cuchaz.enigma.EntryFactory.newBehaviorReferenceByConstructor; +import static cuchaz.enigma.EntryFactory.newBehaviorReferenceByMethod; +import static cuchaz.enigma.EntryFactory.newConstructor; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.containsInAnyOrder; +import static org.hamcrest.Matchers.is; +import static org.hamcrest.Matchers.nullValue; + +import java.io.File; + +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" ) ); + } + + @Test + 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" ) ); + } + + @Test + public void subsubDeclarations( ) + { + assertThat( getDeclarationToken( newConstructor( "none/e", "(I)V" ) ), is( "e" ) ); + } + + @Test + public void defaultDeclarations( ) + { + assertThat( getDeclarationToken( newConstructor( "none/c", "()V" ) ), nullValue() ); + } + + @Test + public void baseDefaultReferences( ) + { + BehaviorEntry source = newConstructor( "none/a", "()V" ); + assertThat( + getReferenceTokens( newBehaviorReferenceByMethod( source, "none/b", "a", "()V" ) ), + containsInAnyOrder( "a" ) + ); + assertThat( + 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" + ); + } + + @Test + public void baseIntReferences( ) + { + BehaviorEntry source = newConstructor( "none/a", "(I)V" ); + assertThat( + getReferenceTokens( newBehaviorReferenceByMethod( source, "none/b", "b", "()V" ) ), + containsInAnyOrder( "a" ) + ); + } + + @Test + public void subDefaultReferences( ) + { + BehaviorEntry source = newConstructor( "none/d", "()V" ); + assertThat( + getReferenceTokens( newBehaviorReferenceByMethod( source, "none/b", "c", "()V" ) ), + containsInAnyOrder( "d" ) + ); + assertThat( + 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" ) + ); + assertThat( + getReferenceTokens( newBehaviorReferenceByConstructor( source, "none/d", "(II)V" ) ), + containsInAnyOrder( "this" ) + ); + assertThat( + getReferenceTokens( newBehaviorReferenceByConstructor( source, "none/e", "(I)V" ) ), + containsInAnyOrder( "super" ) + ); + } + + @Test + public void subIntIntReferences( ) + { + BehaviorEntry source = newConstructor( "none/d", "(II)V" ); + assertThat( + getReferenceTokens( newBehaviorReferenceByMethod( source, "none/b", "e", "()V" ) ), + containsInAnyOrder( "d" ) + ); + } + + @Test + public void subsubIntReferences( ) + { + BehaviorEntry source = newConstructor( "none/e", "(I)V" ); + assertThat( + getReferenceTokens( newBehaviorReferenceByMethod( source, "none/b", "f", "()V" ) ), + containsInAnyOrder( "e" ) + ); + } + + @Test + public void defaultConstructableReferences( ) + { + BehaviorEntry source = newConstructor( "none/c", "()V" ); + assertThat( + getReferenceTokens( newBehaviorReferenceByMethod( source, "none/b", "g", "()V" ) ), + containsInAnyOrder( "c" ) + ); + } +} diff --git a/test/cuchaz/enigma/TokenChecker.java b/test/cuchaz/enigma/TokenChecker.java new file mode 100644 index 0000000..07ab9ec --- /dev/null +++ b/test/cuchaz/enigma/TokenChecker.java @@ -0,0 +1,71 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Public License v3.0 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/gpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ +package cuchaz.enigma; + +import java.io.File; +import java.io.IOException; +import java.util.Collection; +import java.util.List; + +import com.beust.jcommander.internal.Lists; +import com.strobel.decompiler.languages.java.ast.CompilationUnit; + +import cuchaz.enigma.analysis.EntryReference; +import cuchaz.enigma.analysis.SourceIndex; +import cuchaz.enigma.analysis.Token; +import cuchaz.enigma.analysis.TreeDumpVisitor; +import cuchaz.enigma.mapping.Entry; + +public class TokenChecker +{ + private Deobfuscator m_deobfuscator; + + protected TokenChecker( File jarFile ) + throws IOException + { + m_deobfuscator = new Deobfuscator( jarFile ); + } + + protected String getDeclarationToken( Entry entry ) + { + // decompile the class + 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 ); + + // get the token value + Token token = index.getDeclarationToken( entry ); + if( token == null ) + { + return null; + } + return source.substring( token.start, token.end ); + } + + @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 ); + + // get the token values + List values = Lists.newArrayList(); + for( Token token : index.getReferenceTokens( (EntryReference)reference ) ) + { + values.add( source.substring( token.start, token.end ) ); + } + return values; + } +} diff --git a/test/cuchaz/enigma/inputs/constructors/Caller.java b/test/cuchaz/enigma/inputs/constructors/Caller.java index f356b1b..b218619 100644 --- a/test/cuchaz/enigma/inputs/constructors/Caller.java +++ b/test/cuchaz/enigma/inputs/constructors/Caller.java @@ -20,28 +20,35 @@ public class Caller // c()V public void callSubDefault( ) { - // none/c.()V + // none/d.()V System.out.println( new SubClass() ); } // d()V public void callSubInt( ) { - // none/c.(I)V + // none/d.(I)V System.out.println( new SubClass( 6 ) ); } // e()V public void callSubIntInt( ) { - // none/c.(II)V + // none/d.(II)V System.out.println( new SubClass( 4, 2 ) ); } // f()V public void callSubSubInt( ) { - // none/d.(I)V + // none/e.(I)V System.out.println( new SubSubClass( 3 ) ); } + + // g()V + public void callDefaultConstructable() + { + // none/c.()V + System.out.println( new DefaultConstructable() ); + } } diff --git a/test/cuchaz/enigma/inputs/constructors/DefaultConstructable.java b/test/cuchaz/enigma/inputs/constructors/DefaultConstructable.java new file mode 100644 index 0000000..6cfd35e --- /dev/null +++ b/test/cuchaz/enigma/inputs/constructors/DefaultConstructable.java @@ -0,0 +1,6 @@ +package cuchaz.enigma.inputs.constructors; + +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 2235de3..6ef7732 100644 --- a/test/cuchaz/enigma/inputs/constructors/SubClass.java +++ b/test/cuchaz/enigma/inputs/constructors/SubClass.java @@ -1,6 +1,6 @@ package cuchaz.enigma.inputs.constructors; -// none/c extends none/a +// none/d extends none/a public class SubClass extends BaseClass { // ()V @@ -24,6 +24,7 @@ public class SubClass extends BaseClass this( a + b ); } + // (III)V 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 a9445d8..76a0f1f 100644 --- a/test/cuchaz/enigma/inputs/constructors/SubSubClass.java +++ b/test/cuchaz/enigma/inputs/constructors/SubSubClass.java @@ -1,6 +1,6 @@ package cuchaz.enigma.inputs.constructors; -// none/d extends none/c +// none/e extends none/d public class SubSubClass extends SubClass { // (I)V -- cgit v1.2.3 From a8d0f97c270e32653aa246d7437478885077e24d Mon Sep 17 00:00:00 2001 From: jeff Date: Sat, 20 Sep 2014 17:11:25 -0400 Subject: cleaned up imports. I have no idea why Eclipse likes importing jcommander classes instead of guava classes, but it's annoyong! --- test/cuchaz/enigma/TestDeobfuscator.java | 4 ++-- test/cuchaz/enigma/TokenChecker.java | 3 +-- 2 files changed, 3 insertions(+), 4 deletions(-) (limited to 'test') diff --git a/test/cuchaz/enigma/TestDeobfuscator.java b/test/cuchaz/enigma/TestDeobfuscator.java index 3e679fb..3bb0c48 100644 --- a/test/cuchaz/enigma/TestDeobfuscator.java +++ b/test/cuchaz/enigma/TestDeobfuscator.java @@ -11,7 +11,7 @@ ******************************************************************************/ package cuchaz.enigma; -import static org.junit.Assert.*; +import static org.junit.Assert.assertEquals; import java.io.File; import java.io.IOException; @@ -19,7 +19,7 @@ import java.util.List; import org.junit.Test; -import com.beust.jcommander.internal.Lists; +import com.google.common.collect.Lists; import cuchaz.enigma.mapping.ClassEntry; diff --git a/test/cuchaz/enigma/TokenChecker.java b/test/cuchaz/enigma/TokenChecker.java index 07ab9ec..c0852f3 100644 --- a/test/cuchaz/enigma/TokenChecker.java +++ b/test/cuchaz/enigma/TokenChecker.java @@ -15,13 +15,12 @@ import java.io.IOException; import java.util.Collection; import java.util.List; -import com.beust.jcommander.internal.Lists; +import com.google.common.collect.Lists; import com.strobel.decompiler.languages.java.ast.CompilationUnit; import cuchaz.enigma.analysis.EntryReference; import cuchaz.enigma.analysis.SourceIndex; import cuchaz.enigma.analysis.Token; -import cuchaz.enigma.analysis.TreeDumpVisitor; import cuchaz.enigma.mapping.Entry; public class TokenChecker -- cgit v1.2.3 From 8409dea980fa03c06b180969c5e0696f7cb5474b Mon Sep 17 00:00:00 2001 From: jeff Date: Sun, 21 Sep 2014 00:32:03 -0400 Subject: started unit testing for inner/anonymous class detection --- test/cuchaz/enigma/TestDeobfuscator.java | 2 +- test/cuchaz/enigma/TestInnerClasses.java | 64 ++++++++++++++++++++++ .../enigma/TestJarIndexConstructorReferences.java | 10 +--- .../cuchaz/enigma/TestJarIndexInheritanceTree.java | 14 +---- test/cuchaz/enigma/TestJarIndexLoneClass.java | 14 +---- .../enigma/inputs/innerClasses/Anonymous.java | 17 ++++++ .../inputs/innerClasses/ConstructorArgs.java | 22 ++++++++ test/cuchaz/enigma/inputs/innerClasses/Simple.java | 9 +++ 8 files changed, 122 insertions(+), 30 deletions(-) create mode 100644 test/cuchaz/enigma/TestInnerClasses.java create mode 100644 test/cuchaz/enigma/inputs/innerClasses/Anonymous.java create mode 100644 test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java create mode 100644 test/cuchaz/enigma/inputs/innerClasses/Simple.java (limited to 'test') diff --git a/test/cuchaz/enigma/TestDeobfuscator.java b/test/cuchaz/enigma/TestDeobfuscator.java index 3bb0c48..71de24a 100644 --- a/test/cuchaz/enigma/TestDeobfuscator.java +++ b/test/cuchaz/enigma/TestDeobfuscator.java @@ -11,7 +11,7 @@ ******************************************************************************/ package cuchaz.enigma; -import static org.junit.Assert.assertEquals; +import static org.junit.Assert.*; import java.io.File; import java.io.IOException; diff --git a/test/cuchaz/enigma/TestInnerClasses.java b/test/cuchaz/enigma/TestInnerClasses.java new file mode 100644 index 0000000..c6b1b5f --- /dev/null +++ b/test/cuchaz/enigma/TestInnerClasses.java @@ -0,0 +1,64 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Public License v3.0 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/gpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ +package cuchaz.enigma; + +import static org.hamcrest.MatcherAssert.*; +import static org.hamcrest.Matchers.*; + +import java.util.jar.JarFile; + +import org.junit.Test; + +import cuchaz.enigma.analysis.JarIndex; + +public class TestInnerClasses +{ + private JarIndex m_index; + + private static final String AnonymousOuter = "none/a"; + private static final String AnonymousInner = "none/b"; + private static final String SimpleOuter = "none/e"; + private static final String SimpleInner = "none/f"; + private static final String ConstructorArgsOuter = "none/c"; + private static final String ConstructorArgsInner = "none/d"; + + public TestInnerClasses( ) + throws Exception + { + m_index = new JarIndex(); + 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 ) ); + } + + @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 ) ); + } + + @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 ) ); + } +} diff --git a/test/cuchaz/enigma/TestJarIndexConstructorReferences.java b/test/cuchaz/enigma/TestJarIndexConstructorReferences.java index c069188..0238171 100644 --- a/test/cuchaz/enigma/TestJarIndexConstructorReferences.java +++ b/test/cuchaz/enigma/TestJarIndexConstructorReferences.java @@ -10,13 +10,9 @@ ******************************************************************************/ package cuchaz.enigma; -import static cuchaz.enigma.EntryFactory.newBehaviorReferenceByConstructor; -import static cuchaz.enigma.EntryFactory.newBehaviorReferenceByMethod; -import static cuchaz.enigma.EntryFactory.newClass; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.empty; -import static org.hamcrest.Matchers.is; +import static cuchaz.enigma.EntryFactory.*; +import static org.hamcrest.MatcherAssert.*; +import static org.hamcrest.Matchers.*; import java.io.File; import java.util.Collection; diff --git a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java index 3d488ee..317a6bc 100644 --- a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java +++ b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java @@ -10,17 +10,9 @@ ******************************************************************************/ package cuchaz.enigma; -import static cuchaz.enigma.EntryFactory.newBehaviorReferenceByConstructor; -import static cuchaz.enigma.EntryFactory.newBehaviorReferenceByMethod; -import static cuchaz.enigma.EntryFactory.newClass; -import static cuchaz.enigma.EntryFactory.newFieldReferenceByConstructor; -import static cuchaz.enigma.EntryFactory.newFieldReferenceByMethod; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.empty; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.nullValue; +import static cuchaz.enigma.EntryFactory.*; +import static org.hamcrest.MatcherAssert.*; +import static org.hamcrest.Matchers.*; import java.util.Collection; import java.util.Set; diff --git a/test/cuchaz/enigma/TestJarIndexLoneClass.java b/test/cuchaz/enigma/TestJarIndexLoneClass.java index 9236d0c..4c32b70 100644 --- a/test/cuchaz/enigma/TestJarIndexLoneClass.java +++ b/test/cuchaz/enigma/TestJarIndexLoneClass.java @@ -11,17 +11,9 @@ ******************************************************************************/ package cuchaz.enigma; -import static cuchaz.enigma.EntryFactory.newClass; -import static cuchaz.enigma.EntryFactory.newField; -import static cuchaz.enigma.EntryFactory.newFieldReferenceByConstructor; -import static cuchaz.enigma.EntryFactory.newFieldReferenceByMethod; -import static cuchaz.enigma.EntryFactory.newMethod; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.empty; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.not; -import static org.hamcrest.Matchers.nullValue; +import static cuchaz.enigma.EntryFactory.*; +import static org.hamcrest.MatcherAssert.*; +import static org.hamcrest.Matchers.*; import java.util.Collection; import java.util.Set; diff --git a/test/cuchaz/enigma/inputs/innerClasses/Anonymous.java b/test/cuchaz/enigma/inputs/innerClasses/Anonymous.java new file mode 100644 index 0000000..dbff523 --- /dev/null +++ b/test/cuchaz/enigma/inputs/innerClasses/Anonymous.java @@ -0,0 +1,17 @@ +package cuchaz.enigma.inputs.innerClasses; + +public class Anonymous // a +{ + public void foo( ) + { + Runnable runnable = new Runnable( ) // b + { + @Override + public void run( ) + { + // don't care + } + }; + runnable.run(); + } +} diff --git a/test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java b/test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java new file mode 100644 index 0000000..d12d9cf --- /dev/null +++ b/test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java @@ -0,0 +1,22 @@ +package cuchaz.enigma.inputs.innerClasses; + +@SuppressWarnings( "unused" ) +public class ConstructorArgs // c +{ + class Inner // d + { + private int a; + + public Inner( int a ) + { + this.a = a; + } + } + + Inner i; + + 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 new file mode 100644 index 0000000..f2c08a7 --- /dev/null +++ b/test/cuchaz/enigma/inputs/innerClasses/Simple.java @@ -0,0 +1,9 @@ +package cuchaz.enigma.inputs.innerClasses; + +public class Simple // e +{ + class Inner // f + { + // nothing to do + } +} -- cgit v1.2.3 From df06f4ddde5e255750edc4087cfba54823404909 Mon Sep 17 00:00:00 2001 From: jeff Date: Sun, 21 Sep 2014 22:08:05 -0400 Subject: improved inner/anonymous class detection --- test/cuchaz/enigma/TestInnerClasses.java | 18 ++++++++++++++---- test/cuchaz/enigma/inputs/innerClasses/Anonymous.java | 4 ++-- .../inputs/innerClasses/AnonymousWithScopeArgs.java | 16 ++++++++++++++++ .../enigma/inputs/innerClasses/ConstructorArgs.java | 4 ++-- test/cuchaz/enigma/inputs/innerClasses/Simple.java | 4 ++-- 5 files changed, 36 insertions(+), 10 deletions(-) create mode 100644 test/cuchaz/enigma/inputs/innerClasses/AnonymousWithScopeArgs.java (limited to 'test') diff --git a/test/cuchaz/enigma/TestInnerClasses.java b/test/cuchaz/enigma/TestInnerClasses.java index c6b1b5f..e555d92 100644 --- a/test/cuchaz/enigma/TestInnerClasses.java +++ b/test/cuchaz/enigma/TestInnerClasses.java @@ -26,10 +26,12 @@ public class TestInnerClasses private static final String AnonymousOuter = "none/a"; private static final String AnonymousInner = "none/b"; - private static final String SimpleOuter = "none/e"; - private static final String SimpleInner = "none/f"; - private static final String ConstructorArgsOuter = "none/c"; - private static final String ConstructorArgsInner = "none/d"; + private static final String SimpleOuter = "none/g"; + private static final String SimpleInner = "none/h"; + private static final String ConstructorArgsOuter = "none/e"; + private static final String ConstructorArgsInner = "none/f"; + private static final String AnonymousWithScopeArgsOuter = "none/c"; + private static final String AnonymousWithScopeArgsInner = "none/d"; public TestInnerClasses( ) throws Exception @@ -61,4 +63,12 @@ public class TestInnerClasses 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 ) ); + } } diff --git a/test/cuchaz/enigma/inputs/innerClasses/Anonymous.java b/test/cuchaz/enigma/inputs/innerClasses/Anonymous.java index dbff523..d36a514 100644 --- a/test/cuchaz/enigma/inputs/innerClasses/Anonymous.java +++ b/test/cuchaz/enigma/inputs/innerClasses/Anonymous.java @@ -1,10 +1,10 @@ package cuchaz.enigma.inputs.innerClasses; -public class Anonymous // a +public class Anonymous { public void foo( ) { - Runnable runnable = new Runnable( ) // b + Runnable runnable = new Runnable( ) { @Override public void run( ) diff --git a/test/cuchaz/enigma/inputs/innerClasses/AnonymousWithScopeArgs.java b/test/cuchaz/enigma/inputs/innerClasses/AnonymousWithScopeArgs.java new file mode 100644 index 0000000..e0a65e2 --- /dev/null +++ b/test/cuchaz/enigma/inputs/innerClasses/AnonymousWithScopeArgs.java @@ -0,0 +1,16 @@ +package cuchaz.enigma.inputs.innerClasses; + +public class AnonymousWithScopeArgs +{ + public static void foo( final Simple arg ) + { + System.out.println( new Object( ) + { + @Override + 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 d12d9cf..e24395c 100644 --- a/test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java +++ b/test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java @@ -1,9 +1,9 @@ package cuchaz.enigma.inputs.innerClasses; @SuppressWarnings( "unused" ) -public class ConstructorArgs // c +public class ConstructorArgs { - class Inner // d + class Inner { private int a; diff --git a/test/cuchaz/enigma/inputs/innerClasses/Simple.java b/test/cuchaz/enigma/inputs/innerClasses/Simple.java index f2c08a7..405c639 100644 --- a/test/cuchaz/enigma/inputs/innerClasses/Simple.java +++ b/test/cuchaz/enigma/inputs/innerClasses/Simple.java @@ -1,8 +1,8 @@ package cuchaz.enigma.inputs.innerClasses; -public class Simple // e +public class Simple { - class Inner // f + class Inner { // nothing to do } -- cgit v1.2.3 From 8776a8ba38123c822530e5f659c626c8db616217 Mon Sep 17 00:00:00 2001 From: jeff Date: Wed, 24 Sep 2014 01:00:54 -0400 Subject: HOW DO I WRITE SO MANY BUGS?!? --- .../cuchaz/enigma/TestJarIndexInheritanceTree.java | 46 +++++++----------- test/cuchaz/enigma/TestJarIndexLoneClass.java | 13 ++--- test/cuchaz/enigma/TestSourceIndex.java | 56 ++++++++++++++++++++++ 3 files changed, 77 insertions(+), 38 deletions(-) create mode 100644 test/cuchaz/enigma/TestSourceIndex.java (limited to 'test') diff --git a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java index 317a6bc..50c2282 100644 --- a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java +++ b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java @@ -99,28 +99,6 @@ public class TestJarIndexInheritanceTree assertThat( m_index.getAccess( m_numThingsField ), is( Access.Private ) ); } - @Test - public void isImplemented( ) - { - // getName() - assertThat( m_index.isMethodImplemented( new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ) ), is( true ) ); - assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassA, "a", "()Ljava/lang/String;" ) ), is( false ) ); - assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ) ), is( true ) ); - assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassB, "a", "()Ljava/lang/String;" ) ), is( false ) ); - - // doBaseThings() - assertThat( m_index.isMethodImplemented( new MethodEntry( m_baseClass, "a", "()V" ) ), is( true ) ); - assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassA, "a", "()V" ) ), is( false ) ); - assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassAA, "a", "()V" ) ), is( true ) ); - assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassB, "a", "()V" ) ), is( true ) ); - - // doBThings() - assertThat( m_index.isMethodImplemented( new MethodEntry( m_baseClass, "b", "()V" ) ), is( false ) ); - assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassA, "b", "()V" ) ), is( false ) ); - assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassAA, "b", "()V" ) ), is( false ) ); - assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassB, "b", "()V" ) ), is( true ) ); - } - @Test public void relatedMethodImplementations( ) { @@ -238,11 +216,23 @@ public class TestJarIndexInheritanceTree assertThat( m_index.containsObfField( m_numThingsField ), is( true ) ); // methods - assertThat( m_index.containsObfMethod( new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ) ), is( true ) ); - assertThat( m_index.containsObfMethod( new MethodEntry( m_baseClass, "a", "()V" ) ), is( true ) ); - assertThat( m_index.containsObfMethod( new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ) ), is( true ) ); - assertThat( m_index.containsObfMethod( new MethodEntry( m_subClassAA, "a", "()V" ) ), is( true ) ); - assertThat( m_index.containsObfMethod( new MethodEntry( m_subClassB, "a", "()V" ) ), is( true ) ); - assertThat( m_index.containsObfMethod( new MethodEntry( m_subClassB, "b", "()V" ) ), is( true ) ); + // 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 ) ); + + // 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 ) ); + + // 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 ) ); + } } diff --git a/test/cuchaz/enigma/TestJarIndexLoneClass.java b/test/cuchaz/enigma/TestJarIndexLoneClass.java index 4c32b70..f77d86a 100644 --- a/test/cuchaz/enigma/TestJarIndexLoneClass.java +++ b/test/cuchaz/enigma/TestJarIndexLoneClass.java @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2014 Jeff Martin.\ + * Copyright (c) 2014 Jeff Martin. * * All rights reserved. This program and the accompanying materials * are made available under the terms of the GNU Public License v3.0 @@ -72,13 +72,6 @@ public class TestJarIndexLoneClass assertThat( m_index.getAccess( newField( "none/a", "b" ) ), is( nullValue() ) ); } - @Test - public void isImplemented( ) - { - assertThat( m_index.isMethodImplemented( newMethod( "none/a", "a", "()Ljava/lang/String;" ) ), is( true ) ); - assertThat( m_index.isMethodImplemented( newMethod( "none/a", "b", "()Ljava/lang/String;" ) ), is( false ) ); - } - @Test public void classInheritance( ) { @@ -187,7 +180,7 @@ public class TestJarIndexLoneClass 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.containsObfMethod( newMethod( "none/a", "a", "()Ljava/lang/String;" ) ), is( true ) ); - assertThat( m_index.containsObfMethod( newMethod( "none/a", "b", "()Ljava/lang/String;" ) ), 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 new file mode 100644 index 0000000..dc6ca7e --- /dev/null +++ b/test/cuchaz/enigma/TestSourceIndex.java @@ -0,0 +1,56 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Public License v3.0 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/gpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ +package cuchaz.enigma; + +import java.io.File; +import java.util.Set; + +import org.junit.Test; + +import com.google.common.collect.Sets; +import com.strobel.decompiler.languages.java.ast.CompilationUnit; + +import cuchaz.enigma.mapping.ClassEntry; + +public class TestSourceIndex +{ + @Test + 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 : 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 ); + } + } + } +} -- cgit v1.2.3 From cf3ffcee30083a71e68e3edb9ecbb936cc255992 Mon Sep 17 00:00:00 2001 From: jeff Date: Sun, 28 Sep 2014 15:20:54 -0400 Subject: added proper support for renaming constructors --- test/cuchaz/enigma/EntryFactory.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'test') diff --git a/test/cuchaz/enigma/EntryFactory.java b/test/cuchaz/enigma/EntryFactory.java index 66f83df..5a8a427 100644 --- a/test/cuchaz/enigma/EntryFactory.java +++ b/test/cuchaz/enigma/EntryFactory.java @@ -42,21 +42,21 @@ public class EntryFactory public static EntryReference newFieldReferenceByMethod( FieldEntry fieldEntry, String callerClassName, String callerName, String callerSignature ) { - return new EntryReference( fieldEntry, newMethod( callerClassName, callerName, 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 ) ); + 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 ) ); + 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 ) ); + return new EntryReference( behaviorEntry, "", newConstructor( callerClassName, callerSignature ) ); } } -- cgit v1.2.3 From 056f388494337a0f3cec10fab8e207017757bf6d Mon Sep 17 00:00:00 2001 From: jeff Date: Wed, 1 Oct 2014 00:21:29 -0400 Subject: fix inner classes test --- test/cuchaz/enigma/TestInnerClasses.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'test') diff --git a/test/cuchaz/enigma/TestInnerClasses.java b/test/cuchaz/enigma/TestInnerClasses.java index e555d92..a7ee0b6 100644 --- a/test/cuchaz/enigma/TestInnerClasses.java +++ b/test/cuchaz/enigma/TestInnerClasses.java @@ -25,13 +25,13 @@ public class TestInnerClasses private JarIndex m_index; private static final String AnonymousOuter = "none/a"; - private static final String AnonymousInner = "none/b"; + private static final String AnonymousInner = "b"; private static final String SimpleOuter = "none/g"; - private static final String SimpleInner = "none/h"; + private static final String SimpleInner = "h"; private static final String ConstructorArgsOuter = "none/e"; - private static final String ConstructorArgsInner = "none/f"; + private static final String ConstructorArgsInner = "f"; private static final String AnonymousWithScopeArgsOuter = "none/c"; - private static final String AnonymousWithScopeArgsInner = "none/d"; + private static final String AnonymousWithScopeArgsInner = "d"; public TestInnerClasses( ) throws Exception -- cgit v1.2.3 From 22cc7f91d61e32c751b74dc6662bef616ab5ddb7 Mon Sep 17 00:00:00 2001 From: jeff Date: Thu, 2 Oct 2014 22:47:30 -0400 Subject: fixed test case --- test/cuchaz/enigma/TestJarIndexLoneClass.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'test') diff --git a/test/cuchaz/enigma/TestJarIndexLoneClass.java b/test/cuchaz/enigma/TestJarIndexLoneClass.java index f77d86a..e2a87d0 100644 --- a/test/cuchaz/enigma/TestJarIndexLoneClass.java +++ b/test/cuchaz/enigma/TestJarIndexLoneClass.java @@ -140,7 +140,7 @@ public class TestJarIndexLoneClass @Test public void outerClass( ) { - assertThat( m_index.getOuterClass( "none/a" ), is( nullValue() ) ); + assertThat( m_index.getOuterClass( "a" ), is( nullValue() ) ); } @Test -- cgit v1.2.3 From 035e73fba69ab06172ae9d784b9e0e4fffeb8388 Mon Sep 17 00:00:00 2001 From: jeff Date: Wed, 8 Oct 2014 23:54:08 -0400 Subject: relicense as LGPL --- test/cuchaz/enigma/EntryFactory.java | 9 ++++----- test/cuchaz/enigma/TestDeobfuscator.java | 9 ++++----- test/cuchaz/enigma/TestInnerClasses.java | 7 +++---- test/cuchaz/enigma/TestJarIndexConstructorReferences.java | 6 +++--- test/cuchaz/enigma/TestJarIndexInheritanceTree.java | 6 +++--- test/cuchaz/enigma/TestJarIndexLoneClass.java | 7 +++---- test/cuchaz/enigma/TestSourceIndex.java | 7 +++---- test/cuchaz/enigma/TestTokensConstructors.java | 6 +++--- test/cuchaz/enigma/TokenChecker.java | 6 +++--- test/cuchaz/enigma/inputs/Keep.java | 10 ++++++++++ test/cuchaz/enigma/inputs/constructors/BaseClass.java | 10 ++++++++++ test/cuchaz/enigma/inputs/constructors/Caller.java | 10 ++++++++++ .../enigma/inputs/constructors/DefaultConstructable.java | 10 ++++++++++ test/cuchaz/enigma/inputs/constructors/SubClass.java | 10 ++++++++++ test/cuchaz/enigma/inputs/constructors/SubSubClass.java | 10 ++++++++++ test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java | 10 ++++++++++ test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java | 10 ++++++++++ test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java | 10 ++++++++++ test/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java | 10 ++++++++++ test/cuchaz/enigma/inputs/innerClasses/Anonymous.java | 10 ++++++++++ .../enigma/inputs/innerClasses/AnonymousWithScopeArgs.java | 10 ++++++++++ test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java | 10 ++++++++++ test/cuchaz/enigma/inputs/innerClasses/Simple.java | 10 ++++++++++ test/cuchaz/enigma/inputs/loneClass/LoneClass.java | 10 ++++++++++ 24 files changed, 179 insertions(+), 34 deletions(-) (limited to 'test') diff --git a/test/cuchaz/enigma/EntryFactory.java b/test/cuchaz/enigma/EntryFactory.java index 5a8a427..f66149f 100644 --- a/test/cuchaz/enigma/EntryFactory.java +++ b/test/cuchaz/enigma/EntryFactory.java @@ -1,10 +1,9 @@ /******************************************************************************* - * Copyright (c) 2014 Jeff Martin.\ - * + * Copyright (c) 2014 Jeff Martin. * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Public License v3.0 - * which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/gpl.html + * are made available under the terms of the GNU Lesser General Public + * License v3.0 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html * * Contributors: * Jeff Martin - initial API and implementation diff --git a/test/cuchaz/enigma/TestDeobfuscator.java b/test/cuchaz/enigma/TestDeobfuscator.java index 71de24a..1f19329 100644 --- a/test/cuchaz/enigma/TestDeobfuscator.java +++ b/test/cuchaz/enigma/TestDeobfuscator.java @@ -1,10 +1,9 @@ /******************************************************************************* - * Copyright (c) 2014 Jeff Martin.\ - * + * Copyright (c) 2014 Jeff Martin. * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Public License v3.0 - * which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/gpl.html + * are made available under the terms of the GNU Lesser General Public + * License v3.0 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html * * Contributors: * Jeff Martin - initial API and implementation diff --git a/test/cuchaz/enigma/TestInnerClasses.java b/test/cuchaz/enigma/TestInnerClasses.java index a7ee0b6..81626ff 100644 --- a/test/cuchaz/enigma/TestInnerClasses.java +++ b/test/cuchaz/enigma/TestInnerClasses.java @@ -1,10 +1,9 @@ /******************************************************************************* * Copyright (c) 2014 Jeff Martin. - * * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Public License v3.0 - * which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/gpl.html + * are made available under the terms of the GNU Lesser General Public + * License v3.0 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html * * Contributors: * Jeff Martin - initial API and implementation diff --git a/test/cuchaz/enigma/TestJarIndexConstructorReferences.java b/test/cuchaz/enigma/TestJarIndexConstructorReferences.java index 0238171..f2c6525 100644 --- a/test/cuchaz/enigma/TestJarIndexConstructorReferences.java +++ b/test/cuchaz/enigma/TestJarIndexConstructorReferences.java @@ -1,9 +1,9 @@ /******************************************************************************* * Copyright (c) 2014 Jeff Martin. * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Public License v3.0 - * which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/gpl.html + * are made available under the terms of the GNU Lesser General Public + * License v3.0 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html * * Contributors: * Jeff Martin - initial API and implementation diff --git a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java index 50c2282..dc7900c 100644 --- a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java +++ b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java @@ -1,9 +1,9 @@ /******************************************************************************* * Copyright (c) 2014 Jeff Martin. * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Public License v3.0 - * which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/gpl.html + * are made available under the terms of the GNU Lesser General Public + * License v3.0 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html * * Contributors: * Jeff Martin - initial API and implementation diff --git a/test/cuchaz/enigma/TestJarIndexLoneClass.java b/test/cuchaz/enigma/TestJarIndexLoneClass.java index e2a87d0..defec46 100644 --- a/test/cuchaz/enigma/TestJarIndexLoneClass.java +++ b/test/cuchaz/enigma/TestJarIndexLoneClass.java @@ -1,10 +1,9 @@ /******************************************************************************* * Copyright (c) 2014 Jeff Martin. - * * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Public License v3.0 - * which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/gpl.html + * are made available under the terms of the GNU Lesser General Public + * License v3.0 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html * * Contributors: * Jeff Martin - initial API and implementation diff --git a/test/cuchaz/enigma/TestSourceIndex.java b/test/cuchaz/enigma/TestSourceIndex.java index dc6ca7e..408dcde 100644 --- a/test/cuchaz/enigma/TestSourceIndex.java +++ b/test/cuchaz/enigma/TestSourceIndex.java @@ -1,10 +1,9 @@ /******************************************************************************* * Copyright (c) 2014 Jeff Martin. - * * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Public License v3.0 - * which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/gpl.html + * are made available under the terms of the GNU Lesser General Public + * License v3.0 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html * * Contributors: * Jeff Martin - initial API and implementation diff --git a/test/cuchaz/enigma/TestTokensConstructors.java b/test/cuchaz/enigma/TestTokensConstructors.java index 2409153..449d70e 100644 --- a/test/cuchaz/enigma/TestTokensConstructors.java +++ b/test/cuchaz/enigma/TestTokensConstructors.java @@ -1,9 +1,9 @@ /******************************************************************************* * Copyright (c) 2014 Jeff Martin. * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Public License v3.0 - * which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/gpl.html + * are made available under the terms of the GNU Lesser General Public + * License v3.0 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html * * Contributors: * Jeff Martin - initial API and implementation diff --git a/test/cuchaz/enigma/TokenChecker.java b/test/cuchaz/enigma/TokenChecker.java index c0852f3..6bcd2bb 100644 --- a/test/cuchaz/enigma/TokenChecker.java +++ b/test/cuchaz/enigma/TokenChecker.java @@ -1,9 +1,9 @@ /******************************************************************************* * Copyright (c) 2014 Jeff Martin. * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Public License v3.0 - * which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/gpl.html + * are made available under the terms of the GNU Lesser General Public + * License v3.0 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html * * Contributors: * Jeff Martin - initial API and implementation diff --git a/test/cuchaz/enigma/inputs/Keep.java b/test/cuchaz/enigma/inputs/Keep.java index 3c12bae..3fb1457 100644 --- a/test/cuchaz/enigma/inputs/Keep.java +++ b/test/cuchaz/enigma/inputs/Keep.java @@ -1,3 +1,13 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser General Public + * License v3.0 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ package cuchaz.enigma.inputs; public class Keep diff --git a/test/cuchaz/enigma/inputs/constructors/BaseClass.java b/test/cuchaz/enigma/inputs/constructors/BaseClass.java index e6d8768..e4e273d 100644 --- a/test/cuchaz/enigma/inputs/constructors/BaseClass.java +++ b/test/cuchaz/enigma/inputs/constructors/BaseClass.java @@ -1,3 +1,13 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser General Public + * License v3.0 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ package cuchaz.enigma.inputs.constructors; // none/a diff --git a/test/cuchaz/enigma/inputs/constructors/Caller.java b/test/cuchaz/enigma/inputs/constructors/Caller.java index b218619..a7b6f1f 100644 --- a/test/cuchaz/enigma/inputs/constructors/Caller.java +++ b/test/cuchaz/enigma/inputs/constructors/Caller.java @@ -1,3 +1,13 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser General Public + * License v3.0 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ package cuchaz.enigma.inputs.constructors; // none/b diff --git a/test/cuchaz/enigma/inputs/constructors/DefaultConstructable.java b/test/cuchaz/enigma/inputs/constructors/DefaultConstructable.java index 6cfd35e..e89a32e 100644 --- a/test/cuchaz/enigma/inputs/constructors/DefaultConstructable.java +++ b/test/cuchaz/enigma/inputs/constructors/DefaultConstructable.java @@ -1,3 +1,13 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser General Public + * License v3.0 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ package cuchaz.enigma.inputs.constructors; public class DefaultConstructable diff --git a/test/cuchaz/enigma/inputs/constructors/SubClass.java b/test/cuchaz/enigma/inputs/constructors/SubClass.java index 6ef7732..0358989 100644 --- a/test/cuchaz/enigma/inputs/constructors/SubClass.java +++ b/test/cuchaz/enigma/inputs/constructors/SubClass.java @@ -1,3 +1,13 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser General Public + * License v3.0 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ package cuchaz.enigma.inputs.constructors; // none/d extends none/a diff --git a/test/cuchaz/enigma/inputs/constructors/SubSubClass.java b/test/cuchaz/enigma/inputs/constructors/SubSubClass.java index 76a0f1f..76e69c1 100644 --- a/test/cuchaz/enigma/inputs/constructors/SubSubClass.java +++ b/test/cuchaz/enigma/inputs/constructors/SubSubClass.java @@ -1,3 +1,13 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser General Public + * License v3.0 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ package cuchaz.enigma.inputs.constructors; // none/e extends none/d diff --git a/test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java b/test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java index 8402dde..9d3807b 100644 --- a/test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java +++ b/test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java @@ -1,3 +1,13 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser General Public + * License v3.0 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ package cuchaz.enigma.inputs.inheritanceTree; // none/a diff --git a/test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java index ed50709..98a9570 100644 --- a/test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java +++ b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java @@ -1,3 +1,13 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser General Public + * License v3.0 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ package cuchaz.enigma.inputs.inheritanceTree; // none/b extends none/a diff --git a/test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java index fc4c8ee..29a29b8 100644 --- a/test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java +++ b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java @@ -1,3 +1,13 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser General Public + * License v3.0 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ package cuchaz.enigma.inputs.inheritanceTree; // none/c extends none/a diff --git a/test/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java b/test/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java index b3b8342..4aa0af0 100644 --- a/test/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java +++ b/test/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java @@ -1,3 +1,13 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser General Public + * License v3.0 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ package cuchaz.enigma.inputs.inheritanceTree; // none/d extends none/b diff --git a/test/cuchaz/enigma/inputs/innerClasses/Anonymous.java b/test/cuchaz/enigma/inputs/innerClasses/Anonymous.java index d36a514..44b529e 100644 --- a/test/cuchaz/enigma/inputs/innerClasses/Anonymous.java +++ b/test/cuchaz/enigma/inputs/innerClasses/Anonymous.java @@ -1,3 +1,13 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser General Public + * License v3.0 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ package cuchaz.enigma.inputs.innerClasses; public class Anonymous diff --git a/test/cuchaz/enigma/inputs/innerClasses/AnonymousWithScopeArgs.java b/test/cuchaz/enigma/inputs/innerClasses/AnonymousWithScopeArgs.java index e0a65e2..4924d09 100644 --- a/test/cuchaz/enigma/inputs/innerClasses/AnonymousWithScopeArgs.java +++ b/test/cuchaz/enigma/inputs/innerClasses/AnonymousWithScopeArgs.java @@ -1,3 +1,13 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser General Public + * License v3.0 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ package cuchaz.enigma.inputs.innerClasses; public class AnonymousWithScopeArgs diff --git a/test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java b/test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java index e24395c..f7d06d4 100644 --- a/test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java +++ b/test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java @@ -1,3 +1,13 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser General Public + * License v3.0 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ package cuchaz.enigma.inputs.innerClasses; @SuppressWarnings( "unused" ) diff --git a/test/cuchaz/enigma/inputs/innerClasses/Simple.java b/test/cuchaz/enigma/inputs/innerClasses/Simple.java index 405c639..9fc9b0c 100644 --- a/test/cuchaz/enigma/inputs/innerClasses/Simple.java +++ b/test/cuchaz/enigma/inputs/innerClasses/Simple.java @@ -1,3 +1,13 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser General Public + * License v3.0 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ package cuchaz.enigma.inputs.innerClasses; public class Simple diff --git a/test/cuchaz/enigma/inputs/loneClass/LoneClass.java b/test/cuchaz/enigma/inputs/loneClass/LoneClass.java index 961b012..1022aa2 100644 --- a/test/cuchaz/enigma/inputs/loneClass/LoneClass.java +++ b/test/cuchaz/enigma/inputs/loneClass/LoneClass.java @@ -1,3 +1,13 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser General Public + * License v3.0 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ package cuchaz.enigma.inputs.loneClass; public class LoneClass -- cgit v1.2.3 From 812e2a4630ef01463ff153ba5ffae675e8ac24ac Mon Sep 17 00:00:00 2001 From: jeff Date: Thu, 9 Oct 2014 19:37:19 -0400 Subject: reverting to GPL license --- test/cuchaz/enigma/EntryFactory.java | 9 +++++---- test/cuchaz/enigma/TestDeobfuscator.java | 9 +++++---- test/cuchaz/enigma/TestInnerClasses.java | 7 ++++--- test/cuchaz/enigma/TestJarIndexConstructorReferences.java | 6 +++--- test/cuchaz/enigma/TestJarIndexInheritanceTree.java | 6 +++--- test/cuchaz/enigma/TestJarIndexLoneClass.java | 7 ++++--- test/cuchaz/enigma/TestSourceIndex.java | 7 ++++--- test/cuchaz/enigma/TestTokensConstructors.java | 6 +++--- test/cuchaz/enigma/TokenChecker.java | 6 +++--- test/cuchaz/enigma/inputs/Keep.java | 10 ---------- test/cuchaz/enigma/inputs/constructors/BaseClass.java | 10 ---------- test/cuchaz/enigma/inputs/constructors/Caller.java | 10 ---------- .../enigma/inputs/constructors/DefaultConstructable.java | 10 ---------- test/cuchaz/enigma/inputs/constructors/SubClass.java | 10 ---------- test/cuchaz/enigma/inputs/constructors/SubSubClass.java | 10 ---------- test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java | 10 ---------- test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java | 10 ---------- test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java | 10 ---------- test/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java | 10 ---------- test/cuchaz/enigma/inputs/innerClasses/Anonymous.java | 10 ---------- .../enigma/inputs/innerClasses/AnonymousWithScopeArgs.java | 10 ---------- test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java | 10 ---------- test/cuchaz/enigma/inputs/innerClasses/Simple.java | 10 ---------- test/cuchaz/enigma/inputs/loneClass/LoneClass.java | 10 ---------- 24 files changed, 34 insertions(+), 179 deletions(-) (limited to 'test') diff --git a/test/cuchaz/enigma/EntryFactory.java b/test/cuchaz/enigma/EntryFactory.java index f66149f..5a8a427 100644 --- a/test/cuchaz/enigma/EntryFactory.java +++ b/test/cuchaz/enigma/EntryFactory.java @@ -1,9 +1,10 @@ /******************************************************************************* - * Copyright (c) 2014 Jeff Martin. + * Copyright (c) 2014 Jeff Martin.\ + * * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser General Public - * License v3.0 which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl.html + * are made available under the terms of the GNU Public License v3.0 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/gpl.html * * Contributors: * Jeff Martin - initial API and implementation diff --git a/test/cuchaz/enigma/TestDeobfuscator.java b/test/cuchaz/enigma/TestDeobfuscator.java index 1f19329..71de24a 100644 --- a/test/cuchaz/enigma/TestDeobfuscator.java +++ b/test/cuchaz/enigma/TestDeobfuscator.java @@ -1,9 +1,10 @@ /******************************************************************************* - * Copyright (c) 2014 Jeff Martin. + * Copyright (c) 2014 Jeff Martin.\ + * * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser General Public - * License v3.0 which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl.html + * are made available under the terms of the GNU Public License v3.0 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/gpl.html * * Contributors: * Jeff Martin - initial API and implementation diff --git a/test/cuchaz/enigma/TestInnerClasses.java b/test/cuchaz/enigma/TestInnerClasses.java index 81626ff..a7ee0b6 100644 --- a/test/cuchaz/enigma/TestInnerClasses.java +++ b/test/cuchaz/enigma/TestInnerClasses.java @@ -1,9 +1,10 @@ /******************************************************************************* * Copyright (c) 2014 Jeff Martin. + * * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser General Public - * License v3.0 which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl.html + * are made available under the terms of the GNU Public License v3.0 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/gpl.html * * Contributors: * Jeff Martin - initial API and implementation diff --git a/test/cuchaz/enigma/TestJarIndexConstructorReferences.java b/test/cuchaz/enigma/TestJarIndexConstructorReferences.java index f2c6525..0238171 100644 --- a/test/cuchaz/enigma/TestJarIndexConstructorReferences.java +++ b/test/cuchaz/enigma/TestJarIndexConstructorReferences.java @@ -1,9 +1,9 @@ /******************************************************************************* * Copyright (c) 2014 Jeff Martin. * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser General Public - * License v3.0 which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl.html + * are made available under the terms of the GNU Public License v3.0 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/gpl.html * * Contributors: * Jeff Martin - initial API and implementation diff --git a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java index dc7900c..50c2282 100644 --- a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java +++ b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java @@ -1,9 +1,9 @@ /******************************************************************************* * Copyright (c) 2014 Jeff Martin. * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser General Public - * License v3.0 which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl.html + * are made available under the terms of the GNU Public License v3.0 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/gpl.html * * Contributors: * Jeff Martin - initial API and implementation diff --git a/test/cuchaz/enigma/TestJarIndexLoneClass.java b/test/cuchaz/enigma/TestJarIndexLoneClass.java index defec46..e2a87d0 100644 --- a/test/cuchaz/enigma/TestJarIndexLoneClass.java +++ b/test/cuchaz/enigma/TestJarIndexLoneClass.java @@ -1,9 +1,10 @@ /******************************************************************************* * Copyright (c) 2014 Jeff Martin. + * * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser General Public - * License v3.0 which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl.html + * are made available under the terms of the GNU Public License v3.0 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/gpl.html * * Contributors: * Jeff Martin - initial API and implementation diff --git a/test/cuchaz/enigma/TestSourceIndex.java b/test/cuchaz/enigma/TestSourceIndex.java index 408dcde..dc6ca7e 100644 --- a/test/cuchaz/enigma/TestSourceIndex.java +++ b/test/cuchaz/enigma/TestSourceIndex.java @@ -1,9 +1,10 @@ /******************************************************************************* * Copyright (c) 2014 Jeff Martin. + * * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser General Public - * License v3.0 which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl.html + * are made available under the terms of the GNU Public License v3.0 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/gpl.html * * Contributors: * Jeff Martin - initial API and implementation diff --git a/test/cuchaz/enigma/TestTokensConstructors.java b/test/cuchaz/enigma/TestTokensConstructors.java index 449d70e..2409153 100644 --- a/test/cuchaz/enigma/TestTokensConstructors.java +++ b/test/cuchaz/enigma/TestTokensConstructors.java @@ -1,9 +1,9 @@ /******************************************************************************* * Copyright (c) 2014 Jeff Martin. * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser General Public - * License v3.0 which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl.html + * are made available under the terms of the GNU Public License v3.0 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/gpl.html * * Contributors: * Jeff Martin - initial API and implementation diff --git a/test/cuchaz/enigma/TokenChecker.java b/test/cuchaz/enigma/TokenChecker.java index 6bcd2bb..c0852f3 100644 --- a/test/cuchaz/enigma/TokenChecker.java +++ b/test/cuchaz/enigma/TokenChecker.java @@ -1,9 +1,9 @@ /******************************************************************************* * Copyright (c) 2014 Jeff Martin. * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser General Public - * License v3.0 which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl.html + * are made available under the terms of the GNU Public License v3.0 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/gpl.html * * Contributors: * Jeff Martin - initial API and implementation diff --git a/test/cuchaz/enigma/inputs/Keep.java b/test/cuchaz/enigma/inputs/Keep.java index 3fb1457..3c12bae 100644 --- a/test/cuchaz/enigma/inputs/Keep.java +++ b/test/cuchaz/enigma/inputs/Keep.java @@ -1,13 +1,3 @@ -/******************************************************************************* - * Copyright (c) 2014 Jeff Martin. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser General Public - * License v3.0 which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl.html - * - * Contributors: - * Jeff Martin - initial API and implementation - ******************************************************************************/ package cuchaz.enigma.inputs; public class Keep diff --git a/test/cuchaz/enigma/inputs/constructors/BaseClass.java b/test/cuchaz/enigma/inputs/constructors/BaseClass.java index e4e273d..e6d8768 100644 --- a/test/cuchaz/enigma/inputs/constructors/BaseClass.java +++ b/test/cuchaz/enigma/inputs/constructors/BaseClass.java @@ -1,13 +1,3 @@ -/******************************************************************************* - * Copyright (c) 2014 Jeff Martin. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser General Public - * License v3.0 which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl.html - * - * Contributors: - * Jeff Martin - initial API and implementation - ******************************************************************************/ package cuchaz.enigma.inputs.constructors; // none/a diff --git a/test/cuchaz/enigma/inputs/constructors/Caller.java b/test/cuchaz/enigma/inputs/constructors/Caller.java index a7b6f1f..b218619 100644 --- a/test/cuchaz/enigma/inputs/constructors/Caller.java +++ b/test/cuchaz/enigma/inputs/constructors/Caller.java @@ -1,13 +1,3 @@ -/******************************************************************************* - * Copyright (c) 2014 Jeff Martin. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser General Public - * License v3.0 which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl.html - * - * Contributors: - * Jeff Martin - initial API and implementation - ******************************************************************************/ package cuchaz.enigma.inputs.constructors; // none/b diff --git a/test/cuchaz/enigma/inputs/constructors/DefaultConstructable.java b/test/cuchaz/enigma/inputs/constructors/DefaultConstructable.java index e89a32e..6cfd35e 100644 --- a/test/cuchaz/enigma/inputs/constructors/DefaultConstructable.java +++ b/test/cuchaz/enigma/inputs/constructors/DefaultConstructable.java @@ -1,13 +1,3 @@ -/******************************************************************************* - * Copyright (c) 2014 Jeff Martin. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser General Public - * License v3.0 which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl.html - * - * Contributors: - * Jeff Martin - initial API and implementation - ******************************************************************************/ package cuchaz.enigma.inputs.constructors; public class DefaultConstructable diff --git a/test/cuchaz/enigma/inputs/constructors/SubClass.java b/test/cuchaz/enigma/inputs/constructors/SubClass.java index 0358989..6ef7732 100644 --- a/test/cuchaz/enigma/inputs/constructors/SubClass.java +++ b/test/cuchaz/enigma/inputs/constructors/SubClass.java @@ -1,13 +1,3 @@ -/******************************************************************************* - * Copyright (c) 2014 Jeff Martin. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser General Public - * License v3.0 which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl.html - * - * Contributors: - * Jeff Martin - initial API and implementation - ******************************************************************************/ package cuchaz.enigma.inputs.constructors; // none/d extends none/a diff --git a/test/cuchaz/enigma/inputs/constructors/SubSubClass.java b/test/cuchaz/enigma/inputs/constructors/SubSubClass.java index 76e69c1..76a0f1f 100644 --- a/test/cuchaz/enigma/inputs/constructors/SubSubClass.java +++ b/test/cuchaz/enigma/inputs/constructors/SubSubClass.java @@ -1,13 +1,3 @@ -/******************************************************************************* - * Copyright (c) 2014 Jeff Martin. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser General Public - * License v3.0 which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl.html - * - * Contributors: - * Jeff Martin - initial API and implementation - ******************************************************************************/ package cuchaz.enigma.inputs.constructors; // none/e extends none/d diff --git a/test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java b/test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java index 9d3807b..8402dde 100644 --- a/test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java +++ b/test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java @@ -1,13 +1,3 @@ -/******************************************************************************* - * Copyright (c) 2014 Jeff Martin. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser General Public - * License v3.0 which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl.html - * - * Contributors: - * Jeff Martin - initial API and implementation - ******************************************************************************/ package cuchaz.enigma.inputs.inheritanceTree; // none/a diff --git a/test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java index 98a9570..ed50709 100644 --- a/test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java +++ b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java @@ -1,13 +1,3 @@ -/******************************************************************************* - * Copyright (c) 2014 Jeff Martin. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser General Public - * License v3.0 which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl.html - * - * Contributors: - * Jeff Martin - initial API and implementation - ******************************************************************************/ package cuchaz.enigma.inputs.inheritanceTree; // none/b extends none/a diff --git a/test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java index 29a29b8..fc4c8ee 100644 --- a/test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java +++ b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java @@ -1,13 +1,3 @@ -/******************************************************************************* - * Copyright (c) 2014 Jeff Martin. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser General Public - * License v3.0 which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl.html - * - * Contributors: - * Jeff Martin - initial API and implementation - ******************************************************************************/ package cuchaz.enigma.inputs.inheritanceTree; // none/c extends none/a diff --git a/test/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java b/test/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java index 4aa0af0..b3b8342 100644 --- a/test/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java +++ b/test/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java @@ -1,13 +1,3 @@ -/******************************************************************************* - * Copyright (c) 2014 Jeff Martin. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser General Public - * License v3.0 which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl.html - * - * Contributors: - * Jeff Martin - initial API and implementation - ******************************************************************************/ package cuchaz.enigma.inputs.inheritanceTree; // none/d extends none/b diff --git a/test/cuchaz/enigma/inputs/innerClasses/Anonymous.java b/test/cuchaz/enigma/inputs/innerClasses/Anonymous.java index 44b529e..d36a514 100644 --- a/test/cuchaz/enigma/inputs/innerClasses/Anonymous.java +++ b/test/cuchaz/enigma/inputs/innerClasses/Anonymous.java @@ -1,13 +1,3 @@ -/******************************************************************************* - * Copyright (c) 2014 Jeff Martin. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser General Public - * License v3.0 which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl.html - * - * Contributors: - * Jeff Martin - initial API and implementation - ******************************************************************************/ package cuchaz.enigma.inputs.innerClasses; public class Anonymous diff --git a/test/cuchaz/enigma/inputs/innerClasses/AnonymousWithScopeArgs.java b/test/cuchaz/enigma/inputs/innerClasses/AnonymousWithScopeArgs.java index 4924d09..e0a65e2 100644 --- a/test/cuchaz/enigma/inputs/innerClasses/AnonymousWithScopeArgs.java +++ b/test/cuchaz/enigma/inputs/innerClasses/AnonymousWithScopeArgs.java @@ -1,13 +1,3 @@ -/******************************************************************************* - * Copyright (c) 2014 Jeff Martin. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser General Public - * License v3.0 which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl.html - * - * Contributors: - * Jeff Martin - initial API and implementation - ******************************************************************************/ package cuchaz.enigma.inputs.innerClasses; public class AnonymousWithScopeArgs diff --git a/test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java b/test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java index f7d06d4..e24395c 100644 --- a/test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java +++ b/test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java @@ -1,13 +1,3 @@ -/******************************************************************************* - * Copyright (c) 2014 Jeff Martin. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser General Public - * License v3.0 which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl.html - * - * Contributors: - * Jeff Martin - initial API and implementation - ******************************************************************************/ package cuchaz.enigma.inputs.innerClasses; @SuppressWarnings( "unused" ) diff --git a/test/cuchaz/enigma/inputs/innerClasses/Simple.java b/test/cuchaz/enigma/inputs/innerClasses/Simple.java index 9fc9b0c..405c639 100644 --- a/test/cuchaz/enigma/inputs/innerClasses/Simple.java +++ b/test/cuchaz/enigma/inputs/innerClasses/Simple.java @@ -1,13 +1,3 @@ -/******************************************************************************* - * Copyright (c) 2014 Jeff Martin. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser General Public - * License v3.0 which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl.html - * - * Contributors: - * Jeff Martin - initial API and implementation - ******************************************************************************/ package cuchaz.enigma.inputs.innerClasses; public class Simple diff --git a/test/cuchaz/enigma/inputs/loneClass/LoneClass.java b/test/cuchaz/enigma/inputs/loneClass/LoneClass.java index 1022aa2..961b012 100644 --- a/test/cuchaz/enigma/inputs/loneClass/LoneClass.java +++ b/test/cuchaz/enigma/inputs/loneClass/LoneClass.java @@ -1,13 +1,3 @@ -/******************************************************************************* - * Copyright (c) 2014 Jeff Martin. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser General Public - * License v3.0 which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl.html - * - * Contributors: - * Jeff Martin - initial API and implementation - ******************************************************************************/ package cuchaz.enigma.inputs.loneClass; public class LoneClass -- cgit v1.2.3 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 From 2fbcf8e5c4eec0aa4a4fc59c7cc8abac33b1429c Mon Sep 17 00:00:00 2001 From: jeff Date: Mon, 19 Jan 2015 22:22:57 -0500 Subject: solved tricky issue with incorrect translation of fields/methods referenced by a subclass instead of the declaring class --- test/cuchaz/enigma/TestDeobfuscator.java | 2 +- test/cuchaz/enigma/TestInnerClasses.java | 2 +- .../enigma/TestJarIndexConstructorReferences.java | 2 +- .../cuchaz/enigma/TestJarIndexInheritanceTree.java | 30 +++++++++++----------- test/cuchaz/enigma/TestJarIndexLoneClass.java | 15 ++++++----- test/cuchaz/enigma/TestSourceIndex.java | 1 + test/cuchaz/enigma/TestTokensConstructors.java | 2 +- 7 files changed, 28 insertions(+), 26 deletions(-) (limited to 'test') diff --git a/test/cuchaz/enigma/TestDeobfuscator.java b/test/cuchaz/enigma/TestDeobfuscator.java index 45d27c4..6ac4c78 100644 --- a/test/cuchaz/enigma/TestDeobfuscator.java +++ b/test/cuchaz/enigma/TestDeobfuscator.java @@ -26,7 +26,7 @@ import cuchaz.enigma.mapping.ClassEntry; public class TestDeobfuscator { private Deobfuscator getDeobfuscator() throws IOException { - return new Deobfuscator(new File("build/libs/testLoneClass.obf.jar")); + return new Deobfuscator(new File("build/testLoneClass.obf.jar")); } @Test diff --git a/test/cuchaz/enigma/TestInnerClasses.java b/test/cuchaz/enigma/TestInnerClasses.java index c84d755..51fb5e3 100644 --- a/test/cuchaz/enigma/TestInnerClasses.java +++ b/test/cuchaz/enigma/TestInnerClasses.java @@ -35,7 +35,7 @@ public class TestInnerClasses { 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/testInnerClasses.obf.jar"), true); } @Test diff --git a/test/cuchaz/enigma/TestJarIndexConstructorReferences.java b/test/cuchaz/enigma/TestJarIndexConstructorReferences.java index b5f4c7f..8e3ad6d 100644 --- a/test/cuchaz/enigma/TestJarIndexConstructorReferences.java +++ b/test/cuchaz/enigma/TestJarIndexConstructorReferences.java @@ -37,7 +37,7 @@ public class TestJarIndexConstructorReferences { private ClassEntry m_callerClass = new ClassEntry("none/b"); public TestJarIndexConstructorReferences() throws Exception { - File jarFile = new File("build/libs/testConstructors.obf.jar"); + File jarFile = new File("build/testConstructors.obf.jar"); m_index = new JarIndex(); m_index.indexJar(new JarFile(jarFile), false); } diff --git a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java index caf6578..4d66397 100644 --- a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java +++ b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java @@ -43,7 +43,7 @@ public class TestJarIndexInheritanceTree { 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/testInheritanceTree.obf.jar"), false); } @Test @@ -63,27 +63,27 @@ public class TestJarIndexInheritanceTree { 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( - m_subClassA.getName(), - m_subClassB.getName() + assertThat(index.getSuperclass(m_baseClass), is(nullValue())); + assertThat(index.getAncestry(m_baseClass), is(empty())); + assertThat(index.getSubclass(m_baseClass), containsInAnyOrder( + m_subClassA, + m_subClassB )); // 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.getSuperclass(m_subClassA), is(m_baseClass)); + assertThat(index.getAncestry(m_subClassA), contains(m_baseClass)); + assertThat(index.getSubclass(m_subClassA), contains(m_subClassAA)); // 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.getSuperclass(m_subClassAA), is(m_subClassA)); + assertThat(index.getAncestry(m_subClassAA), contains(m_subClassA, m_baseClass)); + assertThat(index.getSubclass(m_subClassAA), 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.getSuperclass(m_subClassB), is(m_baseClass)); + assertThat(index.getAncestry(m_subClassB), contains(m_baseClass)); + assertThat(index.getSubclass(m_subClassB), is(empty())); } @Test diff --git a/test/cuchaz/enigma/TestJarIndexLoneClass.java b/test/cuchaz/enigma/TestJarIndexLoneClass.java index 0575eec..a061b72 100644 --- a/test/cuchaz/enigma/TestJarIndexLoneClass.java +++ b/test/cuchaz/enigma/TestJarIndexLoneClass.java @@ -29,6 +29,7 @@ import cuchaz.enigma.analysis.JarIndex; import cuchaz.enigma.analysis.MethodImplementationsTreeNode; import cuchaz.enigma.analysis.MethodInheritanceTreeNode; import cuchaz.enigma.mapping.BehaviorEntry; +import cuchaz.enigma.mapping.ClassEntry; import cuchaz.enigma.mapping.FieldEntry; import cuchaz.enigma.mapping.MethodEntry; import cuchaz.enigma.mapping.Translator; @@ -39,7 +40,7 @@ public class TestJarIndexLoneClass { 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/testLoneClass.obf.jar"), false); } @Test @@ -52,12 +53,12 @@ public class TestJarIndexLoneClass { @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())); + assertThat(m_index.getTranslationIndex().getSuperclass(new ClassEntry("none/a")), is(nullValue())); + assertThat(m_index.getTranslationIndex().getSuperclass(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(nullValue())); + assertThat(m_index.getTranslationIndex().getAncestry(new ClassEntry("none/a")), is(empty())); + assertThat(m_index.getTranslationIndex().getAncestry(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(empty())); + assertThat(m_index.getTranslationIndex().getSubclass(new ClassEntry("none/a")), is(empty())); + assertThat(m_index.getTranslationIndex().getSubclass(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(empty())); } @Test diff --git a/test/cuchaz/enigma/TestSourceIndex.java b/test/cuchaz/enigma/TestSourceIndex.java index fb385e0..ba7fc79 100644 --- a/test/cuchaz/enigma/TestSourceIndex.java +++ b/test/cuchaz/enigma/TestSourceIndex.java @@ -23,6 +23,7 @@ import cuchaz.enigma.mapping.ClassEntry; public class TestSourceIndex { + // TEMP @Test public void indexEverything() throws Exception { Deobfuscator deobfuscator = new Deobfuscator(new File("input/1.8.jar")); diff --git a/test/cuchaz/enigma/TestTokensConstructors.java b/test/cuchaz/enigma/TestTokensConstructors.java index f805a65..9f85e81 100644 --- a/test/cuchaz/enigma/TestTokensConstructors.java +++ b/test/cuchaz/enigma/TestTokensConstructors.java @@ -27,7 +27,7 @@ import cuchaz.enigma.mapping.BehaviorEntry; public class TestTokensConstructors extends TokenChecker { public TestTokensConstructors() throws Exception { - super(new File("build/libs/testConstructors.obf.jar")); + super(new File("build/testConstructors.obf.jar")); } @Test -- cgit v1.2.3 From 448685653e90415ebe10b08e8335462b81c30421 Mon Sep 17 00:00:00 2001 From: jeff Date: Mon, 2 Feb 2015 21:26:10 -0500 Subject: fix issue with bridge methods --- test/cuchaz/enigma/TestDeobfuscator.java | 4 ++-- test/cuchaz/enigma/TestInnerClasses.java | 23 +++++++++++++++++++++- test/cuchaz/enigma/TestSourceIndex.java | 4 ++-- test/cuchaz/enigma/TestTokensConstructors.java | 18 +++++++---------- test/cuchaz/enigma/TokenChecker.java | 4 ++-- .../enigma/inputs/innerClasses/A_Anonymous.java | 14 +++++++++++++ .../enigma/inputs/innerClasses/Anonymous.java | 14 ------------- .../innerClasses/AnonymousWithScopeArgs.java | 13 ------------ .../innerClasses/B_AnonymousWithScopeArgs.java | 13 ++++++++++++ .../inputs/innerClasses/C_ConstructorArgs.java | 20 +++++++++++++++++++ .../inputs/innerClasses/ConstructorArgs.java | 20 ------------------- .../enigma/inputs/innerClasses/D_Simple.java | 8 ++++++++ .../innerClasses/E_AnonymousWithOuterAccess.java | 21 ++++++++++++++++++++ test/cuchaz/enigma/inputs/innerClasses/Simple.java | 8 -------- 14 files changed, 111 insertions(+), 73 deletions(-) create mode 100644 test/cuchaz/enigma/inputs/innerClasses/A_Anonymous.java delete mode 100644 test/cuchaz/enigma/inputs/innerClasses/Anonymous.java delete mode 100644 test/cuchaz/enigma/inputs/innerClasses/AnonymousWithScopeArgs.java create mode 100644 test/cuchaz/enigma/inputs/innerClasses/B_AnonymousWithScopeArgs.java create mode 100644 test/cuchaz/enigma/inputs/innerClasses/C_ConstructorArgs.java delete mode 100644 test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java create mode 100644 test/cuchaz/enigma/inputs/innerClasses/D_Simple.java create mode 100644 test/cuchaz/enigma/inputs/innerClasses/E_AnonymousWithOuterAccess.java delete mode 100644 test/cuchaz/enigma/inputs/innerClasses/Simple.java (limited to 'test') diff --git a/test/cuchaz/enigma/TestDeobfuscator.java b/test/cuchaz/enigma/TestDeobfuscator.java index 6ac4c78..129d7b2 100644 --- a/test/cuchaz/enigma/TestDeobfuscator.java +++ b/test/cuchaz/enigma/TestDeobfuscator.java @@ -13,9 +13,9 @@ package cuchaz.enigma; import static org.junit.Assert.*; -import java.io.File; import java.io.IOException; import java.util.List; +import java.util.jar.JarFile; import org.junit.Test; @@ -26,7 +26,7 @@ import cuchaz.enigma.mapping.ClassEntry; public class TestDeobfuscator { private Deobfuscator getDeobfuscator() throws IOException { - return new Deobfuscator(new File("build/testLoneClass.obf.jar")); + return new Deobfuscator(new JarFile("build/testLoneClass.obf.jar")); } @Test diff --git a/test/cuchaz/enigma/TestInnerClasses.java b/test/cuchaz/enigma/TestInnerClasses.java index 51fb5e3..63c9b71 100644 --- a/test/cuchaz/enigma/TestInnerClasses.java +++ b/test/cuchaz/enigma/TestInnerClasses.java @@ -23,6 +23,7 @@ import cuchaz.enigma.analysis.JarIndex; public class TestInnerClasses { private JarIndex m_index; + private Deobfuscator m_deobfuscator; private static final String AnonymousOuter = "none/a"; private static final String AnonymousInner = "b"; @@ -32,10 +33,14 @@ public class TestInnerClasses { private static final String ConstructorArgsInner = "f"; private static final String AnonymousWithScopeArgsOuter = "none/c"; private static final String AnonymousWithScopeArgsInner = "d"; + private static final String AnonymousWithOuterAccessOuter = "none/i"; + private static final String AnonymousWithOuterAccessInner = "j"; public TestInnerClasses() throws Exception { m_index = new JarIndex(); - m_index.indexJar(new JarFile("build/testInnerClasses.obf.jar"), true); + JarFile jar = new JarFile("build/testInnerClasses.obf.jar"); + m_index.indexJar(jar, true); + m_deobfuscator = new Deobfuscator(jar); } @Test @@ -43,6 +48,7 @@ public class TestInnerClasses { assertThat(m_index.getOuterClass(SimpleInner), is(SimpleOuter)); assertThat(m_index.getInnerClasses(SimpleOuter), containsInAnyOrder(SimpleInner)); assertThat(m_index.isAnonymousClass(SimpleInner), is(false)); + decompile(SimpleOuter); } @Test @@ -50,6 +56,7 @@ public class TestInnerClasses { assertThat(m_index.getOuterClass(AnonymousInner), is(AnonymousOuter)); assertThat(m_index.getInnerClasses(AnonymousOuter), containsInAnyOrder(AnonymousInner)); assertThat(m_index.isAnonymousClass(AnonymousInner), is(true)); + decompile(AnonymousOuter); } @Test @@ -57,6 +64,7 @@ public class TestInnerClasses { assertThat(m_index.getOuterClass(ConstructorArgsInner), is(ConstructorArgsOuter)); assertThat(m_index.getInnerClasses(ConstructorArgsOuter), containsInAnyOrder(ConstructorArgsInner)); assertThat(m_index.isAnonymousClass(ConstructorArgsInner), is(false)); + decompile(ConstructorArgsOuter); } @Test @@ -64,5 +72,18 @@ public class TestInnerClasses { assertThat(m_index.getOuterClass(AnonymousWithScopeArgsInner), is(AnonymousWithScopeArgsOuter)); assertThat(m_index.getInnerClasses(AnonymousWithScopeArgsOuter), containsInAnyOrder(AnonymousWithScopeArgsInner)); assertThat(m_index.isAnonymousClass(AnonymousWithScopeArgsInner), is(true)); + decompile(AnonymousWithScopeArgsOuter); + } + + @Test + public void anonymousWithOuterAccess() { + assertThat(m_index.getOuterClass(AnonymousWithOuterAccessInner), is(AnonymousWithOuterAccessOuter)); + assertThat(m_index.getInnerClasses(AnonymousWithOuterAccessOuter), containsInAnyOrder(AnonymousWithOuterAccessInner)); + assertThat(m_index.isAnonymousClass(AnonymousWithOuterAccessInner), is(true)); + decompile(AnonymousWithOuterAccessOuter); + } + + private void decompile(String name) { + m_deobfuscator.getSourceTree(name); } } diff --git a/test/cuchaz/enigma/TestSourceIndex.java b/test/cuchaz/enigma/TestSourceIndex.java index ba7fc79..70a5ee4 100644 --- a/test/cuchaz/enigma/TestSourceIndex.java +++ b/test/cuchaz/enigma/TestSourceIndex.java @@ -11,8 +11,8 @@ ******************************************************************************/ package cuchaz.enigma; -import java.io.File; import java.util.Set; +import java.util.jar.JarFile; import org.junit.Test; @@ -26,7 +26,7 @@ public class TestSourceIndex { // TEMP @Test public void indexEverything() throws Exception { - Deobfuscator deobfuscator = new Deobfuscator(new File("input/1.8.jar")); + Deobfuscator deobfuscator = new Deobfuscator(new JarFile("input/1.8.jar")); // get all classes that aren't inner classes Set classEntries = Sets.newHashSet(); diff --git a/test/cuchaz/enigma/TestTokensConstructors.java b/test/cuchaz/enigma/TestTokensConstructors.java index 9f85e81..56424ae 100644 --- a/test/cuchaz/enigma/TestTokensConstructors.java +++ b/test/cuchaz/enigma/TestTokensConstructors.java @@ -10,15 +10,11 @@ ******************************************************************************/ package cuchaz.enigma; -import static cuchaz.enigma.EntryFactory.newBehaviorReferenceByConstructor; -import static cuchaz.enigma.EntryFactory.newBehaviorReferenceByMethod; -import static cuchaz.enigma.EntryFactory.newConstructor; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.nullValue; +import static cuchaz.enigma.EntryFactory.*; +import static org.hamcrest.MatcherAssert.*; +import static org.hamcrest.Matchers.*; -import java.io.File; +import java.util.jar.JarFile; import org.junit.Test; @@ -27,7 +23,7 @@ import cuchaz.enigma.mapping.BehaviorEntry; public class TestTokensConstructors extends TokenChecker { public TestTokensConstructors() throws Exception { - super(new File("build/testConstructors.obf.jar")); + super(new JarFile("build/testConstructors.obf.jar")); } @Test @@ -63,11 +59,11 @@ public class TestTokensConstructors extends TokenChecker { ); assertThat( getReferenceTokens(newBehaviorReferenceByConstructor(source, "none/d", "()V")), - containsInAnyOrder("super") // implicit call, decompiled to "super" + is(empty()) // implicit call, not decompiled to token ); assertThat( getReferenceTokens(newBehaviorReferenceByConstructor(source, "none/d", "(III)V")), - containsInAnyOrder("super") // implicit call, decompiled to "super" + is(empty()) // implicit call, not decompiled to token ); } diff --git a/test/cuchaz/enigma/TokenChecker.java b/test/cuchaz/enigma/TokenChecker.java index 524c5ec..febea2a 100644 --- a/test/cuchaz/enigma/TokenChecker.java +++ b/test/cuchaz/enigma/TokenChecker.java @@ -10,10 +10,10 @@ ******************************************************************************/ package cuchaz.enigma; -import java.io.File; import java.io.IOException; import java.util.Collection; import java.util.List; +import java.util.jar.JarFile; import com.google.common.collect.Lists; import com.strobel.decompiler.languages.java.ast.CompilationUnit; @@ -27,7 +27,7 @@ public class TokenChecker { private Deobfuscator m_deobfuscator; - protected TokenChecker(File jarFile) throws IOException { + protected TokenChecker(JarFile jarFile) throws IOException { m_deobfuscator = new Deobfuscator(jarFile); } diff --git a/test/cuchaz/enigma/inputs/innerClasses/A_Anonymous.java b/test/cuchaz/enigma/inputs/innerClasses/A_Anonymous.java new file mode 100644 index 0000000..f7118f6 --- /dev/null +++ b/test/cuchaz/enigma/inputs/innerClasses/A_Anonymous.java @@ -0,0 +1,14 @@ +package cuchaz.enigma.inputs.innerClasses; + +public class A_Anonymous { + + public void foo() { + Runnable runnable = new Runnable() { + @Override + public void run() { + // don't care + } + }; + runnable.run(); + } +} diff --git a/test/cuchaz/enigma/inputs/innerClasses/Anonymous.java b/test/cuchaz/enigma/inputs/innerClasses/Anonymous.java deleted file mode 100644 index f5d9d1c..0000000 --- a/test/cuchaz/enigma/inputs/innerClasses/Anonymous.java +++ /dev/null @@ -1,14 +0,0 @@ -package cuchaz.enigma.inputs.innerClasses; - -public class Anonymous { - - public void foo() { - Runnable runnable = new Runnable() { - @Override - public void run() { - // don't care - } - }; - runnable.run(); - } -} diff --git a/test/cuchaz/enigma/inputs/innerClasses/AnonymousWithScopeArgs.java b/test/cuchaz/enigma/inputs/innerClasses/AnonymousWithScopeArgs.java deleted file mode 100644 index b3ba1af..0000000 --- a/test/cuchaz/enigma/inputs/innerClasses/AnonymousWithScopeArgs.java +++ /dev/null @@ -1,13 +0,0 @@ -package cuchaz.enigma.inputs.innerClasses; - -public class AnonymousWithScopeArgs { - - public static void foo(final Simple arg) { - System.out.println(new Object() { - @Override - public String toString() { - return arg.toString(); - } - }); - } -} diff --git a/test/cuchaz/enigma/inputs/innerClasses/B_AnonymousWithScopeArgs.java b/test/cuchaz/enigma/inputs/innerClasses/B_AnonymousWithScopeArgs.java new file mode 100644 index 0000000..42fba9a --- /dev/null +++ b/test/cuchaz/enigma/inputs/innerClasses/B_AnonymousWithScopeArgs.java @@ -0,0 +1,13 @@ +package cuchaz.enigma.inputs.innerClasses; + +public class B_AnonymousWithScopeArgs { + + public static void foo(final D_Simple arg) { + System.out.println(new Object() { + @Override + public String toString() { + return arg.toString(); + } + }); + } +} diff --git a/test/cuchaz/enigma/inputs/innerClasses/C_ConstructorArgs.java b/test/cuchaz/enigma/inputs/innerClasses/C_ConstructorArgs.java new file mode 100644 index 0000000..8fa6c5b --- /dev/null +++ b/test/cuchaz/enigma/inputs/innerClasses/C_ConstructorArgs.java @@ -0,0 +1,20 @@ +package cuchaz.enigma.inputs.innerClasses; + +@SuppressWarnings("unused") +public class C_ConstructorArgs { + + class Inner { + + private int a; + + public Inner(int a) { + this.a = a; + } + } + + Inner i; + + public void foo() { + i = new Inner(5); + } +} diff --git a/test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java b/test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java deleted file mode 100644 index 08135fe..0000000 --- a/test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java +++ /dev/null @@ -1,20 +0,0 @@ -package cuchaz.enigma.inputs.innerClasses; - -@SuppressWarnings("unused") -public class ConstructorArgs { - - class Inner { - - private int a; - - public Inner(int a) { - this.a = a; - } - } - - Inner i; - - public void foo() { - i = new Inner(5); - } -} diff --git a/test/cuchaz/enigma/inputs/innerClasses/D_Simple.java b/test/cuchaz/enigma/inputs/innerClasses/D_Simple.java new file mode 100644 index 0000000..c4fc0ef --- /dev/null +++ b/test/cuchaz/enigma/inputs/innerClasses/D_Simple.java @@ -0,0 +1,8 @@ +package cuchaz.enigma.inputs.innerClasses; + +public class D_Simple { + + class Inner { + // nothing to do + } +} diff --git a/test/cuchaz/enigma/inputs/innerClasses/E_AnonymousWithOuterAccess.java b/test/cuchaz/enigma/inputs/innerClasses/E_AnonymousWithOuterAccess.java new file mode 100644 index 0000000..e1de53c --- /dev/null +++ b/test/cuchaz/enigma/inputs/innerClasses/E_AnonymousWithOuterAccess.java @@ -0,0 +1,21 @@ +package cuchaz.enigma.inputs.innerClasses; + +public class E_AnonymousWithOuterAccess { + + // reproduction of error case documented at: + // https://bitbucket.org/cuchaz/enigma/issue/61/stackoverflowerror-when-deobfuscating + + public Object makeInner() { + outerMethod(); + return new Object() { + @Override + public String toString() { + return outerMethod(); + } + }; + } + + private String outerMethod() { + return "foo"; + } +} diff --git a/test/cuchaz/enigma/inputs/innerClasses/Simple.java b/test/cuchaz/enigma/inputs/innerClasses/Simple.java deleted file mode 100644 index cb536fa..0000000 --- a/test/cuchaz/enigma/inputs/innerClasses/Simple.java +++ /dev/null @@ -1,8 +0,0 @@ -package cuchaz.enigma.inputs.innerClasses; - -public class Simple { - - class Inner { - // nothing to do - } -} -- cgit v1.2.3 From 73313b0f1c1660986afc1449960889cac242eee0 Mon Sep 17 00:00:00 2001 From: jeff Date: Thu, 5 Feb 2015 23:51:40 -0500 Subject: add new type/signature system --- test/cuchaz/enigma/TestBehaviorSignature.java | 196 ++++++++++++++++++++++++++ test/cuchaz/enigma/TestType.java | 183 ++++++++++++++++++++++++ 2 files changed, 379 insertions(+) create mode 100644 test/cuchaz/enigma/TestBehaviorSignature.java create mode 100644 test/cuchaz/enigma/TestType.java (limited to 'test') diff --git a/test/cuchaz/enigma/TestBehaviorSignature.java b/test/cuchaz/enigma/TestBehaviorSignature.java new file mode 100644 index 0000000..4705cd1 --- /dev/null +++ b/test/cuchaz/enigma/TestBehaviorSignature.java @@ -0,0 +1,196 @@ +package cuchaz.enigma; + +import static org.hamcrest.MatcherAssert.*; +import static org.hamcrest.Matchers.*; + +import org.junit.Test; + +import cuchaz.enigma.mapping.BehaviorSignature; +import cuchaz.enigma.mapping.ClassEntry; +import cuchaz.enigma.mapping.Type; + + +public class TestBehaviorSignature { + + @Test + public void easiest() { + final BehaviorSignature sig = new BehaviorSignature("()V"); + assertThat(sig.getArgumentTypes(), is(empty())); + assertThat(sig.getReturnType(), is(new Type("V"))); + } + + @Test + public void primitives() { + { + final BehaviorSignature sig = new BehaviorSignature("(I)V"); + assertThat(sig.getArgumentTypes(), contains( + new Type("I") + )); + assertThat(sig.getReturnType(), is(new Type("V"))); + } + { + final BehaviorSignature sig = new BehaviorSignature("(I)I"); + assertThat(sig.getArgumentTypes(), contains( + new Type("I") + )); + assertThat(sig.getReturnType(), is(new Type("I"))); + } + { + final BehaviorSignature sig = new BehaviorSignature("(IBCJ)Z"); + assertThat(sig.getArgumentTypes(), contains( + new Type("I"), + new Type("B"), + new Type("C"), + new Type("J") + )); + assertThat(sig.getReturnType(), is(new Type("Z"))); + } + } + + @Test + public void classes() { + { + final BehaviorSignature sig = new BehaviorSignature("([LFoo;)V"); + assertThat(sig.getArgumentTypes().size(), is(1)); + assertThat(sig.getArgumentTypes().get(0), is(new Type("[LFoo;"))); + assertThat(sig.getReturnType(), is(new Type("V"))); + } + { + final BehaviorSignature sig = new BehaviorSignature("(LFoo;)LBar;"); + assertThat(sig.getArgumentTypes(), contains( + new Type("LFoo;") + )); + assertThat(sig.getReturnType(), is(new Type("LBar;"))); + } + { + final BehaviorSignature sig = new BehaviorSignature("(LFoo;LMoo;LZoo;)LBar;"); + assertThat(sig.getArgumentTypes(), contains( + new Type("LFoo;"), + new Type("LMoo;"), + new Type("LZoo;") + )); + assertThat(sig.getReturnType(), is(new Type("LBar;"))); + } + { + final BehaviorSignature sig = new BehaviorSignature("(LFoo;LMoo;)LBar;"); + assertThat(sig.getArgumentTypes(), contains( + new Type("LFoo;"), + new Type("LMoo;") + )); + assertThat(sig.getReturnType(), is(new Type("LBar;"))); + } + } + + @Test + public void arrays() { + { + final BehaviorSignature sig = new BehaviorSignature("([I)V"); + assertThat(sig.getArgumentTypes(), contains( + new Type("[I") + )); + assertThat(sig.getReturnType(), is(new Type("V"))); + } + { + final BehaviorSignature sig = new BehaviorSignature("([I)[J"); + assertThat(sig.getArgumentTypes(), contains( + new Type("[I") + )); + assertThat(sig.getReturnType(), is(new Type("[J"))); + } + { + final BehaviorSignature sig = new BehaviorSignature("([I[Z[F)[D"); + assertThat(sig.getArgumentTypes(), contains( + new Type("[I"), + new Type("[Z"), + new Type("[F") + )); + assertThat(sig.getReturnType(), is(new Type("[D"))); + } + } + + @Test + public void mixed() { + { + final BehaviorSignature sig = new BehaviorSignature("(I[JLFoo;)Z"); + assertThat(sig.getArgumentTypes(), contains( + new Type("I"), + new Type("[J"), + new Type("LFoo;") + )); + assertThat(sig.getReturnType(), is(new Type("Z"))); + } + { + final BehaviorSignature sig = new BehaviorSignature("(III)[LFoo;"); + assertThat(sig.getArgumentTypes(), contains( + new Type("I"), + new Type("I"), + new Type("I") + )); + assertThat(sig.getReturnType(), is(new Type("[LFoo;"))); + } + } + + @Test + public void replaceClasses() { + { + final BehaviorSignature oldSig = new BehaviorSignature("()V"); + final BehaviorSignature sig = new BehaviorSignature(oldSig, new BehaviorSignature.ClassReplacer() { + @Override + public ClassEntry replace(ClassEntry entry) { + return null; + } + }); + assertThat(sig.getArgumentTypes(), is(empty())); + assertThat(sig.getReturnType(), is(new Type("V"))); + } + { + final BehaviorSignature oldSig = new BehaviorSignature("(IJLFoo;)V"); + final BehaviorSignature sig = new BehaviorSignature(oldSig, new BehaviorSignature.ClassReplacer() { + @Override + public ClassEntry replace(ClassEntry entry) { + return null; + } + }); + assertThat(sig.getArgumentTypes(), contains( + new Type("I"), + new Type("J"), + new Type("LFoo;") + )); + assertThat(sig.getReturnType(), is(new Type("V"))); + } + { + final BehaviorSignature oldSig = new BehaviorSignature("(LFoo;LBar;)LMoo;"); + final BehaviorSignature sig = new BehaviorSignature(oldSig, new BehaviorSignature.ClassReplacer() { + @Override + public ClassEntry replace(ClassEntry entry) { + if (entry.getName().equals("Foo")) { + return new ClassEntry("Bar"); + } + return null; + } + }); + assertThat(sig.getArgumentTypes(), contains( + new Type("LBar;"), + new Type("LBar;") + )); + assertThat(sig.getReturnType(), is(new Type("LMoo;"))); + } + { + final BehaviorSignature oldSig = new BehaviorSignature("(LFoo;LBar;)LMoo;"); + final BehaviorSignature sig = new BehaviorSignature(oldSig, new BehaviorSignature.ClassReplacer() { + @Override + public ClassEntry replace(ClassEntry entry) { + if (entry.getName().equals("Moo")) { + return new ClassEntry("Cow"); + } + return null; + } + }); + assertThat(sig.getArgumentTypes(), contains( + new Type("LFoo;"), + new Type("LBar;") + )); + assertThat(sig.getReturnType(), is(new Type("LCow;"))); + } + } +} diff --git a/test/cuchaz/enigma/TestType.java b/test/cuchaz/enigma/TestType.java new file mode 100644 index 0000000..efc6a4c --- /dev/null +++ b/test/cuchaz/enigma/TestType.java @@ -0,0 +1,183 @@ +package cuchaz.enigma; + +import org.junit.Test; + +import static org.hamcrest.MatcherAssert.*; +import static org.hamcrest.Matchers.*; + +import cuchaz.enigma.mapping.Type; + +import static cuchaz.enigma.EntryFactory.*; + + +public class TestType { + + @Test + public void isVoid() { + assertThat(new Type("V").isVoid(), is(true)); + assertThat(new Type("Z").isVoid(), is(false)); + assertThat(new Type("B").isVoid(), is(false)); + assertThat(new Type("C").isVoid(), is(false)); + assertThat(new Type("I").isVoid(), is(false)); + assertThat(new Type("J").isVoid(), is(false)); + assertThat(new Type("F").isVoid(), is(false)); + assertThat(new Type("D").isVoid(), is(false)); + assertThat(new Type("LFoo;").isVoid(), is(false)); + assertThat(new Type("[I").isVoid(), is(false)); + } + + @Test + public void isPrimitive() { + assertThat(new Type("V").isPrimitive(), is(false)); + assertThat(new Type("Z").isPrimitive(), is(true)); + assertThat(new Type("B").isPrimitive(), is(true)); + assertThat(new Type("C").isPrimitive(), is(true)); + assertThat(new Type("I").isPrimitive(), is(true)); + assertThat(new Type("J").isPrimitive(), is(true)); + assertThat(new Type("F").isPrimitive(), is(true)); + assertThat(new Type("D").isPrimitive(), is(true)); + assertThat(new Type("LFoo;").isPrimitive(), is(false)); + assertThat(new Type("[I").isPrimitive(), is(false)); + } + + @Test + public void getPrimitive() { + assertThat(new Type("Z").getPrimitive(), is(Type.Primitive.Boolean)); + assertThat(new Type("B").getPrimitive(), is(Type.Primitive.Byte)); + assertThat(new Type("C").getPrimitive(), is(Type.Primitive.Character)); + assertThat(new Type("I").getPrimitive(), is(Type.Primitive.Integer)); + assertThat(new Type("J").getPrimitive(), is(Type.Primitive.Long)); + assertThat(new Type("F").getPrimitive(), is(Type.Primitive.Float)); + assertThat(new Type("D").getPrimitive(), is(Type.Primitive.Double)); + } + + @Test + public void isClass() { + assertThat(new Type("V").isClass(), is(false)); + assertThat(new Type("Z").isClass(), is(false)); + assertThat(new Type("B").isClass(), is(false)); + assertThat(new Type("C").isClass(), is(false)); + assertThat(new Type("I").isClass(), is(false)); + assertThat(new Type("J").isClass(), is(false)); + assertThat(new Type("F").isClass(), is(false)); + assertThat(new Type("D").isClass(), is(false)); + assertThat(new Type("LFoo;").isClass(), is(true)); + assertThat(new Type("[I").isClass(), is(false)); + } + + @Test + public void getClassEntry() { + assertThat(new Type("LFoo;").getClassEntry(), is(newClass("Foo"))); + assertThat(new Type("LFoo;").getClassEntry(), is(newClass("Foo"))); + } + + @Test + public void isArray() { + assertThat(new Type("V").isArray(), is(false)); + assertThat(new Type("Z").isArray(), is(false)); + assertThat(new Type("B").isArray(), is(false)); + assertThat(new Type("C").isArray(), is(false)); + assertThat(new Type("I").isArray(), is(false)); + assertThat(new Type("J").isArray(), is(false)); + assertThat(new Type("F").isArray(), is(false)); + assertThat(new Type("D").isArray(), is(false)); + assertThat(new Type("LFoo;").isArray(), is(false)); + assertThat(new Type("[I").isArray(), is(true)); + } + + @Test + public void getArrayDimension() { + assertThat(new Type("[I").getArrayDimension(), is(1)); + assertThat(new Type("[[I").getArrayDimension(), is(2)); + assertThat(new Type("[[[I").getArrayDimension(), is(3)); + } + + @Test + public void getArrayType() { + assertThat(new Type("[I").getArrayType(), is(new Type("I"))); + assertThat(new Type("[[I").getArrayType(), is(new Type("I"))); + assertThat(new Type("[[[I").getArrayType(), is(new Type("I"))); + assertThat(new Type("[Ljava/lang/String;").getArrayType(), is(new Type("Ljava/lang/String;"))); + } + + @Test + public void parseVoid() { + final String answer = "V"; + assertThat(Type.parseFirst("V"), is(answer)); + assertThat(Type.parseFirst("VVV"), is(answer)); + assertThat(Type.parseFirst("VIJ"), is(answer)); + assertThat(Type.parseFirst("V[I"), is(answer)); + assertThat(Type.parseFirst("VLFoo;"), is(answer)); + assertThat(Type.parseFirst("V[LFoo;"), is(answer)); + } + + @Test + public void parsePrimitive() { + final String answer = "I"; + assertThat(Type.parseFirst("I"), is(answer)); + assertThat(Type.parseFirst("III"), is(answer)); + assertThat(Type.parseFirst("IJZ"), is(answer)); + assertThat(Type.parseFirst("I[I"), is(answer)); + assertThat(Type.parseFirst("ILFoo;"), is(answer)); + assertThat(Type.parseFirst("I[LFoo;"), is(answer)); + } + + @Test + public void parseClass() { + { + final String answer = "LFoo;"; + assertThat(Type.parseFirst("LFoo;"), is(answer)); + assertThat(Type.parseFirst("LFoo;I"), is(answer)); + assertThat(Type.parseFirst("LFoo;JZ"), is(answer)); + assertThat(Type.parseFirst("LFoo;[I"), is(answer)); + assertThat(Type.parseFirst("LFoo;LFoo;"), is(answer)); + assertThat(Type.parseFirst("LFoo;[LFoo;"), is(answer)); + } + { + final String answer = "LFoo;"; + assertThat(Type.parseFirst("LFoo;"), is(answer)); + assertThat(Type.parseFirst("LFoo;I"), is(answer)); + assertThat(Type.parseFirst("LFoo;JZ"), is(answer)); + assertThat(Type.parseFirst("LFoo;[I"), is(answer)); + assertThat(Type.parseFirst("LFoo;LFoo;"), is(answer)); + assertThat(Type.parseFirst("LFoo;[LFoo;"), is(answer)); + } + { + final String answer = "LFoo;"; + assertThat(Type.parseFirst("LFoo;"), is(answer)); + assertThat(Type.parseFirst("LFoo;I"), is(answer)); + assertThat(Type.parseFirst("LFoo;JZ"), is(answer)); + assertThat(Type.parseFirst("LFoo;[I"), is(answer)); + assertThat(Type.parseFirst("LFoo;LFoo;"), is(answer)); + assertThat(Type.parseFirst("LFoo;[LFoo;"), is(answer)); + } + } + + @Test + public void parseArray() { + { + final String answer = "[I"; + assertThat(Type.parseFirst("[I"), is(answer)); + assertThat(Type.parseFirst("[III"), is(answer)); + assertThat(Type.parseFirst("[IJZ"), is(answer)); + assertThat(Type.parseFirst("[I[I"), is(answer)); + assertThat(Type.parseFirst("[ILFoo;"), is(answer)); + } + { + final String answer = "[[I"; + assertThat(Type.parseFirst("[[I"), is(answer)); + assertThat(Type.parseFirst("[[III"), is(answer)); + assertThat(Type.parseFirst("[[IJZ"), is(answer)); + assertThat(Type.parseFirst("[[I[I"), is(answer)); + assertThat(Type.parseFirst("[[ILFoo;"), is(answer)); + } + { + final String answer = "[LFoo;"; + assertThat(Type.parseFirst("[LFoo;"), is(answer)); + assertThat(Type.parseFirst("[LFoo;II"), is(answer)); + assertThat(Type.parseFirst("[LFoo;JZ"), is(answer)); + assertThat(Type.parseFirst("[LFoo;[I"), is(answer)); + assertThat(Type.parseFirst("[LFoo;LFoo;"), is(answer)); + } + } +} -- cgit v1.2.3 From 818716acb3992e602e01725b6e151c1eb0f6c2e2 Mon Sep 17 00:00:00 2001 From: jeff Date: Thu, 5 Feb 2015 23:52:55 -0500 Subject: fix test code formatting and disable the super duper slow test for now --- test/cuchaz/enigma/TestDeobfuscator.java | 12 ++++++++---- test/cuchaz/enigma/TestInnerClasses.java | 3 ++- test/cuchaz/enigma/TestJarIndexConstructorReferences.java | 3 ++- test/cuchaz/enigma/TestJarIndexInheritanceTree.java | 3 ++- test/cuchaz/enigma/TestJarIndexLoneClass.java | 3 ++- test/cuchaz/enigma/TestSourceIndex.java | 5 +++-- test/cuchaz/enigma/TestTokensConstructors.java | 3 ++- test/cuchaz/enigma/TokenChecker.java | 3 ++- 8 files changed, 23 insertions(+), 12 deletions(-) (limited to 'test') diff --git a/test/cuchaz/enigma/TestDeobfuscator.java b/test/cuchaz/enigma/TestDeobfuscator.java index 129d7b2..26d492d 100644 --- a/test/cuchaz/enigma/TestDeobfuscator.java +++ b/test/cuchaz/enigma/TestDeobfuscator.java @@ -25,17 +25,20 @@ import cuchaz.enigma.mapping.ClassEntry; public class TestDeobfuscator { - private Deobfuscator getDeobfuscator() throws IOException { + private Deobfuscator getDeobfuscator() + throws IOException { return new Deobfuscator(new JarFile("build/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(); @@ -47,7 +50,8 @@ public class TestDeobfuscator { } @Test - public void decompileClass() throws Exception { + public void decompileClass() + throws Exception { Deobfuscator deobfuscator = getDeobfuscator(); deobfuscator.getSource(deobfuscator.getSourceTree("none/a")); } diff --git a/test/cuchaz/enigma/TestInnerClasses.java b/test/cuchaz/enigma/TestInnerClasses.java index 63c9b71..2e16a33 100644 --- a/test/cuchaz/enigma/TestInnerClasses.java +++ b/test/cuchaz/enigma/TestInnerClasses.java @@ -36,7 +36,8 @@ public class TestInnerClasses { private static final String AnonymousWithOuterAccessOuter = "none/i"; private static final String AnonymousWithOuterAccessInner = "j"; - public TestInnerClasses() throws Exception { + public TestInnerClasses() + throws Exception { m_index = new JarIndex(); JarFile jar = new JarFile("build/testInnerClasses.obf.jar"); m_index.indexJar(jar, true); diff --git a/test/cuchaz/enigma/TestJarIndexConstructorReferences.java b/test/cuchaz/enigma/TestJarIndexConstructorReferences.java index 8e3ad6d..a735de7 100644 --- a/test/cuchaz/enigma/TestJarIndexConstructorReferences.java +++ b/test/cuchaz/enigma/TestJarIndexConstructorReferences.java @@ -36,7 +36,8 @@ public class TestJarIndexConstructorReferences { private ClassEntry m_defaultClass = new ClassEntry("none/c"); private ClassEntry m_callerClass = new ClassEntry("none/b"); - public TestJarIndexConstructorReferences() throws Exception { + public TestJarIndexConstructorReferences() + throws Exception { File jarFile = new File("build/testConstructors.obf.jar"); m_index = new JarIndex(); m_index.indexJar(new JarFile(jarFile), false); diff --git a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java index 4d66397..26499f0 100644 --- a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java +++ b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java @@ -41,7 +41,8 @@ public class TestJarIndexInheritanceTree { 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/testInheritanceTree.obf.jar"), false); } diff --git a/test/cuchaz/enigma/TestJarIndexLoneClass.java b/test/cuchaz/enigma/TestJarIndexLoneClass.java index a061b72..108c623 100644 --- a/test/cuchaz/enigma/TestJarIndexLoneClass.java +++ b/test/cuchaz/enigma/TestJarIndexLoneClass.java @@ -38,7 +38,8 @@ 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/testLoneClass.obf.jar"), false); } diff --git a/test/cuchaz/enigma/TestSourceIndex.java b/test/cuchaz/enigma/TestSourceIndex.java index 70a5ee4..357acb6 100644 --- a/test/cuchaz/enigma/TestSourceIndex.java +++ b/test/cuchaz/enigma/TestSourceIndex.java @@ -24,8 +24,9 @@ import cuchaz.enigma.mapping.ClassEntry; public class TestSourceIndex { // TEMP - @Test - public void indexEverything() throws Exception { + //@Test + public void indexEverything() + throws Exception { Deobfuscator deobfuscator = new Deobfuscator(new JarFile("input/1.8.jar")); // get all classes that aren't inner classes diff --git a/test/cuchaz/enigma/TestTokensConstructors.java b/test/cuchaz/enigma/TestTokensConstructors.java index 56424ae..6758d2a 100644 --- a/test/cuchaz/enigma/TestTokensConstructors.java +++ b/test/cuchaz/enigma/TestTokensConstructors.java @@ -22,7 +22,8 @@ import cuchaz.enigma.mapping.BehaviorEntry; public class TestTokensConstructors extends TokenChecker { - public TestTokensConstructors() throws Exception { + public TestTokensConstructors() + throws Exception { super(new JarFile("build/testConstructors.obf.jar")); } diff --git a/test/cuchaz/enigma/TokenChecker.java b/test/cuchaz/enigma/TokenChecker.java index febea2a..a72c2fc 100644 --- a/test/cuchaz/enigma/TokenChecker.java +++ b/test/cuchaz/enigma/TokenChecker.java @@ -27,7 +27,8 @@ public class TokenChecker { private Deobfuscator m_deobfuscator; - protected TokenChecker(JarFile jarFile) throws IOException { + protected TokenChecker(JarFile jarFile) + throws IOException { m_deobfuscator = new Deobfuscator(jarFile); } -- cgit v1.2.3 From cb22a55b241714a56f78b9c6ee863f0a37bbf005 Mon Sep 17 00:00:00 2001 From: jeff Date: Thu, 5 Feb 2015 23:53:41 -0500 Subject: start some translation tests --- test/cuchaz/enigma/TestTranslator.java | 39 +++++++++++++++++++++++ test/cuchaz/enigma/inputs/translation/A.java | 8 +++++ test/cuchaz/enigma/resources/translation.mappings | 4 +++ 3 files changed, 51 insertions(+) create mode 100644 test/cuchaz/enigma/TestTranslator.java create mode 100644 test/cuchaz/enigma/inputs/translation/A.java create mode 100644 test/cuchaz/enigma/resources/translation.mappings (limited to 'test') diff --git a/test/cuchaz/enigma/TestTranslator.java b/test/cuchaz/enigma/TestTranslator.java new file mode 100644 index 0000000..290f6f0 --- /dev/null +++ b/test/cuchaz/enigma/TestTranslator.java @@ -0,0 +1,39 @@ +package cuchaz.enigma; + +import static cuchaz.enigma.EntryFactory.*; +import static org.hamcrest.MatcherAssert.*; +import static org.hamcrest.Matchers.*; + +import java.io.InputStream; +import java.io.InputStreamReader; +import java.util.jar.JarFile; + +import org.junit.Test; + +import cuchaz.enigma.mapping.Mappings; +import cuchaz.enigma.mapping.MappingsReader; +import cuchaz.enigma.mapping.TranslationDirection; +import cuchaz.enigma.mapping.Translator; + + +public class TestTranslator { + + private Deobfuscator m_deobfuscator; + private Mappings m_mappings; + + public TestTranslator() + throws Exception { + m_deobfuscator = new Deobfuscator(new JarFile("build/testTranslation.obf.jar")); + try (InputStream in = getClass().getResourceAsStream("/cuchaz/enigma/resources/translation.mappings")) { + m_mappings = new MappingsReader().read(new InputStreamReader(in)); + m_deobfuscator.setMappings(m_mappings); + } + } + + @Test + public void deobfuscatingTranslations() + throws Exception { + Translator translator = m_deobfuscator.getTranslator(TranslationDirection.Deobfuscating); + assertThat(translator.translateEntry(newClass("none/a")), is(newClass("deobf/A"))); + } +} diff --git a/test/cuchaz/enigma/inputs/translation/A.java b/test/cuchaz/enigma/inputs/translation/A.java new file mode 100644 index 0000000..b8aaf11 --- /dev/null +++ b/test/cuchaz/enigma/inputs/translation/A.java @@ -0,0 +1,8 @@ +package cuchaz.enigma.inputs.translation; + +public class A { + + public int one; + public float two; + public String three; +} diff --git a/test/cuchaz/enigma/resources/translation.mappings b/test/cuchaz/enigma/resources/translation.mappings new file mode 100644 index 0000000..70755bf --- /dev/null +++ b/test/cuchaz/enigma/resources/translation.mappings @@ -0,0 +1,4 @@ +CLASS none/a deobf/A + FIELD a one + FIELD b two + FIELD c three \ No newline at end of file -- cgit v1.2.3