From 00fcd0550fcdda621c2e4662f6ddd55ce673b931 Mon Sep 17 00:00:00 2001 From: Gegy Date: Thu, 24 Jan 2019 14:48:32 +0200 Subject: [WIP] Mapping rework (#91) * Move packages * Mapping & entry refactor: first pass * Fix deobf -> obf tree remapping * Resolve various issues * Give all entries the potential for parents and treat inner classes as children * Deobf UI tree elements * Tests pass * Sort mapping output * Fix delta tracking * Index separation and first pass for #97 * Keep track of remapped jar index * Fix child entries not being remapped * Drop non-root entries * Track dropped mappings * Fix enigma mapping ordering * EntryTreeNode interface * Small tweaks * Naive full index remap on rename * Entries can resolve to more than one root entry * Support alternative resolution strategies * Bridge method resolution * Tests pass * Fix mappings being used where there are none * Fix methods with different descriptors being considered unique. closes #89 --- src/test/java/cuchaz/enigma/TestDeobfed.java | 9 +- src/test/java/cuchaz/enigma/TestDeobfuscator.java | 2 +- src/test/java/cuchaz/enigma/TestEntryFactory.java | 8 +- src/test/java/cuchaz/enigma/TestInnerClasses.java | 44 +++----- .../enigma/TestJarIndexConstructorReferences.java | 31 +++--- .../cuchaz/enigma/TestJarIndexInheritanceTree.java | 118 +++++++++++---------- .../java/cuchaz/enigma/TestJarIndexLoneClass.java | 93 ++++++++-------- .../java/cuchaz/enigma/TestMethodDescriptor.java | 4 +- src/test/java/cuchaz/enigma/TestSourceIndex.java | 4 +- .../java/cuchaz/enigma/TestTokensConstructors.java | 2 +- src/test/java/cuchaz/enigma/TestTranslator.java | 15 +-- .../java/cuchaz/enigma/TestTypeDescriptor.java | 2 +- src/test/java/cuchaz/enigma/TokenChecker.java | 12 +-- 13 files changed, 167 insertions(+), 177 deletions(-) (limited to 'src/test') diff --git a/src/test/java/cuchaz/enigma/TestDeobfed.java b/src/test/java/cuchaz/enigma/TestDeobfed.java index 9babf1e..25cb60c 100644 --- a/src/test/java/cuchaz/enigma/TestDeobfed.java +++ b/src/test/java/cuchaz/enigma/TestDeobfed.java @@ -11,9 +11,8 @@ package cuchaz.enigma; -import cuchaz.enigma.analysis.JarIndex; import cuchaz.enigma.analysis.ParsedJar; -import cuchaz.enigma.mapping.entry.ReferencedEntryPool; +import cuchaz.enigma.analysis.index.JarIndex; import org.junit.BeforeClass; import org.junit.Test; @@ -32,13 +31,13 @@ public class TestDeobfed { public static void beforeClass() throws Exception { jar = new ParsedJar(new JarFile("build/test-deobf/translation.jar")); - index = new JarIndex(new ReferencedEntryPool()); - index.indexJar(jar, true); + index = JarIndex.empty(); + index.indexJar(jar, s -> {}); } @Test public void obfEntries() { - assertThat(index.getObfClassEntries(), containsInAnyOrder( + assertThat(index.getEntryIndex().getClasses(), containsInAnyOrder( newClass("cuchaz/enigma/inputs/Keep"), newClass("a"), newClass("b"), diff --git a/src/test/java/cuchaz/enigma/TestDeobfuscator.java b/src/test/java/cuchaz/enigma/TestDeobfuscator.java index 63a6f55..5f11721 100644 --- a/src/test/java/cuchaz/enigma/TestDeobfuscator.java +++ b/src/test/java/cuchaz/enigma/TestDeobfuscator.java @@ -12,7 +12,7 @@ package cuchaz.enigma; import com.google.common.collect.Lists; -import cuchaz.enigma.mapping.entry.ClassEntry; +import cuchaz.enigma.translation.representation.entry.ClassEntry; import org.junit.Test; import java.io.IOException; diff --git a/src/test/java/cuchaz/enigma/TestEntryFactory.java b/src/test/java/cuchaz/enigma/TestEntryFactory.java index 4f52609..9e1425a 100644 --- a/src/test/java/cuchaz/enigma/TestEntryFactory.java +++ b/src/test/java/cuchaz/enigma/TestEntryFactory.java @@ -12,10 +12,10 @@ package cuchaz.enigma; import cuchaz.enigma.analysis.EntryReference; -import cuchaz.enigma.mapping.*; -import cuchaz.enigma.mapping.entry.ClassEntry; -import cuchaz.enigma.mapping.entry.FieldEntry; -import cuchaz.enigma.mapping.entry.MethodEntry; +import cuchaz.enigma.translation.representation.*; +import cuchaz.enigma.translation.representation.entry.ClassEntry; +import cuchaz.enigma.translation.representation.entry.FieldEntry; +import cuchaz.enigma.translation.representation.entry.MethodEntry; public class TestEntryFactory { diff --git a/src/test/java/cuchaz/enigma/TestInnerClasses.java b/src/test/java/cuchaz/enigma/TestInnerClasses.java index 843a63c..0319cf6 100644 --- a/src/test/java/cuchaz/enigma/TestInnerClasses.java +++ b/src/test/java/cuchaz/enigma/TestInnerClasses.java @@ -11,20 +11,16 @@ package cuchaz.enigma; -import cuchaz.enigma.analysis.JarIndex; import cuchaz.enigma.analysis.ParsedJar; -import cuchaz.enigma.mapping.entry.ClassEntry; -import cuchaz.enigma.mapping.entry.ReferencedEntryPool; +import cuchaz.enigma.analysis.index.JarIndex; +import cuchaz.enigma.translation.representation.entry.ClassEntry; import org.junit.Test; import java.util.jar.JarFile; import static cuchaz.enigma.TestEntryFactory.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 org.hamcrest.Matchers.nullValue; public class TestInnerClasses { @@ -41,23 +37,19 @@ public class TestInnerClasses { public TestInnerClasses() throws Exception { - index = new JarIndex(new ReferencedEntryPool()); + index = JarIndex.empty(); ParsedJar jar = new ParsedJar(new JarFile("build/test-obf/innerClasses.jar")); - index.indexJar(jar, true); + index.indexJar(jar, s -> {}); deobfuscator = new Deobfuscator(jar); } @Test public void simple() { - assertThat(index.getOuterClass(SimpleInner), is(SimpleOuter)); - assertThat(index.getInnerClasses(SimpleOuter), containsInAnyOrder(SimpleInner)); decompile(SimpleOuter); } @Test public void constructorArgs() { - assertThat(index.getOuterClass(ConstructorArgsInner), is(ConstructorArgsOuter)); - assertThat(index.getInnerClasses(ConstructorArgsOuter), containsInAnyOrder(ConstructorArgsInner)); decompile(ConstructorArgsOuter); } @@ -65,33 +57,25 @@ public class TestInnerClasses { public void classTree() { // root level - assertThat(index.containsObfClass(ClassTreeRoot), is(true)); - assertThat(index.getOuterClass(ClassTreeRoot), is(nullValue())); - assertThat(index.getInnerClasses(ClassTreeRoot), containsInAnyOrder(ClassTreeLevel1)); + assertThat(index.getEntryIndex().hasClass(ClassTreeRoot), is(true)); // level 1 ClassEntry fullClassEntry = new ClassEntry(ClassTreeRoot.getName() - + "$" + ClassTreeLevel1.getInnermostClassName()); - assertThat(index.containsObfClass(fullClassEntry), is(true)); - assertThat(index.getOuterClass(ClassTreeLevel1), is(ClassTreeRoot)); - assertThat(index.getInnerClasses(ClassTreeLevel1), containsInAnyOrder(ClassTreeLevel2)); + + "$" + ClassTreeLevel1.getSimpleName()); + assertThat(index.getEntryIndex().hasClass(fullClassEntry), is(true)); // level 2 fullClassEntry = new ClassEntry(ClassTreeRoot.getName() - + "$" + ClassTreeLevel1.getInnermostClassName() - + "$" + ClassTreeLevel2.getInnermostClassName()); - assertThat(index.containsObfClass(fullClassEntry), is(true)); - assertThat(index.getOuterClass(ClassTreeLevel2), is(ClassTreeLevel1)); - assertThat(index.getInnerClasses(ClassTreeLevel2), containsInAnyOrder(ClassTreeLevel3)); + + "$" + ClassTreeLevel1.getSimpleName() + + "$" + ClassTreeLevel2.getSimpleName()); + assertThat(index.getEntryIndex().hasClass(fullClassEntry), is(true)); // level 3 fullClassEntry = new ClassEntry(ClassTreeRoot.getName() - + "$" + ClassTreeLevel1.getInnermostClassName() - + "$" + ClassTreeLevel2.getInnermostClassName() - + "$" + ClassTreeLevel3.getInnermostClassName()); - assertThat(index.containsObfClass(fullClassEntry), is(true)); - assertThat(index.getOuterClass(ClassTreeLevel3), is(ClassTreeLevel2)); - assertThat(index.getInnerClasses(ClassTreeLevel3), is(empty())); + + "$" + ClassTreeLevel1.getSimpleName() + + "$" + ClassTreeLevel2.getSimpleName() + + "$" + ClassTreeLevel3.getSimpleName()); + assertThat(index.getEntryIndex().hasClass(fullClassEntry), is(true)); } private void decompile(ClassEntry classEntry) { diff --git a/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java b/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java index 763639a..c3f3b66 100644 --- a/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java +++ b/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java @@ -12,12 +12,11 @@ package cuchaz.enigma; import cuchaz.enigma.analysis.EntryReference; -import cuchaz.enigma.analysis.JarIndex; import cuchaz.enigma.analysis.ParsedJar; -import cuchaz.enigma.mapping.entry.ClassEntry; -import cuchaz.enigma.mapping.entry.MethodDefEntry; -import cuchaz.enigma.mapping.entry.MethodEntry; -import cuchaz.enigma.mapping.entry.ReferencedEntryPool; +import cuchaz.enigma.analysis.index.JarIndex; +import cuchaz.enigma.translation.representation.entry.ClassEntry; +import cuchaz.enigma.translation.representation.entry.MethodDefEntry; +import cuchaz.enigma.translation.representation.entry.MethodEntry; import org.junit.Test; import java.io.File; @@ -41,13 +40,13 @@ public class TestJarIndexConstructorReferences { public TestJarIndexConstructorReferences() throws Exception { File jarFile = new File("build/test-obf/constructors.jar"); - index = new JarIndex(new ReferencedEntryPool()); - index.indexJar(new ParsedJar(new JarFile(jarFile)), false); + index = JarIndex.empty(); + index.indexJar(new ParsedJar(new JarFile(jarFile)), s -> {}); } @Test public void obfEntries() { - assertThat(index.getObfClassEntries(), containsInAnyOrder(newClass("cuchaz/enigma/inputs/Keep"), baseClass, + assertThat(index.getEntryIndex().getClasses(), containsInAnyOrder(newClass("cuchaz/enigma/inputs/Keep"), baseClass, subClass, subsubClass, defaultClass, callerClass)); } @@ -55,7 +54,7 @@ public class TestJarIndexConstructorReferences { @SuppressWarnings("unchecked") public void baseDefault() { MethodEntry source = newMethod(baseClass, "", "()V"); - Collection> references = index.getMethodsReferencing(source); + Collection> references = index.getReferenceIndex().getReferencesToMethod(source); assertThat(references, containsInAnyOrder( newBehaviorReferenceByMethod(source, callerClass.getName(), "a", "()V"), newBehaviorReferenceByMethod(source, subClass.getName(), "", "()V"), @@ -67,7 +66,7 @@ public class TestJarIndexConstructorReferences { @SuppressWarnings("unchecked") public void baseInt() { MethodEntry source = newMethod(baseClass, "", "(I)V"); - assertThat(index.getMethodsReferencing(source), containsInAnyOrder( + assertThat(index.getReferenceIndex().getReferencesToMethod(source), containsInAnyOrder( newBehaviorReferenceByMethod(source, callerClass.getName(), "b", "()V") )); } @@ -76,7 +75,7 @@ public class TestJarIndexConstructorReferences { @SuppressWarnings("unchecked") public void subDefault() { MethodEntry source = newMethod(subClass, "", "()V"); - assertThat(index.getMethodsReferencing(source), containsInAnyOrder( + assertThat(index.getReferenceIndex().getReferencesToMethod(source), containsInAnyOrder( newBehaviorReferenceByMethod(source, callerClass.getName(), "c", "()V"), newBehaviorReferenceByMethod(source, subClass.getName(), "", "(I)V") )); @@ -86,7 +85,7 @@ public class TestJarIndexConstructorReferences { @SuppressWarnings("unchecked") public void subInt() { MethodEntry source = newMethod(subClass, "", "(I)V"); - assertThat(index.getMethodsReferencing(source), containsInAnyOrder( + assertThat(index.getReferenceIndex().getReferencesToMethod(source), containsInAnyOrder( newBehaviorReferenceByMethod(source, callerClass.getName(), "d", "()V"), newBehaviorReferenceByMethod(source, subClass.getName(), "", "(II)V"), newBehaviorReferenceByMethod(source, subsubClass.getName(), "", "(I)V") @@ -97,7 +96,7 @@ public class TestJarIndexConstructorReferences { @SuppressWarnings("unchecked") public void subIntInt() { MethodEntry source = newMethod(subClass, "", "(II)V"); - assertThat(index.getMethodsReferencing(source), containsInAnyOrder( + assertThat(index.getReferenceIndex().getReferencesToMethod(source), containsInAnyOrder( newBehaviorReferenceByMethod(source, callerClass.getName(), "e", "()V") )); } @@ -105,14 +104,14 @@ public class TestJarIndexConstructorReferences { @Test public void subIntIntInt() { MethodEntry source = newMethod(subClass, "", "(III)V"); - assertThat(index.getMethodsReferencing(source), is(empty())); + assertThat(index.getReferenceIndex().getReferencesToMethod(source), is(empty())); } @Test @SuppressWarnings("unchecked") public void subsubInt() { MethodEntry source = newMethod(subsubClass, "", "(I)V"); - assertThat(index.getMethodsReferencing(source), containsInAnyOrder( + assertThat(index.getReferenceIndex().getReferencesToMethod(source), containsInAnyOrder( newBehaviorReferenceByMethod(source, callerClass.getName(), "f", "()V") )); } @@ -121,7 +120,7 @@ public class TestJarIndexConstructorReferences { @SuppressWarnings("unchecked") public void defaultConstructable() { MethodEntry source = newMethod(defaultClass, "", "()V"); - assertThat(index.getMethodsReferencing(source), containsInAnyOrder( + assertThat(index.getReferenceIndex().getReferencesToMethod(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 23df1a9..36595a3 100644 --- a/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java +++ b/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java @@ -11,12 +11,22 @@ package cuchaz.enigma; -import cuchaz.enigma.analysis.*; -import cuchaz.enigma.mapping.entry.*; +import cuchaz.enigma.analysis.EntryReference; +import cuchaz.enigma.analysis.ParsedJar; +import cuchaz.enigma.analysis.index.EntryIndex; +import cuchaz.enigma.analysis.index.InheritanceIndex; +import cuchaz.enigma.analysis.index.JarIndex; +import cuchaz.enigma.translation.mapping.EntryResolver; +import cuchaz.enigma.translation.mapping.IndexEntryResolver; +import cuchaz.enigma.translation.representation.AccessFlags; +import cuchaz.enigma.translation.representation.entry.ClassEntry; +import cuchaz.enigma.translation.representation.entry.FieldEntry; +import cuchaz.enigma.translation.representation.entry.MethodDefEntry; +import cuchaz.enigma.translation.representation.entry.MethodEntry; import org.junit.Test; +import org.objectweb.asm.Opcodes; import java.util.Collection; -import java.util.Set; import java.util.jar.JarFile; import static cuchaz.enigma.TestEntryFactory.*; @@ -27,7 +37,6 @@ public class TestJarIndexInheritanceTree { private JarIndex index; - private ClassEntry objectClass = newClass("java/lang/Object"); private ClassEntry baseClass = newClass("a"); private ClassEntry subClassA = newClass("b"); private ClassEntry subClassAA = newClass("d"); @@ -37,13 +46,13 @@ public class TestJarIndexInheritanceTree { public TestJarIndexInheritanceTree() throws Exception { - index = new JarIndex(new ReferencedEntryPool()); - index.indexJar(new ParsedJar(new JarFile("build/test-obf/inheritanceTree.jar")), false); + index = JarIndex.empty(); + index.indexJar(new ParsedJar(new JarFile("build/test-obf/inheritanceTree.jar")), s -> {}); } @Test public void obfEntries() { - assertThat(index.getObfClassEntries(), containsInAnyOrder( + assertThat(index.getEntryIndex().getClasses(), containsInAnyOrder( newClass("cuchaz/enigma/inputs/Keep"), baseClass, subClassA, subClassAA, subClassB )); } @@ -51,67 +60,68 @@ public class TestJarIndexInheritanceTree { @Test public void translationIndex() { - TranslationIndex index = this.index.getTranslationIndex(); + InheritanceIndex index = this.index.getInheritanceIndex(); // base class - assertThat(index.getSuperclass(baseClass), is(objectClass)); - assertThat(index.getAncestry(baseClass), contains(objectClass)); - assertThat(index.getSubclass(baseClass), containsInAnyOrder(subClassA, subClassB + assertThat(index.getParents(baseClass), is(empty())); + assertThat(index.getAncestors(baseClass), is(empty())); + assertThat(index.getChildren(baseClass), containsInAnyOrder(subClassA, subClassB )); // subclass a - assertThat(index.getSuperclass(subClassA), is(baseClass)); - assertThat(index.getAncestry(subClassA), contains(baseClass, objectClass)); - assertThat(index.getSubclass(subClassA), contains(subClassAA)); + assertThat(index.getParents(subClassA), contains(baseClass)); + assertThat(index.getAncestors(subClassA), containsInAnyOrder(baseClass)); + assertThat(index.getChildren(subClassA), contains(subClassAA)); // subclass aa - assertThat(index.getSuperclass(subClassAA), is(subClassA)); - assertThat(index.getAncestry(subClassAA), contains(subClassA, baseClass, objectClass)); - assertThat(index.getSubclass(subClassAA), is(empty())); + assertThat(index.getParents(subClassAA), contains(subClassA)); + assertThat(index.getAncestors(subClassAA), containsInAnyOrder(subClassA, baseClass)); + assertThat(index.getChildren(subClassAA), is(empty())); // subclass b - assertThat(index.getSuperclass(subClassB), is(baseClass)); - assertThat(index.getAncestry(subClassB), contains(baseClass, objectClass)); - assertThat(index.getSubclass(subClassB), is(empty())); + assertThat(index.getParents(subClassB), contains(baseClass)); + assertThat(index.getAncestors(subClassB), containsInAnyOrder(baseClass)); + assertThat(index.getChildren(subClassB), is(empty())); } @Test public void access() { - assertThat(index.getAccess(nameField), is(Access.PRIVATE)); - assertThat(index.getAccess(numThingsField), is(Access.PRIVATE)); + assertThat(index.getEntryIndex().getFieldAccess(nameField), is(new AccessFlags(Opcodes.ACC_PRIVATE))); + assertThat(index.getEntryIndex().getFieldAccess(numThingsField), is(new AccessFlags(Opcodes.ACC_PRIVATE))); } @Test public void relatedMethodImplementations() { - Set entries; + Collection entries; + EntryResolver resolver = new IndexEntryResolver(index); // getName() - entries = index.getRelatedMethodImplementations(newMethod(baseClass, "a", "()Ljava/lang/String;")); + entries = resolver.resolveEquivalentMethods(newMethod(baseClass, "a", "()Ljava/lang/String;")); assertThat(entries, containsInAnyOrder( newMethod(baseClass, "a", "()Ljava/lang/String;"), newMethod(subClassAA, "a", "()Ljava/lang/String;") )); - entries = index.getRelatedMethodImplementations(newMethod(subClassAA, "a", "()Ljava/lang/String;")); + entries = resolver.resolveEquivalentMethods(newMethod(subClassAA, "a", "()Ljava/lang/String;")); assertThat(entries, containsInAnyOrder( newMethod(baseClass, "a", "()Ljava/lang/String;"), newMethod(subClassAA, "a", "()Ljava/lang/String;") )); // doBaseThings() - entries = index.getRelatedMethodImplementations(newMethod(baseClass, "a", "()V")); + entries = resolver.resolveEquivalentMethods(newMethod(baseClass, "a", "()V")); assertThat(entries, containsInAnyOrder( newMethod(baseClass, "a", "()V"), newMethod(subClassAA, "a", "()V"), newMethod(subClassB, "a", "()V") )); - entries = index.getRelatedMethodImplementations(newMethod(subClassAA, "a", "()V")); + entries = resolver.resolveEquivalentMethods(newMethod(subClassAA, "a", "()V")); assertThat(entries, containsInAnyOrder( newMethod(baseClass, "a", "()V"), newMethod(subClassAA, "a", "()V"), newMethod(subClassB, "a", "()V") )); - entries = index.getRelatedMethodImplementations(newMethod(subClassB, "a", "()V")); + entries = resolver.resolveEquivalentMethods(newMethod(subClassB, "a", "()V")); assertThat(entries, containsInAnyOrder( newMethod(baseClass, "a", "()V"), newMethod(subClassAA, "a", "()V"), @@ -119,7 +129,7 @@ public class TestJarIndexInheritanceTree { )); // doBThings - entries = index.getRelatedMethodImplementations(newMethod(subClassB, "b", "()V")); + entries = resolver.resolveEquivalentMethods(newMethod(subClassB, "b", "()V")); assertThat(entries, containsInAnyOrder(newMethod(subClassB, "b", "()V"))); } @@ -129,14 +139,14 @@ public class TestJarIndexInheritanceTree { Collection> references; // name - references = index.getFieldReferences(nameField); + references = index.getReferenceIndex().getReferencesToField(nameField); assertThat(references, containsInAnyOrder( newFieldReferenceByMethod(nameField, baseClass.getName(), "", "(Ljava/lang/String;)V"), newFieldReferenceByMethod(nameField, baseClass.getName(), "a", "()Ljava/lang/String;") )); // numThings - references = index.getFieldReferences(numThingsField); + references = index.getReferenceIndex().getReferencesToField(numThingsField); assertThat(references, containsInAnyOrder( newFieldReferenceByMethod(numThingsField, subClassB.getName(), "", "()V"), newFieldReferenceByMethod(numThingsField, subClassB.getName(), "b", "()V") @@ -152,7 +162,7 @@ public class TestJarIndexInheritanceTree { // baseClass constructor source = newMethod(baseClass, "", "(Ljava/lang/String;)V"); - references = index.getMethodsReferencing(source); + references = index.getReferenceIndex().getReferencesToMethod(source); assertThat(references, containsInAnyOrder( newBehaviorReferenceByMethod(source, subClassA.getName(), "", "(Ljava/lang/String;)V"), newBehaviorReferenceByMethod(source, subClassB.getName(), "", "()V") @@ -160,14 +170,14 @@ public class TestJarIndexInheritanceTree { // subClassA constructor source = newMethod(subClassA, "", "(Ljava/lang/String;)V"); - references = index.getMethodsReferencing(source); + references = index.getReferenceIndex().getReferencesToMethod(source); assertThat(references, containsInAnyOrder( newBehaviorReferenceByMethod(source, subClassAA.getName(), "", "()V") )); // baseClass.getName() source = newMethod(baseClass, "a", "()Ljava/lang/String;"); - references = index.getMethodsReferencing(source); + references = index.getReferenceIndex().getReferencesToMethod(source); assertThat(references, containsInAnyOrder( newBehaviorReferenceByMethod(source, subClassAA.getName(), "a", "()Ljava/lang/String;"), newBehaviorReferenceByMethod(source, subClassB.getName(), "a", "()V") @@ -175,7 +185,7 @@ public class TestJarIndexInheritanceTree { // subclassAA.getName() source = newMethod(subClassAA, "a", "()Ljava/lang/String;"); - references = index.getMethodsReferencing(source); + references = index.getReferenceIndex().getReferencesToMethod(source); assertThat(references, containsInAnyOrder( newBehaviorReferenceByMethod(source, subClassAA.getName(), "a", "()V") )); @@ -183,35 +193,35 @@ public class TestJarIndexInheritanceTree { @Test public void containsEntries() { - + EntryIndex entryIndex = index.getEntryIndex(); // classes - assertThat(index.containsObfClass(baseClass), is(true)); - assertThat(index.containsObfClass(subClassA), is(true)); - assertThat(index.containsObfClass(subClassAA), is(true)); - assertThat(index.containsObfClass(subClassB), is(true)); + assertThat(entryIndex.hasClass(baseClass), is(true)); + assertThat(entryIndex.hasClass(subClassA), is(true)); + assertThat(entryIndex.hasClass(subClassAA), is(true)); + assertThat(entryIndex.hasClass(subClassB), is(true)); // fields - assertThat(index.containsObfField(nameField), is(true)); - assertThat(index.containsObfField(numThingsField), is(true)); + assertThat(entryIndex.hasField(nameField), is(true)); + assertThat(entryIndex.hasField(numThingsField), is(true)); // methods // getName() - assertThat(index.containsObfMethod(newMethod(baseClass, "a", "()Ljava/lang/String;")), is(true)); - assertThat(index.containsObfMethod(newMethod(subClassA, "a", "()Ljava/lang/String;")), is(false)); - assertThat(index.containsObfMethod(newMethod(subClassAA, "a", "()Ljava/lang/String;")), is(true)); - assertThat(index.containsObfMethod(newMethod(subClassB, "a", "()Ljava/lang/String;")), is(false)); + assertThat(entryIndex.hasMethod(newMethod(baseClass, "a", "()Ljava/lang/String;")), is(true)); + assertThat(entryIndex.hasMethod(newMethod(subClassA, "a", "()Ljava/lang/String;")), is(false)); + assertThat(entryIndex.hasMethod(newMethod(subClassAA, "a", "()Ljava/lang/String;")), is(true)); + assertThat(entryIndex.hasMethod(newMethod(subClassB, "a", "()Ljava/lang/String;")), is(false)); // doBaseThings() - assertThat(index.containsObfMethod(newMethod(baseClass, "a", "()V")), is(true)); - assertThat(index.containsObfMethod(newMethod(subClassA, "a", "()V")), is(false)); - assertThat(index.containsObfMethod(newMethod(subClassAA, "a", "()V")), is(true)); - assertThat(index.containsObfMethod(newMethod(subClassB, "a", "()V")), is(true)); + assertThat(entryIndex.hasMethod(newMethod(baseClass, "a", "()V")), is(true)); + assertThat(entryIndex.hasMethod(newMethod(subClassA, "a", "()V")), is(false)); + assertThat(entryIndex.hasMethod(newMethod(subClassAA, "a", "()V")), is(true)); + assertThat(entryIndex.hasMethod(newMethod(subClassB, "a", "()V")), is(true)); // doBThings() - assertThat(index.containsObfMethod(newMethod(baseClass, "b", "()V")), is(false)); - assertThat(index.containsObfMethod(newMethod(subClassA, "b", "()V")), is(false)); - assertThat(index.containsObfMethod(newMethod(subClassAA, "b", "()V")), is(false)); - assertThat(index.containsObfMethod(newMethod(subClassB, "b", "()V")), is(true)); + assertThat(entryIndex.hasMethod(newMethod(baseClass, "b", "()V")), is(false)); + assertThat(entryIndex.hasMethod(newMethod(subClassA, "b", "()V")), is(false)); + assertThat(entryIndex.hasMethod(newMethod(subClassAA, "b", "()V")), is(false)); + assertThat(entryIndex.hasMethod(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 b4529dd..1299bcc 100644 --- a/src/test/java/cuchaz/enigma/TestJarIndexLoneClass.java +++ b/src/test/java/cuchaz/enigma/TestJarIndexLoneClass.java @@ -12,12 +12,19 @@ package cuchaz.enigma; import cuchaz.enigma.analysis.*; -import cuchaz.enigma.mapping.*; -import cuchaz.enigma.mapping.entry.*; +import cuchaz.enigma.analysis.index.EntryIndex; +import cuchaz.enigma.analysis.index.InheritanceIndex; +import cuchaz.enigma.analysis.index.JarIndex; +import cuchaz.enigma.translation.VoidTranslator; +import cuchaz.enigma.translation.representation.AccessFlags; +import cuchaz.enigma.translation.representation.entry.ClassEntry; +import cuchaz.enigma.translation.representation.entry.FieldEntry; +import cuchaz.enigma.translation.representation.entry.MethodDefEntry; +import cuchaz.enigma.translation.representation.entry.MethodEntry; import org.junit.Test; import java.util.Collection; -import java.util.Set; +import java.util.List; import java.util.jar.JarFile; import static cuchaz.enigma.TestEntryFactory.*; @@ -30,13 +37,13 @@ public class TestJarIndexLoneClass { public TestJarIndexLoneClass() throws Exception { - index = new JarIndex(new ReferencedEntryPool()); - index.indexJar(new ParsedJar(new JarFile("build/test-obf/loneClass.jar")), false); + index = JarIndex.empty(); + index.indexJar(new ParsedJar(new JarFile("build/test-obf/loneClass.jar")), s -> {}); } @Test public void obfEntries() { - assertThat(index.getObfClassEntries(), containsInAnyOrder( + assertThat(index.getEntryIndex().getClasses(), containsInAnyOrder( newClass("cuchaz/enigma/inputs/Keep"), newClass("a") )); @@ -44,25 +51,28 @@ public class TestJarIndexLoneClass { @Test public void translationIndex() { - 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())); + InheritanceIndex inheritanceIndex = index.getInheritanceIndex(); + assertThat(inheritanceIndex.getParents(new ClassEntry("a")), is(empty())); + assertThat(inheritanceIndex.getParents(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(empty())); + assertThat(inheritanceIndex.getAncestors(new ClassEntry("a")), is(empty())); + assertThat(inheritanceIndex.getAncestors(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(empty())); + assertThat(inheritanceIndex.getChildren(new ClassEntry("a")), is(empty())); + assertThat(inheritanceIndex.getChildren(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(empty())); } @Test public void access() { - 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())); + EntryIndex entryIndex = index.getEntryIndex(); + assertThat(entryIndex.getFieldAccess(newField("a", "a", "Ljava/lang/String;")), is(AccessFlags.PRIVATE)); + assertThat(entryIndex.getMethodAccess(newMethod("a", "a", "()Ljava/lang/String;")), is(AccessFlags.PUBLIC)); + assertThat(entryIndex.getFieldAccess(newField("a", "b", "Ljava/lang/String;")), is(nullValue())); + assertThat(entryIndex.getFieldAccess(newField("a", "a", "LFoo;")), is(nullValue())); } @Test public void classInheritance() { - ClassInheritanceTreeNode node = index.getClassInheritance(new DirectionalTranslator(new ReferencedEntryPool()), newClass("a")); + IndexTreeBuilder treeBuilder = new IndexTreeBuilder(index); + ClassInheritanceTreeNode node = treeBuilder.buildClassInheritance(VoidTranslator.INSTANCE, newClass("a")); assertThat(node, is(not(nullValue()))); assertThat(node.getObfClassName(), is("a")); assertThat(node.getChildCount(), is(0)); @@ -70,8 +80,9 @@ public class TestJarIndexLoneClass { @Test public void methodInheritance() { + IndexTreeBuilder treeBuilder = new IndexTreeBuilder(index); MethodEntry source = newMethod("a", "a", "()Ljava/lang/String;"); - MethodInheritanceTreeNode node = index.getMethodInheritance(new DirectionalTranslator(new ReferencedEntryPool()), source); + MethodInheritanceTreeNode node = treeBuilder.buildMethodInheritance(VoidTranslator.INSTANCE, source); assertThat(node, is(not(nullValue()))); assertThat(node.getMethodEntry(), is(source)); assertThat(node.getChildCount(), is(0)); @@ -79,19 +90,24 @@ public class TestJarIndexLoneClass { @Test public void classImplementations() { - ClassImplementationsTreeNode node = index.getClassImplementations(new DirectionalTranslator(new ReferencedEntryPool()), newClass("a")); + IndexTreeBuilder treeBuilder = new IndexTreeBuilder(index); + ClassImplementationsTreeNode node = treeBuilder.buildClassImplementations(VoidTranslator.INSTANCE, newClass("a")); assertThat(node, is(nullValue())); } @Test public void methodImplementations() { + IndexTreeBuilder treeBuilder = new IndexTreeBuilder(index); MethodEntry source = newMethod("a", "a", "()Ljava/lang/String;"); - assertThat(index.getMethodImplementations(new DirectionalTranslator(new ReferencedEntryPool()), source), is(empty())); + + List nodes = treeBuilder.buildMethodImplementations(VoidTranslator.INSTANCE, source); + assertThat(nodes, hasSize(1)); + assertThat(nodes.get(0).getMethodEntry(), is(source)); } @Test public void relatedMethodImplementations() { - Set entries = index.getRelatedMethodImplementations(newMethod("a", "a", "()Ljava/lang/String;")); + Collection entries = index.getEntryResolver().resolveEquivalentMethods(newMethod("a", "a", "()Ljava/lang/String;")); assertThat(entries, containsInAnyOrder( newMethod("a", "a", "()Ljava/lang/String;") )); @@ -101,7 +117,7 @@ public class TestJarIndexLoneClass { @SuppressWarnings("unchecked") public void fieldReferences() { FieldEntry source = newField("a", "a", "Ljava/lang/String;"); - Collection> references = index.getFieldReferences(source); + Collection> references = index.getReferenceIndex().getReferencesToField(source); assertThat(references, containsInAnyOrder( newFieldReferenceByMethod(source, "a", "", "(Ljava/lang/String;)V"), newFieldReferenceByMethod(source, "a", "a", "()Ljava/lang/String;") @@ -110,42 +126,33 @@ public class TestJarIndexLoneClass { @Test public void behaviorReferences() { - assertThat(index.getMethodsReferencing(newMethod("a", "a", "()Ljava/lang/String;")), is(empty())); - } - - @Test - public void innerClasses() { - assertThat(index.getInnerClasses(newClass("a")), is(empty())); - } - - @Test - public void outerClass() { - assertThat(index.getOuterClass(newClass("a")), is(nullValue())); + assertThat(index.getReferenceIndex().getReferencesToMethod(newMethod("a", "a", "()Ljava/lang/String;")), is(empty())); } @Test public void interfaces() { - assertThat(index.getInterfaces("a"), is(empty())); + assertThat(index.getInheritanceIndex().getParents(new ClassEntry("a")), is(empty())); } @Test public void implementingClasses() { - assertThat(index.getImplementingClasses("a"), is(empty())); + assertThat(index.getInheritanceIndex().getChildren(new ClassEntry("a")), is(empty())); } @Test public void isInterface() { - assertThat(index.isInterface("a"), is(false)); + assertThat(index.getInheritanceIndex().isParent(new ClassEntry("a")), is(false)); } @Test public void testContains() { - 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.containsObfMethod(newMethod("a", "a", "()Ljava/lang/String;")), is(true)); - assertThat(index.containsObfMethod(newMethod("a", "b", "()Ljava/lang/String;")), is(false)); + EntryIndex entryIndex = index.getEntryIndex(); + assertThat(entryIndex.hasClass(newClass("a")), is(true)); + assertThat(entryIndex.hasClass(newClass("b")), is(false)); + assertThat(entryIndex.hasField(newField("a", "a", "Ljava/lang/String;")), is(true)); + assertThat(entryIndex.hasField(newField("a", "b", "Ljava/lang/String;")), is(false)); + assertThat(entryIndex.hasField(newField("a", "a", "LFoo;")), is(false)); + assertThat(entryIndex.hasMethod(newMethod("a", "a", "()Ljava/lang/String;")), is(true)); + assertThat(entryIndex.hasMethod(newMethod("a", "b", "()Ljava/lang/String;")), is(false)); } } diff --git a/src/test/java/cuchaz/enigma/TestMethodDescriptor.java b/src/test/java/cuchaz/enigma/TestMethodDescriptor.java index 48c46e5..a73880d 100644 --- a/src/test/java/cuchaz/enigma/TestMethodDescriptor.java +++ b/src/test/java/cuchaz/enigma/TestMethodDescriptor.java @@ -11,8 +11,8 @@ package cuchaz.enigma; -import cuchaz.enigma.mapping.MethodDescriptor; -import cuchaz.enigma.mapping.TypeDescriptor; +import cuchaz.enigma.translation.representation.MethodDescriptor; +import cuchaz.enigma.translation.representation.TypeDescriptor; import org.junit.Test; import static org.hamcrest.MatcherAssert.assertThat; diff --git a/src/test/java/cuchaz/enigma/TestSourceIndex.java b/src/test/java/cuchaz/enigma/TestSourceIndex.java index 0754275..a5f5f71 100644 --- a/src/test/java/cuchaz/enigma/TestSourceIndex.java +++ b/src/test/java/cuchaz/enigma/TestSourceIndex.java @@ -13,7 +13,7 @@ package cuchaz.enigma; import com.google.common.collect.Sets; import com.strobel.decompiler.languages.java.ast.CompilationUnit; -import cuchaz.enigma.mapping.entry.ClassEntry; +import cuchaz.enigma.translation.representation.entry.ClassEntry; import org.junit.Test; import java.io.File; @@ -44,7 +44,7 @@ public class TestSourceIndex { // get all classes that aren't inner classes Set classEntries = Sets.newHashSet(); - for (ClassEntry obfClassEntry : deobfuscator.getJarIndex().getObfClassEntries()) { + for (ClassEntry obfClassEntry : deobfuscator.getJarIndex().getEntryIndex().getClasses()) { if (!obfClassEntry.isInnerClass()) { classEntries.add(obfClassEntry); } diff --git a/src/test/java/cuchaz/enigma/TestTokensConstructors.java b/src/test/java/cuchaz/enigma/TestTokensConstructors.java index 0e98da7..1ee0bde 100644 --- a/src/test/java/cuchaz/enigma/TestTokensConstructors.java +++ b/src/test/java/cuchaz/enigma/TestTokensConstructors.java @@ -11,7 +11,7 @@ package cuchaz.enigma; -import cuchaz.enigma.mapping.entry.MethodEntry; +import cuchaz.enigma.translation.representation.entry.MethodEntry; import org.junit.Test; import java.util.jar.JarFile; diff --git a/src/test/java/cuchaz/enigma/TestTranslator.java b/src/test/java/cuchaz/enigma/TestTranslator.java index 9b6eb91..b978129 100644 --- a/src/test/java/cuchaz/enigma/TestTranslator.java +++ b/src/test/java/cuchaz/enigma/TestTranslator.java @@ -11,23 +11,14 @@ package cuchaz.enigma; -import cuchaz.enigma.mapping.entry.Entry; -import cuchaz.enigma.mapping.Mappings; -import cuchaz.enigma.mapping.Translator; +import cuchaz.enigma.translation.representation.entry.Entry; import org.junit.BeforeClass; import org.junit.Test; -import static cuchaz.enigma.TestEntryFactory.newClass; -import static cuchaz.enigma.TestEntryFactory.newField; -import static cuchaz.enigma.TestEntryFactory.newMethod; +import static cuchaz.enigma.TestEntryFactory.*; public class TestTranslator { - private static Deobfuscator deobfuscator; - private static Mappings mappings; - private static Translator deobfTranslator; - private static Translator obfTranslator; - @BeforeClass public static void beforeClass() throws Exception { @@ -147,7 +138,7 @@ public class TestTranslator { assertMapping(newMethod("i$b", "a", "()Ljava/lang/Object;"), newMethod("deobf/I_Generics$B_Generic", "m1", "()Ljava/lang/Object;")); } - private void assertMapping(Entry obf, Entry deobf) { + private void assertMapping(Entry obf, Entry deobf) { //assertThat(deobfTranslator.translateEntry(obf), is(deobf)); //assertThat(obfTranslator.translateEntry(deobf), is(obf)); diff --git a/src/test/java/cuchaz/enigma/TestTypeDescriptor.java b/src/test/java/cuchaz/enigma/TestTypeDescriptor.java index 8172848..b9ebe55 100644 --- a/src/test/java/cuchaz/enigma/TestTypeDescriptor.java +++ b/src/test/java/cuchaz/enigma/TestTypeDescriptor.java @@ -11,7 +11,7 @@ package cuchaz.enigma; -import cuchaz.enigma.mapping.TypeDescriptor; +import cuchaz.enigma.translation.representation.TypeDescriptor; import org.junit.Test; import static cuchaz.enigma.TestEntryFactory.newClass; diff --git a/src/test/java/cuchaz/enigma/TokenChecker.java b/src/test/java/cuchaz/enigma/TokenChecker.java index d863a5a..aac2866 100644 --- a/src/test/java/cuchaz/enigma/TokenChecker.java +++ b/src/test/java/cuchaz/enigma/TokenChecker.java @@ -16,7 +16,7 @@ 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.mapping.entry.Entry; +import cuchaz.enigma.translation.representation.entry.Entry; import java.io.IOException; import java.util.Collection; @@ -32,9 +32,9 @@ public class TokenChecker { deobfuscator = new Deobfuscator(jarFile); } - protected String getDeclarationToken(Entry entry) { + protected String getDeclarationToken(Entry entry) { // decompile the class - CompilationUnit tree = deobfuscator.getSourceTree(entry.getClassName()); + CompilationUnit tree = deobfuscator.getSourceTree(entry.getContainingClass().getFullName()); // DEBUG // tree.acceptVisitor( new TreeDumpVisitor( new File( "tree." + entry.getClassName().replace( '/', '.' ) + ".txt" ) ), null ); String source = deobfuscator.getSource(tree); @@ -49,15 +49,15 @@ public class TokenChecker { } @SuppressWarnings("unchecked") - protected Collection getReferenceTokens(EntryReference reference) { + protected Collection getReferenceTokens(EntryReference, ? extends Entry> reference) { // decompile the class - CompilationUnit tree = deobfuscator.getSourceTree(reference.context.getClassName()); + CompilationUnit tree = deobfuscator.getSourceTree(reference.context.getContainingClass().getFullName()); String source = deobfuscator.getSource(tree); SourceIndex index = deobfuscator.getSourceIndex(tree, source); // get the token values List values = Lists.newArrayList(); - for (Token token : index.getReferenceTokens((EntryReference) reference)) { + for (Token token : index.getReferenceTokens((EntryReference, Entry>) reference)) { values.add(source.substring(token.start, token.end)); } return values; -- cgit v1.2.3