From b4aaff683d78ab92b83f3a7257c33b8e27d1affa Mon Sep 17 00:00:00 2001 From: Thog Date: Tue, 7 Mar 2017 21:24:39 +0100 Subject: Drop unix case style and implement hashCode when equals is overrided Also update Guava to version 21 --- src/test/java/cuchaz/enigma/TestDeobfed.java | 14 +- src/test/java/cuchaz/enigma/TestInnerClasses.java | 66 ++++---- .../enigma/TestJarIndexConstructorReferences.java | 75 ++++----- .../cuchaz/enigma/TestJarIndexInheritanceTree.java | 176 ++++++++++----------- .../java/cuchaz/enigma/TestJarIndexLoneClass.java | 68 ++++---- src/test/java/cuchaz/enigma/TestTranslator.java | 26 +-- src/test/java/cuchaz/enigma/TokenChecker.java | 16 +- .../enigma/inputs/inheritanceTree/BaseClass.java | 6 +- .../enigma/inputs/inheritanceTree/SubclassB.java | 6 +- .../cuchaz/enigma/inputs/loneClass/LoneClass.java | 6 +- .../enigma/inputs/translation/F_ObjectMethods.java | 1 + 11 files changed, 228 insertions(+), 232 deletions(-) (limited to 'src/test') diff --git a/src/test/java/cuchaz/enigma/TestDeobfed.java b/src/test/java/cuchaz/enigma/TestDeobfed.java index 2f318c8..76a3d3b 100644 --- a/src/test/java/cuchaz/enigma/TestDeobfed.java +++ b/src/test/java/cuchaz/enigma/TestDeobfed.java @@ -25,20 +25,20 @@ import cuchaz.enigma.analysis.JarIndex; public class TestDeobfed { - private static JarFile m_jar; - private static JarIndex m_index; + private static JarFile jar; + private static JarIndex index; @BeforeClass public static void beforeClass() throws Exception { - m_jar = new JarFile("build/test-deobf/translation.jar"); - m_index = new JarIndex(); - m_index.indexJar(m_jar, true); + jar = new JarFile("build/test-deobf/translation.jar"); + index = new JarIndex(); + index.indexJar(jar, true); } @Test public void obfEntries() { - assertThat(m_index.getObfClassEntries(), containsInAnyOrder( + assertThat(index.getObfClassEntries(), containsInAnyOrder( newClass("cuchaz/enigma/inputs/Keep"), newClass("a"), newClass("b"), @@ -68,7 +68,7 @@ public class TestDeobfed { @Test public void decompile() throws Exception { - Deobfuscator deobfuscator = new Deobfuscator(m_jar); + Deobfuscator deobfuscator = new Deobfuscator(jar); deobfuscator.getSourceTree("a"); deobfuscator.getSourceTree("b"); deobfuscator.getSourceTree("c"); diff --git a/src/test/java/cuchaz/enigma/TestInnerClasses.java b/src/test/java/cuchaz/enigma/TestInnerClasses.java index 70765e3..64a695a 100644 --- a/src/test/java/cuchaz/enigma/TestInnerClasses.java +++ b/src/test/java/cuchaz/enigma/TestInnerClasses.java @@ -24,8 +24,8 @@ import cuchaz.enigma.mapping.ClassEntry; public class TestInnerClasses { - private JarIndex m_index; - private Deobfuscator m_deobfuscator; + private JarIndex index; + private Deobfuscator deobfuscator; private static final ClassEntry AnonymousOuter = newClass("a"); private static final ClassEntry AnonymousInner = newClass("a$1"); @@ -44,49 +44,49 @@ public class TestInnerClasses { public TestInnerClasses() throws Exception { - m_index = new JarIndex(); + index = new JarIndex(); JarFile jar = new JarFile("build/test-obf/innerClasses.jar"); - m_index.indexJar(jar, true); - m_deobfuscator = new Deobfuscator(jar); + index.indexJar(jar, true); + deobfuscator = new Deobfuscator(jar); } @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)); + assertThat(index.getOuterClass(SimpleInner), is(SimpleOuter)); + assertThat(index.getInnerClasses(SimpleOuter), containsInAnyOrder(SimpleInner)); + assertThat(index.isAnonymousClass(SimpleInner), is(false)); decompile(SimpleOuter); } @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)); + assertThat(index.getOuterClass(AnonymousInner), is(AnonymousOuter)); + assertThat(index.getInnerClasses(AnonymousOuter), containsInAnyOrder(AnonymousInner)); + assertThat(index.isAnonymousClass(AnonymousInner), is(true)); decompile(AnonymousOuter); } @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)); + assertThat(index.getOuterClass(ConstructorArgsInner), is(ConstructorArgsOuter)); + assertThat(index.getInnerClasses(ConstructorArgsOuter), containsInAnyOrder(ConstructorArgsInner)); + assertThat(index.isAnonymousClass(ConstructorArgsInner), is(false)); decompile(ConstructorArgsOuter); } @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)); + assertThat(index.getOuterClass(AnonymousWithScopeArgsInner), is(AnonymousWithScopeArgsOuter)); + assertThat(index.getInnerClasses(AnonymousWithScopeArgsOuter), containsInAnyOrder(AnonymousWithScopeArgsInner)); + assertThat(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)); + assertThat(index.getOuterClass(AnonymousWithOuterAccessInner), is(AnonymousWithOuterAccessOuter)); + assertThat(index.getInnerClasses(AnonymousWithOuterAccessOuter), containsInAnyOrder(AnonymousWithOuterAccessInner)); + assertThat(index.isAnonymousClass(AnonymousWithOuterAccessInner), is(true)); decompile(AnonymousWithOuterAccessOuter); } @@ -94,26 +94,26 @@ public class TestInnerClasses { public void classTree() { // root level - assertThat(m_index.containsObfClass(ClassTreeRoot), is(true)); - assertThat(m_index.getOuterClass(ClassTreeRoot), is(nullValue())); - assertThat(m_index.getInnerClasses(ClassTreeRoot), containsInAnyOrder(ClassTreeLevel1)); + assertThat(index.containsObfClass(ClassTreeRoot), is(true)); + assertThat(index.getOuterClass(ClassTreeRoot), is(nullValue())); + assertThat(index.getInnerClasses(ClassTreeRoot), containsInAnyOrder(ClassTreeLevel1)); // level 1 ClassEntry fullClassEntry = new ClassEntry(ClassTreeRoot.getName() + "$" + ClassTreeLevel1.getInnermostClassName() ); - assertThat(m_index.containsObfClass(fullClassEntry), is(true)); - assertThat(m_index.getOuterClass(ClassTreeLevel1), is(ClassTreeRoot)); - assertThat(m_index.getInnerClasses(ClassTreeLevel1), containsInAnyOrder(ClassTreeLevel2)); + assertThat(index.containsObfClass(fullClassEntry), is(true)); + assertThat(index.getOuterClass(ClassTreeLevel1), is(ClassTreeRoot)); + assertThat(index.getInnerClasses(ClassTreeLevel1), containsInAnyOrder(ClassTreeLevel2)); // level 2 fullClassEntry = new ClassEntry(ClassTreeRoot.getName() + "$" + ClassTreeLevel1.getInnermostClassName() + "$" + ClassTreeLevel2.getInnermostClassName() ); - assertThat(m_index.containsObfClass(fullClassEntry), is(true)); - assertThat(m_index.getOuterClass(ClassTreeLevel2), is(ClassTreeLevel1)); - assertThat(m_index.getInnerClasses(ClassTreeLevel2), containsInAnyOrder(ClassTreeLevel3)); + assertThat(index.containsObfClass(fullClassEntry), is(true)); + assertThat(index.getOuterClass(ClassTreeLevel2), is(ClassTreeLevel1)); + assertThat(index.getInnerClasses(ClassTreeLevel2), containsInAnyOrder(ClassTreeLevel3)); // level 3 fullClassEntry = new ClassEntry(ClassTreeRoot.getName() @@ -121,12 +121,12 @@ public class TestInnerClasses { + "$" + ClassTreeLevel2.getInnermostClassName() + "$" + ClassTreeLevel3.getInnermostClassName() ); - assertThat(m_index.containsObfClass(fullClassEntry), is(true)); - assertThat(m_index.getOuterClass(ClassTreeLevel3), is(ClassTreeLevel2)); - assertThat(m_index.getInnerClasses(ClassTreeLevel3), is(empty())); + assertThat(index.containsObfClass(fullClassEntry), is(true)); + assertThat(index.getOuterClass(ClassTreeLevel3), is(ClassTreeLevel2)); + assertThat(index.getInnerClasses(ClassTreeLevel3), is(empty())); } private void decompile(ClassEntry classEntry) { - m_deobfuscator.getSourceTree(classEntry.getName()); + deobfuscator.getSourceTree(classEntry.getName()); } } diff --git a/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java b/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java index cb65cd0..01d4bab 100644 --- a/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java +++ b/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java @@ -27,98 +27,99 @@ import cuchaz.enigma.mapping.ClassEntry; public class TestJarIndexConstructorReferences { - private JarIndex m_index; + private JarIndex index; - private ClassEntry m_baseClass = newClass("a"); - private ClassEntry m_subClass = newClass("d"); - private ClassEntry m_subsubClass = newClass("e"); - private ClassEntry m_defaultClass = newClass("c"); - private ClassEntry m_callerClass = newClass("b"); + private ClassEntry baseClass = newClass("a"); + private ClassEntry subClass = newClass("d"); + private ClassEntry subsubClass = newClass("e"); + private ClassEntry defaultClass = newClass("c"); + private ClassEntry callerClass = newClass("b"); public TestJarIndexConstructorReferences() throws Exception { File jarFile = new File("build/test-obf/constructors.jar"); - m_index = new JarIndex(); - m_index.indexJar(new JarFile(jarFile), false); + index = new JarIndex(); + 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)); + assertThat(index.getObfClassEntries(), containsInAnyOrder(newClass("cuchaz/enigma/inputs/Keep"), baseClass, + subClass, subsubClass, defaultClass, callerClass)); } @Test @SuppressWarnings("unchecked") public void baseDefault() { - BehaviorEntry source = newConstructor(m_baseClass, "()V"); - Collection> references = m_index.getBehaviorReferences(source); + BehaviorEntry source = newConstructor(baseClass, "()V"); + Collection> references = 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") + newBehaviorReferenceByMethod(source, callerClass.getName(), "a", "()V"), + newBehaviorReferenceByConstructor(source, subClass.getName(), "()V"), + newBehaviorReferenceByConstructor(source, subClass.getName(), "(III)V") )); } @Test @SuppressWarnings("unchecked") public void baseInt() { - BehaviorEntry source = newConstructor(m_baseClass, "(I)V"); - assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder( - newBehaviorReferenceByMethod(source, m_callerClass.getName(), "b", "()V") + BehaviorEntry source = newConstructor(baseClass, "(I)V"); + assertThat(index.getBehaviorReferences(source), containsInAnyOrder( + newBehaviorReferenceByMethod(source, callerClass.getName(), "b", "()V") )); } @Test @SuppressWarnings("unchecked") public void subDefault() { - BehaviorEntry source = newConstructor(m_subClass, "()V"); - assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder( - newBehaviorReferenceByMethod(source, m_callerClass.getName(), "c", "()V"), - newBehaviorReferenceByConstructor(source, m_subClass.getName(), "(I)V") + BehaviorEntry source = newConstructor(subClass, "()V"); + assertThat(index.getBehaviorReferences(source), containsInAnyOrder( + newBehaviorReferenceByMethod(source, callerClass.getName(), "c", "()V"), + newBehaviorReferenceByConstructor(source, subClass.getName(), "(I)V") )); } @Test @SuppressWarnings("unchecked") public void subInt() { - BehaviorEntry source = newConstructor(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") + BehaviorEntry source = newConstructor(subClass, "(I)V"); + assertThat(index.getBehaviorReferences(source), containsInAnyOrder( + newBehaviorReferenceByMethod(source, callerClass.getName(), "d", "()V"), + newBehaviorReferenceByConstructor(source, subClass.getName(), "(II)V"), + newBehaviorReferenceByConstructor(source, subsubClass.getName(), "(I)V") )); } @Test @SuppressWarnings("unchecked") public void subIntInt() { - BehaviorEntry source = newConstructor(m_subClass, "(II)V"); - assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder( - newBehaviorReferenceByMethod(source, m_callerClass.getName(), "e", "()V") + BehaviorEntry source = newConstructor(subClass, "(II)V"); + assertThat(index.getBehaviorReferences(source), containsInAnyOrder( + newBehaviorReferenceByMethod(source, callerClass.getName(), "e", "()V") )); } @Test public void subIntIntInt() { - BehaviorEntry source = newConstructor(m_subClass, "(III)V"); - assertThat(m_index.getBehaviorReferences(source), is(empty())); + BehaviorEntry source = newConstructor(subClass, "(III)V"); + assertThat(index.getBehaviorReferences(source), is(empty())); } @Test @SuppressWarnings("unchecked") public void subsubInt() { - BehaviorEntry source = newConstructor(m_subsubClass, "(I)V"); - assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder( - newBehaviorReferenceByMethod(source, m_callerClass.getName(), "f", "()V") + BehaviorEntry source = newConstructor(subsubClass, "(I)V"); + assertThat(index.getBehaviorReferences(source), containsInAnyOrder( + newBehaviorReferenceByMethod(source, callerClass.getName(), "f", "()V") )); } @Test @SuppressWarnings("unchecked") public void defaultConstructable() { - BehaviorEntry source = newConstructor(m_defaultClass, "()V"); - assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder( - newBehaviorReferenceByMethod(source, m_callerClass.getName(), "g", "()V") + BehaviorEntry source = newConstructor(defaultClass, "()V"); + assertThat(index.getBehaviorReferences(source), containsInAnyOrder( + newBehaviorReferenceByMethod(source, callerClass.getName(), "g", "()V") )); } } diff --git a/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java b/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java index 28408f2..4d9c8dc 100644 --- a/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java +++ b/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java @@ -41,66 +41,60 @@ import cuchaz.enigma.mapping.MethodEntry; public class TestJarIndexInheritanceTree { - private JarIndex m_index; + private JarIndex index; - private ClassEntry m_objectClass = newClass("java/lang/Object"); - private ClassEntry m_baseClass = newClass("a"); - private ClassEntry m_subClassA = newClass("b"); - private ClassEntry m_subClassAA = newClass("d"); - private ClassEntry m_subClassB = newClass("c"); - private FieldEntry m_nameField = newField(m_baseClass, "a", "Ljava/lang/String;"); - private FieldEntry m_numThingsField = newField(m_subClassB, "a", "I"); + private ClassEntry objectClass = newClass("java/lang/Object"); + private ClassEntry baseClass = newClass("a"); + private ClassEntry subClassA = newClass("b"); + private ClassEntry subClassAA = newClass("d"); + private ClassEntry subClassB = newClass("c"); + private FieldEntry nameField = newField(baseClass, "a", "Ljava/lang/String;"); + private FieldEntry numThingsField = newField(subClassB, "a", "I"); public TestJarIndexInheritanceTree() throws Exception { - m_index = new JarIndex(); - m_index.indexJar(new JarFile("build/test-obf/inheritanceTree.jar"), false); + index = new JarIndex(); + index.indexJar(new JarFile("build/test-obf/inheritanceTree.jar"), false); } @Test public void obfEntries() { - assertThat(m_index.getObfClassEntries(), containsInAnyOrder( - newClass("cuchaz/enigma/inputs/Keep"), - m_baseClass, - m_subClassA, - m_subClassAA, - m_subClassB + assertThat(index.getObfClassEntries(), containsInAnyOrder( + newClass("cuchaz/enigma/inputs/Keep"), baseClass, subClassA, subClassAA, subClassB )); } @Test public void translationIndex() { - TranslationIndex index = m_index.getTranslationIndex(); + TranslationIndex index = this.index.getTranslationIndex(); // base class - assertThat(index.getSuperclass(m_baseClass), is(m_objectClass)); - assertThat(index.getAncestry(m_baseClass), contains(m_objectClass)); - assertThat(index.getSubclass(m_baseClass), containsInAnyOrder( - m_subClassA, - m_subClassB + assertThat(index.getSuperclass(baseClass), is(objectClass)); + assertThat(index.getAncestry(baseClass), contains(objectClass)); + assertThat(index.getSubclass(baseClass), containsInAnyOrder(subClassA, subClassB )); // subclass a - assertThat(index.getSuperclass(m_subClassA), is(m_baseClass)); - assertThat(index.getAncestry(m_subClassA), contains(m_baseClass, m_objectClass)); - assertThat(index.getSubclass(m_subClassA), contains(m_subClassAA)); + assertThat(index.getSuperclass(subClassA), is(baseClass)); + assertThat(index.getAncestry(subClassA), contains(baseClass, objectClass)); + assertThat(index.getSubclass(subClassA), contains(subClassAA)); // subclass aa - assertThat(index.getSuperclass(m_subClassAA), is(m_subClassA)); - assertThat(index.getAncestry(m_subClassAA), contains(m_subClassA, m_baseClass, m_objectClass)); - assertThat(index.getSubclass(m_subClassAA), is(empty())); + assertThat(index.getSuperclass(subClassAA), is(subClassA)); + assertThat(index.getAncestry(subClassAA), contains(subClassA, baseClass, objectClass)); + assertThat(index.getSubclass(subClassAA), is(empty())); // subclass b - assertThat(index.getSuperclass(m_subClassB), is(m_baseClass)); - assertThat(index.getAncestry(m_subClassB), contains(m_baseClass, m_objectClass)); - assertThat(index.getSubclass(m_subClassB), is(empty())); + assertThat(index.getSuperclass(subClassB), is(baseClass)); + assertThat(index.getAncestry(subClassB), contains(baseClass, objectClass)); + assertThat(index.getSubclass(subClassB), is(empty())); } @Test public void access() { - assertThat(m_index.getAccess(m_nameField), is(Access.Private)); - assertThat(m_index.getAccess(m_numThingsField), is(Access.Private)); + assertThat(index.getAccess(nameField), is(Access.PRIVATE)); + assertThat(index.getAccess(numThingsField), is(Access.PRIVATE)); } @Test @@ -109,40 +103,40 @@ public class TestJarIndexInheritanceTree { Set entries; // getName() - entries = m_index.getRelatedMethodImplementations(newMethod(m_baseClass, "a", "()Ljava/lang/String;")); + entries = index.getRelatedMethodImplementations(newMethod(baseClass, "a", "()Ljava/lang/String;")); assertThat(entries, containsInAnyOrder( - newMethod(m_baseClass, "a", "()Ljava/lang/String;"), - newMethod(m_subClassAA, "a", "()Ljava/lang/String;") + newMethod(baseClass, "a", "()Ljava/lang/String;"), + newMethod(subClassAA, "a", "()Ljava/lang/String;") )); - entries = m_index.getRelatedMethodImplementations(newMethod(m_subClassAA, "a", "()Ljava/lang/String;")); + entries = index.getRelatedMethodImplementations(newMethod(subClassAA, "a", "()Ljava/lang/String;")); assertThat(entries, containsInAnyOrder( - newMethod(m_baseClass, "a", "()Ljava/lang/String;"), - newMethod(m_subClassAA, "a", "()Ljava/lang/String;") + newMethod(baseClass, "a", "()Ljava/lang/String;"), + newMethod(subClassAA, "a", "()Ljava/lang/String;") )); // doBaseThings() - entries = m_index.getRelatedMethodImplementations(newMethod(m_baseClass, "a", "()V")); + entries = index.getRelatedMethodImplementations(newMethod(baseClass, "a", "()V")); assertThat(entries, containsInAnyOrder( - newMethod(m_baseClass, "a", "()V"), - newMethod(m_subClassAA, "a", "()V"), - newMethod(m_subClassB, "a", "()V") + newMethod(baseClass, "a", "()V"), + newMethod(subClassAA, "a", "()V"), + newMethod(subClassB, "a", "()V") )); - entries = m_index.getRelatedMethodImplementations(newMethod(m_subClassAA, "a", "()V")); + entries = index.getRelatedMethodImplementations(newMethod(subClassAA, "a", "()V")); assertThat(entries, containsInAnyOrder( - newMethod(m_baseClass, "a", "()V"), - newMethod(m_subClassAA, "a", "()V"), - newMethod(m_subClassB, "a", "()V") + newMethod(baseClass, "a", "()V"), + newMethod(subClassAA, "a", "()V"), + newMethod(subClassB, "a", "()V") )); - entries = m_index.getRelatedMethodImplementations(newMethod(m_subClassB, "a", "()V")); + entries = index.getRelatedMethodImplementations(newMethod(subClassB, "a", "()V")); assertThat(entries, containsInAnyOrder( - newMethod(m_baseClass, "a", "()V"), - newMethod(m_subClassAA, "a", "()V"), - newMethod(m_subClassB, "a", "()V") + newMethod(baseClass, "a", "()V"), + newMethod(subClassAA, "a", "()V"), + newMethod(subClassB, "a", "()V") )); // doBThings - entries = m_index.getRelatedMethodImplementations(newMethod(m_subClassB, "b", "()V")); - assertThat(entries, containsInAnyOrder(newMethod(m_subClassB, "b", "()V"))); + entries = index.getRelatedMethodImplementations(newMethod(subClassB, "b", "()V")); + assertThat(entries, containsInAnyOrder(newMethod(subClassB, "b", "()V"))); } @Test @@ -151,17 +145,17 @@ public class TestJarIndexInheritanceTree { Collection> references; // name - references = m_index.getFieldReferences(m_nameField); + references = index.getFieldReferences(nameField); assertThat(references, containsInAnyOrder( - newFieldReferenceByConstructor(m_nameField, m_baseClass.getName(), "(Ljava/lang/String;)V"), - newFieldReferenceByMethod(m_nameField, m_baseClass.getName(), "a", "()Ljava/lang/String;") + newFieldReferenceByConstructor(nameField, baseClass.getName(), "(Ljava/lang/String;)V"), + newFieldReferenceByMethod(nameField, baseClass.getName(), "a", "()Ljava/lang/String;") )); // numThings - references = m_index.getFieldReferences(m_numThingsField); + references = index.getFieldReferences(numThingsField); assertThat(references, containsInAnyOrder( - newFieldReferenceByConstructor(m_numThingsField, m_subClassB.getName(), "()V"), - newFieldReferenceByMethod(m_numThingsField, m_subClassB.getName(), "b", "()V") + newFieldReferenceByConstructor(numThingsField, subClassB.getName(), "()V"), + newFieldReferenceByMethod(numThingsField, subClassB.getName(), "b", "()V") )); } @@ -173,33 +167,33 @@ public class TestJarIndexInheritanceTree { Collection> references; // baseClass constructor - source = newConstructor(m_baseClass, "(Ljava/lang/String;)V"); - references = m_index.getBehaviorReferences(source); + source = newConstructor(baseClass, "(Ljava/lang/String;)V"); + references = index.getBehaviorReferences(source); assertThat(references, containsInAnyOrder( - newBehaviorReferenceByConstructor(source, m_subClassA.getName(), "(Ljava/lang/String;)V"), - newBehaviorReferenceByConstructor(source, m_subClassB.getName(), "()V") + newBehaviorReferenceByConstructor(source, subClassA.getName(), "(Ljava/lang/String;)V"), + newBehaviorReferenceByConstructor(source, subClassB.getName(), "()V") )); // subClassA constructor - source = newConstructor(m_subClassA, "(Ljava/lang/String;)V"); - references = m_index.getBehaviorReferences(source); + source = newConstructor(subClassA, "(Ljava/lang/String;)V"); + references = index.getBehaviorReferences(source); assertThat(references, containsInAnyOrder( - newBehaviorReferenceByConstructor(source, m_subClassAA.getName(), "()V") + newBehaviorReferenceByConstructor(source, subClassAA.getName(), "()V") )); // baseClass.getName() - source = newMethod(m_baseClass, "a", "()Ljava/lang/String;"); - references = m_index.getBehaviorReferences(source); + source = newMethod(baseClass, "a", "()Ljava/lang/String;"); + references = index.getBehaviorReferences(source); assertThat(references, containsInAnyOrder( - newBehaviorReferenceByMethod(source, m_subClassAA.getName(), "a", "()Ljava/lang/String;"), - newBehaviorReferenceByMethod(source, m_subClassB.getName(), "a", "()V") + newBehaviorReferenceByMethod(source, subClassAA.getName(), "a", "()Ljava/lang/String;"), + newBehaviorReferenceByMethod(source, subClassB.getName(), "a", "()V") )); // subclassAA.getName() - source = newMethod(m_subClassAA, "a", "()Ljava/lang/String;"); - references = m_index.getBehaviorReferences(source); + source = newMethod(subClassAA, "a", "()Ljava/lang/String;"); + references = index.getBehaviorReferences(source); assertThat(references, containsInAnyOrder( - newBehaviorReferenceByMethod(source, m_subClassAA.getName(), "a", "()V") + newBehaviorReferenceByMethod(source, subClassAA.getName(), "a", "()V") )); } @@ -207,33 +201,33 @@ public class TestJarIndexInheritanceTree { 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(index.containsObfClass(baseClass), is(true)); + assertThat(index.containsObfClass(subClassA), is(true)); + assertThat(index.containsObfClass(subClassAA), is(true)); + assertThat(index.containsObfClass(subClassB), is(true)); // fields - assertThat(m_index.containsObfField(m_nameField), is(true)); - assertThat(m_index.containsObfField(m_numThingsField), is(true)); + assertThat(index.containsObfField(nameField), is(true)); + assertThat(index.containsObfField(numThingsField), is(true)); // methods // getName() - assertThat(m_index.containsObfBehavior(newMethod(m_baseClass, "a", "()Ljava/lang/String;")), is(true)); - assertThat(m_index.containsObfBehavior(newMethod(m_subClassA, "a", "()Ljava/lang/String;")), is(false)); - assertThat(m_index.containsObfBehavior(newMethod(m_subClassAA, "a", "()Ljava/lang/String;")), is(true)); - assertThat(m_index.containsObfBehavior(newMethod(m_subClassB, "a", "()Ljava/lang/String;")), is(false)); + assertThat(index.containsObfBehavior(newMethod(baseClass, "a", "()Ljava/lang/String;")), is(true)); + assertThat(index.containsObfBehavior(newMethod(subClassA, "a", "()Ljava/lang/String;")), is(false)); + assertThat(index.containsObfBehavior(newMethod(subClassAA, "a", "()Ljava/lang/String;")), is(true)); + assertThat(index.containsObfBehavior(newMethod(subClassB, "a", "()Ljava/lang/String;")), is(false)); // doBaseThings() - assertThat(m_index.containsObfBehavior(newMethod(m_baseClass, "a", "()V")), is(true)); - assertThat(m_index.containsObfBehavior(newMethod(m_subClassA, "a", "()V")), is(false)); - assertThat(m_index.containsObfBehavior(newMethod(m_subClassAA, "a", "()V")), is(true)); - assertThat(m_index.containsObfBehavior(newMethod(m_subClassB, "a", "()V")), is(true)); + assertThat(index.containsObfBehavior(newMethod(baseClass, "a", "()V")), is(true)); + assertThat(index.containsObfBehavior(newMethod(subClassA, "a", "()V")), is(false)); + assertThat(index.containsObfBehavior(newMethod(subClassAA, "a", "()V")), is(true)); + assertThat(index.containsObfBehavior(newMethod(subClassB, "a", "()V")), is(true)); // doBThings() - assertThat(m_index.containsObfBehavior(newMethod(m_baseClass, "b", "()V")), is(false)); - assertThat(m_index.containsObfBehavior(newMethod(m_subClassA, "b", "()V")), is(false)); - assertThat(m_index.containsObfBehavior(newMethod(m_subClassAA, "b", "()V")), is(false)); - assertThat(m_index.containsObfBehavior(newMethod(m_subClassB, "b", "()V")), is(true)); + assertThat(index.containsObfBehavior(newMethod(baseClass, "b", "()V")), is(false)); + assertThat(index.containsObfBehavior(newMethod(subClassA, "b", "()V")), is(false)); + assertThat(index.containsObfBehavior(newMethod(subClassAA, "b", "()V")), is(false)); + assertThat(index.containsObfBehavior(newMethod(subClassB, "b", "()V")), is(true)); } } diff --git a/src/test/java/cuchaz/enigma/TestJarIndexLoneClass.java b/src/test/java/cuchaz/enigma/TestJarIndexLoneClass.java index 65af6d8..8efa57c 100644 --- a/src/test/java/cuchaz/enigma/TestJarIndexLoneClass.java +++ b/src/test/java/cuchaz/enigma/TestJarIndexLoneClass.java @@ -34,17 +34,17 @@ import cuchaz.enigma.mapping.Translator; public class TestJarIndexLoneClass { - private JarIndex m_index; + private JarIndex index; public TestJarIndexLoneClass() throws Exception { - m_index = new JarIndex(); - m_index.indexJar(new JarFile("build/test-obf/loneClass.jar"), false); + index = new JarIndex(); + index.indexJar(new JarFile("build/test-obf/loneClass.jar"), false); } @Test public void obfEntries() { - assertThat(m_index.getObfClassEntries(), containsInAnyOrder( + assertThat(index.getObfClassEntries(), containsInAnyOrder( newClass("cuchaz/enigma/inputs/Keep"), newClass("a") )); @@ -52,25 +52,25 @@ public class TestJarIndexLoneClass { @Test public void translationIndex() { - assertThat(m_index.getTranslationIndex().getSuperclass(new ClassEntry("a")), is(new ClassEntry("java/lang/Object"))); - assertThat(m_index.getTranslationIndex().getSuperclass(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(new ClassEntry("java/lang/Object"))); - assertThat(m_index.getTranslationIndex().getAncestry(new ClassEntry("a")), contains(new ClassEntry("java/lang/Object"))); - assertThat(m_index.getTranslationIndex().getAncestry(new ClassEntry("cuchaz/enigma/inputs/Keep")), contains(new ClassEntry("java/lang/Object"))); - assertThat(m_index.getTranslationIndex().getSubclass(new ClassEntry("a")), is(empty())); - assertThat(m_index.getTranslationIndex().getSubclass(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(empty())); + assertThat(index.getTranslationIndex().getSuperclass(new ClassEntry("a")), is(new ClassEntry("java/lang/Object"))); + assertThat(index.getTranslationIndex().getSuperclass(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(new ClassEntry("java/lang/Object"))); + assertThat(index.getTranslationIndex().getAncestry(new ClassEntry("a")), contains(new ClassEntry("java/lang/Object"))); + assertThat(index.getTranslationIndex().getAncestry(new ClassEntry("cuchaz/enigma/inputs/Keep")), contains(new ClassEntry("java/lang/Object"))); + assertThat(index.getTranslationIndex().getSubclass(new ClassEntry("a")), is(empty())); + assertThat(index.getTranslationIndex().getSubclass(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(empty())); } @Test public void access() { - assertThat(m_index.getAccess(newField("a", "a", "Ljava/lang/String;")), is(Access.Private)); - assertThat(m_index.getAccess(newMethod("a", "a", "()Ljava/lang/String;")), is(Access.Public)); - assertThat(m_index.getAccess(newField("a", "b", "Ljava/lang/String;")), is(nullValue())); - assertThat(m_index.getAccess(newField("a", "a", "LFoo;")), is(nullValue())); + assertThat(index.getAccess(newField("a", "a", "Ljava/lang/String;")), is(Access.PRIVATE)); + assertThat(index.getAccess(newMethod("a", "a", "()Ljava/lang/String;")), is(Access.PUBLIC)); + assertThat(index.getAccess(newField("a", "b", "Ljava/lang/String;")), is(nullValue())); + assertThat(index.getAccess(newField("a", "a", "LFoo;")), is(nullValue())); } @Test public void classInheritance() { - ClassInheritanceTreeNode node = m_index.getClassInheritance(new Translator(), newClass("a")); + ClassInheritanceTreeNode node = index.getClassInheritance(new Translator(), newClass("a")); assertThat(node, is(not(nullValue()))); assertThat(node.getObfClassName(), is("a")); assertThat(node.getChildCount(), is(0)); @@ -79,7 +79,7 @@ public class TestJarIndexLoneClass { @Test public void methodInheritance() { MethodEntry source = newMethod("a", "a", "()Ljava/lang/String;"); - MethodInheritanceTreeNode node = m_index.getMethodInheritance(new Translator(), source); + MethodInheritanceTreeNode node = index.getMethodInheritance(new Translator(), source); assertThat(node, is(not(nullValue()))); assertThat(node.getMethodEntry(), is(source)); assertThat(node.getChildCount(), is(0)); @@ -87,19 +87,19 @@ public class TestJarIndexLoneClass { @Test public void classImplementations() { - ClassImplementationsTreeNode node = m_index.getClassImplementations(new Translator(), newClass("a")); + ClassImplementationsTreeNode node = index.getClassImplementations(new Translator(), newClass("a")); assertThat(node, is(nullValue())); } @Test public void methodImplementations() { MethodEntry source = newMethod("a", "a", "()Ljava/lang/String;"); - assertThat(m_index.getMethodImplementations(new Translator(), source), is(empty())); + assertThat(index.getMethodImplementations(new Translator(), source), is(empty())); } @Test public void relatedMethodImplementations() { - Set entries = m_index.getRelatedMethodImplementations(newMethod("a", "a", "()Ljava/lang/String;")); + Set entries = index.getRelatedMethodImplementations(newMethod("a", "a", "()Ljava/lang/String;")); assertThat(entries, containsInAnyOrder( newMethod("a", "a", "()Ljava/lang/String;") )); @@ -109,7 +109,7 @@ public class TestJarIndexLoneClass { @SuppressWarnings("unchecked") public void fieldReferences() { FieldEntry source = newField("a", "a", "Ljava/lang/String;"); - Collection> references = m_index.getFieldReferences(source); + Collection> references = index.getFieldReferences(source); assertThat(references, containsInAnyOrder( newFieldReferenceByConstructor(source, "a", "(Ljava/lang/String;)V"), newFieldReferenceByMethod(source, "a", "a", "()Ljava/lang/String;") @@ -118,47 +118,47 @@ public class TestJarIndexLoneClass { @Test public void behaviorReferences() { - assertThat(m_index.getBehaviorReferences(newMethod("a", "a", "()Ljava/lang/String;")), is(empty())); + assertThat(index.getBehaviorReferences(newMethod("a", "a", "()Ljava/lang/String;")), is(empty())); } @Test public void innerClasses() { - assertThat(m_index.getInnerClasses(newClass("a")), is(empty())); + assertThat(index.getInnerClasses(newClass("a")), is(empty())); } @Test public void outerClass() { - assertThat(m_index.getOuterClass(newClass("a")), is(nullValue())); + assertThat(index.getOuterClass(newClass("a")), is(nullValue())); } @Test public void isAnonymousClass() { - assertThat(m_index.isAnonymousClass(newClass("a")), is(false)); + assertThat(index.isAnonymousClass(newClass("a")), is(false)); } @Test public void interfaces() { - assertThat(m_index.getInterfaces("a"), is(empty())); + assertThat(index.getInterfaces("a"), is(empty())); } @Test public void implementingClasses() { - assertThat(m_index.getImplementingClasses("a"), is(empty())); + assertThat(index.getImplementingClasses("a"), is(empty())); } @Test public void isInterface() { - assertThat(m_index.isInterface("a"), is(false)); + assertThat(index.isInterface("a"), is(false)); } @Test public void testContains() { - assertThat(m_index.containsObfClass(newClass("a")), is(true)); - assertThat(m_index.containsObfClass(newClass("b")), is(false)); - assertThat(m_index.containsObfField(newField("a", "a", "Ljava/lang/String;")), is(true)); - assertThat(m_index.containsObfField(newField("a", "b", "Ljava/lang/String;")), is(false)); - assertThat(m_index.containsObfField(newField("a", "a", "LFoo;")), is(false)); - assertThat(m_index.containsObfBehavior(newMethod("a", "a", "()Ljava/lang/String;")), is(true)); - assertThat(m_index.containsObfBehavior(newMethod("a", "b", "()Ljava/lang/String;")), is(false)); + assertThat(index.containsObfClass(newClass("a")), is(true)); + assertThat(index.containsObfClass(newClass("b")), is(false)); + assertThat(index.containsObfField(newField("a", "a", "Ljava/lang/String;")), is(true)); + assertThat(index.containsObfField(newField("a", "b", "Ljava/lang/String;")), is(false)); + assertThat(index.containsObfField(newField("a", "a", "LFoo;")), is(false)); + assertThat(index.containsObfBehavior(newMethod("a", "a", "()Ljava/lang/String;")), is(true)); + assertThat(index.containsObfBehavior(newMethod("a", "b", "()Ljava/lang/String;")), is(false)); } } diff --git a/src/test/java/cuchaz/enigma/TestTranslator.java b/src/test/java/cuchaz/enigma/TestTranslator.java index c8af307..2c54603 100644 --- a/src/test/java/cuchaz/enigma/TestTranslator.java +++ b/src/test/java/cuchaz/enigma/TestTranslator.java @@ -22,21 +22,21 @@ import cuchaz.enigma.mapping.Translator; public class TestTranslator { - private static Deobfuscator m_deobfuscator; - private static Mappings m_mappings; - private static Translator m_deobfTranslator; - private static Translator m_obfTranslator; + private static Deobfuscator deobfuscator; + private static Mappings mappings; + private static Translator deobfTranslator; + private static Translator obfTranslator; @BeforeClass public static void beforeClass() throws Exception { //TODO FIx - //m_deobfuscator = new Deobfuscator(new JarFile("build/test-obf/translation.jar")); + //deobfuscator = new Deobfuscator(new JarFile("build/test-obf/translation.jar")); //try (InputStream in = TestTranslator.class.getResourceAsStream("/cuchaz/enigma/resources/translation.mappings")) { - // m_mappings = new MappingsJsonReader().read(new InputStreamReader(in)); - // m_deobfuscator.setMappings(m_mappings); - // m_deobfTranslator = m_deobfuscator.getTranslator(TranslationDirection.Deobfuscating); - // m_obfTranslator = m_deobfuscator.getTranslator(TranslationDirection.Obfuscating); + // mappings = new MappingsJsonReader().read(new InputStreamReader(in)); + // deobfuscator.setMappings(mappings); + // deobfTranslator = deobfuscator.getTranslator(TranslationDirection.Deobfuscating); + // obfTranslator = deobfuscator.getTranslator(TranslationDirection.Obfuscating); //} } @@ -147,15 +147,15 @@ public class TestTranslator { } private void assertMapping(Entry obf, Entry deobf) { - //assertThat(m_deobfTranslator.translateEntry(obf), is(deobf)); - //assertThat(m_obfTranslator.translateEntry(deobf), is(obf)); + //assertThat(deobfTranslator.translateEntry(obf), is(deobf)); + //assertThat(obfTranslator.translateEntry(deobf), is(obf)); - //String deobfName = m_deobfTranslator.translate(obf); + //String deobfName = deobfTranslator.translate(obf); //if (deobfName != null) { // assertThat(deobfName, is(deobf.getName())); //} - //String obfName = m_obfTranslator.translate(deobf); + //String obfName = obfTranslator.translate(deobf); //if (obfName != null) { // assertThat(obfName, is(obf.getName())); //} diff --git a/src/test/java/cuchaz/enigma/TokenChecker.java b/src/test/java/cuchaz/enigma/TokenChecker.java index 7afb4cf..0746320 100644 --- a/src/test/java/cuchaz/enigma/TokenChecker.java +++ b/src/test/java/cuchaz/enigma/TokenChecker.java @@ -25,20 +25,20 @@ import cuchaz.enigma.mapping.Entry; public class TokenChecker { - private Deobfuscator m_deobfuscator; + private Deobfuscator deobfuscator; protected TokenChecker(JarFile jarFile) throws IOException { - m_deobfuscator = new Deobfuscator(jarFile); + deobfuscator = new Deobfuscator(jarFile); } protected String getDeclarationToken(Entry entry) { // decompile the class - CompilationUnit tree = m_deobfuscator.getSourceTree(entry.getClassName()); + CompilationUnit tree = 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); + String source = deobfuscator.getSource(tree); + SourceIndex index = deobfuscator.getSourceIndex(tree, source); // get the token value Token token = index.getDeclarationToken(entry); @@ -51,9 +51,9 @@ public class TokenChecker { @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 = deobfuscator.getSourceTree(reference.context.getClassName()); + String source = deobfuscator.getSource(tree); + SourceIndex index = deobfuscator.getSourceIndex(tree, source); // get the token values List values = Lists.newArrayList(); diff --git a/src/test/java/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java b/src/test/java/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java index d676ba2..1b1f369 100644 --- a/src/test/java/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java +++ b/src/test/java/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java @@ -14,16 +14,16 @@ package cuchaz.enigma.inputs.inheritanceTree; public abstract class BaseClass { // a - private String m_name; + private String name; // (Ljava/lang/String;)V protected BaseClass(String name) { - m_name = name; + this.name = name; } // a()Ljava/lang/String; public String getName() { - return m_name; + return name; } // a()V diff --git a/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java b/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java index 751fdd1..6d3b0d0 100644 --- a/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java +++ b/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java @@ -14,7 +14,7 @@ package cuchaz.enigma.inputs.inheritanceTree; public class SubclassB extends BaseClass { // a - private int m_numThings; + private int numThings; // ()V protected SubclassB() { @@ -22,7 +22,7 @@ public class SubclassB extends BaseClass { super("B"); // access to a - m_numThings = 4; + numThings = 4; } @Override @@ -35,6 +35,6 @@ public class SubclassB extends BaseClass { // b()V public void doBThings() { // access to a - System.out.println("" + m_numThings + " B things!"); + System.out.println("" + numThings + " B things!"); } } diff --git a/src/test/java/cuchaz/enigma/inputs/loneClass/LoneClass.java b/src/test/java/cuchaz/enigma/inputs/loneClass/LoneClass.java index bf264fa..d28ae97 100644 --- a/src/test/java/cuchaz/enigma/inputs/loneClass/LoneClass.java +++ b/src/test/java/cuchaz/enigma/inputs/loneClass/LoneClass.java @@ -12,13 +12,13 @@ package cuchaz.enigma.inputs.loneClass; public class LoneClass { - private String m_name; + private String name; public LoneClass(String name) { - m_name = name; + this.name = name; } public String getName() { - return m_name; + return name; } } diff --git a/src/test/java/cuchaz/enigma/inputs/translation/F_ObjectMethods.java b/src/test/java/cuchaz/enigma/inputs/translation/F_ObjectMethods.java index 32c246c..845d62b 100644 --- a/src/test/java/cuchaz/enigma/inputs/translation/F_ObjectMethods.java +++ b/src/test/java/cuchaz/enigma/inputs/translation/F_ObjectMethods.java @@ -10,6 +10,7 @@ ******************************************************************************/ package cuchaz.enigma.inputs.translation; +@SuppressWarnings("FinalizeCalledExplicitly") public class F_ObjectMethods { public void callEmAll() -- cgit v1.2.3