Merge with a04907514a113e299dc667aa221a67573c5faa1b

18 files changed, 730 insertions, 36 deletions

diff --git a/build.py b/build.py
index 8e37d0ff..47294987 100644
--- a/build.py
+++ b/build.py
@@ -105,6 +105,7 @@ def taskBuildTestJars():
         buildTestJar("testConstructors", "cuchaz/enigma/inputs/constructors/*.class")
         buildTestJar("testInheritanceTree", "cuchaz/enigma/inputs/inheritanceTree/*.class")
         buildTestJar("testInnerClasses", "cuchaz/enigma/inputs/innerClasses/*.class")
+        buildTestJar("testTranslation", "cuchaz/enigma/inputs/translation/*.class")
 
 def taskBuild():
         ssjb.file.delete(DirBuild)
diff --git a/src/cuchaz/enigma/TranslatingTypeLoader.java b/src/cuchaz/enigma/TranslatingTypeLoader.java
index 9287999b..cfa03a1a 100644
--- a/src/cuchaz/enigma/TranslatingTypeLoader.java
+++ b/src/cuchaz/enigma/TranslatingTypeLoader.java
@@ -167,7 +167,7 @@ public class TranslatingTypeLoader implements ITypeLoader {
                         assertClassName(c, deobfClassEntry);
                         
                         // DEBUG
-                        Util.writeClass( c );
+                        //Util.writeClass( c );
                         
                         // we have a transformed class!
                         return c.toBytecode();
diff --git a/src/cuchaz/enigma/mapping/BehaviorSignature.java b/src/cuchaz/enigma/mapping/BehaviorSignature.java
new file mode 100644
index 00000000..a6371f85
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/BehaviorSignature.java
@@ -0,0 +1,96 @@
+package cuchaz.enigma.mapping;
+
+import java.util.List;
+
+import com.beust.jcommander.internal.Lists;
+
+public class BehaviorSignature {
+        
+        public static interface ClassReplacer {
+                ClassEntry replace(ClassEntry entry);
+        }
+        
+        private List<Type> m_argumentTypes;
+        private Type m_returnType;
+        
+        public BehaviorSignature(String signature) {
+                m_argumentTypes = Lists.newArrayList();
+                int i=0;
+                while (i<signature.length()) {
+                        char c = signature.charAt(i);
+                        if (c == '(') {
+                                assert(m_argumentTypes.isEmpty());
+                                assert(m_returnType == null);
+                                i++;
+                        } else if (c == ')') {
+                                i++;
+                                break;
+                        } else {
+                                String type = Type.parseFirst(signature.substring(i));
+                                m_argumentTypes.add(new Type(type));
+                                i += type.length();
+                        }
+                }
+                m_returnType = new Type(Type.parseFirst(signature.substring(i)));
+        }
+        
+        public BehaviorSignature(BehaviorSignature other, ClassReplacer replacer) {
+                m_argumentTypes = Lists.newArrayList(other.m_argumentTypes);
+                for (int i=0; i<m_argumentTypes.size(); i++) {
+                        Type type = m_argumentTypes.get(i);
+                        if (type.isClass()) {
+                                ClassEntry newClassEntry = replacer.replace(type.getClassEntry());
+                                if (newClassEntry != null) {
+                                        m_argumentTypes.set(i, new Type(newClassEntry));
+                                }
+                        }
+                }
+                m_returnType = other.m_returnType;
+                if (other.m_returnType.isClass()) {
+                        ClassEntry newClassEntry = replacer.replace(m_returnType.getClassEntry());
+                        if (newClassEntry != null) {
+                                m_returnType = new Type(newClassEntry);
+                        }
+                }
+        }
+        
+        public List<Type> getArgumentTypes() {
+                return m_argumentTypes;
+        }
+        
+        public Type getReturnType() {
+                return m_returnType;
+        }
+        
+        @Override
+        public String toString() {
+                StringBuilder buf = new StringBuilder();
+                buf.append("(");
+                for (int i=0; i<m_argumentTypes.size(); i++) {
+                        if (i > 0) {
+                                buf.append(",");
+                        }
+                        buf.append(m_argumentTypes.get(i).toString());
+                }
+                buf.append(")");
+                buf.append(m_returnType.toString());
+                return buf.toString();
+        }
+        
+        public Iterable<Type> types() {
+                List<Type> types = Lists.newArrayList();
+                types.addAll(m_argumentTypes);
+                types.add(m_returnType);
+                return types;
+        }
+        
+        public Iterable<ClassEntry> classes() {
+                List<ClassEntry> out = Lists.newArrayList();
+                for (Type type : types()) {
+                        if (type.isClass()) {
+                                out.add(type.getClassEntry());
+                        }
+                }
+                return out;
+        }
+}
diff --git a/src/cuchaz/enigma/mapping/Mappings.java b/src/cuchaz/enigma/mapping/Mappings.java
index cc560a87..92134edf 100644
--- a/src/cuchaz/enigma/mapping/Mappings.java
+++ b/src/cuchaz/enigma/mapping/Mappings.java
@@ -10,20 +10,15 @@
  ******************************************************************************/
 package cuchaz.enigma.mapping;
 
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.ObjectInputStream;
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Map;
 import java.util.Set;
-import java.util.zip.GZIPInputStream;
 
 import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
 
-import cuchaz.enigma.Util;
 import cuchaz.enigma.analysis.TranslationIndex;
 import cuchaz.enigma.mapping.SignatureUpdater.ClassNameUpdater;
 
@@ -50,16 +45,6 @@ public class Mappings implements Serializable {
                 }
         }
         
