Drop unix case style and implement hashCode when equals is overrided

Also update Guava to version 21

11 files changed, 228 insertions, 232 deletions

diff --git a/src/test/java/cuchaz/enigma/TestDeobfed.java b/src/test/java/cuchaz/enigma/TestDeobfed.java
index 2f318c80..76a3d3b5 100644
--- a/src/test/java/cuchaz/enigma/TestDeobfed.java
+++ b/src/test/java/cuchaz/enigma/TestDeobfed.java
@@ -25,20 +25,20 @@ import cuchaz.enigma.analysis.JarIndex;
 
 public class TestDeobfed {
 
-        private static JarFile m_jar;
-        private static JarIndex m_index;
+        private static JarFile  jar;
+        private static JarIndex index;
         
         @BeforeClass
         public static void beforeClass()
         throws Exception {
-                m_jar = new JarFile("build/test-deobf/translation.jar");
-                m_index = new JarIndex();
-                m_index.indexJar(m_jar, true);
+                jar = new JarFile("build/test-deobf/translation.jar");
+                index = new JarIndex();
+                index.indexJar(jar, true);
         }
         
         @Test
         public void obfEntries() {
-                assertThat(m_index.getObfClassEntries(), containsInAnyOrder(
+                assertThat(index.getObfClassEntries(), containsInAnyOrder(
                         newClass("cuchaz/enigma/inputs/Keep"),
                         newClass("a"),
                         newClass("b"),
@@ -68,7 +68,7 @@ public class TestDeobfed {
         @Test
         public void decompile()
         throws Exception {
-                Deobfuscator deobfuscator = new Deobfuscator(m_jar);
+                Deobfuscator deobfuscator = new Deobfuscator(jar);
                 deobfuscator.getSourceTree("a");
                 deobfuscator.getSourceTree("b");
                 deobfuscator.getSourceTree("c");
diff --git a/src/test/java/cuchaz/enigma/TestInnerClasses.java b/src/test/java/cuchaz/enigma/TestInnerClasses.java
index 70765e32..64a695a9 100644
--- a/src/test/java/cuchaz/enigma/TestInnerClasses.java
+++ b/src/test/java/cuchaz/enigma/TestInnerClasses.java
@@ -24,8 +24,8 @@ import cuchaz.enigma.mapping.ClassEntry;
 
 public class TestInnerClasses {
         
-        private JarIndex m_index;
-        private Deobfuscator m_deobfuscator;
+        private JarIndex     index;
+        private Deobfuscator deobfuscator;
         
         private static final ClassEntry AnonymousOuter = newClass("a");
         private static final ClassEntry AnonymousInner = newClass("a$1");
@@ -44,49 +44,49 @@ public class TestInnerClasses {
         
         public TestInnerClasses()
         throws Exception {
-                m_index = new JarIndex();
+                index = new JarIndex();
                 JarFile jar = new JarFile("build/test-obf/innerClasses.jar");
-                m_index.indexJar(jar, true);
-                m_deobfuscator = new Deobfuscator(jar);
+                index.indexJar(jar, true);
+                deobfuscator = new Deobfuscator(jar);
         }
         
         @Test
         public void simple() {
-                assertThat(m_index.getOuterClass(SimpleInner), is(SimpleOuter));
-                assertThat(m_index.getInnerClasses(SimpleOuter), containsInAnyOrder(SimpleInner));
-                assertThat(m_index.isAnonymousClass(SimpleInner), is(false));
+                assertThat(index.getOuterClass(SimpleInner), is(SimpleOuter));
+                assertThat(index.getInnerClasses(SimpleOuter), containsInAnyOrder(SimpleInner));
+                assertThat(index.isAnonymousClass(SimpleInner), is(false));
                 decompile(SimpleOuter);
         }
         
         @Test
         public void anonymous() {
-                assertThat(m_index.getOuterClass(AnonymousInner), is(AnonymousOuter));
-                assertThat(m_index.getInnerClasses(AnonymousOuter), containsInAnyOrder(AnonymousInner));
-                assertThat(m_index.isAnonymousClass(AnonymousInner), is(true));
+                assertThat(index.getOuterClass(AnonymousInner), is(AnonymousOuter));
+                assertThat(index.getInnerClasses(AnonymousOuter), containsInAnyOrder(AnonymousInner));
+                assertThat(index.isAnonymousClass(AnonymousInner), is(true));
                 decompile(AnonymousOuter);
         }
         
         @Test
         public void constructorArgs() {
-                assertThat(m_index.getOuterClass(ConstructorArgsInner), is(ConstructorArgsOuter));
-                assertThat(m_index.getInnerClasses(ConstructorArgsOuter), containsInAnyOrder(ConstructorArgsInner));
-                assertThat(m_index.isAnonymousClass(ConstructorArgsInner), is(false));
+                assertThat(index.getOuterClass(ConstructorArgsInner), is(ConstructorArgsOuter));
+                assertThat(index.getInnerClasses(ConstructorArgsOuter), containsInAnyOrder(ConstructorArgsInner));
+                assertThat(index.isAnonymousClass(ConstructorArgsInner), is(false));
                 decompile(ConstructorArgsOuter);
         }
         
         @Test
         public void anonymousWithScopeArgs() {
-                assertThat(m_index.getOuterClass(AnonymousWithScopeArgsInner), is(AnonymousWithScopeArgsOuter));
-                assertThat(m_index.getInnerClasses(AnonymousWithScopeArgsOuter), containsInAnyOrder(AnonymousWithScopeArgsInner));
-                assertThat(m_index.isAnonymousClass(AnonymousWithScopeArgsInner), is(true));
+                assertThat(index.getOuterClass(AnonymousWithScopeArgsInner), is(AnonymousWithScopeArgsOuter));
+                assertThat(index.getInnerClasses(AnonymousWithScopeArgsOuter), containsInAnyOrder(AnonymousWithScopeArgsInner));
+                assertThat(index.isAnonymousClass(AnonymousWithScopeArgsInner), is(true));
                 decompile(AnonymousWithScopeArgsOuter);
         }
         
         @Test
         public void anonymousWithOuterAccess() {
-                assertThat(m_index.getOuterClass(AnonymousWithOuterAccessInner), is(AnonymousWithOuterAccessOuter));
-                assertThat(m_index.getInnerClasses(AnonymousWithOuterAccessOuter), containsInAnyOrder(AnonymousWithOuterAccessInner));
-                assertThat(m_index.isAnonymousClass(AnonymousWithOuterAccessInner), is(true));
+                assertThat(index.getOuterClass(AnonymousWithOuterAccessInner), is(AnonymousWithOuterAccessOuter));
+                assertThat(index.getInnerClasses(AnonymousWithOuterAccessOuter), containsInAnyOrder(AnonymousWithOuterAccessInner));
+                assertThat(index.isAnonymousClass(AnonymousWithOuterAccessInner), is(true));
                 decompile(AnonymousWithOuterAccessOuter);
         }
         
@@ -94,26 +94,26 @@ public class TestInnerClasses {
         public void classTree() {
                 
                 // root level
-                assertThat(m_index.containsObfClass(ClassTreeRoot), is(true));
-                assertThat(m_index.getOuterClass(ClassTreeRoot), is(nullValue()));
-                assertThat(m_index.getInnerClasses(ClassTreeRoot), containsInAnyOrder(ClassTreeLevel1));
+                assertThat(index.containsObfClass(ClassTreeRoot), is(true));
+                assertThat(index.getOuterClass(ClassTreeRoot), is(nullValue()));
+                assertThat(index.getInnerClasses(ClassTreeRoot), containsInAnyOrder(ClassTreeLevel1));
                 
                 // level 1
                 ClassEntry fullClassEntry = new ClassEntry(ClassTreeRoot.getName()
                         + "$" + ClassTreeLevel1.getInnermostClassName()
                 );
-                assertThat(m_index.containsObfClass(fullClassEntry), is(true));
-                assertThat(m_index.getOuterClass(ClassTreeLevel1), is(ClassTreeRoot));
-                assertThat(m_index.getInnerClasses(ClassTreeLevel1), containsInAnyOrder(ClassTreeLevel2));
+                assertThat(index.containsObfClass(fullClassEntry), is(true));
+                assertThat(index.getOuterClass(ClassTreeLevel1), is(ClassTreeRoot));
+                assertThat(index.getInnerClasses(ClassTreeLevel1), containsInAnyOrder(ClassTreeLevel2));
                 
                 // level 2
                 fullClassEntry = new ClassEntry(ClassTreeRoot.getName()
                         + "$" + ClassTreeLevel1.getInnermostClassName()
                         + "$" + ClassTreeLevel2.getInnermostClassName()
                 );
-                assertThat(m_index.containsObfClass(fullClassEntry), is(true));
-                assertThat(m_index.getOuterClass(ClassTreeLevel2), is(ClassTreeLevel1));
-                assertThat(m_index.getInnerClasses(ClassTreeLevel2), containsInAnyOrder(ClassTreeLevel3));
+                assertThat(index.containsObfClass(fullClassEntry), is(true));
+                assertThat(index.getOuterClass(ClassTreeLevel2), is(ClassTreeLevel1));
+                assertThat(index.getInnerClasses(ClassTreeLevel2), containsInAnyOrder(ClassTreeLevel3));
                 
                 // level 3
                 fullClassEntry = new ClassEntry(ClassTreeRoot.getName()
@@ -121,12 +121,12 @@ public class TestInnerClasses {
                         + "$" + ClassTreeLevel2.getInnermostClassName()
                         + "$" + ClassTreeLevel3.getInnermostClassName()
                 );
-                assertThat(m_index.containsObfClass(fullClassEntry), is(true));
-                assertThat(m_index.getOuterClass(ClassTreeLevel3), is(ClassTreeLevel2));
-                assertThat(m_index.getInnerClasses(ClassTreeLevel3), is(empty()));
+                assertThat(index.containsObfClass(fullClassEntry), is(true));
+                assertThat(index.getOuterClass(ClassTreeLevel3), is(ClassTreeLevel2));
+                assertThat(index.getInnerClasses(ClassTreeLevel3), is(empty()));
         }
         
         private void decompile(ClassEntry classEntry) {
-                m_deobfuscator.getSourceTree(classEntry.getName());
+                deobfuscator.getSourceTree(classEntry.getName());
         }
 }
diff --git a/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java b/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java
index cb65cd07..01d4bab6 100644
--- a/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java
+++ b/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java
@@ -27,98 +27,99 @@ import cuchaz.enigma.mapping.ClassEntry;
 
 public class TestJarIndexConstructorReferences {
         
-        private JarIndex m_index;
+        private JarIndex index;
         
-        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");
+        private ClassEntry baseClass    = newClass("a");
+        private ClassEntry subClass     = newClass("d");
+        private ClassEntry subsubClass  = newClass("e");
+        private ClassEntry defaultClass = newClass("c");
+        private ClassEntry callerClass  = newClass("b");
         
         public TestJarIndexConstructorReferences()
         throws Exception {
                 File jarFile = new File("build/test-obf/constructors.jar");
-                m_index = new JarIndex();
-                m_index.indexJar(new JarFile(jarFile), false);
+                index = new JarIndex();
+                index.indexJar(new JarFile(jarFile), false);
         }
         
         @Test
         public void obfEntries() {
-                assertThat(m_index.getObfClassEntries(), containsInAnyOrder(newClass("cuchaz/enigma/inputs/Keep"), m_baseClass, m_subClass, m_subsubClass, m_defaultClass, m_callerClass));
+                assertThat(index.getObfClassEntries(), containsInAnyOrder(newClass("cuchaz/enigma/inputs/Keep"), baseClass,
+                                subClass, subsubClass, defaultClass, callerClass));
         }
         
         @Test
         @SuppressWarnings("unchecked")
         public void baseDefault() {
-                BehaviorEntry source = newConstructor(m_baseClass, "()V");
-                Collection<EntryReference<BehaviorEntry,BehaviorEntry>> references = m_index.getBehaviorReferences(source);
+                BehaviorEntry source = newConstructor(baseClass, "()V");
+                Collection<EntryReference<BehaviorEntry,BehaviorEntry>> references = index.getBehaviorReferences(source);
                 assertThat(references, containsInAnyOrder(
-                        newBehaviorReferenceByMethod(source, m_callerClass.getName(), "a", "()V"),
-                        newBehaviorReferenceByConstructor(source, m_subClass.getName(), "()V"),
-                        newBehaviorReferenceByConstructor(source, m_subClass.getName(), "(III)V")
+                        newBehaviorReferenceByMethod(source, callerClass.getName(), "a", "()V"),
+                        newBehaviorReferenceByConstructor(source, subClass.getName(), "()V"),
+                        newBehaviorReferenceByConstructor(source, subClass.getName(), "(III)V")
                 ));
         }
         
         @Test
         @SuppressWarnings("unchecked")
         public void baseInt() {
-                BehaviorEntry source = newConstructor(m_baseClass, "(I)V");
-                assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder(
-                        newBehaviorReferenceByMethod(source, m_callerClass.getName(), "b", "()V")
+                BehaviorEntry source = newConstructor(baseClass, "(I)V");
+                assertThat(index.getBehaviorReferences(source), containsInAnyOrder(
+                        newBehaviorReferenceByMethod(source, callerClass.getName(), "b", "()V")
                 ));
         }
         
         @Test
         @SuppressWarnings("unchecked")
         public void subDefault() {
-                BehaviorEntry source = newConstructor(m_subClass, "()V");
-                assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder(
-                        newBehaviorReferenceByMethod(source, m_callerClass.getName(), "c", "()V"),
-                        newBehaviorReferenceByConstructor(source, m_subClass.getName(), "(I)V")
+                BehaviorEntry source = newConstructor(subClass, "()V");
+                assertThat(index.getBehaviorReferences(source), containsInAnyOrder(
+                        newBehaviorReferenceByMethod(source, callerClass.getName(), "c", "()V"),
+                        newBehaviorReferenceByConstructor(source, subClass.getName(), "(I)V")
                 ));
         }
         
         @Test
         @SuppressWarnings("unchecked")
         public void subInt() {
-                BehaviorEntry source = newConstructor(m_subClass, "(I)V");
-                assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder(
-                        newBehaviorReferenceByMethod(source, m_callerClass.getName(), "d", "()V"),
-                        newBehaviorReferenceByConstructor(source, m_subClass.getName(), "(II)V"),
-                        newBehaviorReferenceByConstructor(source, m_subsubClass.getName(), "(I)V")
+                BehaviorEntry source = newConstructor(subClass, "(I)V");
+                assertThat(index.getBehaviorReferences(source), containsInAnyOrder(
+                        newBehaviorReferenceByMethod(source, callerClass.getName(), "d", "()V"),
+                        newBehaviorReferenceByConstructor(source, subClass.getName(), "(II)V"),
+                        newBehaviorReferenceByConstructor(source, subsubClass.getName(), "(I)V")
                 ));
         }
         
         @Test
         @SuppressWarnings("unchecked")
         public void subIntInt() {
-                BehaviorEntry source = newConstructor(m_subClass, "(II)V");
-                assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder(
-                        newBehaviorReferenceByMethod(source, m_callerClass.getName(), "e", "()V")
+                BehaviorEntry source = newConstructor(subClass, "(II)V");
+                assertThat(index.getBehaviorReferences(source), containsInAnyOrder(
+                        newBehaviorReferenceByMethod(source, callerClass.getName(), "e", "()V")
                 ));
         }
         
         @Test
         public void subIntIntInt() {
-                BehaviorEntry source = newConstructor(m_subClass, "(III)V");
-                assertThat(m_index.getBehaviorReferences(source), is(empty()));
+                BehaviorEntry source = newConstructor(subClass, "(III)V");
+                assertThat(index.getBehaviorReferences(source), is(empty()));
         }
         
         @Test
         @SuppressWarnings("unchecked")
         public void subsubInt() {
-                BehaviorEntry source = newConstructor(m_subsubClass, "(I)V");
-                assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder(
-                        newBehaviorReferenceByMethod(source, m_callerClass.getName(), "f", "()V")
+                BehaviorEntry source = newConstructor(subsubClass, "(I)V");
+                assertThat(index.getBehaviorReferences(source), containsInAnyOrder(
+                        newBehaviorReferenceByMethod(source, callerClass.getName(), "f", "()V")
                 ));
         }
         
         @Test
         @SuppressWarnings("unchecked")
         public void defaultConstructable() {
-                BehaviorEntry source = newConstructor(m_defaultClass, "()V");
-                assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder(
-                        newBehaviorReferenceByMethod(source, m_callerClass.getName(), "g", "()V")
+                BehaviorEntry source = newConstructor(defaultClass, "()V");
+                assertThat(index.getBehaviorReferences(source), containsInAnyOrder(
+                        newBehaviorReferenceByMethod(source, callerClass.getName(), "g", "()V")
                 ));
         }
 }
diff --git a/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java b/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java
index 28408f2a..4d9c8dc1 100644
--- a/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java
+++ b/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java
@@ -41,66 +41,60 @@ import cuchaz.enigma.mapping.MethodEntry;
 
 public class TestJarIndexInheritanceTree {
         
-        private JarIndex m_index;
+        private JarIndex index;
         
-        private ClassEntry m_objectClass = newClass("java/lang/Object");
-        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");
+        private ClassEntry objectClass    = newClass("java/lang/Object");
+        private ClassEntry baseClass      = newClass("a");
+        private ClassEntry subClassA      = newClass("b");
+        private ClassEntry subClassAA     = newClass("d");
+        private ClassEntry subClassB      = newClass("c");
+        private FieldEntry nameField      = newField(baseClass, "a", "Ljava/lang/String;");
+        private FieldEntry numThingsField = newField(subClassB, "a", "I");
         
         public TestJarIndexInheritanceTree()
         throws Exception {
-                m_index = new JarIndex();
-                m_index.indexJar(new JarFile("build/test-obf/inheritanceTree.jar"), false);
+                index = new JarIndex();
+                index.indexJar(new JarFile("build/test-obf/inheritanceTree.jar"), false);
         }
         
         @Test
         public void obfEntries() {
-                assertThat(m_index.getObfClassEntries(), containsInAnyOrder(
-                        newClass("cuchaz/enigma/inputs/Keep"),
-                        m_baseClass,
-                        m_subClassA,
-                        m_subClassAA,
-                        m_subClassB
+                assertThat(index.getObfClassEntries(), containsInAnyOrder(
+                        newClass("cuchaz/enigma/inputs/Keep"), baseClass, subClassA, subClassAA, subClassB
                 ));
         }
         
         @Test
         public void translationIndex() {
                 
-                TranslationIndex index = m_index.getTranslationIndex();
+                TranslationIndex index = this.index.getTranslationIndex();
                 
                 // base class
-                assertThat(index.getSuperclass(m_baseClass), is(m_objectClass));
-                assertThat(index.getAncestry(m_baseClass), contains(m_objectClass));
-                assertThat(index.getSubclass(m_baseClass), containsInAnyOrder(
-                        m_subClassA,
-                        m_subClassB
+                assertThat(index.getSuperclass(baseClass), is(objectClass));
+                assertThat(index.getAncestry(baseClass), contains(objectClass));
+                assertThat(index.getSubclass(baseClass), containsInAnyOrder(subClassA, subClassB
                 ));
                 
                 // subclass a
-                assertThat(index.getSuperclass(m_subClassA), is(m_baseClass));
-                assertThat(index.getAncestry(m_subClassA), contains(m_baseClass, m_objectClass));
-                assertThat(index.getSubclass(m_subClassA), contains(m_subClassAA));
+                assertThat(index.getSuperclass(subClassA), is(baseClass));
+                assertThat(index.getAncestry(subClassA), contains(baseClass, objectClass));
+                assertThat(index.getSubclass(subClassA), contains(subClassAA));
                 
                 // subclass aa
-                assertThat(index.getSuperclass(m_subClassAA), is(m_subClassA));
-                assertThat(index.getAncestry(m_subClassAA), contains(m_subClassA, m_baseClass, m_objectClass));
-                assertThat(index.getSubclass(m_subClassAA), is(empty()));
+                assertThat(index.getSuperclass(subClassAA), is(subClassA));
+                assertThat(index.getAncestry(subClassAA), contains(subClassA, baseClass, objectClass));
+                assertThat(index.getSubclass(subClassAA), is(empty()));
                 
                 // subclass b
-                assertThat(index.getSuperclass(m_subClassB), is(m_baseClass));
-                assertThat(index.getAncestry(m_subClassB), contains(m_baseClass, m_objectClass));
-                assertThat(index.getSubclass(m_subClassB), is(empty()));
+                assertThat(index.getSuperclass(subClassB), is(baseClass));
+                assertThat(index.getAncestry(subClassB), contains(baseClass, objectClass));
+                assertThat(index.getSubclass(subClassB), is(empty()));
         }
         
         @Test
         public void access() {
-                assertThat(m_index.getAccess(m_nameField), is(Access.Private));
-                assertThat(m_index.getAccess(m_numThingsField), is(Access.Private));
+                assertThat(index.getAccess(nameField), is(Access.PRIVATE));
+                assertThat(index.getAccess(numThingsField), is(Access.PRIVATE));
         }
         
         @Test
@@ -109,40 +103,40 @@ public class TestJarIndexInheritanceTree {
                 Set<MethodEntry> entries;
                 
                 // getName()
-                entries = m_index.getRelatedMethodImplementations(newMethod(m_baseClass, "a", "()Ljava/lang/String;"));
+                entries = index.getRelatedMethodImplementations(newMethod(baseClass, "a", "()Ljava/lang/String;"));
                 assertThat(entries, containsInAnyOrder(
-                        newMethod(m_baseClass, "a", "()Ljava/lang/String;"),
-                        newMethod(m_subClassAA, "a", "()Ljava/lang/String;")
+                        newMethod(baseClass, "a", "()Ljava/lang/String;"),
+                        newMethod(subClassAA, "a", "()Ljava/lang/String;")
                 ));
-                entries = m_index.getRelatedMethodImplementations(newMethod(m_subClassAA, "a", "()Ljava/lang/String;"));
+                entries = index.getRelatedMethodImplementations(newMethod(subClassAA, "a", "()Ljava/lang/String;"));
                 assertThat(entries, containsInAnyOrder(
-                        newMethod(m_baseClass, "a", "()Ljava/lang/String;"),
-                        newMethod(m_subClassAA, "a", "()Ljava/lang/String;")
+                        newMethod(baseClass, "a", "()Ljava/lang/String;"),
+                        newMethod(subClassAA, "a", "()Ljava/lang/String;")
                 ));
                 
                 // doBaseThings()
-                entries = m_index.getRelatedMethodImplementations(newMethod(m_baseClass, "a", "()V"));
+                entries = index.getRelatedMethodImplementations(newMethod(baseClass, "a", "()V"));
                 assertThat(entries, containsInAnyOrder(
-                        newMethod(m_baseClass, "a", "()V"),
-                        newMethod(m_subClassAA, "a", "()V"),
-                        newMethod(m_subClassB, "a", "()V")
+                        newMethod(baseClass, "a", "()V"),
+                        newMethod(subClassAA, "a", "()V"),
+                        newMethod(subClassB, "a", "()V")
                 ));
-                entries = m_index.getRelatedMethodImplementations(newMethod(m_subClassAA, "a", "()V"));
+                entries = index.getRelatedMethodImplementations(newMethod(subClassAA, "a", "()V"));
                 assertThat(entries, containsInAnyOrder(
-                        newMethod(m_baseClass, "a", "()V"),
-                        newMethod(m_subClassAA, "a", "()V"),
-                        newMethod(m_subClassB, "a", "()V")
+                        newMethod(baseClass, "a", "()V"),
+                        newMethod(subClassAA, "a", "()V"),
+                        newMethod(subClassB, "a", "()V")
                 ));
-                entries = m_index.getRelatedMethodImplementations(newMethod(m_subClassB, "a", "()V"));
+                entries = index.getRelatedMethodImplementations(newMethod(subClassB, "a", "()V"));
                 assertThat(entries, containsInAnyOrder(
-                        newMethod(m_baseClass, "a", "()V"),
-                        newMethod(m_subClassAA, "a", "()V"),
-                        newMethod(m_subClassB, "a", "()V")
+                        newMethod(baseClass, "a", "()V"),
+                        newMethod(subClassAA, "a", "()V"),
+                        newMethod(subClassB, "a", "()V")
                 ));
                 
                 // doBThings
-                entries = m_index.getRelatedMethodImplementations(newMethod(m_subClassB, "b", "()V"));
-                assertThat(entries, containsInAnyOrder(newMethod(m_subClassB, "b", "()V")));
+                entries = index.getRelatedMethodImplementations(newMethod(subClassB, "b", "()V"));
+                assertThat(entries, containsInAnyOrder(newMethod(subClassB, "b", "()V")));
         }
         
         @Test
@@ -151,17 +145,17 @@ public class TestJarIndexInheritanceTree {
                 Collection<EntryReference<FieldEntry,BehaviorEntry>> references;
                 
                 // name
-                references = m_index.getFieldReferences(m_nameField);
+                references = index.getFieldReferences(nameField);
                 assertThat(references, containsInAnyOrder(
-                        newFieldReferenceByConstructor(m_nameField, m_baseClass.getName(), "(Ljava/lang/String;)V"),
-                        newFieldReferenceByMethod(m_nameField, m_baseClass.getName(), "a", "()Ljava/lang/String;")
+                        newFieldReferenceByConstructor(nameField, baseClass.getName(), "(Ljava/lang/String;)V"),
+                        newFieldReferenceByMethod(nameField, baseClass.getName(), "a", "()Ljava/lang/String;")
                 ));
                 
                 // numThings
-                references = m_index.getFieldReferences(m_numThingsField);
+                references = index.getFieldReferences(numThingsField);
                 assertThat(references, containsInAnyOrder(
-                        newFieldReferenceByConstructor(m_numThingsField, m_subClassB.getName(), "()V"),
-                        newFieldReferenceByMethod(m_numThingsField, m_subClassB.getName(), "b", "()V")
+                        newFieldReferenceByConstructor(numThingsField, subClassB.getName(), "()V"),
+                        newFieldReferenceByMethod(numThingsField, subClassB.getName(), "b", "()V")
                 ));
         }
         
@@ -173,33 +167,33 @@ public class TestJarIndexInheritanceTree {
                 Collection<EntryReference<BehaviorEntry,BehaviorEntry>> references;
                 
                 // baseClass constructor
-                source = newConstructor(m_baseClass, "(Ljava/lang/String;)V");
-                references = m_index.getBehaviorReferences(source);
+                source = newConstructor(baseClass, "(Ljava/lang/String;)V");
+                references = index.getBehaviorReferences(source);
                 assertThat(references, containsInAnyOrder(
-                        newBehaviorReferenceByConstructor(source, m_subClassA.getName(), "(Ljava/lang/String;)V"),
-                        newBehaviorReferenceByConstructor(source, m_subClassB.getName(), "()V")
+                        newBehaviorReferenceByConstructor(source, subClassA.getName(), "(Ljava/lang/String;)V"),
+                        newBehaviorReferenceByConstructor(source, subClassB.getName(), "()V")
                 ));
                 
                 // subClassA constructor
-                source = newConstructor(m_subClassA, "(Ljava/lang/String;)V");
-                references = m_index.getBehaviorReferences(source);
+                source = newConstructor(subClassA, "(Ljava/lang/String;)V");
+                references = index.getBehaviorReferences(source);
                 assertThat(references, containsInAnyOrder(
-                        newBehaviorReferenceByConstructor(source, m_subClassAA.getName(), "()V")
+                        newBehaviorReferenceByConstructor(source, subClassAA.getName(), "()V")
                 ));
                 
                 // baseClass.getName()
-                source = newMethod(m_baseClass, "a", "()Ljava/lang/String;");
-                references = m_index.getBehaviorReferences(source);
+                source = newMethod(baseClass, "a", "()Ljava/lang/String;");
+                references = index.getBehaviorReferences(source);
                 assertThat(references, containsInAnyOrder(
-                        newBehaviorReferenceByMethod(source, m_subClassAA.getName(), "a", "()Ljava/lang/String;"),
-                        newBehaviorReferenceByMethod(source, m_subClassB.getName(), "a", "()V")
+                        newBehaviorReferenceByMethod(source, subClassAA.getName(), "a", "()Ljava/lang/String;"),
+                        newBehaviorReferenceByMethod(source, subClassB.getName(), "a", "()V")
                 ));
                 
                 // subclassAA.getName()
-                source = newMethod(m_subClassAA, "a", "()Ljava/lang/String;");
-                references = m_index.getBehaviorReferences(source);
+                source = newMethod(subClassAA, "a", "()Ljava/lang/String;");
+                references = index.getBehaviorReferences(source);
                 assertThat(references, containsInAnyOrder(
-                        newBehaviorReferenceByMethod(source, m_subClassAA.getName(), "a", "()V")
+                        newBehaviorReferenceByMethod(source, subClassAA.getName(), "a", "()V")
                 ));
         }
         
@@ -207,33 +201,33 @@ public class TestJarIndexInheritanceTree {
         public void containsEntries() {
                 
                 // classes
-                assertThat(m_index.containsObfClass(m_baseClass), is(true));
-                assertThat(m_index.containsObfClass(m_subClassA), is(true));
-                assertThat(m_index.containsObfClass(m_subClassAA), is(true));
-                assertThat(m_index.containsObfClass(m_subClassB), is(true));
+                assertThat(index.containsObfClass(baseClass), is(true));
+                assertThat(index.containsObfClass(subClassA), is(true));
+                assertThat(index.containsObfClass(subClassAA), is(true));
+                assertThat(index.containsObfClass(subClassB), is(true));
                 
                 // fields
-                assertThat(m_index.containsObfField(m_nameField), is(true));
-                assertThat(m_index.containsObfField(m_numThingsField), is(true));
+                assertThat(index.containsObfField(nameField), is(true));
+                assertThat(index.containsObfField(numThingsField), is(true));
                 
                 // methods
                 // getName()
-                assertThat(m_index.containsObfBehavior(newMethod(m_baseClass, "a", "()Ljava/lang/String;")), is(true));
-                assertThat(m_index.containsObfBehavior(newMethod(m_subClassA, "a", "()Ljava/lang/String;")), is(false));
-                assertThat(m_index.containsObfBehavior(newMethod(m_subClassAA, "a", "()Ljava/lang/String;")), is(true));
-                assertThat(m_index.containsObfBehavior(newMethod(m_subClassB, "a", "()Ljava/lang/String;")), is(false));
+                assertThat(index.containsObfBehavior(newMethod(baseClass, "a", "()Ljava/lang/String;")), is(true));
+                assertThat(index.containsObfBehavior(newMethod(subClassA, "a", "()Ljava/lang/String;")), is(false));
+                assertThat(index.containsObfBehavior(newMethod(subClassAA, "a", "()Ljava/lang/String;")), is(true));
+                assertThat(index.containsObfBehavior(newMethod(subClassB, "a", "()Ljava/lang/String;")), is(false));
                 
                 // doBaseThings()
-                assertThat(m_index.containsObfBehavior(newMethod(m_baseClass, "a", "()V")), is(true));
-                assertThat(m_index.containsObfBehavior(newMethod(m_subClassA, "a", "()V")), is(false));
-                assertThat(m_index.containsObfBehavior(newMethod(m_subClassAA, "a", "()V")), is(true));
-                assertThat(m_index.containsObfBehavior(newMethod(m_subClassB, "a", "()V")), is(true));
+                assertThat(index.containsObfBehavior(newMethod(baseClass, "a", "()V")), is(true));
+                assertThat(index.containsObfBehavior(newMethod(subClassA, "a", "()V")), is(false));
+                assertThat(index.containsObfBehavior(newMethod(subClassAA, "a", "()V")), is(true));
+                assertThat(index.containsObfBehavior(newMethod(subClassB, "a", "()V")), is(true));
                 
                 // doBThings()
-                assertThat(m_index.containsObfBehavior(newMethod(m_baseClass, "b", "()V")), is(false));
-                assertThat(m_index.containsObfBehavior(newMethod(m_subClassA, "b", "()V")), is(false));
-                assertThat(m_index.containsObfBehavior(newMethod(m_subClassAA, "b", "()V")), is(false));
-                assertThat(m_index.containsObfBehavior(newMethod(m_subClassB, "b", "()V")), is(true));
+                assertThat(index.containsObfBehavior(newMethod(baseClass, "b", "()V")), is(false));
+                assertThat(index.containsObfBehavior(newMethod(subClassA, "b", "()V")), is(false));
+                assertThat(index.containsObfBehavior(newMethod(subClassAA, "b", "()V")), is(false));
+                assertThat(index.containsObfBehavior(newMethod(subClassB, "b", "()V")), is(true));
                 
         }
 }
diff --git a/src/test/java/cuchaz/enigma/TestJarIndexLoneClass.java b/src/test/java/cuchaz/enigma/TestJarIndexLoneClass.java
index 65af6d83..8efa57c6 100644
--- a/src/test/java/cuchaz/enigma/TestJarIndexLoneClass.java
+++ b/src/test/java/cuchaz/enigma/TestJarIndexLoneClass.java
@@ -34,17 +34,17 @@ import cuchaz.enigma.mapping.Translator;
 
 public class TestJarIndexLoneClass {
         
-        private JarIndex m_index;
+        private JarIndex index;
         
         public TestJarIndexLoneClass()
         throws Exception {
-                m_index = new JarIndex();
-                m_index.indexJar(new JarFile("build/test-obf/loneClass.jar"), false);
+                index = new JarIndex();
+                index.indexJar(new JarFile("build/test-obf/loneClass.jar"), false);
         }
         
         @Test
         public void obfEntries() {
-                assertThat(m_index.getObfClassEntries(), containsInAnyOrder(
+                assertThat(index.getObfClassEntries(), containsInAnyOrder(
                         newClass("cuchaz/enigma/inputs/Keep"),
                         newClass("a")
                 ));
@@ -52,25 +52,25 @@ public class TestJarIndexLoneClass {
         
         @Test
         public void translationIndex() {
-                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("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("a")), is(empty()));
-                assertThat(m_index.getTranslationIndex().getSubclass(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(empty()));
+                assertThat(index.getTranslationIndex().getSuperclass(new ClassEntry("a")), is(new ClassEntry("java/lang/Object")));
+                assertThat(index.getTranslationIndex().getSuperclass(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(new ClassEntry("java/lang/Object")));
+                assertThat(index.getTranslationIndex().getAncestry(new ClassEntry("a")), contains(new ClassEntry("java/lang/Object")));
+                assertThat(index.getTranslationIndex().getAncestry(new ClassEntry("cuchaz/enigma/inputs/Keep")), contains(new ClassEntry("java/lang/Object")));
+                assertThat(index.getTranslationIndex().getSubclass(new ClassEntry("a")), is(empty()));
+                assertThat(index.getTranslationIndex().getSubclass(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(empty()));
         }
         
         @Test
         public void access() {
-                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()));
+                assertThat(index.getAccess(newField("a", "a", "Ljava/lang/String;")), is(Access.PRIVATE));
+                assertThat(index.getAccess(newMethod("a", "a", "()Ljava/lang/String;")), is(Access.PUBLIC));
+                assertThat(index.getAccess(newField("a", "b", "Ljava/lang/String;")), is(nullValue()));
+                assertThat(index.getAccess(newField("a", "a", "LFoo;")), is(nullValue()));
         }
         
         @Test
         public void classInheritance() {
-                ClassInheritanceTreeNode node = m_index.getClassInheritance(new Translator(), newClass("a"));
+                ClassInheritanceTreeNode node = index.getClassInheritance(new Translator(), newClass("a"));
                 assertThat(node, is(not(nullValue())));
                 assertThat(node.getObfClassName(), is("a"));
                 assertThat(node.getChildCount(), is(0));
@@ -79,7 +79,7 @@ public class TestJarIndexLoneClass {
         @Test
         public void methodInheritance() {
                 MethodEntry source = newMethod("a", "a", "()Ljava/lang/String;");
-                MethodInheritanceTreeNode node = m_index.getMethodInheritance(new Translator(), source);
+                MethodInheritanceTreeNode node = index.getMethodInheritance(new Translator(), source);
                 assertThat(node, is(not(nullValue())));
                 assertThat(node.getMethodEntry(), is(source));
                 assertThat(node.getChildCount(), is(0));
@@ -87,19 +87,19 @@ public class TestJarIndexLoneClass {
         
         @Test
         public void classImplementations() {
-                ClassImplementationsTreeNode node = m_index.getClassImplementations(new Translator(), newClass("a"));
+                ClassImplementationsTreeNode node = index.getClassImplementations(new Translator(), newClass("a"));
                 assertThat(node, is(nullValue()));
         }
         
         @Test
         public void methodImplementations() {
                 MethodEntry source = newMethod("a", "a", "()Ljava/lang/String;");
-                assertThat(m_index.getMethodImplementations(new Translator(), source), is(empty()));
+                assertThat(index.getMethodImplementations(new Translator(), source), is(empty()));
         }
         
         @Test
         public void relatedMethodImplementations() {
-                Set<MethodEntry> entries = m_index.getRelatedMethodImplementations(newMethod("a", "a", "()Ljava/lang/String;"));
+                Set<MethodEntry> entries = index.getRelatedMethodImplementations(newMethod("a", "a", "()Ljava/lang/String;"));
                 assertThat(entries, containsInAnyOrder(
                         newMethod("a", "a", "()Ljava/lang/String;")
                 ));
@@ -109,7 +109,7 @@ public class TestJarIndexLoneClass {
         @SuppressWarnings("unchecked")
         public void fieldReferences() {
                 FieldEntry source = newField("a", "a", "Ljava/lang/String;");
-                Collection<EntryReference<FieldEntry,BehaviorEntry>> references = m_index.getFieldReferences(source);
+                Collection<EntryReference<FieldEntry,BehaviorEntry>> references = index.getFieldReferences(source);
                 assertThat(references, containsInAnyOrder(
                         newFieldReferenceByConstructor(source, "a", "(Ljava/lang/String;)V"),
                         newFieldReferenceByMethod(source, "a", "a", "()Ljava/lang/String;")
@@ -118,47 +118,47 @@ public class TestJarIndexLoneClass {
         
         @Test
         public void behaviorReferences() {
-                assertThat(m_index.getBehaviorReferences(newMethod("a", "a", "()Ljava/lang/String;")), is(empty()));
+                assertThat(index.getBehaviorReferences(newMethod("a", "a", "()Ljava/lang/String;")), is(empty()));
         }
         
         @Test
         public void innerClasses() {
-                assertThat(m_index.getInnerClasses(newClass("a")), is(empty()));
+                assertThat(index.getInnerClasses(newClass("a")), is(empty()));
         }
         
         @Test
         public void outerClass() {
-                assertThat(m_index.getOuterClass(newClass("a")), is(nullValue()));
+                assertThat(index.getOuterClass(newClass("a")), is(nullValue()));
         }
         
         @Test
         public void isAnonymousClass() {
-                assertThat(m_index.isAnonymousClass(newClass("a")), is(false));
+                assertThat(index.isAnonymousClass(newClass("a")), is(false));
         }
         
         @Test
         public void interfaces() {
-                assertThat(m_index.getInterfaces("a"), is(empty()));
+                assertThat(index.getInterfaces("a"), is(empty()));
         }
         
         @Test
         public void implementingClasses() {
-                assertThat(m_index.getImplementingClasses("a"), is(empty()));
+                assertThat(index.getImplementingClasses("a"), is(empty()));
         }
         
         @Test
         public void isInterface() {
-                assertThat(m_index.isInterface("a"), is(false));
+                assertThat(index.isInterface("a"), is(false));
         }
         
         @Test
         public void testContains() {
-                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));
+                assertThat(index.containsObfClass(newClass("a")), is(true));
+                assertThat(index.containsObfClass(newClass("b")), is(false));
+                assertThat(index.containsObfField(newField("a", "a", "Ljava/lang/String;")), is(true));
+                assertThat(index.containsObfField(newField("a", "b", "Ljava/lang/String;")), is(false));
+                assertThat(index.containsObfField(newField("a", "a", "LFoo;")), is(false));
+                assertThat(index.containsObfBehavior(newMethod("a", "a", "()Ljava/lang/String;")), is(true));
+                assertThat(index.containsObfBehavior(newMethod("a", "b", "()Ljava/lang/String;")), is(false));
         }
 }
diff --git a/src/test/java/cuchaz/enigma/TestTranslator.java b/src/test/java/cuchaz/enigma/TestTranslator.java
index c8af307b..2c54603b 100644
--- a/src/test/java/cuchaz/enigma/TestTranslator.java
+++ b/src/test/java/cuchaz/enigma/TestTranslator.java
@@ -22,21 +22,21 @@ import cuchaz.enigma.mapping.Translator;
 
 public class TestTranslator {
 
-        private static Deobfuscator m_deobfuscator;
-        private static Mappings m_mappings;
-        private static Translator m_deobfTranslator;
-        private static Translator m_obfTranslator;
+        private static Deobfuscator deobfuscator;
+        private static Mappings     mappings;
+        private static Translator   deobfTranslator;
+        private static Translator   obfTranslator;
 
         @BeforeClass
         public static void beforeClass()
         throws Exception {
                 //TODO FIx
-                //m_deobfuscator = new Deobfuscator(new JarFile("build/test-obf/translation.jar"));
+                //deobfuscator = new Deobfuscator(new JarFile("build/test-obf/translation.jar"));
                 //try (InputStream in = TestTranslator.class.getResourceAsStream("/cuchaz/enigma/resources/translation.mappings")) {
-                //      m_mappings = new MappingsJsonReader().read(new InputStreamReader(in));
-                //      m_deobfuscator.setMappings(m_mappings);
-                //      m_deobfTranslator = m_deobfuscator.getTranslator(TranslationDirection.Deobfuscating);
-                //      m_obfTranslator = m_deobfuscator.getTranslator(TranslationDirection.Obfuscating);
+                //      mappings = new MappingsJsonReader().read(new InputStreamReader(in));
+                //      deobfuscator.setMappings(mappings);
+                //      deobfTranslator = deobfuscator.getTranslator(TranslationDirection.Deobfuscating);
+                //      obfTranslator = deobfuscator.getTranslator(TranslationDirection.Obfuscating);
                 //}
         }
 
@@ -147,15 +147,15 @@ public class TestTranslator {
         }
 
         private void assertMapping(Entry obf, Entry deobf) {
-                //assertThat(m_deobfTranslator.translateEntry(obf), is(deobf));
-                //assertThat(m_obfTranslator.translateEntry(deobf), is(obf));
+                //assertThat(deobfTranslator.translateEntry(obf), is(deobf));
+                //assertThat(obfTranslator.translateEntry(deobf), is(obf));
 
-                //String deobfName = m_deobfTranslator.translate(obf);
+                //String deobfName = deobfTranslator.translate(obf);
                 //if (deobfName != null) {
                 //      assertThat(deobfName, is(deobf.getName()));
                 //}
 
-                //String obfName = m_obfTranslator.translate(deobf);
+                //String obfName = obfTranslator.translate(deobf);
                 //if (obfName != null) {
                 //      assertThat(obfName, is(obf.getName()));
                 //}
diff --git a/src/test/java/cuchaz/enigma/TokenChecker.java b/src/test/java/cuchaz/enigma/TokenChecker.java
index 7afb4cfe..07463206 100644
--- a/src/test/java/cuchaz/enigma/TokenChecker.java
+++ b/src/test/java/cuchaz/enigma/TokenChecker.java
@@ -25,20 +25,20 @@ import cuchaz.enigma.mapping.Entry;
 
 public class TokenChecker {
         
-        private Deobfuscator m_deobfuscator;
+        private Deobfuscator deobfuscator;
         
         protected TokenChecker(JarFile jarFile)
         throws IOException {
-                m_deobfuscator = new Deobfuscator(jarFile);
+                deobfuscator = new Deobfuscator(jarFile);
         }
         
         protected String getDeclarationToken(Entry entry) {
                 // decompile the class
-                CompilationUnit tree = m_deobfuscator.getSourceTree(entry.getClassName());
+                CompilationUnit tree = deobfuscator.getSourceTree(entry.getClassName());
                 // DEBUG
                 // tree.acceptVisitor( new TreeDumpVisitor( new File( "tree." + entry.getClassName().replace( '/', '.' ) + ".txt" ) ), null );
-                String source = m_deobfuscator.getSource(tree);
-                SourceIndex index = m_deobfuscator.getSourceIndex(tree, source);
+                String source = deobfuscator.getSource(tree);
+                SourceIndex index = deobfuscator.getSourceIndex(tree, source);
                 
                 // get the token value
                 Token token = index.getDeclarationToken(entry);
@@ -51,9 +51,9 @@ public class TokenChecker {
         @SuppressWarnings("unchecked")
         protected Collection<String> getReferenceTokens(EntryReference<? extends Entry,? extends Entry> reference) {
                 // decompile the class
-                CompilationUnit tree = m_deobfuscator.getSourceTree(reference.context.getClassName());
-                String source = m_deobfuscator.getSource(tree);
-                SourceIndex index = m_deobfuscator.getSourceIndex(tree, source);
+                CompilationUnit tree = deobfuscator.getSourceTree(reference.context.getClassName());
+                String source = deobfuscator.getSource(tree);
+                SourceIndex index = deobfuscator.getSourceIndex(tree, source);
                 
                 // get the token values
                 List<String> values = Lists.newArrayList();
diff --git a/src/test/java/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java b/src/test/java/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java
index d676ba24..1b1f3694 100644
--- a/src/test/java/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java
+++ b/src/test/java/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java
@@ -14,16 +14,16 @@ package cuchaz.enigma.inputs.inheritanceTree;
 public abstract class BaseClass {
         
         // a
-        private String m_name;
+        private String name;
         
         // <init>(Ljava/lang/String;)V
         protected BaseClass(String name) {
-                m_name = name;
+                this.name = name;
         }
         
         // a()Ljava/lang/String;
         public String getName() {
-                return m_name;
+                return name;
         }
         
         // a()V
diff --git a/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java b/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java
index 751fdd16..6d3b0d0f 100644
--- a/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java
+++ b/src/test/java/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java
@@ -14,7 +14,7 @@ package cuchaz.enigma.inputs.inheritanceTree;
 public class SubclassB extends BaseClass {
         
         // a
-        private int m_numThings;
+        private int numThings;
         
         // <init>()V
         protected SubclassB() {
@@ -22,7 +22,7 @@ public class SubclassB extends BaseClass {
                 super("B");
                 
                 // access to a
-                m_numThings = 4;
+                numThings = 4;
         }
         
         @Override
@@ -35,6 +35,6 @@ public class SubclassB extends BaseClass {
         // b()V
         public void doBThings() {
                 // access to a
-                System.out.println("" + m_numThings + " B things!");
+                System.out.println("" + numThings + " B things!");
         }
 }
diff --git a/src/test/java/cuchaz/enigma/inputs/loneClass/LoneClass.java b/src/test/java/cuchaz/enigma/inputs/loneClass/LoneClass.java
index bf264fa5..d28ae97c 100644
--- a/src/test/java/cuchaz/enigma/inputs/loneClass/LoneClass.java
+++ b/src/test/java/cuchaz/enigma/inputs/loneClass/LoneClass.java
@@ -12,13 +12,13 @@ package cuchaz.enigma.inputs.loneClass;
 
 public class LoneClass {
         
-        private String m_name;
+        private String name;
         
         public LoneClass(String name) {
-                m_name = name;
+                this.name = name;
         }
         
         public String getName() {
-                return m_name;
+                return name;
         }
 }
diff --git a/src/test/java/cuchaz/enigma/inputs/translation/F_ObjectMethods.java b/src/test/java/cuchaz/enigma/inputs/translation/F_ObjectMethods.java
index 32c246cb..845d62b0 100644
--- a/src/test/java/cuchaz/enigma/inputs/translation/F_ObjectMethods.java
+++ b/src/test/java/cuchaz/enigma/inputs/translation/F_ObjectMethods.java
@@ -10,6 +10,7 @@
  ******************************************************************************/
 package cuchaz.enigma.inputs.translation;
 
+@SuppressWarnings("FinalizeCalledExplicitly")
 public class F_ObjectMethods {
         
         public void callEmAll()