From a68dc42b6a835bd513e9d617c9892e85f321ddb6 Mon Sep 17 00:00:00 2001 From: jeff Date: Mon, 8 Sep 2014 00:23:46 -0400 Subject: added some tests for a small inheritance hierarchy --- .../cuchaz/enigma/TestJarIndexInheritanceTree.java | 255 +++++++++++++++++++++ 1 file changed, 255 insertions(+) create mode 100644 test/cuchaz/enigma/TestJarIndexInheritanceTree.java (limited to 'test/cuchaz/enigma/TestJarIndexInheritanceTree.java') diff --git a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java new file mode 100644 index 0000000..5ded5df --- /dev/null +++ b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java @@ -0,0 +1,255 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Public License v3.0 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/gpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ +package cuchaz.enigma; + +import static cuchaz.enigma.EntryFactory.newBehaviorReferenceByConstructor; +import static cuchaz.enigma.EntryFactory.newBehaviorReferenceByMethod; +import static cuchaz.enigma.EntryFactory.newClass; +import static cuchaz.enigma.EntryFactory.newFieldReferenceByConstructor; +import static cuchaz.enigma.EntryFactory.newFieldReferenceByMethod; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.contains; +import static org.hamcrest.Matchers.containsInAnyOrder; +import static org.hamcrest.Matchers.empty; +import static org.hamcrest.Matchers.is; +import static org.hamcrest.Matchers.nullValue; + +import java.util.Collection; +import java.util.Set; +import java.util.jar.JarFile; + +import org.junit.Test; + +import cuchaz.enigma.analysis.Access; +import cuchaz.enigma.analysis.EntryReference; +import cuchaz.enigma.analysis.JarIndex; +import cuchaz.enigma.analysis.TranslationIndex; +import cuchaz.enigma.mapping.BehaviorEntry; +import cuchaz.enigma.mapping.ClassEntry; +import cuchaz.enigma.mapping.ConstructorEntry; +import cuchaz.enigma.mapping.FieldEntry; +import cuchaz.enigma.mapping.MethodEntry; + +public class TestJarIndexInheritanceTree +{ + private JarIndex m_index; + + private ClassEntry m_baseClass = new ClassEntry( "none/a" ); + private ClassEntry m_subClassA = new ClassEntry( "none/b" ); + private ClassEntry m_subClassAA = new ClassEntry( "none/d" ); + private ClassEntry m_subClassB = new ClassEntry( "none/c" ); + private FieldEntry m_nameField = new FieldEntry( m_baseClass, "a" ); + private FieldEntry m_numThingsField = new FieldEntry( m_subClassB, "a" ); + + public TestJarIndexInheritanceTree( ) + throws Exception + { + m_index = new JarIndex(); + m_index.indexJar( new JarFile( "build/libs/testInheritanceTree.obf.jar" ), false ); + } + + @Test + public void obfEntries( ) + { + assertThat( m_index.getObfClassEntries(), containsInAnyOrder( + newClass( "cuchaz/enigma/inputs/Keep" ), + m_baseClass, + m_subClassA, + m_subClassAA, + m_subClassB + ) ); + } + + @Test + public void translationIndex( ) + { + TranslationIndex index = m_index.getTranslationIndex(); + + // base class + assertThat( index.getSuperclassName( m_baseClass.getName() ), is( nullValue() ) ); + assertThat( index.getAncestry( m_baseClass.getName() ), is( empty() ) ); + assertThat( index.getSubclassNames( m_baseClass.getName() ), containsInAnyOrder( + m_subClassA.getName(), + m_subClassB.getName() + ) ); + + // subclass a + assertThat( index.getSuperclassName( m_subClassA.getName() ), is( m_baseClass.getName() ) ); + assertThat( index.getAncestry( m_subClassA.getName() ), contains( m_baseClass.getName() ) ); + assertThat( index.getSubclassNames( m_subClassA.getName() ), contains( m_subClassAA.getName() ) ); + + // subclass aa + assertThat( index.getSuperclassName( m_subClassAA.getName() ), is( m_subClassA.getName() ) ); + assertThat( index.getAncestry( m_subClassAA.getName() ), contains( + m_subClassA.getName(), + m_baseClass.getName() + ) ); + assertThat( index.getSubclassNames( m_subClassAA.getName() ), is( empty() ) ); + + // subclass b + assertThat( index.getSuperclassName( m_subClassB.getName() ), is( m_baseClass.getName() ) ); + assertThat( index.getAncestry( m_subClassB.getName() ), contains( m_baseClass.getName() ) ); + assertThat( index.getSubclassNames( m_subClassB.getName() ), is( empty() ) ); + } + + @Test + public void access( ) + { + assertThat( m_index.getAccess( m_nameField ), is( Access.Private ) ); + assertThat( m_index.getAccess( m_numThingsField ), is( Access.Private ) ); + } + + @Test + public void isImplemented( ) + { + // getName() + assertThat( m_index.isMethodImplemented( new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ) ), is( true ) ); + assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassA, "a", "()Ljava/lang/String;" ) ), is( false ) ); + assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ) ), is( true ) ); + assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassB, "a", "()Ljava/lang/String;" ) ), is( false ) ); + + // doBaseThings() + assertThat( m_index.isMethodImplemented( new MethodEntry( m_baseClass, "a", "()V" ) ), is( true ) ); + assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassA, "a", "()V" ) ), is( false ) ); + assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassAA, "a", "()V" ) ), is( true ) ); + assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassB, "a", "()V" ) ), is( true ) ); + + // doBThings() + assertThat( m_index.isMethodImplemented( new MethodEntry( m_baseClass, "b", "()V" ) ), is( false ) ); + assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassA, "b", "()V" ) ), is( false ) ); + assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassAA, "b", "()V" ) ), is( false ) ); + assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassB, "b", "()V" ) ), is( true ) ); + } + + @Test + public void relatedMethodImplementations( ) + { + Set entries; + + // getName() + entries = m_index.getRelatedMethodImplementations( new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ) ); + assertThat( entries, containsInAnyOrder( + new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ), + new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ) + ) ); + entries = m_index.getRelatedMethodImplementations( new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ) ); + assertThat( entries, containsInAnyOrder( + new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ), + new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ) + ) ); + + // doBaseThings() + entries = m_index.getRelatedMethodImplementations( new MethodEntry( m_baseClass, "a", "()V" ) ); + assertThat( entries, containsInAnyOrder( + new MethodEntry( m_baseClass, "a", "()V" ), + new MethodEntry( m_subClassAA, "a", "()V" ), + new MethodEntry( m_subClassB, "a", "()V" ) + ) ); + entries = m_index.getRelatedMethodImplementations( new MethodEntry( m_subClassAA, "a", "()V" ) ); + assertThat( entries, containsInAnyOrder( + new MethodEntry( m_baseClass, "a", "()V" ), + new MethodEntry( m_subClassAA, "a", "()V" ), + new MethodEntry( m_subClassB, "a", "()V" ) + ) ); + entries = m_index.getRelatedMethodImplementations( new MethodEntry( m_subClassB, "a", "()V" ) ); + assertThat( entries, containsInAnyOrder( + new MethodEntry( m_baseClass, "a", "()V" ), + new MethodEntry( m_subClassAA, "a", "()V" ), + new MethodEntry( m_subClassB, "a", "()V" ) + ) ); + + // doBThings + entries = m_index.getRelatedMethodImplementations( new MethodEntry( m_subClassB, "b", "()V" ) ); + assertThat( entries, containsInAnyOrder( + new MethodEntry( m_subClassB, "b", "()V" ) + ) ); + } + + @Test + @SuppressWarnings( "unchecked" ) + public void fieldReferences( ) + { + Collection> references; + + // name + references = m_index.getFieldReferences( m_nameField ); + assertThat( references, containsInAnyOrder( + newFieldReferenceByConstructor( m_nameField, m_baseClass.getName(), "(Ljava/lang/String;)V" ), + newFieldReferenceByMethod( m_nameField, m_baseClass.getName(), "a", "()Ljava/lang/String;" ) + ) ); + + // numThings + references = m_index.getFieldReferences( m_numThingsField ); + assertThat( references, containsInAnyOrder( + newFieldReferenceByConstructor( m_numThingsField, m_subClassB.getName(), "()V" ), + newFieldReferenceByMethod( m_numThingsField, m_subClassB.getName(), "b", "()V" ) + ) ); + } + + @Test + @SuppressWarnings( "unchecked" ) + public void behaviorReferences( ) + { + BehaviorEntry source; + Collection> references; + + // baseClass constructor + source = new ConstructorEntry( m_baseClass, "(Ljava/lang/String;)V" ); + references = m_index.getBehaviorReferences( source ); + assertThat( references, containsInAnyOrder( + newBehaviorReferenceByConstructor( source, m_subClassA.getName(), "(Ljava/lang/String;)V" ), + newBehaviorReferenceByConstructor( source, m_subClassB.getName(), "()V" ) + ) ); + + // subClassA constructor + source = new ConstructorEntry( m_subClassA, "(Ljava/lang/String;)V" ); + references = m_index.getBehaviorReferences( source ); + assertThat( references, containsInAnyOrder( + newBehaviorReferenceByConstructor( source, m_subClassAA.getName(), "()V" ) + ) ); + + // baseClass.getName() + source = new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ); + references = m_index.getBehaviorReferences( source ); + assertThat( references, containsInAnyOrder( + newBehaviorReferenceByMethod( source, m_subClassAA.getName(), "a", "()Ljava/lang/String;" ) + ) ); + + // subclassAA.getName() + source = new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ); + references = m_index.getBehaviorReferences( source ); + assertThat( references, containsInAnyOrder( + newBehaviorReferenceByMethod( source, m_subClassAA.getName(), "a", "()V" ) + ) ); + } + + @Test + 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 ) ); + + // fields + assertThat( m_index.containsObfField( m_nameField ), is( true ) ); + assertThat( m_index.containsObfField( m_numThingsField ), is( true ) ); + + // methods + assertThat( m_index.containsObfMethod( new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ) ), is( true ) ); + assertThat( m_index.containsObfMethod( new MethodEntry( m_baseClass, "a", "()V" ) ), is( true ) ); + assertThat( m_index.containsObfMethod( new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ) ), is( true ) ); + assertThat( m_index.containsObfMethod( new MethodEntry( m_subClassAA, "a", "()V" ) ), is( true ) ); + assertThat( m_index.containsObfMethod( new MethodEntry( m_subClassB, "a", "()V" ) ), is( true ) ); + assertThat( m_index.containsObfMethod( new MethodEntry( m_subClassB, "b", "()V" ) ), is( true ) ); + } +} -- cgit v1.2.3 From aa68099bb252dd1a1c275459f8babe537868bcaf Mon Sep 17 00:00:00 2001 From: jeff Date: Sun, 14 Sep 2014 19:06:55 -0400 Subject: fixed bug with method references pointing to wrong class --- test/cuchaz/enigma/TestJarIndexInheritanceTree.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'test/cuchaz/enigma/TestJarIndexInheritanceTree.java') diff --git a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java index 5ded5df..3d488ee 100644 --- a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java +++ b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java @@ -220,7 +220,8 @@ public class TestJarIndexInheritanceTree source = new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ); references = m_index.getBehaviorReferences( source ); assertThat( references, containsInAnyOrder( - newBehaviorReferenceByMethod( source, m_subClassAA.getName(), "a", "()Ljava/lang/String;" ) + newBehaviorReferenceByMethod( source, m_subClassAA.getName(), "a", "()Ljava/lang/String;" ), + newBehaviorReferenceByMethod( source, m_subClassB.getName(), "a", "()V" ) ) ); // subclassAA.getName() -- cgit v1.2.3 From 8409dea980fa03c06b180969c5e0696f7cb5474b Mon Sep 17 00:00:00 2001 From: jeff Date: Sun, 21 Sep 2014 00:32:03 -0400 Subject: started unit testing for inner/anonymous class detection --- test/cuchaz/enigma/TestJarIndexInheritanceTree.java | 14 +++----------- 1 file changed, 3 insertions(+), 11 deletions(-) (limited to 'test/cuchaz/enigma/TestJarIndexInheritanceTree.java') diff --git a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java index 3d488ee..317a6bc 100644 --- a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java +++ b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java @@ -10,17 +10,9 @@ ******************************************************************************/ package cuchaz.enigma; -import static cuchaz.enigma.EntryFactory.newBehaviorReferenceByConstructor; -import static cuchaz.enigma.EntryFactory.newBehaviorReferenceByMethod; -import static cuchaz.enigma.EntryFactory.newClass; -import static cuchaz.enigma.EntryFactory.newFieldReferenceByConstructor; -import static cuchaz.enigma.EntryFactory.newFieldReferenceByMethod; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.empty; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.nullValue; +import static cuchaz.enigma.EntryFactory.*; +import static org.hamcrest.MatcherAssert.*; +import static org.hamcrest.Matchers.*; import java.util.Collection; import java.util.Set; -- cgit v1.2.3 From 8776a8ba38123c822530e5f659c626c8db616217 Mon Sep 17 00:00:00 2001 From: jeff Date: Wed, 24 Sep 2014 01:00:54 -0400 Subject: HOW DO I WRITE SO MANY BUGS?!? --- .../cuchaz/enigma/TestJarIndexInheritanceTree.java | 46 +++++++++------------- 1 file changed, 18 insertions(+), 28 deletions(-) (limited to 'test/cuchaz/enigma/TestJarIndexInheritanceTree.java') diff --git a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java index 317a6bc..50c2282 100644 --- a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java +++ b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java @@ -99,28 +99,6 @@ public class TestJarIndexInheritanceTree assertThat( m_index.getAccess( m_numThingsField ), is( Access.Private ) ); } - @Test - public void isImplemented( ) - { - // getName() - assertThat( m_index.isMethodImplemented( new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ) ), is( true ) ); - assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassA, "a", "()Ljava/lang/String;" ) ), is( false ) ); - assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ) ), is( true ) ); - assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassB, "a", "()Ljava/lang/String;" ) ), is( false ) ); - - // doBaseThings() - assertThat( m_index.isMethodImplemented( new MethodEntry( m_baseClass, "a", "()V" ) ), is( true ) ); - assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassA, "a", "()V" ) ), is( false ) ); - assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassAA, "a", "()V" ) ), is( true ) ); - assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassB, "a", "()V" ) ), is( true ) ); - - // doBThings() - assertThat( m_index.isMethodImplemented( new MethodEntry( m_baseClass, "b", "()V" ) ), is( false ) ); - assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassA, "b", "()V" ) ), is( false ) ); - assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassAA, "b", "()V" ) ), is( false ) ); - assertThat( m_index.isMethodImplemented( new MethodEntry( m_subClassB, "b", "()V" ) ), is( true ) ); - } - @Test public void relatedMethodImplementations( ) { @@ -238,11 +216,23 @@ public class TestJarIndexInheritanceTree assertThat( m_index.containsObfField( m_numThingsField ), is( true ) ); // methods - assertThat( m_index.containsObfMethod( new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ) ), is( true ) ); - assertThat( m_index.containsObfMethod( new MethodEntry( m_baseClass, "a", "()V" ) ), is( true ) ); - assertThat( m_index.containsObfMethod( new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ) ), is( true ) ); - assertThat( m_index.containsObfMethod( new MethodEntry( m_subClassAA, "a", "()V" ) ), is( true ) ); - assertThat( m_index.containsObfMethod( new MethodEntry( m_subClassB, "a", "()V" ) ), is( true ) ); - assertThat( m_index.containsObfMethod( new MethodEntry( m_subClassB, "b", "()V" ) ), is( true ) ); + // getName() + assertThat( m_index.containsObfBehavior( new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ) ), is( true ) ); + assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassA, "a", "()Ljava/lang/String;" ) ), is( false ) ); + assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ) ), is( true ) ); + assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassB, "a", "()Ljava/lang/String;" ) ), is( false ) ); + + // doBaseThings() + assertThat( m_index.containsObfBehavior( new MethodEntry( m_baseClass, "a", "()V" ) ), is( true ) ); + assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassA, "a", "()V" ) ), is( false ) ); + assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassAA, "a", "()V" ) ), is( true ) ); + assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassB, "a", "()V" ) ), is( true ) ); + + // doBThings() + assertThat( m_index.containsObfBehavior( new MethodEntry( m_baseClass, "b", "()V" ) ), is( false ) ); + assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassA, "b", "()V" ) ), is( false ) ); + assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassAA, "b", "()V" ) ), is( false ) ); + assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassB, "b", "()V" ) ), is( true ) ); + } } -- cgit v1.2.3 From 035e73fba69ab06172ae9d784b9e0e4fffeb8388 Mon Sep 17 00:00:00 2001 From: jeff Date: Wed, 8 Oct 2014 23:54:08 -0400 Subject: relicense as LGPL --- test/cuchaz/enigma/TestJarIndexInheritanceTree.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'test/cuchaz/enigma/TestJarIndexInheritanceTree.java') diff --git a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java index 50c2282..dc7900c 100644 --- a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java +++ b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java @@ -1,9 +1,9 @@ /******************************************************************************* * Copyright (c) 2014 Jeff Martin. * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Public License v3.0 - * which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/gpl.html + * are made available under the terms of the GNU Lesser General Public + * License v3.0 which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl.html * * Contributors: * Jeff Martin - initial API and implementation -- cgit v1.2.3 From 812e2a4630ef01463ff153ba5ffae675e8ac24ac Mon Sep 17 00:00:00 2001 From: jeff Date: Thu, 9 Oct 2014 19:37:19 -0400 Subject: reverting to GPL license --- test/cuchaz/enigma/TestJarIndexInheritanceTree.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'test/cuchaz/enigma/TestJarIndexInheritanceTree.java') diff --git a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java index dc7900c..50c2282 100644 --- a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java +++ b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java @@ -1,9 +1,9 @@ /******************************************************************************* * Copyright (c) 2014 Jeff Martin. * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser General Public - * License v3.0 which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl.html + * are made available under the terms of the GNU Public License v3.0 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/gpl.html * * Contributors: * Jeff Martin - initial API and implementation -- cgit v1.2.3 From 959cb5fd4f9586ec3bd265b452fe25fe1db82e3f Mon Sep 17 00:00:00 2001 From: jeff Date: Tue, 13 Jan 2015 23:25:04 -0500 Subject: source format change don't hate me too much if you were planning a big merge. =P --- .../cuchaz/enigma/TestJarIndexInheritanceTree.java | 254 ++++++++++----------- 1 file changed, 122 insertions(+), 132 deletions(-) (limited to 'test/cuchaz/enigma/TestJarIndexInheritanceTree.java') diff --git a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java index 50c2282..caf6578 100644 --- a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java +++ b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java @@ -30,209 +30,199 @@ import cuchaz.enigma.mapping.ConstructorEntry; import cuchaz.enigma.mapping.FieldEntry; import cuchaz.enigma.mapping.MethodEntry; -public class TestJarIndexInheritanceTree -{ +public class TestJarIndexInheritanceTree { + private JarIndex m_index; - private ClassEntry m_baseClass = new ClassEntry( "none/a" ); - private ClassEntry m_subClassA = new ClassEntry( "none/b" ); - private ClassEntry m_subClassAA = new ClassEntry( "none/d" ); - private ClassEntry m_subClassB = new ClassEntry( "none/c" ); - private FieldEntry m_nameField = new FieldEntry( m_baseClass, "a" ); - private FieldEntry m_numThingsField = new FieldEntry( m_subClassB, "a" ); + private ClassEntry m_baseClass = new ClassEntry("none/a"); + private ClassEntry m_subClassA = new ClassEntry("none/b"); + private ClassEntry m_subClassAA = new ClassEntry("none/d"); + private ClassEntry m_subClassB = new ClassEntry("none/c"); + 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/libs/testInheritanceTree.obf.jar" ), false ); + m_index.indexJar(new JarFile("build/libs/testInheritanceTree.obf.jar"), false); } @Test - public void obfEntries( ) - { - assertThat( m_index.getObfClassEntries(), containsInAnyOrder( - newClass( "cuchaz/enigma/inputs/Keep" ), + public void obfEntries() { + assertThat(m_index.getObfClassEntries(), containsInAnyOrder( + newClass("cuchaz/enigma/inputs/Keep"), m_baseClass, m_subClassA, m_subClassAA, m_subClassB - ) ); + )); } @Test - public void translationIndex( ) - { + public void translationIndex() { + TranslationIndex index = m_index.getTranslationIndex(); // base class - assertThat( index.getSuperclassName( m_baseClass.getName() ), is( nullValue() ) ); - assertThat( index.getAncestry( m_baseClass.getName() ), is( empty() ) ); - assertThat( index.getSubclassNames( m_baseClass.getName() ), containsInAnyOrder( + assertThat(index.getSuperclassName(m_baseClass.getName()), is(nullValue())); + assertThat(index.getAncestry(m_baseClass.getName()), is(empty())); + assertThat(index.getSubclassNames(m_baseClass.getName()), containsInAnyOrder( m_subClassA.getName(), m_subClassB.getName() - ) ); + )); // subclass a - assertThat( index.getSuperclassName( m_subClassA.getName() ), is( m_baseClass.getName() ) ); - assertThat( index.getAncestry( m_subClassA.getName() ), contains( m_baseClass.getName() ) ); - assertThat( index.getSubclassNames( m_subClassA.getName() ), contains( m_subClassAA.getName() ) ); + assertThat(index.getSuperclassName(m_subClassA.getName()), is(m_baseClass.getName())); + assertThat(index.getAncestry(m_subClassA.getName()), contains(m_baseClass.getName())); + assertThat(index.getSubclassNames(m_subClassA.getName()), contains(m_subClassAA.getName())); // subclass aa - assertThat( index.getSuperclassName( m_subClassAA.getName() ), is( m_subClassA.getName() ) ); - assertThat( index.getAncestry( m_subClassAA.getName() ), contains( - m_subClassA.getName(), - m_baseClass.getName() - ) ); - assertThat( index.getSubclassNames( m_subClassAA.getName() ), is( empty() ) ); + assertThat(index.getSuperclassName(m_subClassAA.getName()), is(m_subClassA.getName())); + assertThat(index.getAncestry(m_subClassAA.getName()), contains(m_subClassA.getName(), m_baseClass.getName())); + assertThat(index.getSubclassNames(m_subClassAA.getName()), is(empty())); // subclass b - assertThat( index.getSuperclassName( m_subClassB.getName() ), is( m_baseClass.getName() ) ); - assertThat( index.getAncestry( m_subClassB.getName() ), contains( m_baseClass.getName() ) ); - assertThat( index.getSubclassNames( m_subClassB.getName() ), is( empty() ) ); + assertThat(index.getSuperclassName(m_subClassB.getName()), is(m_baseClass.getName())); + assertThat(index.getAncestry(m_subClassB.getName()), contains(m_baseClass.getName())); + assertThat(index.getSubclassNames(m_subClassB.getName()), is(empty())); } @Test - public void access( ) - { - assertThat( m_index.getAccess( m_nameField ), is( Access.Private ) ); - assertThat( m_index.getAccess( m_numThingsField ), is( Access.Private ) ); + public void access() { + assertThat(m_index.getAccess(m_nameField), is(Access.Private)); + assertThat(m_index.getAccess(m_numThingsField), is(Access.Private)); } @Test - public void relatedMethodImplementations( ) - { + public void relatedMethodImplementations() { + Set entries; // getName() - entries = m_index.getRelatedMethodImplementations( new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ) ); - assertThat( entries, containsInAnyOrder( - new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ), - new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ) - ) ); - entries = m_index.getRelatedMethodImplementations( new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ) ); - assertThat( entries, containsInAnyOrder( - new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ), - new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ) - ) ); + entries = m_index.getRelatedMethodImplementations(new MethodEntry(m_baseClass, "a", "()Ljava/lang/String;")); + assertThat(entries, containsInAnyOrder( + new MethodEntry(m_baseClass, "a", "()Ljava/lang/String;"), + new MethodEntry(m_subClassAA, "a", "()Ljava/lang/String;") + )); + entries = m_index.getRelatedMethodImplementations(new MethodEntry(m_subClassAA, "a", "()Ljava/lang/String;")); + assertThat(entries, containsInAnyOrder( + new MethodEntry(m_baseClass, "a", "()Ljava/lang/String;"), + new MethodEntry(m_subClassAA, "a", "()Ljava/lang/String;") + )); // doBaseThings() - entries = m_index.getRelatedMethodImplementations( new MethodEntry( m_baseClass, "a", "()V" ) ); - assertThat( entries, containsInAnyOrder( - new MethodEntry( m_baseClass, "a", "()V" ), - new MethodEntry( m_subClassAA, "a", "()V" ), - new MethodEntry( m_subClassB, "a", "()V" ) - ) ); - entries = m_index.getRelatedMethodImplementations( new MethodEntry( m_subClassAA, "a", "()V" ) ); - assertThat( entries, containsInAnyOrder( - new MethodEntry( m_baseClass, "a", "()V" ), - new MethodEntry( m_subClassAA, "a", "()V" ), - new MethodEntry( m_subClassB, "a", "()V" ) - ) ); - entries = m_index.getRelatedMethodImplementations( new MethodEntry( m_subClassB, "a", "()V" ) ); - assertThat( entries, containsInAnyOrder( - new MethodEntry( m_baseClass, "a", "()V" ), - new MethodEntry( m_subClassAA, "a", "()V" ), - new MethodEntry( m_subClassB, "a", "()V" ) - ) ); + entries = m_index.getRelatedMethodImplementations(new MethodEntry(m_baseClass, "a", "()V")); + assertThat(entries, containsInAnyOrder( + new MethodEntry(m_baseClass, "a", "()V"), + new MethodEntry(m_subClassAA, "a", "()V"), + new MethodEntry(m_subClassB, "a", "()V") + )); + entries = m_index.getRelatedMethodImplementations(new MethodEntry(m_subClassAA, "a", "()V")); + assertThat(entries, containsInAnyOrder( + new MethodEntry(m_baseClass, "a", "()V"), + new MethodEntry(m_subClassAA, "a", "()V"), + new MethodEntry(m_subClassB, "a", "()V") + )); + entries = m_index.getRelatedMethodImplementations(new MethodEntry(m_subClassB, "a", "()V")); + assertThat(entries, containsInAnyOrder( + new MethodEntry(m_baseClass, "a", "()V"), + new MethodEntry(m_subClassAA, "a", "()V"), + new MethodEntry(m_subClassB, "a", "()V") + )); // doBThings - entries = m_index.getRelatedMethodImplementations( new MethodEntry( m_subClassB, "b", "()V" ) ); - assertThat( entries, containsInAnyOrder( - new MethodEntry( m_subClassB, "b", "()V" ) - ) ); + entries = m_index.getRelatedMethodImplementations(new MethodEntry(m_subClassB, "b", "()V")); + assertThat(entries, containsInAnyOrder(new MethodEntry(m_subClassB, "b", "()V"))); } @Test - @SuppressWarnings( "unchecked" ) - public void fieldReferences( ) - { + @SuppressWarnings("unchecked") + public void fieldReferences() { Collection> references; // name - references = m_index.getFieldReferences( m_nameField ); - assertThat( references, containsInAnyOrder( - newFieldReferenceByConstructor( m_nameField, m_baseClass.getName(), "(Ljava/lang/String;)V" ), - newFieldReferenceByMethod( m_nameField, m_baseClass.getName(), "a", "()Ljava/lang/String;" ) - ) ); + references = m_index.getFieldReferences(m_nameField); + assertThat(references, containsInAnyOrder( + newFieldReferenceByConstructor(m_nameField, m_baseClass.getName(), "(Ljava/lang/String;)V"), + newFieldReferenceByMethod(m_nameField, m_baseClass.getName(), "a", "()Ljava/lang/String;") + )); // numThings - references = m_index.getFieldReferences( m_numThingsField ); - assertThat( references, containsInAnyOrder( - newFieldReferenceByConstructor( m_numThingsField, m_subClassB.getName(), "()V" ), - newFieldReferenceByMethod( m_numThingsField, m_subClassB.getName(), "b", "()V" ) - ) ); + references = m_index.getFieldReferences(m_numThingsField); + assertThat(references, containsInAnyOrder( + newFieldReferenceByConstructor(m_numThingsField, m_subClassB.getName(), "()V"), + newFieldReferenceByMethod(m_numThingsField, m_subClassB.getName(), "b", "()V") + )); } @Test - @SuppressWarnings( "unchecked" ) - public void behaviorReferences( ) - { + @SuppressWarnings("unchecked") + public void behaviorReferences() { + BehaviorEntry source; Collection> references; // baseClass constructor - source = new ConstructorEntry( m_baseClass, "(Ljava/lang/String;)V" ); - references = m_index.getBehaviorReferences( source ); - assertThat( references, containsInAnyOrder( - newBehaviorReferenceByConstructor( source, m_subClassA.getName(), "(Ljava/lang/String;)V" ), - newBehaviorReferenceByConstructor( source, m_subClassB.getName(), "()V" ) - ) ); + source = new ConstructorEntry(m_baseClass, "(Ljava/lang/String;)V"); + references = m_index.getBehaviorReferences(source); + assertThat(references, containsInAnyOrder( + newBehaviorReferenceByConstructor(source, m_subClassA.getName(), "(Ljava/lang/String;)V"), + newBehaviorReferenceByConstructor(source, m_subClassB.getName(), "()V") + )); // subClassA constructor - source = new ConstructorEntry( m_subClassA, "(Ljava/lang/String;)V" ); - references = m_index.getBehaviorReferences( source ); - assertThat( references, containsInAnyOrder( - newBehaviorReferenceByConstructor( source, m_subClassAA.getName(), "()V" ) - ) ); + source = new ConstructorEntry(m_subClassA, "(Ljava/lang/String;)V"); + references = m_index.getBehaviorReferences(source); + assertThat(references, containsInAnyOrder( + newBehaviorReferenceByConstructor(source, m_subClassAA.getName(), "()V") + )); // baseClass.getName() - source = new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ); - references = m_index.getBehaviorReferences( source ); - assertThat( references, containsInAnyOrder( - newBehaviorReferenceByMethod( source, m_subClassAA.getName(), "a", "()Ljava/lang/String;" ), - newBehaviorReferenceByMethod( source, m_subClassB.getName(), "a", "()V" ) - ) ); + source = new MethodEntry(m_baseClass, "a", "()Ljava/lang/String;"); + references = m_index.getBehaviorReferences(source); + assertThat(references, containsInAnyOrder( + newBehaviorReferenceByMethod(source, m_subClassAA.getName(), "a", "()Ljava/lang/String;"), + newBehaviorReferenceByMethod(source, m_subClassB.getName(), "a", "()V") + )); // subclassAA.getName() - source = new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ); - references = m_index.getBehaviorReferences( source ); - assertThat( references, containsInAnyOrder( - newBehaviorReferenceByMethod( source, m_subClassAA.getName(), "a", "()V" ) - ) ); + source = new MethodEntry(m_subClassAA, "a", "()Ljava/lang/String;"); + references = m_index.getBehaviorReferences(source); + assertThat(references, containsInAnyOrder( + newBehaviorReferenceByMethod(source, m_subClassAA.getName(), "a", "()V") + )); } @Test - public void containsEntries( ) - { + 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(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)); // fields - assertThat( m_index.containsObfField( m_nameField ), is( true ) ); - assertThat( m_index.containsObfField( m_numThingsField ), is( true ) ); + assertThat(m_index.containsObfField(m_nameField), is(true)); + assertThat(m_index.containsObfField(m_numThingsField), is(true)); // methods // getName() - assertThat( m_index.containsObfBehavior( new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ) ), is( true ) ); - assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassA, "a", "()Ljava/lang/String;" ) ), is( false ) ); - assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ) ), is( true ) ); - assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassB, "a", "()Ljava/lang/String;" ) ), is( false ) ); + assertThat(m_index.containsObfBehavior(new MethodEntry(m_baseClass, "a", "()Ljava/lang/String;")), is(true)); + assertThat(m_index.containsObfBehavior(new MethodEntry(m_subClassA, "a", "()Ljava/lang/String;")), is(false)); + assertThat(m_index.containsObfBehavior(new MethodEntry(m_subClassAA, "a", "()Ljava/lang/String;")), is(true)); + assertThat(m_index.containsObfBehavior(new MethodEntry(m_subClassB, "a", "()Ljava/lang/String;")), is(false)); // doBaseThings() - assertThat( m_index.containsObfBehavior( new MethodEntry( m_baseClass, "a", "()V" ) ), is( true ) ); - assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassA, "a", "()V" ) ), is( false ) ); - assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassAA, "a", "()V" ) ), is( true ) ); - assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassB, "a", "()V" ) ), is( true ) ); + assertThat(m_index.containsObfBehavior(new MethodEntry(m_baseClass, "a", "()V")), is(true)); + assertThat(m_index.containsObfBehavior(new MethodEntry(m_subClassA, "a", "()V")), is(false)); + assertThat(m_index.containsObfBehavior(new MethodEntry(m_subClassAA, "a", "()V")), is(true)); + assertThat(m_index.containsObfBehavior(new MethodEntry(m_subClassB, "a", "()V")), is(true)); // doBThings() - assertThat( m_index.containsObfBehavior( new MethodEntry( m_baseClass, "b", "()V" ) ), is( false ) ); - assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassA, "b", "()V" ) ), is( false ) ); - assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassAA, "b", "()V" ) ), is( false ) ); - assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassB, "b", "()V" ) ), is( true ) ); - + assertThat(m_index.containsObfBehavior(new MethodEntry(m_baseClass, "b", "()V")), is(false)); + assertThat(m_index.containsObfBehavior(new MethodEntry(m_subClassA, "b", "()V")), is(false)); + assertThat(m_index.containsObfBehavior(new MethodEntry(m_subClassAA, "b", "()V")), is(false)); + assertThat(m_index.containsObfBehavior(new MethodEntry(m_subClassB, "b", "()V")), is(true)); + } } -- cgit v1.2.3 From 2fbcf8e5c4eec0aa4a4fc59c7cc8abac33b1429c Mon Sep 17 00:00:00 2001 From: jeff Date: Mon, 19 Jan 2015 22:22:57 -0500 Subject: solved tricky issue with incorrect translation of fields/methods referenced by a subclass instead of the declaring class --- .../cuchaz/enigma/TestJarIndexInheritanceTree.java | 30 +++++++++++----------- 1 file changed, 15 insertions(+), 15 deletions(-) (limited to 'test/cuchaz/enigma/TestJarIndexInheritanceTree.java') diff --git a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java index caf6578..4d66397 100644 --- a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java +++ b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java @@ -43,7 +43,7 @@ public class TestJarIndexInheritanceTree { public TestJarIndexInheritanceTree() throws Exception { m_index = new JarIndex(); - m_index.indexJar(new JarFile("build/libs/testInheritanceTree.obf.jar"), false); + m_index.indexJar(new JarFile("build/testInheritanceTree.obf.jar"), false); } @Test @@ -63,27 +63,27 @@ public class TestJarIndexInheritanceTree { TranslationIndex index = m_index.getTranslationIndex(); // base class - assertThat(index.getSuperclassName(m_baseClass.getName()), is(nullValue())); - assertThat(index.getAncestry(m_baseClass.getName()), is(empty())); - assertThat(index.getSubclassNames(m_baseClass.getName()), containsInAnyOrder( - m_subClassA.getName(), - m_subClassB.getName() + assertThat(index.getSuperclass(m_baseClass), is(nullValue())); + assertThat(index.getAncestry(m_baseClass), is(empty())); + assertThat(index.getSubclass(m_baseClass), containsInAnyOrder( + m_subClassA, + m_subClassB )); // subclass a - assertThat(index.getSuperclassName(m_subClassA.getName()), is(m_baseClass.getName())); - assertThat(index.getAncestry(m_subClassA.getName()), contains(m_baseClass.getName())); - assertThat(index.getSubclassNames(m_subClassA.getName()), contains(m_subClassAA.getName())); + assertThat(index.getSuperclass(m_subClassA), is(m_baseClass)); + assertThat(index.getAncestry(m_subClassA), contains(m_baseClass)); + assertThat(index.getSubclass(m_subClassA), contains(m_subClassAA)); // subclass aa - assertThat(index.getSuperclassName(m_subClassAA.getName()), is(m_subClassA.getName())); - assertThat(index.getAncestry(m_subClassAA.getName()), contains(m_subClassA.getName(), m_baseClass.getName())); - assertThat(index.getSubclassNames(m_subClassAA.getName()), is(empty())); + assertThat(index.getSuperclass(m_subClassAA), is(m_subClassA)); + assertThat(index.getAncestry(m_subClassAA), contains(m_subClassA, m_baseClass)); + assertThat(index.getSubclass(m_subClassAA), is(empty())); // subclass b - assertThat(index.getSuperclassName(m_subClassB.getName()), is(m_baseClass.getName())); - assertThat(index.getAncestry(m_subClassB.getName()), contains(m_baseClass.getName())); - assertThat(index.getSubclassNames(m_subClassB.getName()), is(empty())); + assertThat(index.getSuperclass(m_subClassB), is(m_baseClass)); + assertThat(index.getAncestry(m_subClassB), contains(m_baseClass)); + assertThat(index.getSubclass(m_subClassB), is(empty())); } @Test -- cgit v1.2.3 From 818716acb3992e602e01725b6e151c1eb0f6c2e2 Mon Sep 17 00:00:00 2001 From: jeff Date: Thu, 5 Feb 2015 23:52:55 -0500 Subject: fix test code formatting and disable the super duper slow test for now --- test/cuchaz/enigma/TestJarIndexInheritanceTree.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'test/cuchaz/enigma/TestJarIndexInheritanceTree.java') 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); } -- cgit v1.2.3