-        public static Mappings newFromResource(String resource) throws IOException {
-                InputStream in = null;
-                try {
-                        in = Mappings.class.getResourceAsStream(resource);
-                        return newFromStream(in);
-                } finally {
-                        Util.closeQuietly(in);
-                }
-        }
-        
         public Collection<ClassMapping> classes() {
                 assert (m_classesByObf.size() >= m_classesByDeobf.size());
                 return m_classesByObf.values();
@@ -134,14 +119,6 @@ public class Mappings implements Serializable {
                 }
         }
         
-        public static Mappings newFromStream(InputStream in) throws IOException {
-                try {
-                        return (Mappings)new ObjectInputStream(new GZIPInputStream(in)).readObject();
-                } catch (ClassNotFoundException ex) {
-                        throw new Error(ex);
-                }
-        }
-        
         @Override
         public String toString() {
                 StringBuilder buf = new StringBuilder();
diff --git a/src/cuchaz/enigma/mapping/Type.java b/src/cuchaz/enigma/mapping/Type.java
new file mode 100644
index 00000000..2273e21b
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/Type.java
@@ -0,0 +1,179 @@
+package cuchaz.enigma.mapping;
+
+import java.util.Map;
+
+import com.google.common.collect.Maps;
+
+public class Type {
+        
+        public enum Primitive {
+                Byte('B'),
+                Character('C'),
+                Short('S'),
+                Integer('I'),
+                Long('J'),
+                Float('F'),
+                Double('D'),
+                Boolean('Z');
+                
+                private static final Map<Character,Primitive> m_lookup;
+                
+                static {
+                        m_lookup = Maps.newTreeMap();
+                        for (Primitive val : values()) {
+                                m_lookup.put(val.getCode(), val);
+                        }
+                }
+                
+                public static Primitive get(char code) {
+                        return m_lookup.get(code);
+                }
+                
+                private char m_code;
+                
+                private Primitive(char code) {
+                        m_code = code;
+                }
+        
+                public char getCode() {
+                        return m_code;
+                }
+        }
+        
+        public static String parseFirst(String in) {
+                
+                // read one type from the input
+                
+                char c = in.charAt(0);
+                
+                // first check for void
+                if (c == 'V') {
+                        return "V";
+                }
+                
+                // then check for primitives
+                Primitive primitive = Primitive.get(c);
+                if (primitive != null) {
+                        return in.substring(0, 1);
+                }
+                
+                // then check for classes
+                if (c == 'L') {
+                        return readClass(in);
+                }
+
+                // then check for arrays
+                int dim = countArrayDimension(in);
+                if (dim > 0) {
+                        String arrayType = Type.parseFirst(in.substring(dim));
+                        return in.substring(0, dim + arrayType.length());
+                }
+                
+                throw new IllegalArgumentException("don't know how to parse: " + in);
+        }
+                
+        private String m_name;
+        
+        public Type(String name) {
+                m_name = name;
+        }
+        
+        public Type(ClassEntry classEntry) {
+                m_name = "L" + classEntry.getClassName() + ";";
+        }
+        
+        @Override
+        public String toString() {
+                return m_name;
+        }
+        
+        public boolean isVoid() {
+                return m_name.length() == 1 && m_name.charAt(0) == 'V';
+        }
+        
+        public boolean isPrimitive() {
+                return m_name.length() == 1 && Primitive.get(m_name.charAt(0)) != null;
+        }
+        
+        public Primitive getPrimitive() {
+                if (!isPrimitive()) {
+                        throw new IllegalStateException("not a primitive");
+                }
+                return Primitive.get(m_name.charAt(0));
+        }
+        
+        public boolean isClass() {
+                return m_name.charAt(0) == 'L' && m_name.charAt(m_name.length() - 1) == ';';
+        }
+        
+        public ClassEntry getClassEntry() {
+                if (!isClass()) {
+                        throw new IllegalStateException("not a class");
+                }
+                String name = m_name.substring(1, m_name.length() - 1);
+                
+                int pos = name.indexOf('<');
+                if (pos >= 0) {
+                        // remove the parameters from the class name
+                        name = name.substring(0, pos);
+                }
+                
+                return new ClassEntry(name);
+        }
+        
+        public boolean isArray() {
+                return m_name.charAt(0) == '[';
+        }
+        
+        public int getArrayDimension() {
+                if (!isArray()) {
+                        throw new IllegalStateException("not an array");
+                }
+                return countArrayDimension(m_name);
+        }
+        
+        public Type getArrayType() {
+                if (!isArray()) {
+                        throw new IllegalStateException("not an array");
+                }
+                return new Type(m_name.substring(getArrayDimension(), m_name.length()));
+        }
+        
+        @Override
+        public boolean equals(Object other) {
+                if (other instanceof Type) {
+                        return equals((Type)other);
+                }
+                return false;
+        }
+        
+        public boolean equals(Type other) {
+                return m_name.equals(other.m_name);
+        }
+        
+        private static int countArrayDimension(String in) {
+                int i=0;
+                for(; i < in.length() && in.charAt(i) == '['; i++);
+                return i;
+        }
+        
+        private static String readClass(String in) {
+                // read all the characters in the buffer until we hit a ';'
+                // remember to treat parameters correctly
+                StringBuilder buf = new StringBuilder();
+                int depth = 0;
+                for (int i=0; i<in.length(); i++) {
+                        char c = in.charAt(i);
+                        buf.append(c);
+                        
+                        if (c == '<') {
+                                depth++;
+                        } else if (c == '>') {
+                                depth--;
+                        } else if (depth == 0 && c == ';') {
+                                return buf.toString();
+                        }
+                }
+                return null;
+        }
+}
diff --git a/test/cuchaz/enigma/TestBehaviorSignature.java b/test/cuchaz/enigma/TestBehaviorSignature.java
new file mode 100644
index 00000000..4705cd12
--- /dev/null
+++ b/test/cuchaz/enigma/TestBehaviorSignature.java
@@ -0,0 +1,196 @@
+package cuchaz.enigma;
+
+import static org.hamcrest.MatcherAssert.*;
+import static org.hamcrest.Matchers.*;
+
+import org.junit.Test;
+
+import cuchaz.enigma.mapping.BehaviorSignature;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.Type;
+
+
+public class TestBehaviorSignature {
+        
+        @Test
+        public void easiest() {
+                final BehaviorSignature sig = new BehaviorSignature("()V");
+                assertThat(sig.getArgumentTypes(), is(empty()));
+                assertThat(sig.getReturnType(), is(new Type("V")));
+        }
+        
+        @Test
+        public void primitives() {
+                {
+                        final BehaviorSignature sig = new BehaviorSignature("(I)V");
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("I")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("V")));
+                }
+                {
+                        final BehaviorSignature sig = new BehaviorSignature("(I)I");
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("I")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("I")));
+                }
+                {
+                        final BehaviorSignature sig = new BehaviorSignature("(IBCJ)Z");
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("I"),
+                                new Type("B"),
+                                new Type("C"),
+                                new Type("J")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("Z")));
+                }
+        }
+        
+        @Test
+        public void classes() {
+                {
+                        final BehaviorSignature sig = new BehaviorSignature("([LFoo;)V");
+                        assertThat(sig.getArgumentTypes().size(), is(1));
+                        assertThat(sig.getArgumentTypes().get(0), is(new Type("[LFoo;")));
+                        assertThat(sig.getReturnType(), is(new Type("V")));
+                }
+                {
+                        final BehaviorSignature sig = new BehaviorSignature("(LFoo;)LBar;");
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("LFoo;")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("LBar;")));
+                }
+                {
+                        final BehaviorSignature sig = new BehaviorSignature("(LFoo;LMoo;LZoo;)LBar;");
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("LFoo;"),
+                                new Type("LMoo;"),
+                                new Type("LZoo;")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("LBar;")));
+                }
+                {
+                        final BehaviorSignature sig = new BehaviorSignature("(LFoo<LParm;>;LMoo<LParm;>;)LBar<LParm;>;");
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("LFoo<LParm;>;"),
+                                new Type("LMoo<LParm;>;")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("LBar<LParm;>;")));
+                }
+        }
+        
+        @Test
+        public void arrays() {
+                {
+                        final BehaviorSignature sig = new BehaviorSignature("([I)V");
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("[I")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("V")));
+                }
+                {
+                        final BehaviorSignature sig = new BehaviorSignature("([I)[J");
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("[I")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("[J")));
+                }
+                {
+                        final BehaviorSignature sig = new BehaviorSignature("([I[Z[F)[D");
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("[I"),
+                                new Type("[Z"),
+                                new Type("[F")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("[D")));
+                }
+        }
+        
+        @Test
+        public void mixed() {
+                {
+                        final BehaviorSignature sig = new BehaviorSignature("(I[JLFoo;)Z");
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("I"),
+                                new Type("[J"),
+                                new Type("LFoo;")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("Z")));
+                }
+                {
+                        final BehaviorSignature sig = new BehaviorSignature("(III)[LFoo;");
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("I"),
+                                new Type("I"),
+                                new Type("I")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("[LFoo;")));
+                }
+        }
+        
+        @Test
+        public void replaceClasses() {
+                {
+                        final BehaviorSignature oldSig = new BehaviorSignature("()V");
+                        final BehaviorSignature sig = new BehaviorSignature(oldSig, new BehaviorSignature.ClassReplacer() {
+                                @Override
+                                public ClassEntry replace(ClassEntry entry) {
+                                        return null;
+                                }
+                        });
+                        assertThat(sig.getArgumentTypes(), is(empty()));
+                        assertThat(sig.getReturnType(), is(new Type("V")));
+                }
+                {
+                        final BehaviorSignature oldSig = new BehaviorSignature("(IJLFoo;)V");
+                        final BehaviorSignature sig = new BehaviorSignature(oldSig, new BehaviorSignature.ClassReplacer() {
+                                @Override
+                                public ClassEntry replace(ClassEntry entry) {
+                                        return null;
+                                }
+                        });
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("I"),
+                                new Type("J"),
+                                new Type("LFoo;")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("V")));
+                }
+                {
+                        final BehaviorSignature oldSig = new BehaviorSignature("(LFoo;LBar;)LMoo;");
+                        final BehaviorSignature sig = new BehaviorSignature(oldSig, new BehaviorSignature.ClassReplacer() {
+                                @Override
+                                public ClassEntry replace(ClassEntry entry) {
+                                        if (entry.getName().equals("Foo")) {
+                                                return new ClassEntry("Bar");
+                                        }
+                                        return null;
+                                }
+                        });
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("LBar;"),
+                                new Type("LBar;")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("LMoo;")));
+                }
+                {
+                        final BehaviorSignature oldSig = new BehaviorSignature("(LFoo;LBar;)LMoo;");
+                        final BehaviorSignature sig = new BehaviorSignature(oldSig, new BehaviorSignature.ClassReplacer() {
+                                @Override
+                                public ClassEntry replace(ClassEntry entry) {
+                                        if (entry.getName().equals("Moo")) {
+                                                return new ClassEntry("Cow");
+                                        }
+                                        return null;
+                                }
+                        });
+                        assertThat(sig.getArgumentTypes(), contains(
+                                new Type("LFoo;"),
+                                new Type("LBar;")
+                        ));
+                        assertThat(sig.getReturnType(), is(new Type("LCow;")));
+                }
+        }
+}
diff --git a/test/cuchaz/enigma/TestDeobfuscator.java b/test/cuchaz/enigma/TestDeobfuscator.java
index 129d7b25..26d492d8 100644
--- a/test/cuchaz/enigma/TestDeobfuscator.java
+++ b/test/cuchaz/enigma/TestDeobfuscator.java
@@ -25,17 +25,20 @@ import cuchaz.enigma.mapping.ClassEntry;
 
 public class TestDeobfuscator {
         
-        private Deobfuscator getDeobfuscator() throws IOException {
+        private Deobfuscator getDeobfuscator()
+        throws IOException {
                 return new Deobfuscator(new JarFile("build/testLoneClass.obf.jar"));
         }
         
         @Test
-        public void loadJar() throws Exception {
+        public void loadJar()
+        throws Exception {
                 getDeobfuscator();
         }
         
         @Test
-        public void getClasses() throws Exception {
+        public void getClasses()
+        throws Exception {
                 Deobfuscator deobfuscator = getDeobfuscator();
                 List<ClassEntry> obfClasses = Lists.newArrayList();
                 List<ClassEntry> deobfClasses = Lists.newArrayList();
@@ -47,7 +50,8 @@ public class TestDeobfuscator {
         }
         
         @Test
-        public void decompileClass() throws Exception {
+        public void decompileClass()
+        throws Exception {
                 Deobfuscator deobfuscator = getDeobfuscator();
                 deobfuscator.getSource(deobfuscator.getSourceTree("none/a"));
         }
diff --git a/test/cuchaz/enigma/TestInnerClasses.java b/test/cuchaz/enigma/TestInnerClasses.java
index 63c9b719..2e16a330 100644
--- a/test/cuchaz/enigma/TestInnerClasses.java
+++ b/test/cuchaz/enigma/TestInnerClasses.java
@@ -36,7 +36,8 @@ public class TestInnerClasses {
         private static final String AnonymousWithOuterAccessOuter = "none/i";
         private static final String AnonymousWithOuterAccessInner = "j";
         
-        public TestInnerClasses() throws Exception {
+        public TestInnerClasses()
+        throws Exception {
                 m_index = new JarIndex();
                 JarFile jar = new JarFile("build/testInnerClasses.obf.jar");
                 m_index.indexJar(jar, true);
diff --git a/test/cuchaz/enigma/TestJarIndexConstructorReferences.java b/test/cuchaz/enigma/TestJarIndexConstructorReferences.java
index 8e3ad6d2..a735de7c 100644
--- a/test/cuchaz/enigma/TestJarIndexConstructorReferences.java
+++ b/test/cuchaz/enigma/TestJarIndexConstructorReferences.java
@@ -36,7 +36,8 @@ public class TestJarIndexConstructorReferences {
         private ClassEntry m_defaultClass = new ClassEntry("none/c");
         private ClassEntry m_callerClass = new ClassEntry("none/b");
         
-        public TestJarIndexConstructorReferences() throws Exception {
+        public TestJarIndexConstructorReferences()
+        throws Exception {
                 File jarFile = new File("build/testConstructors.obf.jar");
                 m_index = new JarIndex();
                 m_index.indexJar(new JarFile(jarFile), false);
diff --git a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java
index 4d663972..26499f06 100644
--- a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java
+++ b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java
@@ -41,7 +41,8 @@ public class TestJarIndexInheritanceTree {
         private FieldEntry m_nameField = new FieldEntry(m_baseClass, "a");
         private FieldEntry m_numThingsField = new FieldEntry(m_subClassB, "a");
         
-        public TestJarIndexInheritanceTree() throws Exception {
+        public TestJarIndexInheritanceTree()
+        throws Exception {
                 m_index = new JarIndex();
                 m_index.indexJar(new JarFile("build/testInheritanceTree.obf.jar"), false);
         }
diff --git a/test/cuchaz/enigma/TestJarIndexLoneClass.java b/test/cuchaz/enigma/TestJarIndexLoneClass.java
index a061b72d..108c623a 100644
--- a/test/cuchaz/enigma/TestJarIndexLoneClass.java
+++ b/test/cuchaz/enigma/TestJarIndexLoneClass.java
@@ -38,7 +38,8 @@ public class TestJarIndexLoneClass {
         
         private JarIndex m_index;
         
-        public TestJarIndexLoneClass() throws Exception {
+        public TestJarIndexLoneClass()
+        throws Exception {
                 m_index = new JarIndex();
                 m_index.indexJar(new JarFile("build/testLoneClass.obf.jar"), false);
         }
diff --git a/test/cuchaz/enigma/TestSourceIndex.java b/test/cuchaz/enigma/TestSourceIndex.java
index 70a5ee4c..357acb62 100644
--- a/test/cuchaz/enigma/TestSourceIndex.java
+++ b/test/cuchaz/enigma/TestSourceIndex.java
@@ -24,8 +24,9 @@ import cuchaz.enigma.mapping.ClassEntry;
 public class TestSourceIndex {
         
         // TEMP
-        @Test
-        public void indexEverything() throws Exception {
+        //@Test
+        public void indexEverything()
+        throws Exception {
                 Deobfuscator deobfuscator = new Deobfuscator(new JarFile("input/1.8.jar"));
                 
                 // get all classes that aren't inner classes
diff --git a/test/cuchaz/enigma/TestTokensConstructors.java b/test/cuchaz/enigma/TestTokensConstructors.java
index 56424ae8..6758d2a7 100644
--- a/test/cuchaz/enigma/TestTokensConstructors.java
+++ b/test/cuchaz/enigma/TestTokensConstructors.java
@@ -22,7 +22,8 @@ import cuchaz.enigma.mapping.BehaviorEntry;
 
 public class TestTokensConstructors extends TokenChecker {
         
-        public TestTokensConstructors() throws Exception {
+        public TestTokensConstructors()
+        throws Exception {
                 super(new JarFile("build/testConstructors.obf.jar"));
         }
         
diff --git a/test/cuchaz/enigma/TestTranslator.java b/test/cuchaz/enigma/TestTranslator.java
new file mode 100644
index 00000000..290f6f04
--- /dev/null
+++ b/test/cuchaz/enigma/TestTranslator.java
@@ -0,0 +1,39 @@
+package cuchaz.enigma;
+
+import static cuchaz.enigma.EntryFactory.*;
+import static org.hamcrest.MatcherAssert.*;
+import static org.hamcrest.Matchers.*;
+
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.jar.JarFile;
+
+import org.junit.Test;
+
+import cuchaz.enigma.mapping.Mappings;
+import cuchaz.enigma.mapping.MappingsReader;
+import cuchaz.enigma.mapping.TranslationDirection;
+import cuchaz.enigma.mapping.Translator;
+
+
+public class TestTranslator {
+
+        private Deobfuscator m_deobfuscator;
+        private Mappings m_mappings;
+        
+        public TestTranslator()
+        throws Exception {
+                m_deobfuscator = new Deobfuscator(new JarFile("build/testTranslation.obf.jar"));
+                try (InputStream in = getClass().getResourceAsStream("/cuchaz/enigma/resources/translation.mappings")) {
+                        m_mappings = new MappingsReader().read(new InputStreamReader(in));
+                        m_deobfuscator.setMappings(m_mappings);
+                }
+        }
+        
+        @Test
+        public void deobfuscatingTranslations()
+        throws Exception {
+                Translator translator = m_deobfuscator.getTranslator(TranslationDirection.Deobfuscating);
+                assertThat(translator.translateEntry(newClass("none/a")), is(newClass("deobf/A")));
+        }
+}
diff --git a/test/cuchaz/enigma/TestType.java b/test/cuchaz/enigma/TestType.java
new file mode 100644
index 00000000..efc6a4c3
--- /dev/null
+++ b/test/cuchaz/enigma/TestType.java
@@ -0,0 +1,183 @@
+package cuchaz.enigma;
+
+import org.junit.Test;
+
+import static org.hamcrest.MatcherAssert.*;
+import static org.hamcrest.Matchers.*;
+
+import cuchaz.enigma.mapping.Type;
+
+import static cuchaz.enigma.EntryFactory.*;
+
+
+public class TestType {
+        
+        @Test
+        public void isVoid() {
+                assertThat(new Type("V").isVoid(), is(true));
+                assertThat(new Type("Z").isVoid(), is(false));
+                assertThat(new Type("B").isVoid(), is(false));
+                assertThat(new Type("C").isVoid(), is(false));
+                assertThat(new Type("I").isVoid(), is(false));
+                assertThat(new Type("J").isVoid(), is(false));
+                assertThat(new Type("F").isVoid(), is(false));
+                assertThat(new Type("D").isVoid(), is(false));
+                assertThat(new Type("LFoo;").isVoid(), is(false));
+                assertThat(new Type("[I").isVoid(), is(false));
+        }
+        
+        @Test
+        public void isPrimitive() {
+                assertThat(new Type("V").isPrimitive(), is(false));
+                assertThat(new Type("Z").isPrimitive(), is(true));
+                assertThat(new Type("B").isPrimitive(), is(true));
+                assertThat(new Type("C").isPrimitive(), is(true));
+                assertThat(new Type("I").isPrimitive(), is(true));
+                assertThat(new Type("J").isPrimitive(), is(true));
+                assertThat(new Type("F").isPrimitive(), is(true));
+                assertThat(new Type("D").isPrimitive(), is(true));
+                assertThat(new Type("LFoo;").isPrimitive(), is(false));
+                assertThat(new Type("[I").isPrimitive(), is(false));
+        }
+        
+        @Test
+        public void getPrimitive() {
+                assertThat(new Type("Z").getPrimitive(), is(Type.Primitive.Boolean));
+                assertThat(new Type("B").getPrimitive(), is(Type.Primitive.Byte));
+                assertThat(new Type("C").getPrimitive(), is(Type.Primitive.Character));
+                assertThat(new Type("I").getPrimitive(), is(Type.Primitive.Integer));
+                assertThat(new Type("J").getPrimitive(), is(Type.Primitive.Long));
+                assertThat(new Type("F").getPrimitive(), is(Type.Primitive.Float));
+                assertThat(new Type("D").getPrimitive(), is(Type.Primitive.Double));
+        }
+        
+        @Test
+        public void isClass() {
+                assertThat(new Type("V").isClass(), is(false));
+                assertThat(new Type("Z").isClass(), is(false));
+                assertThat(new Type("B").isClass(), is(false));
+                assertThat(new Type("C").isClass(), is(false));
+                assertThat(new Type("I").isClass(), is(false));
+                assertThat(new Type("J").isClass(), is(false));
+                assertThat(new Type("F").isClass(), is(false));
+                assertThat(new Type("D").isClass(), is(false));
+                assertThat(new Type("LFoo;").isClass(), is(true));
+                assertThat(new Type("[I").isClass(), is(false));
+        }
+        
+        @Test
+        public void getClassEntry() {
+                assertThat(new Type("LFoo;").getClassEntry(), is(newClass("Foo")));
+                assertThat(new Type("LFoo<Ljava/lang/String;>;").getClassEntry(), is(newClass("Foo")));
+        }
+        
+        @Test
+        public void isArray() {
+                assertThat(new Type("V").isArray(), is(false));
+                assertThat(new Type("Z").isArray(), is(false));
+                assertThat(new Type("B").isArray(), is(false));
+                assertThat(new Type("C").isArray(), is(false));
+                assertThat(new Type("I").isArray(), is(false));
+                assertThat(new Type("J").isArray(), is(false));
+                assertThat(new Type("F").isArray(), is(false));
+                assertThat(new Type("D").isArray(), is(false));
+                assertThat(new Type("LFoo;").isArray(), is(false));
+                assertThat(new Type("[I").isArray(), is(true));
+        }
+        
+        @Test
+        public void getArrayDimension() {
+                assertThat(new Type("[I").getArrayDimension(), is(1));
+                assertThat(new Type("[[I").getArrayDimension(), is(2));
+                assertThat(new Type("[[[I").getArrayDimension(), is(3));
+        }
+        
+        @Test
+        public void getArrayType() {
+                assertThat(new Type("[I").getArrayType(), is(new Type("I")));
+                assertThat(new Type("[[I").getArrayType(), is(new Type("I")));
+                assertThat(new Type("[[[I").getArrayType(), is(new Type("I")));
+                assertThat(new Type("[Ljava/lang/String;").getArrayType(), is(new Type("Ljava/lang/String;")));
+        }
+        
+        @Test
+        public void parseVoid() {
+                final String answer = "V";
+                assertThat(Type.parseFirst("V"), is(answer));
+                assertThat(Type.parseFirst("VVV"), is(answer));
+                assertThat(Type.parseFirst("VIJ"), is(answer));
+                assertThat(Type.parseFirst("V[I"), is(answer));
+                assertThat(Type.parseFirst("VLFoo;"), is(answer));
+                assertThat(Type.parseFirst("V[LFoo;"), is(answer));
+        }
+        
+        @Test
+        public void parsePrimitive() {
+                final String answer = "I";
+                assertThat(Type.parseFirst("I"), is(answer));
+                assertThat(Type.parseFirst("III"), is(answer));
+                assertThat(Type.parseFirst("IJZ"), is(answer));
+                assertThat(Type.parseFirst("I[I"), is(answer));
+                assertThat(Type.parseFirst("ILFoo;"), is(answer));
+                assertThat(Type.parseFirst("I[LFoo;"), is(answer));
+        }
+        
+        @Test
+        public void parseClass() {
+                {
+                        final String answer = "LFoo;";
+                        assertThat(Type.parseFirst("LFoo;"), is(answer));
+                        assertThat(Type.parseFirst("LFoo;I"), is(answer));
+                        assertThat(Type.parseFirst("LFoo;JZ"), is(answer));
+                        assertThat(Type.parseFirst("LFoo;[I"), is(answer));
+                        assertThat(Type.parseFirst("LFoo;LFoo;"), is(answer));
+                        assertThat(Type.parseFirst("LFoo;[LFoo;"), is(answer));
+                }
+                {
+                        final String answer = "LFoo<LFoo;>;";
+                        assertThat(Type.parseFirst("LFoo<LFoo;>;"), is(answer));
+                        assertThat(Type.parseFirst("LFoo<LFoo;>;I"), is(answer));
+                        assertThat(Type.parseFirst("LFoo<LFoo;>;JZ"), is(answer));
+                        assertThat(Type.parseFirst("LFoo<LFoo;>;[I"), is(answer));
+                        assertThat(Type.parseFirst("LFoo<LFoo;>;LFoo;"), is(answer));
+                        assertThat(Type.parseFirst("LFoo<LFoo;>;[LFoo;"), is(answer));
+                }
+                {
+                        final String answer = "LFoo<LFoo;,LBar;>;";
+                        assertThat(Type.parseFirst("LFoo<LFoo;,LBar;>;"), is(answer));
+                        assertThat(Type.parseFirst("LFoo<LFoo;,LBar;>;I"), is(answer));
+                        assertThat(Type.parseFirst("LFoo<LFoo;,LBar;>;JZ"), is(answer));
+                        assertThat(Type.parseFirst("LFoo<LFoo;,LBar;>;[I"), is(answer));
+                        assertThat(Type.parseFirst("LFoo<LFoo;,LBar;>;LFoo;"), is(answer));
+                        assertThat(Type.parseFirst("LFoo<LFoo;,LBar;>;[LFoo;"), is(answer));
+                }
+        }
+        
+        @Test
+        public void parseArray() {
+                {
+                        final String answer = "[I";
+                        assertThat(Type.parseFirst("[I"), is(answer));
+                        assertThat(Type.parseFirst("[III"), is(answer));
+                        assertThat(Type.parseFirst("[IJZ"), is(answer));
+                        assertThat(Type.parseFirst("[I[I"), is(answer));
+                        assertThat(Type.parseFirst("[ILFoo;"), is(answer));
+                }
+                {
+                        final String answer = "[[I";
+                        assertThat(Type.parseFirst("[[I"), is(answer));
+                        assertThat(Type.parseFirst("[[III"), is(answer));
+                        assertThat(Type.parseFirst("[[IJZ"), is(answer));
+                        assertThat(Type.parseFirst("[[I[I"), is(answer));
+                        assertThat(Type.parseFirst("[[ILFoo;"), is(answer));
+                }
+                {
+                        final String answer = "[LFoo;";
+                        assertThat(Type.parseFirst("[LFoo;"), is(answer));
+                        assertThat(Type.parseFirst("[LFoo;II"), is(answer));
+                        assertThat(Type.parseFirst("[LFoo;JZ"), is(answer));
+                        assertThat(Type.parseFirst("[LFoo;[I"), is(answer));
+                        assertThat(Type.parseFirst("[LFoo;LFoo;"), is(answer));
+                }
+        }
+}
diff --git a/test/cuchaz/enigma/TokenChecker.java b/test/cuchaz/enigma/TokenChecker.java
index febea2ae..a72c2fc8 100644
--- a/test/cuchaz/enigma/TokenChecker.java
+++ b/test/cuchaz/enigma/TokenChecker.java
@@ -27,7 +27,8 @@ public class TokenChecker {
         
         private Deobfuscator m_deobfuscator;
         
-        protected TokenChecker(JarFile jarFile) throws IOException {
+        protected TokenChecker(JarFile jarFile)
+        throws IOException {
                 m_deobfuscator = new Deobfuscator(jarFile);
         }
         
diff --git a/test/cuchaz/enigma/inputs/translation/A.java b/test/cuchaz/enigma/inputs/translation/A.java
new file mode 100644
index 00000000..b8aaf11e
--- /dev/null
+++ b/test/cuchaz/enigma/inputs/translation/A.java
@@ -0,0 +1,8 @@
+package cuchaz.enigma.inputs.translation;
+
+public class A {
+        
+        public int one;
+        public float two;
+        public String three;
+}
diff --git a/test/cuchaz/enigma/resources/translation.mappings b/test/cuchaz/enigma/resources/translation.mappings
new file mode 100644
index 00000000..70755bf6
--- /dev/null
+++ b/test/cuchaz/enigma/resources/translation.mappings
@@ -0,0 +1,4 @@
+CLASS none/a deobf/A
+        FIELD a one
+        FIELD b two
+        FIELD c three
\ No newline at end of file