From b4aaff683d78ab92b83f3a7257c33b8e27d1affa Mon Sep 17 00:00:00 2001
From: Thog
Date: Tue, 7 Mar 2017 21:24:39 +0100
Subject: Drop unix case style and implement hashCode when equals is overrided

Also update Guava to version 21
---
 src/test/java/cuchaz/enigma/TestInnerClasses.java | 66 +++++++++++------------
 1 file changed, 33 insertions(+), 33 deletions(-)

(limited to 'src/test/java/cuchaz/enigma/TestInnerClasses.java')

diff --git a/src/test/java/cuchaz/enigma/TestInnerClasses.java b/src/test/java/cuchaz/enigma/TestInnerClasses.java
index 70765e3..64a695a 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());
 	}
 }
-- 
cgit v1.2.3