From af1041731c8c0ce1846ff7e7b6052ed7327a5dbc Mon Sep 17 00:00:00 2001
From: jeff
Date: Mon, 9 Feb 2015 22:23:45 -0500
Subject: fix translation issues, particularly with fields

---
 test/cuchaz/enigma/TestTranslator.java | 86 +++++++++++++++++++++++++++++-----
 1 file changed, 74 insertions(+), 12 deletions(-)

(limited to 'test/cuchaz/enigma/TestTranslator.java')

diff --git a/test/cuchaz/enigma/TestTranslator.java b/test/cuchaz/enigma/TestTranslator.java
index f91c585..3fe1680 100644
--- a/test/cuchaz/enigma/TestTranslator.java
+++ b/test/cuchaz/enigma/TestTranslator.java
@@ -1,6 +1,6 @@
 package cuchaz.enigma;
 
-import static cuchaz.enigma.EntryFactory.*;
+import static cuchaz.enigma.TestEntryFactory.*;
 import static org.hamcrest.MatcherAssert.*;
 import static org.hamcrest.Matchers.*;
 
@@ -8,8 +8,10 @@ import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.util.jar.JarFile;
 
+import org.junit.BeforeClass;
 import org.junit.Test;
 
+import cuchaz.enigma.mapping.Entry;
 import cuchaz.enigma.mapping.Mappings;
 import cuchaz.enigma.mapping.MappingsReader;
 import cuchaz.enigma.mapping.TranslationDirection;
@@ -18,25 +20,85 @@ import cuchaz.enigma.mapping.Translator;
 
 public class TestTranslator {
 
-	private Deobfuscator m_deobfuscator;
-	private Mappings m_mappings;
+	private static Deobfuscator m_deobfuscator;
+	private static Mappings m_mappings;
+	private static Translator m_deobfTranslator;
+	private static Translator m_obfTranslator;
 	
-	public TestTranslator()
+	@BeforeClass
+	public static void beforeClass()
 	throws Exception {
 		m_deobfuscator = new Deobfuscator(new JarFile("build/testTranslation.obf.jar"));
-		try (InputStream in = getClass().getResourceAsStream("/cuchaz/enigma/resources/translation.mappings")) {
+		try (InputStream in = TestTranslator.class.getResourceAsStream("/cuchaz/enigma/resources/translation.mappings")) {
 			m_mappings = new MappingsReader().read(new InputStreamReader(in));
 			m_deobfuscator.setMappings(m_mappings);
+			m_deobfTranslator = m_deobfuscator.getTranslator(TranslationDirection.Deobfuscating);
+			m_obfTranslator = m_deobfuscator.getTranslator(TranslationDirection.Obfuscating);
 		}
 	}
 	
 	@Test
-	public void deobfuscatingTranslations()
-	throws Exception {
-		Translator translator = m_deobfuscator.getTranslator(TranslationDirection.Deobfuscating);
-		assertThat(translator.translateEntry(newClass("none/a")), is(newClass("deobf/A")));
-		assertThat(translator.translateEntry(newField("none/a", "a", "I")), is(newField("deobf/A", "one", "I")));
-		assertThat(translator.translateEntry(newField("none/a", "a", "F")), is(newField("deobf/A", "two", "F")));
-		assertThat(translator.translateEntry(newField("none/a", "a", "Ljava/lang/String;")), is(newField("deobf/A", "three", "Ljava/lang/String;")));
+	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"));
+	}
+
+	@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;"));
+	}
+	
+	@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"));
+	}
+	
+	// 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"));
+	}
+	
+	@Test
+	public void inheritanceFieldsShadowing() {
+		assertMapping(newField("none/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"));
+		// 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"));
+	}
+	
+	@Test
+	public void inheritanceMethodsOverrides() {
+		assertMapping(newMethod("none/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"));
+	}
+	
+	private void assertMapping(Entry obf, Entry deobf) {
+		assertThat(m_deobfTranslator.translateEntry(obf), is(deobf));
+		assertThat(m_obfTranslator.translateEntry(deobf), is(obf));
 	}
 }
-- 
cgit v1.2.3