From eb93bc2cb083409c123463a20844f7e1ed58deab Mon Sep 17 00:00:00 2001 From: asiekierka Date: Tue, 18 Oct 2016 17:35:11 +0200 Subject: remove none/ prefix --- src/main/java/cuchaz/enigma/Constants.java | 1 - src/main/java/cuchaz/enigma/Deobfuscator.java | 2 +- .../java/cuchaz/enigma/TranslatingTypeLoader.java | 8 -- src/main/java/cuchaz/enigma/analysis/JarIndex.java | 12 +-- .../java/cuchaz/enigma/convert/ClassIdentity.java | 2 +- .../cuchaz/enigma/convert/MappingsConverter.java | 2 +- src/main/java/cuchaz/enigma/gui/Gui.java | 8 +- .../enigma/gui/node/ClassSelectorPackageNode.java | 5 +- .../cuchaz/enigma/mapping/MappingsSRGWriter.java | 12 +-- src/test/java/cuchaz/enigma/TestDeobfed.java | 88 +++++++++++----------- src/test/java/cuchaz/enigma/TestDeobfuscator.java | 4 +- src/test/java/cuchaz/enigma/TestInnerClasses.java | 28 +++---- .../enigma/TestJarIndexConstructorReferences.java | 10 +-- .../cuchaz/enigma/TestJarIndexInheritanceTree.java | 8 +- .../java/cuchaz/enigma/TestJarIndexLoneClass.java | 62 +++++++-------- .../java/cuchaz/enigma/TestTokensConstructors.java | 54 ++++++------- src/test/java/cuchaz/enigma/TestTranslator.java | 86 ++++++++++----------- .../enigma/inputs/constructors/BaseClass.java | 2 +- .../cuchaz/enigma/inputs/constructors/Caller.java | 16 ++-- .../enigma/inputs/constructors/SubClass.java | 6 +- .../enigma/inputs/constructors/SubSubClass.java | 4 +- .../enigma/inputs/inheritanceTree/BaseClass.java | 2 +- .../enigma/inputs/inheritanceTree/SubclassA.java | 4 +- .../enigma/inputs/inheritanceTree/SubclassB.java | 6 +- .../inputs/inheritanceTree/SubsubclassAA.java | 8 +- .../cuchaz/enigma/resources/translation.mappings | 28 +++---- 26 files changed, 224 insertions(+), 244 deletions(-) (limited to 'src') diff --git a/src/main/java/cuchaz/enigma/Constants.java b/src/main/java/cuchaz/enigma/Constants.java index 5bdb3af7..04730480 100644 --- a/src/main/java/cuchaz/enigma/Constants.java +++ b/src/main/java/cuchaz/enigma/Constants.java @@ -16,5 +16,4 @@ public class Constants { public static final String URL = "http://www.cuchazinteractive.com/enigma"; public static final int MiB = 1024 * 1024; // 1 mebibyte public static final int KiB = 1024; // 1 kebibyte - public static final String NONE_PACKAGE = "none"; } diff --git a/src/main/java/cuchaz/enigma/Deobfuscator.java b/src/main/java/cuchaz/enigma/Deobfuscator.java index 2207999d..e9a998da 100644 --- a/src/main/java/cuchaz/enigma/Deobfuscator.java +++ b/src/main/java/cuchaz/enigma/Deobfuscator.java @@ -146,7 +146,7 @@ public class Deobfuscator { if (!deobfClassEntry.equals(obfClassEntry)) { // if the class has a mapping, clearly it's deobfuscated deobfClasses.add(deobfClassEntry); - } else if (!obfClassEntry.getPackageName().equals(Constants.NONE_PACKAGE)) { + } else if (obfClassEntry.getPackageName() != null) { // also call it deobufscated if it's not in the none package deobfClasses.add(obfClassEntry); } else { diff --git a/src/main/java/cuchaz/enigma/TranslatingTypeLoader.java b/src/main/java/cuchaz/enigma/TranslatingTypeLoader.java index 13efbd51..e4c162da 100644 --- a/src/main/java/cuchaz/enigma/TranslatingTypeLoader.java +++ b/src/main/java/cuchaz/enigma/TranslatingTypeLoader.java @@ -187,10 +187,6 @@ public class TranslatingTypeLoader implements ITypeLoader { public List getClassNamesToTry(ClassEntry obfClassEntry) { List classNamesToTry = Lists.newArrayList(); classNamesToTry.add(obfClassEntry.getName()); - if (obfClassEntry.getPackageName().equals(Constants.NONE_PACKAGE)) { - // taking off the none package, if any - classNamesToTry.add(obfClassEntry.getSimpleName()); - } if (obfClassEntry.isInnerClass()) { // try just the inner class name classNamesToTry.add(obfClassEntry.getInnermostClassName()); @@ -201,10 +197,6 @@ public class TranslatingTypeLoader implements ITypeLoader { public CtClass transformClass(CtClass c) throws IOException, NotFoundException, CannotCompileException { - // we moved a lot of classes out of the default package into the none package - // make sure all the class references are consistent - ClassRenamer.moveAllClassesOutOfDefaultPackage(c, Constants.NONE_PACKAGE); - // reconstruct inner classes new InnerClassWriter(this.jarIndex).write(c); diff --git a/src/main/java/cuchaz/enigma/analysis/JarIndex.java b/src/main/java/cuchaz/enigma/analysis/JarIndex.java index e501540d..619d862c 100644 --- a/src/main/java/cuchaz/enigma/analysis/JarIndex.java +++ b/src/main/java/cuchaz/enigma/analysis/JarIndex.java @@ -59,17 +59,10 @@ public class JarIndex { public void indexJar(JarFile jar, boolean buildInnerClasses) { // step 1: read the class names - for (ClassEntry classEntry : JarClassIterator.getClassEntries(jar)) { - if (classEntry.isInDefaultPackage()) { - // move out of default package - classEntry = new ClassEntry(Constants.NONE_PACKAGE + "/" + classEntry.getName()); - } - this.obfClassEntries.add(classEntry); - } + this.obfClassEntries.addAll(JarClassIterator.getClassEntries(jar)); // step 2: index field/method/constructor access for (CtClass c : JarClassIterator.classes(jar)) { - ClassRenamer.moveAllClassesOutOfDefaultPackage(c, Constants.NONE_PACKAGE); for (CtField field : c.getDeclaredFields()) { FieldEntry fieldEntry = EntryFactory.getFieldEntry(field); this.access.put(fieldEntry, Access.get(field)); @@ -84,7 +77,6 @@ public class JarIndex { // step 3: index extends, implements, fields, and methods for (CtClass c : JarClassIterator.classes(jar)) { - ClassRenamer.moveAllClassesOutOfDefaultPackage(c, Constants.NONE_PACKAGE); this.translationIndex.indexClass(c); String className = Descriptor.toJvmName(c.getName()); for (String interfaceName : c.getClassFile().getInterfaces()) { @@ -101,7 +93,6 @@ public class JarIndex { // step 4: index field, method, constructor references for (CtClass c : JarClassIterator.classes(jar)) { - ClassRenamer.moveAllClassesOutOfDefaultPackage(c, Constants.NONE_PACKAGE); for (CtBehavior behavior : c.getDeclaredBehaviors()) { indexBehaviorReferences(behavior); } @@ -111,7 +102,6 @@ public class JarIndex { // step 5: index inner classes and anonymous classes for (CtClass c : JarClassIterator.classes(jar)) { - ClassRenamer.moveAllClassesOutOfDefaultPackage(c, Constants.NONE_PACKAGE); ClassEntry innerClassEntry = EntryFactory.getClassEntry(c); ClassEntry outerClassEntry = findOuterClass(c); if (outerClassEntry != null) { diff --git a/src/main/java/cuchaz/enigma/convert/ClassIdentity.java b/src/main/java/cuchaz/enigma/convert/ClassIdentity.java index 0960c86b..4d1b3caa 100644 --- a/src/main/java/cuchaz/enigma/convert/ClassIdentity.java +++ b/src/main/java/cuchaz/enigma/convert/ClassIdentity.java @@ -58,7 +58,7 @@ public class ClassIdentity { // classes not in the none package can be passed through ClassEntry classEntry = new ClassEntry(className); - if (!classEntry.getPackageName().equals(Constants.NONE_PACKAGE)) { + if (!classEntry.getClassName().contains("/")) { return className; } diff --git a/src/main/java/cuchaz/enigma/convert/MappingsConverter.java b/src/main/java/cuchaz/enigma/convert/MappingsConverter.java index a80d9ce1..01de9a51 100644 --- a/src/main/java/cuchaz/enigma/convert/MappingsConverter.java +++ b/src/main/java/cuchaz/enigma/convert/MappingsConverter.java @@ -235,7 +235,7 @@ public class MappingsConverter { // non obfuscated classes can be migrated ClassEntry classEntry = oldObfType.getClassEntry(); - if (!classEntry.getPackageName().equals(Constants.NONE_PACKAGE)) { + if (!classEntry.getClassName().contains("/")) { return true; } diff --git a/src/main/java/cuchaz/enigma/gui/Gui.java b/src/main/java/cuchaz/enigma/gui/Gui.java index 0ccb3f79..a81ad066 100644 --- a/src/main/java/cuchaz/enigma/gui/Gui.java +++ b/src/main/java/cuchaz/enigma/gui/Gui.java @@ -574,8 +574,7 @@ public class Gui { int offset = text.getText().lastIndexOf('/') + 1; // If it's a class and isn't in the default package, assume that it's deobfuscated. - if (m_reference.getNameableEntry() instanceof ClassEntry && !text.getText().startsWith(Constants.NONE_PACKAGE) - && offset != 0) + if (m_reference.getNameableEntry() instanceof ClassEntry && text.getText().contains("/") && offset != 0) text.select(offset, text.getText().length()); else text.selectAll(); @@ -778,9 +777,8 @@ public class Gui { { String oldEntry = deobfReference.entry.getClassEntry().getPackageName(); String newEntry = new ClassEntry(Descriptor.toJvmName(newName)).getPackageName(); - if (oldEntry != null && newEntry != null) - moveClassTree(deobfReference, newName, oldEntry.equals(Constants.NONE_PACKAGE), - newEntry.equals(Constants.NONE_PACKAGE)); + moveClassTree(deobfReference, newName, oldEntry == null, + newEntry == null); } public void moveClassTree(EntryReference deobfReference, String newName, boolean isOldOb, boolean isNewOb) diff --git a/src/main/java/cuchaz/enigma/gui/node/ClassSelectorPackageNode.java b/src/main/java/cuchaz/enigma/gui/node/ClassSelectorPackageNode.java index d2e421e7..30d8a9ca 100644 --- a/src/main/java/cuchaz/enigma/gui/node/ClassSelectorPackageNode.java +++ b/src/main/java/cuchaz/enigma/gui/node/ClassSelectorPackageNode.java @@ -10,6 +10,7 @@ ******************************************************************************/ package cuchaz.enigma.gui.node; +import com.strobel.annotations.Nullable; import javassist.bytecode.Descriptor; import javax.swing.tree.DefaultMutableTreeNode; @@ -18,8 +19,8 @@ public class ClassSelectorPackageNode extends DefaultMutableTreeNode { private String packageName; - public ClassSelectorPackageNode(String packageName) { - this.packageName = packageName; + public ClassSelectorPackageNode(@Nullable String packageName) { + this.packageName = packageName != null ? packageName : "(none)"; } public String getPackageName() { diff --git a/src/main/java/cuchaz/enigma/mapping/MappingsSRGWriter.java b/src/main/java/cuchaz/enigma/mapping/MappingsSRGWriter.java index 229bf464..4d0c2610 100644 --- a/src/main/java/cuchaz/enigma/mapping/MappingsSRGWriter.java +++ b/src/main/java/cuchaz/enigma/mapping/MappingsSRGWriter.java @@ -34,25 +34,25 @@ public class MappingsSRGWriter { if(innerClassMapping.getDeobfName() == null || innerClassMapping.getObfSimpleName() == null || innerClassMapping.getDeobfName() == null){ continue; } - String innerClassName = classMapping.getObfSimpleName() + "$" + innerClassMapping.getObfSimpleName().replace("none/", ""); - String innerDebofClassName = classMapping.getDeobfName() + "$" + innerClassMapping.getDeobfName().replace("none/", ""); + String innerClassName = classMapping.getObfSimpleName() + "$" + innerClassMapping.getObfSimpleName(); + String innerDeobfClassName = classMapping.getDeobfName() + "$" + innerClassMapping.getDeobfName(); writer.write("CL: " + innerClassName + " " + classMapping.getDeobfName() + "$" + innerClassMapping.getDeobfName()); writer.write(System.lineSeparator()); for (FieldMapping fieldMapping : sorted(innerClassMapping.fields())) { - fieldMappings.add("FD: " + innerClassName + "/" + fieldMapping.getObfName() + " " + innerDebofClassName + "/" + fieldMapping.getDeobfName()); + fieldMappings.add("FD: " + innerClassName + "/" + fieldMapping.getObfName() + " " + innerDeobfClassName + "/" + fieldMapping.getDeobfName()); } for (MethodMapping methodMapping : sorted(innerClassMapping.methods())) { - methodMappings.add("MD: " + innerClassName + "/" + methodMapping.getObfName() + " " + methodMapping.getObfSignature().toString().replace("none/", "") + " " + innerDebofClassName + "/" + methodMapping.getDeobfName() + " " + mappings.getTranslator(TranslationDirection.Deobfuscating, index).translateSignature(methodMapping.getObfSignature())); + methodMappings.add("MD: " + innerClassName + "/" + methodMapping.getObfName() + " " + methodMapping.getObfSignature().toString() + " " + innerDeobfClassName + "/" + methodMapping.getDeobfName() + " " + mappings.getTranslator(TranslationDirection.Deobfuscating, index).translateSignature(methodMapping.getObfSignature())); } } for (FieldMapping fieldMapping : sorted(classMapping.fields())) { - fieldMappings.add("FD: " + classMapping.getObfFullName().replace("none/", "") + "/" + fieldMapping.getObfName() + " " + classMapping.getDeobfName() + "/" + fieldMapping.getDeobfName()); + fieldMappings.add("FD: " + classMapping.getObfFullName() + "/" + fieldMapping.getObfName() + " " + classMapping.getDeobfName() + "/" + fieldMapping.getDeobfName()); } for (MethodMapping methodMapping : sorted(classMapping.methods())) { - methodMappings.add("MD: " + classMapping.getObfFullName().replace("none/", "") + "/" + methodMapping.getObfName() + " " + methodMapping.getObfSignature().toString().replace("none/", "") + " " + classMapping.getDeobfName() + "/" + methodMapping.getDeobfName() + " " + mappings.getTranslator(TranslationDirection.Deobfuscating, index).translateSignature(methodMapping.getObfSignature())); + methodMappings.add("MD: " + classMapping.getObfFullName() + "/" + methodMapping.getObfName() + " " + methodMapping.getObfSignature().toString() + " " + classMapping.getDeobfName() + "/" + methodMapping.getDeobfName() + " " + mappings.getTranslator(TranslationDirection.Deobfuscating, index).translateSignature(methodMapping.getObfSignature())); } } for(String fd : fieldMappings){ diff --git a/src/test/java/cuchaz/enigma/TestDeobfed.java b/src/test/java/cuchaz/enigma/TestDeobfed.java index 5f3ef8cf..2f318c80 100644 --- a/src/test/java/cuchaz/enigma/TestDeobfed.java +++ b/src/test/java/cuchaz/enigma/TestDeobfed.java @@ -40,28 +40,28 @@ public class TestDeobfed { public void obfEntries() { assertThat(m_index.getObfClassEntries(), containsInAnyOrder( newClass("cuchaz/enigma/inputs/Keep"), - newClass("none/a"), - newClass("none/b"), - newClass("none/c"), - newClass("none/d"), - newClass("none/d$1"), - newClass("none/e"), - newClass("none/f"), - newClass("none/g"), - newClass("none/g$a"), - newClass("none/g$a$a"), - newClass("none/g$b"), - newClass("none/g$b$a"), - newClass("none/h"), - newClass("none/h$a"), - newClass("none/h$a$a"), - newClass("none/h$b"), - newClass("none/h$b$a"), - newClass("none/h$b$a$a"), - newClass("none/h$b$a$b"), - newClass("none/i"), - newClass("none/i$a"), - newClass("none/i$b") + newClass("a"), + newClass("b"), + newClass("c"), + newClass("d"), + newClass("d$1"), + newClass("e"), + newClass("f"), + newClass("g"), + newClass("g$a"), + newClass("g$a$a"), + newClass("g$b"), + newClass("g$b$a"), + newClass("h"), + newClass("h$a"), + newClass("h$a$a"), + newClass("h$b"), + newClass("h$b$a"), + newClass("h$b$a$a"), + newClass("h$b$a$b"), + newClass("i"), + newClass("i$a"), + newClass("i$b") )); } @@ -69,27 +69,27 @@ public class TestDeobfed { public void decompile() throws Exception { Deobfuscator deobfuscator = new Deobfuscator(m_jar); - deobfuscator.getSourceTree("none/a"); - deobfuscator.getSourceTree("none/b"); - deobfuscator.getSourceTree("none/c"); - deobfuscator.getSourceTree("none/d"); - deobfuscator.getSourceTree("none/d$1"); - deobfuscator.getSourceTree("none/e"); - deobfuscator.getSourceTree("none/f"); - deobfuscator.getSourceTree("none/g"); - deobfuscator.getSourceTree("none/g$a"); - deobfuscator.getSourceTree("none/g$a$a"); - deobfuscator.getSourceTree("none/g$b"); - deobfuscator.getSourceTree("none/g$b$a"); - deobfuscator.getSourceTree("none/h"); - deobfuscator.getSourceTree("none/h$a"); - deobfuscator.getSourceTree("none/h$a$a"); - deobfuscator.getSourceTree("none/h$b"); - deobfuscator.getSourceTree("none/h$b$a"); - deobfuscator.getSourceTree("none/h$b$a$a"); - deobfuscator.getSourceTree("none/h$b$a$b"); - deobfuscator.getSourceTree("none/i"); - deobfuscator.getSourceTree("none/i$a"); - deobfuscator.getSourceTree("none/i$b"); + deobfuscator.getSourceTree("a"); + deobfuscator.getSourceTree("b"); + deobfuscator.getSourceTree("c"); + deobfuscator.getSourceTree("d"); + deobfuscator.getSourceTree("d$1"); + deobfuscator.getSourceTree("e"); + deobfuscator.getSourceTree("f"); + deobfuscator.getSourceTree("g"); + deobfuscator.getSourceTree("g$a"); + deobfuscator.getSourceTree("g$a$a"); + deobfuscator.getSourceTree("g$b"); + deobfuscator.getSourceTree("g$b$a"); + deobfuscator.getSourceTree("h"); + deobfuscator.getSourceTree("h$a"); + deobfuscator.getSourceTree("h$a$a"); + deobfuscator.getSourceTree("h$b"); + deobfuscator.getSourceTree("h$b$a"); + deobfuscator.getSourceTree("h$b$a$a"); + deobfuscator.getSourceTree("h$b$a$b"); + deobfuscator.getSourceTree("i"); + deobfuscator.getSourceTree("i$a"); + deobfuscator.getSourceTree("i$b"); } } diff --git a/src/test/java/cuchaz/enigma/TestDeobfuscator.java b/src/test/java/cuchaz/enigma/TestDeobfuscator.java index 1b0aa74d..8c97ff34 100644 --- a/src/test/java/cuchaz/enigma/TestDeobfuscator.java +++ b/src/test/java/cuchaz/enigma/TestDeobfuscator.java @@ -43,7 +43,7 @@ public class TestDeobfuscator { List deobfClasses = Lists.newArrayList(); deobfuscator.getSeparatedClasses(obfClasses, deobfClasses); assertEquals(1, obfClasses.size()); - assertEquals("none/a", obfClasses.get(0).getName()); + assertEquals("a", obfClasses.get(0).getName()); assertEquals(1, deobfClasses.size()); assertEquals("cuchaz/enigma/inputs/Keep", deobfClasses.get(0).getName()); } @@ -52,6 +52,6 @@ public class TestDeobfuscator { public void decompileClass() throws Exception { Deobfuscator deobfuscator = getDeobfuscator(); - deobfuscator.getSource(deobfuscator.getSourceTree("none/a")); + deobfuscator.getSource(deobfuscator.getSourceTree("a")); } } diff --git a/src/test/java/cuchaz/enigma/TestInnerClasses.java b/src/test/java/cuchaz/enigma/TestInnerClasses.java index a4f90217..70765e32 100644 --- a/src/test/java/cuchaz/enigma/TestInnerClasses.java +++ b/src/test/java/cuchaz/enigma/TestInnerClasses.java @@ -27,20 +27,20 @@ public class TestInnerClasses { private JarIndex m_index; private Deobfuscator m_deobfuscator; - private static final ClassEntry AnonymousOuter = newClass("none/a"); - private static final ClassEntry AnonymousInner = newClass("none/a$1"); - private static final ClassEntry SimpleOuter = newClass("none/d"); - private static final ClassEntry SimpleInner = newClass("none/d$a"); - private static final ClassEntry ConstructorArgsOuter = newClass("none/c"); - private static final ClassEntry ConstructorArgsInner = newClass("none/c$a"); - private static final ClassEntry AnonymousWithScopeArgsOuter = newClass("none/b"); - private static final ClassEntry AnonymousWithScopeArgsInner = newClass("none/b$1"); - private static final ClassEntry AnonymousWithOuterAccessOuter = newClass("none/e"); - private static final ClassEntry AnonymousWithOuterAccessInner = newClass("none/e$1"); - private static final ClassEntry ClassTreeRoot = newClass("none/f"); - private static final ClassEntry ClassTreeLevel1 = newClass("none/f$a"); - private static final ClassEntry ClassTreeLevel2 = newClass("none/f$a$a"); - private static final ClassEntry ClassTreeLevel3 = newClass("none/f$a$a$a"); + private static final ClassEntry AnonymousOuter = newClass("a"); + private static final ClassEntry AnonymousInner = newClass("a$1"); + private static final ClassEntry SimpleOuter = newClass("d"); + private static final ClassEntry SimpleInner = newClass("d$a"); + private static final ClassEntry ConstructorArgsOuter = newClass("c"); + private static final ClassEntry ConstructorArgsInner = newClass("c$a"); + private static final ClassEntry AnonymousWithScopeArgsOuter = newClass("b"); + private static final ClassEntry AnonymousWithScopeArgsInner = newClass("b$1"); + private static final ClassEntry AnonymousWithOuterAccessOuter = newClass("e"); + private static final ClassEntry AnonymousWithOuterAccessInner = newClass("e$1"); + private static final ClassEntry ClassTreeRoot = newClass("f"); + private static final ClassEntry ClassTreeLevel1 = newClass("f$a"); + private static final ClassEntry ClassTreeLevel2 = newClass("f$a$a"); + private static final ClassEntry ClassTreeLevel3 = newClass("f$a$a$a"); public TestInnerClasses() throws Exception { diff --git a/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java b/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java index 606801bd..cb65cd07 100644 --- a/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java +++ b/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java @@ -29,11 +29,11 @@ public class TestJarIndexConstructorReferences { private JarIndex m_index; - private ClassEntry m_baseClass = newClass("none/a"); - private ClassEntry m_subClass = newClass("none/d"); - private ClassEntry m_subsubClass = newClass("none/e"); - private ClassEntry m_defaultClass = newClass("none/c"); - private ClassEntry m_callerClass = newClass("none/b"); + 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"); public TestJarIndexConstructorReferences() throws Exception { diff --git a/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java b/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java index 84d21158..28408f2a 100644 --- a/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java +++ b/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java @@ -44,10 +44,10 @@ public class TestJarIndexInheritanceTree { private JarIndex m_index; private ClassEntry m_objectClass = newClass("java/lang/Object"); - private ClassEntry m_baseClass = newClass("none/a"); - private ClassEntry m_subClassA = newClass("none/b"); - private ClassEntry m_subClassAA = newClass("none/d"); - private ClassEntry m_subClassB = newClass("none/c"); + 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"); diff --git a/src/test/java/cuchaz/enigma/TestJarIndexLoneClass.java b/src/test/java/cuchaz/enigma/TestJarIndexLoneClass.java index bd7b03a0..65af6d83 100644 --- a/src/test/java/cuchaz/enigma/TestJarIndexLoneClass.java +++ b/src/test/java/cuchaz/enigma/TestJarIndexLoneClass.java @@ -46,39 +46,39 @@ public class TestJarIndexLoneClass { public void obfEntries() { assertThat(m_index.getObfClassEntries(), containsInAnyOrder( newClass("cuchaz/enigma/inputs/Keep"), - newClass("none/a") + newClass("a") )); } @Test public void translationIndex() { - assertThat(m_index.getTranslationIndex().getSuperclass(new ClassEntry("none/a")), is(new ClassEntry("java/lang/Object"))); + 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("none/a")), contains(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("none/a")), is(empty())); + assertThat(m_index.getTranslationIndex().getSubclass(new ClassEntry("a")), is(empty())); assertThat(m_index.getTranslationIndex().getSubclass(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(empty())); } @Test public void access() { - assertThat(m_index.getAccess(newField("none/a", "a", "Ljava/lang/String;")), 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", "Ljava/lang/String;")), is(nullValue())); - assertThat(m_index.getAccess(newField("none/a", "a", "LFoo;")), is(nullValue())); + 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())); } @Test public void classInheritance() { - ClassInheritanceTreeNode node = m_index.getClassInheritance(new Translator(), newClass("none/a")); + ClassInheritanceTreeNode node = m_index.getClassInheritance(new Translator(), newClass("a")); assertThat(node, is(not(nullValue()))); - assertThat(node.getObfClassName(), is("none/a")); + assertThat(node.getObfClassName(), is("a")); assertThat(node.getChildCount(), is(0)); } @Test public void methodInheritance() { - MethodEntry source = newMethod("none/a", "a", "()Ljava/lang/String;"); + MethodEntry source = newMethod("a", "a", "()Ljava/lang/String;"); MethodInheritanceTreeNode node = m_index.getMethodInheritance(new Translator(), source); assertThat(node, is(not(nullValue()))); assertThat(node.getMethodEntry(), is(source)); @@ -87,43 +87,43 @@ public class TestJarIndexLoneClass { @Test public void classImplementations() { - ClassImplementationsTreeNode node = m_index.getClassImplementations(new Translator(), newClass("none/a")); + ClassImplementationsTreeNode node = m_index.getClassImplementations(new Translator(), newClass("a")); assertThat(node, is(nullValue())); } @Test public void methodImplementations() { - MethodEntry source = newMethod("none/a", "a", "()Ljava/lang/String;"); + MethodEntry source = newMethod("a", "a", "()Ljava/lang/String;"); assertThat(m_index.getMethodImplementations(new Translator(), source), is(empty())); } @Test public void relatedMethodImplementations() { - Set entries = m_index.getRelatedMethodImplementations(newMethod("none/a", "a", "()Ljava/lang/String;")); + Set entries = m_index.getRelatedMethodImplementations(newMethod("a", "a", "()Ljava/lang/String;")); assertThat(entries, containsInAnyOrder( - newMethod("none/a", "a", "()Ljava/lang/String;") + newMethod("a", "a", "()Ljava/lang/String;") )); } @Test @SuppressWarnings("unchecked") public void fieldReferences() { - FieldEntry source = newField("none/a", "a", "Ljava/lang/String;"); + FieldEntry source = newField("a", "a", "Ljava/lang/String;"); 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;") + newFieldReferenceByConstructor(source, "a", "(Ljava/lang/String;)V"), + newFieldReferenceByMethod(source, "a", "a", "()Ljava/lang/String;") )); } @Test public void behaviorReferences() { - assertThat(m_index.getBehaviorReferences(newMethod("none/a", "a", "()Ljava/lang/String;")), is(empty())); + assertThat(m_index.getBehaviorReferences(newMethod("a", "a", "()Ljava/lang/String;")), is(empty())); } @Test public void innerClasses() { - assertThat(m_index.getInnerClasses(newClass("none/a")), is(empty())); + assertThat(m_index.getInnerClasses(newClass("a")), is(empty())); } @Test @@ -133,32 +133,32 @@ public class TestJarIndexLoneClass { @Test public void isAnonymousClass() { - assertThat(m_index.isAnonymousClass(newClass("none/a")), is(false)); + assertThat(m_index.isAnonymousClass(newClass("a")), is(false)); } @Test public void interfaces() { - assertThat(m_index.getInterfaces("none/a"), is(empty())); + assertThat(m_index.getInterfaces("a"), is(empty())); } @Test public void implementingClasses() { - assertThat(m_index.getImplementingClasses("none/a"), is(empty())); + assertThat(m_index.getImplementingClasses("a"), is(empty())); } @Test public void isInterface() { - assertThat(m_index.isInterface("none/a"), is(false)); + assertThat(m_index.isInterface("a"), is(false)); } @Test public void testContains() { - 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", "Ljava/lang/String;")), is(true)); - assertThat(m_index.containsObfField(newField("none/a", "b", "Ljava/lang/String;")), is(false)); - assertThat(m_index.containsObfField(newField("none/a", "a", "LFoo;")), 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)); + 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)); } } diff --git a/src/test/java/cuchaz/enigma/TestTokensConstructors.java b/src/test/java/cuchaz/enigma/TestTokensConstructors.java index 66c6fd1b..890a4fd3 100644 --- a/src/test/java/cuchaz/enigma/TestTokensConstructors.java +++ b/src/test/java/cuchaz/enigma/TestTokensConstructors.java @@ -29,107 +29,107 @@ public class TestTokensConstructors extends TokenChecker { @Test public void baseDeclarations() { - assertThat(getDeclarationToken(newConstructor("none/a", "()V")), is("a")); - assertThat(getDeclarationToken(newConstructor("none/a", "(I)V")), is("a")); + assertThat(getDeclarationToken(newConstructor("a", "()V")), is("a")); + assertThat(getDeclarationToken(newConstructor("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")); + assertThat(getDeclarationToken(newConstructor("d", "()V")), is("d")); + assertThat(getDeclarationToken(newConstructor("d", "(I)V")), is("d")); + assertThat(getDeclarationToken(newConstructor("d", "(II)V")), is("d")); + assertThat(getDeclarationToken(newConstructor("d", "(III)V")), is("d")); } @Test public void subsubDeclarations() { - assertThat(getDeclarationToken(newConstructor("none/e", "(I)V")), is("e")); + assertThat(getDeclarationToken(newConstructor("e", "(I)V")), is("e")); } @Test public void defaultDeclarations() { - assertThat(getDeclarationToken(newConstructor("none/c", "()V")), nullValue()); + assertThat(getDeclarationToken(newConstructor("c", "()V")), nullValue()); } @Test public void baseDefaultReferences() { - BehaviorEntry source = newConstructor("none/a", "()V"); + BehaviorEntry source = newConstructor("a", "()V"); assertThat( - getReferenceTokens(newBehaviorReferenceByMethod(source, "none/b", "a", "()V")), + getReferenceTokens(newBehaviorReferenceByMethod(source, "b", "a", "()V")), containsInAnyOrder("a") ); assertThat( - getReferenceTokens(newBehaviorReferenceByConstructor(source, "none/d", "()V")), + getReferenceTokens(newBehaviorReferenceByConstructor(source, "d", "()V")), is(empty()) // implicit call, not decompiled to token ); assertThat( - getReferenceTokens(newBehaviorReferenceByConstructor(source, "none/d", "(III)V")), + getReferenceTokens(newBehaviorReferenceByConstructor(source, "d", "(III)V")), is(empty()) // implicit call, not decompiled to token ); } @Test public void baseIntReferences() { - BehaviorEntry source = newConstructor("none/a", "(I)V"); + BehaviorEntry source = newConstructor("a", "(I)V"); assertThat( - getReferenceTokens(newBehaviorReferenceByMethod(source, "none/b", "b", "()V")), + getReferenceTokens(newBehaviorReferenceByMethod(source, "b", "b", "()V")), containsInAnyOrder("a") ); } @Test public void subDefaultReferences() { - BehaviorEntry source = newConstructor("none/d", "()V"); + BehaviorEntry source = newConstructor("d", "()V"); assertThat( - getReferenceTokens(newBehaviorReferenceByMethod(source, "none/b", "c", "()V")), + getReferenceTokens(newBehaviorReferenceByMethod(source, "b", "c", "()V")), containsInAnyOrder("d") ); assertThat( - getReferenceTokens(newBehaviorReferenceByConstructor(source, "none/d", "(I)V")), + getReferenceTokens(newBehaviorReferenceByConstructor(source, "d", "(I)V")), containsInAnyOrder("this") ); } @Test public void subIntReferences() { - BehaviorEntry source = newConstructor("none/d", "(I)V"); + BehaviorEntry source = newConstructor("d", "(I)V"); assertThat(getReferenceTokens( - newBehaviorReferenceByMethod(source, "none/b", "d", "()V")), + newBehaviorReferenceByMethod(source, "b", "d", "()V")), containsInAnyOrder("d") ); assertThat(getReferenceTokens( - newBehaviorReferenceByConstructor(source, "none/d", "(II)V")), + newBehaviorReferenceByConstructor(source, "d", "(II)V")), containsInAnyOrder("this") ); assertThat(getReferenceTokens( - newBehaviorReferenceByConstructor(source, "none/e", "(I)V")), + newBehaviorReferenceByConstructor(source, "e", "(I)V")), containsInAnyOrder("super") ); } @Test public void subIntIntReferences() { - BehaviorEntry source = newConstructor("none/d", "(II)V"); + BehaviorEntry source = newConstructor("d", "(II)V"); assertThat( - getReferenceTokens(newBehaviorReferenceByMethod(source, "none/b", "e", "()V")), + getReferenceTokens(newBehaviorReferenceByMethod(source, "b", "e", "()V")), containsInAnyOrder("d") ); } @Test public void subsubIntReferences() { - BehaviorEntry source = newConstructor("none/e", "(I)V"); + BehaviorEntry source = newConstructor("e", "(I)V"); assertThat( - getReferenceTokens(newBehaviorReferenceByMethod(source, "none/b", "f", "()V")), + getReferenceTokens(newBehaviorReferenceByMethod(source, "b", "f", "()V")), containsInAnyOrder("e") ); } @Test public void defaultConstructableReferences() { - BehaviorEntry source = newConstructor("none/c", "()V"); + BehaviorEntry source = newConstructor("c", "()V"); assertThat( - getReferenceTokens(newBehaviorReferenceByMethod(source, "none/b", "g", "()V")), + getReferenceTokens(newBehaviorReferenceByMethod(source, "b", "g", "()V")), containsInAnyOrder("c") ); } diff --git a/src/test/java/cuchaz/enigma/TestTranslator.java b/src/test/java/cuchaz/enigma/TestTranslator.java index dddfb704..c8af307b 100644 --- a/src/test/java/cuchaz/enigma/TestTranslator.java +++ b/src/test/java/cuchaz/enigma/TestTranslator.java @@ -42,108 +42,108 @@ public class TestTranslator { @Test public void basicClasses() { - assertMapping(newClass("none/a"), newClass("deobf/A_Basic")); - assertMapping(newClass("none/b"), newClass("deobf/B_BaseClass")); - assertMapping(newClass("none/c"), newClass("deobf/C_SubClass")); + assertMapping(newClass("a"), newClass("deobf/A_Basic")); + assertMapping(newClass("b"), newClass("deobf/B_BaseClass")); + assertMapping(newClass("c"), newClass("deobf/C_SubClass")); } @Test public void basicFields() { - assertMapping(newField("none/a", "a", "I"), newField("deobf/A_Basic", "f1", "I")); - assertMapping(newField("none/a", "a", "F"), newField("deobf/A_Basic", "f2", "F")); - assertMapping(newField("none/a", "a", "Ljava/lang/String;"), newField("deobf/A_Basic", "f3", "Ljava/lang/String;")); + assertMapping(newField("a", "a", "I"), newField("deobf/A_Basic", "f1", "I")); + assertMapping(newField("a", "a", "F"), newField("deobf/A_Basic", "f2", "F")); + assertMapping(newField("a", "a", "Ljava/lang/String;"), newField("deobf/A_Basic", "f3", "Ljava/lang/String;")); } @Test public void basicMethods() { - assertMapping(newMethod("none/a", "a", "()V"), newMethod("deobf/A_Basic", "m1", "()V")); - assertMapping(newMethod("none/a", "a", "()I"), newMethod("deobf/A_Basic", "m2", "()I")); - assertMapping(newMethod("none/a", "a", "(I)V"), newMethod("deobf/A_Basic", "m3", "(I)V")); - assertMapping(newMethod("none/a", "a", "(I)I"), newMethod("deobf/A_Basic", "m4", "(I)I")); + assertMapping(newMethod("a", "a", "()V"), newMethod("deobf/A_Basic", "m1", "()V")); + assertMapping(newMethod("a", "a", "()I"), newMethod("deobf/A_Basic", "m2", "()I")); + assertMapping(newMethod("a", "a", "(I)V"), newMethod("deobf/A_Basic", "m3", "(I)V")); + assertMapping(newMethod("a", "a", "(I)I"), newMethod("deobf/A_Basic", "m4", "(I)I")); } // TODO: basic constructors @Test public void inheritanceFields() { - assertMapping(newField("none/b", "a", "I"), newField("deobf/B_BaseClass", "f1", "I")); - assertMapping(newField("none/b", "a", "C"), newField("deobf/B_BaseClass", "f2", "C")); - assertMapping(newField("none/c", "b", "I"), newField("deobf/C_SubClass", "f3", "I")); - assertMapping(newField("none/c", "c", "I"), newField("deobf/C_SubClass", "f4", "I")); + assertMapping(newField("b", "a", "I"), newField("deobf/B_BaseClass", "f1", "I")); + assertMapping(newField("b", "a", "C"), newField("deobf/B_BaseClass", "f2", "C")); + assertMapping(newField("c", "b", "I"), newField("deobf/C_SubClass", "f3", "I")); + assertMapping(newField("c", "c", "I"), newField("deobf/C_SubClass", "f4", "I")); } @Test public void inheritanceFieldsShadowing() { - assertMapping(newField("none/c", "b", "C"), newField("deobf/C_SubClass", "f2", "C")); + assertMapping(newField("c", "b", "C"), newField("deobf/C_SubClass", "f2", "C")); } @Test public void inheritanceFieldsBySubClass() { - assertMapping(newField("none/c", "a", "I"), newField("deobf/C_SubClass", "f1", "I")); + assertMapping(newField("c", "a", "I"), newField("deobf/C_SubClass", "f1", "I")); // NOTE: can't reference b.C by subclass since it's shadowed } @Test public void inheritanceMethods() { - assertMapping(newMethod("none/b", "a", "()I"), newMethod("deobf/B_BaseClass", "m1", "()I")); - assertMapping(newMethod("none/b", "b", "()I"), newMethod("deobf/B_BaseClass", "m2", "()I")); - assertMapping(newMethod("none/c", "c", "()I"), newMethod("deobf/C_SubClass", "m3", "()I")); + assertMapping(newMethod("b", "a", "()I"), newMethod("deobf/B_BaseClass", "m1", "()I")); + assertMapping(newMethod("b", "b", "()I"), newMethod("deobf/B_BaseClass", "m2", "()I")); + assertMapping(newMethod("c", "c", "()I"), newMethod("deobf/C_SubClass", "m3", "()I")); } @Test public void inheritanceMethodsOverrides() { - assertMapping(newMethod("none/c", "a", "()I"), newMethod("deobf/C_SubClass", "m1", "()I")); + assertMapping(newMethod("c", "a", "()I"), newMethod("deobf/C_SubClass", "m1", "()I")); } @Test public void inheritanceMethodsBySubClass() { - assertMapping(newMethod("none/c", "b", "()I"), newMethod("deobf/C_SubClass", "m2", "()I")); + assertMapping(newMethod("c", "b", "()I"), newMethod("deobf/C_SubClass", "m2", "()I")); } @Test public void innerClasses() { // classes - assertMapping(newClass("none/g"), newClass("deobf/G_OuterClass")); - assertMapping(newClass("none/g$a"), newClass("deobf/G_OuterClass$A_InnerClass")); - assertMapping(newClass("none/g$a$a"), newClass("deobf/G_OuterClass$A_InnerClass$A_InnerInnerClass")); - assertMapping(newClass("none/g$b"), newClass("deobf/G_OuterClass$b")); - assertMapping(newClass("none/g$b$a"), newClass("deobf/G_OuterClass$b$A_NamedInnerClass")); + assertMapping(newClass("g"), newClass("deobf/G_OuterClass")); + assertMapping(newClass("g$a"), newClass("deobf/G_OuterClass$A_InnerClass")); + assertMapping(newClass("g$a$a"), newClass("deobf/G_OuterClass$A_InnerClass$A_InnerInnerClass")); + assertMapping(newClass("g$b"), newClass("deobf/G_OuterClass$b")); + assertMapping(newClass("g$b$a"), newClass("deobf/G_OuterClass$b$A_NamedInnerClass")); // fields - assertMapping(newField("none/g$a", "a", "I"), newField("deobf/G_OuterClass$A_InnerClass", "f1", "I")); - assertMapping(newField("none/g$a", "a", "Ljava/lang/String;"), newField("deobf/G_OuterClass$A_InnerClass", "f2", "Ljava/lang/String;")); - assertMapping(newField("none/g$a$a", "a", "I"), newField("deobf/G_OuterClass$A_InnerClass$A_InnerInnerClass", "f3", "I")); - assertMapping(newField("none/g$b$a", "a", "I"), newField("deobf/G_OuterClass$b$A_NamedInnerClass", "f4", "I")); + assertMapping(newField("g$a", "a", "I"), newField("deobf/G_OuterClass$A_InnerClass", "f1", "I")); + assertMapping(newField("g$a", "a", "Ljava/lang/String;"), newField("deobf/G_OuterClass$A_InnerClass", "f2", "Ljava/lang/String;")); + assertMapping(newField("g$a$a", "a", "I"), newField("deobf/G_OuterClass$A_InnerClass$A_InnerInnerClass", "f3", "I")); + assertMapping(newField("g$b$a", "a", "I"), newField("deobf/G_OuterClass$b$A_NamedInnerClass", "f4", "I")); // methods - assertMapping(newMethod("none/g$a", "a", "()V"), newMethod("deobf/G_OuterClass$A_InnerClass", "m1", "()V")); - assertMapping(newMethod("none/g$a$a", "a", "()V"), newMethod("deobf/G_OuterClass$A_InnerClass$A_InnerInnerClass", "m2", "()V")); + assertMapping(newMethod("g$a", "a", "()V"), newMethod("deobf/G_OuterClass$A_InnerClass", "m1", "()V")); + assertMapping(newMethod("g$a$a", "a", "()V"), newMethod("deobf/G_OuterClass$A_InnerClass$A_InnerInnerClass", "m2", "()V")); } @Test public void namelessClass() { - assertMapping(newClass("none/h"), newClass("none/h")); + assertMapping(newClass("h"), newClass("h")); } @Test public void testGenerics() { // classes - assertMapping(newClass("none/i"), newClass("deobf/I_Generics")); - assertMapping(newClass("none/i$a"), newClass("deobf/I_Generics$A_Type")); - assertMapping(newClass("none/i$b"), newClass("deobf/I_Generics$B_Generic")); + assertMapping(newClass("i"), newClass("deobf/I_Generics")); + assertMapping(newClass("i$a"), newClass("deobf/I_Generics$A_Type")); + assertMapping(newClass("i$b"), newClass("deobf/I_Generics$B_Generic")); // fields - assertMapping(newField("none/i", "a", "Ljava/util/List;"), newField("deobf/I_Generics", "f1", "Ljava/util/List;")); - assertMapping(newField("none/i", "b", "Ljava/util/List;"), newField("deobf/I_Generics", "f2", "Ljava/util/List;")); - assertMapping(newField("none/i", "a", "Ljava/util/Map;"), newField("deobf/I_Generics", "f3", "Ljava/util/Map;")); - assertMapping(newField("none/i$b", "a", "Ljava/lang/Object;"), newField("deobf/I_Generics$B_Generic", "f4", "Ljava/lang/Object;")); - assertMapping(newField("none/i", "a", "Lnone/i$b;"), newField("deobf/I_Generics", "f5", "Ldeobf/I_Generics$B_Generic;")); - assertMapping(newField("none/i", "b", "Lnone/i$b;"), newField("deobf/I_Generics", "f6", "Ldeobf/I_Generics$B_Generic;")); + assertMapping(newField("i", "a", "Ljava/util/List;"), newField("deobf/I_Generics", "f1", "Ljava/util/List;")); + assertMapping(newField("i", "b", "Ljava/util/List;"), newField("deobf/I_Generics", "f2", "Ljava/util/List;")); + assertMapping(newField("i", "a", "Ljava/util/Map;"), newField("deobf/I_Generics", "f3", "Ljava/util/Map;")); + assertMapping(newField("i$b", "a", "Ljava/lang/Object;"), newField("deobf/I_Generics$B_Generic", "f4", "Ljava/lang/Object;")); + assertMapping(newField("i", "a", "Li$b;"), newField("deobf/I_Generics", "f5", "Ldeobf/I_Generics$B_Generic;")); + assertMapping(newField("i", "b", "Li$b;"), newField("deobf/I_Generics", "f6", "Ldeobf/I_Generics$B_Generic;")); // methods - assertMapping(newMethod("none/i$b", "a", "()Ljava/lang/Object;"), newMethod("deobf/I_Generics$B_Generic", "m1", "()Ljava/lang/Object;")); + 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) { diff --git a/src/test/java/cuchaz/enigma/inputs/constructors/BaseClass.java b/src/test/java/cuchaz/enigma/inputs/constructors/BaseClass.java index 65e782a2..ad5e950e 100644 --- a/src/test/java/cuchaz/enigma/inputs/constructors/BaseClass.java +++ b/src/test/java/cuchaz/enigma/inputs/constructors/BaseClass.java @@ -10,7 +10,7 @@ ******************************************************************************/ package cuchaz.enigma.inputs.constructors; -// none/a +// a public class BaseClass { // ()V diff --git a/src/test/java/cuchaz/enigma/inputs/constructors/Caller.java b/src/test/java/cuchaz/enigma/inputs/constructors/Caller.java index 75096ec1..dcd96173 100644 --- a/src/test/java/cuchaz/enigma/inputs/constructors/Caller.java +++ b/src/test/java/cuchaz/enigma/inputs/constructors/Caller.java @@ -10,48 +10,48 @@ ******************************************************************************/ package cuchaz.enigma.inputs.constructors; -// none/b +// b public class Caller { // a()V public void callBaseDefault() { - // none/a.()V + // a.()V System.out.println(new BaseClass()); } // b()V public void callBaseInt() { - // none/a.(I)V + // a.(I)V System.out.println(new BaseClass(5)); } // c()V public void callSubDefault() { - // none/d.()V + // d.()V System.out.println(new SubClass()); } // d()V public void callSubInt() { - // none/d.(I)V + // d.(I)V System.out.println(new SubClass(6)); } // e()V public void callSubIntInt() { - // none/d.(II)V + // d.(II)V System.out.println(new SubClass(4, 2)); } // f()V public void callSubSubInt() { - // none/e.(I)V + // e.(I)V System.out.println(new SubSubClass(3)); } // g()V public void callDefaultConstructable() { - // none/c.()V + // c.()V System.out.println(new DefaultConstructable()); } } diff --git a/src/test/java/cuchaz/enigma/inputs/constructors/SubClass.java b/src/test/java/cuchaz/enigma/inputs/constructors/SubClass.java index b0fb3e9b..b2934a27 100644 --- a/src/test/java/cuchaz/enigma/inputs/constructors/SubClass.java +++ b/src/test/java/cuchaz/enigma/inputs/constructors/SubClass.java @@ -10,12 +10,12 @@ ******************************************************************************/ package cuchaz.enigma.inputs.constructors; -// none/d extends none/a +// d extends a public class SubClass extends BaseClass { // ()V public SubClass() { - // none/a.()V + // a.()V } // (I)V @@ -33,6 +33,6 @@ public class SubClass extends BaseClass { // (III)V public SubClass(int a, int b, int c) { - // none/a.()V + // a.()V } } diff --git a/src/test/java/cuchaz/enigma/inputs/constructors/SubSubClass.java b/src/test/java/cuchaz/enigma/inputs/constructors/SubSubClass.java index 50314050..c1725fea 100644 --- a/src/test/java/cuchaz/enigma/inputs/constructors/SubSubClass.java +++ b/src/test/java/cuchaz/enigma/inputs/constructors/SubSubClass.java @@ -10,12 +10,12 @@ ******************************************************************************/ package cuchaz.enigma.inputs.constructors; -// none/e extends none/d +// e extends d public class SubSubClass extends SubClass { // (I)V public SubSubClass(int i) { - // none/c.(I)V + // c.(I)V super(i); } } diff --git a/src/test/java/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java b/src/test/java/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java index 4f9c5b0e..d676ba24 100644 --- a/src/test/java/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java +++ b/src/test/java/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java @@ -10,7 +10,7 @@ ******************************************************************************/ package cuchaz.enigma.inputs.inheritanceTree; -// none/a +// a public abstract class BaseClass { // a diff --git a/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java b/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java index 140d2a81..d0213a37 100644 --- a/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java +++ b/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java @@ -10,12 +10,12 @@ ******************************************************************************/ package cuchaz.enigma.inputs.inheritanceTree; -// none/b extends none/a +// b extends a public abstract class SubclassA extends BaseClass { // (Ljava/lang/String;)V protected SubclassA(String name) { - // call to none/a.(Ljava/lang/String)V + // call to a.(Ljava/lang/String)V super(name); } } diff --git a/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java b/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java index 99d149bb..751fdd16 100644 --- a/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java +++ b/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java @@ -10,7 +10,7 @@ ******************************************************************************/ package cuchaz.enigma.inputs.inheritanceTree; -// none/c extends none/a +// c extends a public class SubclassB extends BaseClass { // a @@ -18,7 +18,7 @@ public class SubclassB extends BaseClass { // ()V protected SubclassB() { - // none/a.(Ljava/lang/String;)V + // a.(Ljava/lang/String;)V super("B"); // access to a @@ -28,7 +28,7 @@ public class SubclassB extends BaseClass { @Override // a()V public void doBaseThings() { - // call to none/a.a()Ljava/lang/String; + // call to a.a()Ljava/lang/String; System.out.println("Base things by B! " + getName()); } diff --git a/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java b/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java index 2e414b75..a5b25fd5 100644 --- a/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java +++ b/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java @@ -10,25 +10,25 @@ ******************************************************************************/ package cuchaz.enigma.inputs.inheritanceTree; -// none/d extends none/b +// d extends b public class SubsubclassAA extends SubclassA { protected SubsubclassAA() { - // call to none/b.(Ljava/lang/String;)V + // call to b.(Ljava/lang/String;)V super("AA"); } @Override // a()Ljava/lang/String; public String getName() { - // call to none/b.a()Ljava/lang/String; + // call to b.a()Ljava/lang/String; return "subsub" + super.getName(); } @Override // a()V public void doBaseThings() { - // call to none/d.a()Ljava/lang/String; + // call to d.a()Ljava/lang/String; System.out.println("Base things by " + getName()); } } diff --git a/src/test/java/cuchaz/enigma/resources/translation.mappings b/src/test/java/cuchaz/enigma/resources/translation.mappings index db78c19d..c08765c7 100644 --- a/src/test/java/cuchaz/enigma/resources/translation.mappings +++ b/src/test/java/cuchaz/enigma/resources/translation.mappings @@ -1,4 +1,4 @@ -CLASS none/a deobf/A_Basic +CLASS a deobf/A_Basic FIELD a f1 I FIELD a f2 F FIELD a f3 Ljava/lang/String; @@ -6,36 +6,36 @@ CLASS none/a deobf/A_Basic METHOD a m2 ()I METHOD a m3 (I)V METHOD a m4 (I)I -CLASS none/b deobf/B_BaseClass +CLASS b deobf/B_BaseClass FIELD a f1 I FIELD a f2 C METHOD a m1 ()I METHOD b m2 ()I -CLASS none/c deobf/C_SubClass +CLASS c deobf/C_SubClass FIELD b f2 C FIELD b f3 I FIELD c f4 I METHOD a m1 ()I METHOD c m3 ()I -CLASS none/g deobf/G_OuterClass - CLASS none/g$a A_InnerClass - CLASS none/g$a$a A_InnerInnerClass +CLASS g deobf/G_OuterClass + CLASS g$a A_InnerClass + CLASS g$a$a A_InnerInnerClass FIELD a f3 I METHOD a m2 ()V FIELD a f1 I FIELD a f2 Ljava/lang/String; METHOD a m1 ()V - CLASS none/g$b - CLASS none/g$b$a A_NamedInnerClass + CLASS g$b + CLASS g$b$a A_NamedInnerClass FIELD a f4 I -CLASS none/h -CLASS none/i deobf/I_Generics - CLASS none/i$a A_Type - CLASS none/i$b B_Generic +CLASS h +CLASS i deobf/I_Generics + CLASS i$a A_Type + CLASS i$b B_Generic FIELD a f4 Ljava/lang/Object; METHOD a m1 ()Ljava/lang/Object; FIELD a f1 Ljava/util/List; FIELD b f2 Ljava/util/List; FIELD a f3 Ljava/util/Map; - FIELD a f5 Lnone/i$b; - FIELD b f6 Lnone/i$b; + FIELD a f5 Li$b; + FIELD b f6 Li$b; -- cgit v1.2.3