Merge with a04907514a113e299dc667aa221a67573c5faa1b

13 files changed, 453 insertions, 12 deletions

diff --git a/test/cuchaz/enigma/TestBehaviorSignature.java b/test/cuchaz/enigma/TestBehaviorSignature.java
new file mode 100644
index 0000000..4705cd1
--- /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 129d7b2..26d492d 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 63c9b71..2e16a33 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 8e3ad6d..a735de7 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 4d66397..26499f0 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 a061b72..108c623 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 70a5ee4..357acb6 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 56424ae..6758d2a 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 0000000..290f6f0
--- /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 0000000..efc6a4c
--- /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 febea2a..a72c2fc 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 0000000..b8aaf11
--- /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 0000000..70755bf
--- /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