1 files changed, 34 insertions, 34 deletions

diff --git a/src/test/java/cuchaz/enigma/TestJarIndexLoneClass.java b/src/test/java/cuchaz/enigma/TestJarIndexLoneClass.java
index 65af6d8..8efa57c 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));
         }
 }