summaryrefslogtreecommitdiff
path: root/test
diff options
context:
space:
mode:
Diffstat (limited to 'test')
-rw-r--r--test/cuchaz/enigma/EntryFactory.java44
-rw-r--r--test/cuchaz/enigma/TestDeobfuscator.java34
-rw-r--r--test/cuchaz/enigma/TestInnerClasses.java48
-rw-r--r--test/cuchaz/enigma/TestJarIndexConstructorReferences.java160
-rw-r--r--test/cuchaz/enigma/TestJarIndexInheritanceTree.java254
-rw-r--r--test/cuchaz/enigma/TestJarIndexLoneClass.java168
-rw-r--r--test/cuchaz/enigma/TestSourceIndex.java36
-rw-r--r--test/cuchaz/enigma/TestTokensConstructors.java137
-rw-r--r--test/cuchaz/enigma/TokenChecker.java46
-rw-r--r--test/cuchaz/enigma/inputs/Keep.java8
-rw-r--r--test/cuchaz/enigma/inputs/constructors/BaseClass.java16
-rw-r--r--test/cuchaz/enigma/inputs/constructors/Caller.java49
-rw-r--r--test/cuchaz/enigma/inputs/constructors/DefaultConstructable.java3
-rw-r--r--test/cuchaz/enigma/inputs/constructors/SubClass.java20
-rw-r--r--test/cuchaz/enigma/inputs/constructors/SubSubClass.java9
-rw-r--r--test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java12
-rw-r--r--test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java9
-rw-r--r--test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java19
-rw-r--r--test/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java17
-rw-r--r--test/cuchaz/enigma/inputs/innerClasses/Anonymous.java13
-rw-r--r--test/cuchaz/enigma/inputs/innerClasses/AnonymousWithScopeArgs.java15
-rw-r--r--test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java18
-rw-r--r--test/cuchaz/enigma/inputs/innerClasses/Simple.java7
-rw-r--r--test/cuchaz/enigma/inputs/loneClass/LoneClass.java10
24 files changed, 510 insertions, 642 deletions
diff --git a/test/cuchaz/enigma/EntryFactory.java b/test/cuchaz/enigma/EntryFactory.java
index 5a8a427..d9317ef 100644
--- a/test/cuchaz/enigma/EntryFactory.java
+++ b/test/cuchaz/enigma/EntryFactory.java
@@ -18,45 +18,37 @@ import cuchaz.enigma.mapping.ConstructorEntry;
18import cuchaz.enigma.mapping.FieldEntry; 18import cuchaz.enigma.mapping.FieldEntry;
19import cuchaz.enigma.mapping.MethodEntry; 19import cuchaz.enigma.mapping.MethodEntry;
20 20
21public class EntryFactory 21public class EntryFactory {
22{ 22
23 public static ClassEntry newClass( String name ) 23 public static ClassEntry newClass(String name) {
24 { 24 return new ClassEntry(name);
25 return new ClassEntry( name );
26 } 25 }
27 26
28 public static FieldEntry newField( String className, String fieldName ) 27 public static FieldEntry newField(String className, String fieldName) {
29 { 28 return new FieldEntry(newClass(className), fieldName);
30 return new FieldEntry( newClass( className ), fieldName );
31 } 29 }
32 30
33 public static MethodEntry newMethod( String className, String methodName, String methodSignature ) 31 public static MethodEntry newMethod(String className, String methodName, String methodSignature) {
34 { 32 return new MethodEntry(newClass(className), methodName, methodSignature);
35 return new MethodEntry( newClass( className ), methodName, methodSignature );
36 } 33 }
37 34
38 public static ConstructorEntry newConstructor( String className, String signature ) 35 public static ConstructorEntry newConstructor(String className, String signature) {
39 { 36 return new ConstructorEntry(newClass(className), signature);
40 return new ConstructorEntry( newClass( className ), signature );
41 } 37 }
42 38
43 public static EntryReference<FieldEntry,BehaviorEntry> newFieldReferenceByMethod( FieldEntry fieldEntry, String callerClassName, String callerName, String callerSignature ) 39 public static EntryReference<FieldEntry,BehaviorEntry> newFieldReferenceByMethod(FieldEntry fieldEntry, String callerClassName, String callerName, String callerSignature) {
44 { 40 return new EntryReference<FieldEntry,BehaviorEntry>(fieldEntry, "", newMethod(callerClassName, callerName, callerSignature));
45 return new EntryReference<FieldEntry,BehaviorEntry>( fieldEntry, "", newMethod( callerClassName, callerName, callerSignature ) );
46 } 41 }
47 42
48 public static EntryReference<FieldEntry,BehaviorEntry> newFieldReferenceByConstructor( FieldEntry fieldEntry, String callerClassName, String callerSignature ) 43 public static EntryReference<FieldEntry,BehaviorEntry> newFieldReferenceByConstructor(FieldEntry fieldEntry, String callerClassName, String callerSignature) {
49 { 44 return new EntryReference<FieldEntry,BehaviorEntry>(fieldEntry, "", newConstructor(callerClassName, callerSignature));
50 return new EntryReference<FieldEntry,BehaviorEntry>( fieldEntry, "", newConstructor( callerClassName, callerSignature ) );
51 } 45 }
52 46
53 public static EntryReference<BehaviorEntry,BehaviorEntry> newBehaviorReferenceByMethod( BehaviorEntry behaviorEntry, String callerClassName, String callerName, String callerSignature ) 47 public static EntryReference<BehaviorEntry,BehaviorEntry> newBehaviorReferenceByMethod(BehaviorEntry behaviorEntry, String callerClassName, String callerName, String callerSignature) {
54 { 48 return new EntryReference<BehaviorEntry,BehaviorEntry>(behaviorEntry, "", newMethod(callerClassName, callerName, callerSignature));
55 return new EntryReference<BehaviorEntry,BehaviorEntry>( behaviorEntry, "", newMethod( callerClassName, callerName, callerSignature ) );
56 } 49 }
57 50
58 public static EntryReference<BehaviorEntry,BehaviorEntry> newBehaviorReferenceByConstructor( BehaviorEntry behaviorEntry, String callerClassName, String callerSignature ) 51 public static EntryReference<BehaviorEntry,BehaviorEntry> newBehaviorReferenceByConstructor(BehaviorEntry behaviorEntry, String callerClassName, String callerSignature) {
59 { 52 return new EntryReference<BehaviorEntry,BehaviorEntry>(behaviorEntry, "", newConstructor(callerClassName, callerSignature));
60 return new EntryReference<BehaviorEntry,BehaviorEntry>( behaviorEntry, "", newConstructor( callerClassName, callerSignature ) );
61 } 53 }
62} 54}
diff --git a/test/cuchaz/enigma/TestDeobfuscator.java b/test/cuchaz/enigma/TestDeobfuscator.java
index 71de24a..45d27c4 100644
--- a/test/cuchaz/enigma/TestDeobfuscator.java
+++ b/test/cuchaz/enigma/TestDeobfuscator.java
@@ -23,40 +23,32 @@ import com.google.common.collect.Lists;
23 23
24import cuchaz.enigma.mapping.ClassEntry; 24import cuchaz.enigma.mapping.ClassEntry;
25 25
26public class TestDeobfuscator 26public class TestDeobfuscator {
27{ 27
28 private Deobfuscator getDeobfuscator( ) 28 private Deobfuscator getDeobfuscator() throws IOException {
29 throws IOException 29 return new Deobfuscator(new File("build/libs/testLoneClass.obf.jar"));
30 {
31 return new Deobfuscator( new File( "build/libs/testLoneClass.obf.jar" ) );
32 } 30 }
33 31
34 @Test 32 @Test
35 public void loadJar( ) 33 public void loadJar() throws Exception {
36 throws Exception
37 {
38 getDeobfuscator(); 34 getDeobfuscator();
39 } 35 }
40 36
41 @Test 37 @Test
42 public void getClasses( ) 38 public void getClasses() throws Exception {
43 throws Exception
44 {
45 Deobfuscator deobfuscator = getDeobfuscator(); 39 Deobfuscator deobfuscator = getDeobfuscator();
46 List<ClassEntry> obfClasses = Lists.newArrayList(); 40 List<ClassEntry> obfClasses = Lists.newArrayList();
47 List<ClassEntry> deobfClasses = Lists.newArrayList(); 41 List<ClassEntry> deobfClasses = Lists.newArrayList();
48 deobfuscator.getSeparatedClasses( obfClasses, deobfClasses ); 42 deobfuscator.getSeparatedClasses(obfClasses, deobfClasses);
49 assertEquals( 1, obfClasses.size() ); 43 assertEquals(1, obfClasses.size());
50 assertEquals( "none/a", obfClasses.get( 0 ).getName() ); 44 assertEquals("none/a", obfClasses.get(0).getName());
51 assertEquals( 1, deobfClasses.size() ); 45 assertEquals(1, deobfClasses.size());
52 assertEquals( "cuchaz/enigma/inputs/Keep", deobfClasses.get( 0 ).getName() ); 46 assertEquals("cuchaz/enigma/inputs/Keep", deobfClasses.get(0).getName());
53 } 47 }
54 48
55 @Test 49 @Test
56 public void decompileClass( ) 50 public void decompileClass() throws Exception {
57 throws Exception
58 {
59 Deobfuscator deobfuscator = getDeobfuscator(); 51 Deobfuscator deobfuscator = getDeobfuscator();
60 deobfuscator.getSource( deobfuscator.getSourceTree( "none/a" ) ); 52 deobfuscator.getSource(deobfuscator.getSourceTree("none/a"));
61 } 53 }
62} 54}
diff --git a/test/cuchaz/enigma/TestInnerClasses.java b/test/cuchaz/enigma/TestInnerClasses.java
index a7ee0b6..c84d755 100644
--- a/test/cuchaz/enigma/TestInnerClasses.java
+++ b/test/cuchaz/enigma/TestInnerClasses.java
@@ -20,8 +20,8 @@ import org.junit.Test;
20 20
21import cuchaz.enigma.analysis.JarIndex; 21import cuchaz.enigma.analysis.JarIndex;
22 22
23public class TestInnerClasses 23public class TestInnerClasses {
24{ 24
25 private JarIndex m_index; 25 private JarIndex m_index;
26 26
27 private static final String AnonymousOuter = "none/a"; 27 private static final String AnonymousOuter = "none/a";
@@ -33,42 +33,36 @@ public class TestInnerClasses
33 private static final String AnonymousWithScopeArgsOuter = "none/c"; 33 private static final String AnonymousWithScopeArgsOuter = "none/c";
34 private static final String AnonymousWithScopeArgsInner = "d"; 34 private static final String AnonymousWithScopeArgsInner = "d";
35 35
36 public TestInnerClasses( ) 36 public TestInnerClasses() throws Exception {
37 throws Exception
38 {
39 m_index = new JarIndex(); 37 m_index = new JarIndex();
40 m_index.indexJar( new JarFile( "build/libs/testInnerClasses.obf.jar" ), true ); 38 m_index.indexJar(new JarFile("build/libs/testInnerClasses.obf.jar"), true);
41 } 39 }
42 40
43 @Test 41 @Test
44 public void simple( ) 42 public void simple() {
45 { 43 assertThat(m_index.getOuterClass(SimpleInner), is(SimpleOuter));
46 assertThat( m_index.getOuterClass( SimpleInner ), is( SimpleOuter ) ); 44 assertThat(m_index.getInnerClasses(SimpleOuter), containsInAnyOrder(SimpleInner));
47 assertThat( m_index.getInnerClasses( SimpleOuter ), containsInAnyOrder( SimpleInner ) ); 45 assertThat(m_index.isAnonymousClass(SimpleInner), is(false));
48 assertThat( m_index.isAnonymousClass( SimpleInner ), is( false ) );
49 } 46 }
50 47
51 @Test 48 @Test
52 public void anonymous( ) 49 public void anonymous() {
53 { 50 assertThat(m_index.getOuterClass(AnonymousInner), is(AnonymousOuter));
54 assertThat( m_index.getOuterClass( AnonymousInner ), is( AnonymousOuter ) ); 51 assertThat(m_index.getInnerClasses(AnonymousOuter), containsInAnyOrder(AnonymousInner));
55 assertThat( m_index.getInnerClasses( AnonymousOuter ), containsInAnyOrder( AnonymousInner ) ); 52 assertThat(m_index.isAnonymousClass(AnonymousInner), is(true));
56 assertThat( m_index.isAnonymousClass( AnonymousInner ), is( true ) );
57 } 53 }
58 54
59 @Test 55 @Test
60 public void constructorArgs( ) 56 public void constructorArgs() {
61 { 57 assertThat(m_index.getOuterClass(ConstructorArgsInner), is(ConstructorArgsOuter));
62 assertThat( m_index.getOuterClass( ConstructorArgsInner ), is( ConstructorArgsOuter ) ); 58 assertThat(m_index.getInnerClasses(ConstructorArgsOuter), containsInAnyOrder(ConstructorArgsInner));
63 assertThat( m_index.getInnerClasses( ConstructorArgsOuter ), containsInAnyOrder( ConstructorArgsInner ) ); 59 assertThat(m_index.isAnonymousClass(ConstructorArgsInner), is(false));
64 assertThat( m_index.isAnonymousClass( ConstructorArgsInner ), is( false ) );
65 } 60 }
66 61
67 @Test 62 @Test
68 public void anonymousWithScopeArgs( ) 63 public void anonymousWithScopeArgs() {
69 { 64 assertThat(m_index.getOuterClass(AnonymousWithScopeArgsInner), is(AnonymousWithScopeArgsOuter));
70 assertThat( m_index.getOuterClass( AnonymousWithScopeArgsInner ), is( AnonymousWithScopeArgsOuter ) ); 65 assertThat(m_index.getInnerClasses(AnonymousWithScopeArgsOuter), containsInAnyOrder(AnonymousWithScopeArgsInner));
71 assertThat( m_index.getInnerClasses( AnonymousWithScopeArgsOuter ), containsInAnyOrder( AnonymousWithScopeArgsInner ) ); 66 assertThat(m_index.isAnonymousClass(AnonymousWithScopeArgsInner), is(true));
72 assertThat( m_index.isAnonymousClass( AnonymousWithScopeArgsInner ), is( true ) );
73 } 67 }
74} 68}
diff --git a/test/cuchaz/enigma/TestJarIndexConstructorReferences.java b/test/cuchaz/enigma/TestJarIndexConstructorReferences.java
index 0238171..b5f4c7f 100644
--- a/test/cuchaz/enigma/TestJarIndexConstructorReferences.java
+++ b/test/cuchaz/enigma/TestJarIndexConstructorReferences.java
@@ -26,117 +26,99 @@ import cuchaz.enigma.mapping.BehaviorEntry;
26import cuchaz.enigma.mapping.ClassEntry; 26import cuchaz.enigma.mapping.ClassEntry;
27import cuchaz.enigma.mapping.ConstructorEntry; 27import cuchaz.enigma.mapping.ConstructorEntry;
28 28
29public class TestJarIndexConstructorReferences 29public class TestJarIndexConstructorReferences {
30{ 30
31 private JarIndex m_index; 31 private JarIndex m_index;
32 32
33 private ClassEntry m_baseClass = new ClassEntry( "none/a" ); 33 private ClassEntry m_baseClass = new ClassEntry("none/a");
34 private ClassEntry m_subClass = new ClassEntry( "none/d" ); 34 private ClassEntry m_subClass = new ClassEntry("none/d");
35 private ClassEntry m_subsubClass = new ClassEntry( "none/e" ); 35 private ClassEntry m_subsubClass = new ClassEntry("none/e");
36 private ClassEntry m_defaultClass = new ClassEntry( "none/c" ); 36 private ClassEntry m_defaultClass = new ClassEntry("none/c");
37 private ClassEntry m_callerClass = new ClassEntry( "none/b" ); 37 private ClassEntry m_callerClass = new ClassEntry("none/b");
38 38
39 public TestJarIndexConstructorReferences( ) 39 public TestJarIndexConstructorReferences() throws Exception {
40 throws Exception 40 File jarFile = new File("build/libs/testConstructors.obf.jar");
41 {
42 File jarFile = new File( "build/libs/testConstructors.obf.jar" );
43 m_index = new JarIndex(); 41 m_index = new JarIndex();
44 m_index.indexJar( new JarFile( jarFile ), false ); 42 m_index.indexJar(new JarFile(jarFile), false);
45 } 43 }
46 44
47 @Test 45 @Test
48 public void obfEntries( ) 46 public void obfEntries() {
49 { 47 assertThat(m_index.getObfClassEntries(), containsInAnyOrder(newClass("cuchaz/enigma/inputs/Keep"), m_baseClass, m_subClass, m_subsubClass, m_defaultClass, m_callerClass));
50 assertThat( m_index.getObfClassEntries(), containsInAnyOrder(
51 newClass( "cuchaz/enigma/inputs/Keep" ),
52 m_baseClass,
53 m_subClass,
54 m_subsubClass,
55 m_defaultClass,
56 m_callerClass
57 ) );
58 } 48 }
59 49
60 @Test 50 @Test
61 @SuppressWarnings( "unchecked" ) 51 @SuppressWarnings("unchecked")
62 public void baseDefault( ) 52 public void baseDefault() {
63 { 53 BehaviorEntry source = new ConstructorEntry(m_baseClass, "()V");
64 BehaviorEntry source = new ConstructorEntry( m_baseClass, "()V" ); 54 Collection<EntryReference<BehaviorEntry,BehaviorEntry>> references = m_index.getBehaviorReferences(source);
65 Collection<EntryReference<BehaviorEntry,BehaviorEntry>> references = m_index.getBehaviorReferences( source ); 55 assertThat(references, containsInAnyOrder(
66 assertThat( references, containsInAnyOrder( 56 newBehaviorReferenceByMethod(source, m_callerClass.getName(), "a", "()V"),
67 newBehaviorReferenceByMethod( source, m_callerClass.getName(), "a", "()V" ), 57 newBehaviorReferenceByConstructor(source, m_subClass.getName(), "()V"),
68 newBehaviorReferenceByConstructor( source, m_subClass.getName(), "()V" ), 58 newBehaviorReferenceByConstructor(source, m_subClass.getName(), "(III)V")
69 newBehaviorReferenceByConstructor( source, m_subClass.getName(), "(III)V" ) 59 ));
70 ) );
71 } 60 }
72 61
73 @Test 62 @Test
74 @SuppressWarnings( "unchecked" ) 63 @SuppressWarnings("unchecked")
75 public void baseInt( ) 64 public void baseInt() {
76 { 65 BehaviorEntry source = new ConstructorEntry(m_baseClass, "(I)V");
77 BehaviorEntry source = new ConstructorEntry( m_baseClass, "(I)V" ); 66 assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder(
78 assertThat( m_index.getBehaviorReferences( source ), containsInAnyOrder( 67 newBehaviorReferenceByMethod(source, m_callerClass.getName(), "b", "()V")
79 newBehaviorReferenceByMethod( source, m_callerClass.getName(), "b", "()V" ) 68 ));
80 ) );
81 } 69 }
82 70
83 @Test 71 @Test
84 @SuppressWarnings( "unchecked" ) 72 @SuppressWarnings("unchecked")
85 public void subDefault( ) 73 public void subDefault() {
86 { 74 BehaviorEntry source = new ConstructorEntry(m_subClass, "()V");
87 BehaviorEntry source = new ConstructorEntry( m_subClass, "()V" ); 75 assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder(
88 assertThat( m_index.getBehaviorReferences( source ), containsInAnyOrder( 76 newBehaviorReferenceByMethod(source, m_callerClass.getName(), "c", "()V"),
89 newBehaviorReferenceByMethod( source, m_callerClass.getName(), "c", "()V" ), 77 newBehaviorReferenceByConstructor(source, m_subClass.getName(), "(I)V")
90 newBehaviorReferenceByConstructor( source, m_subClass.getName(), "(I)V" ) 78 ));
91 ) );
92 } 79 }
93 80
94 @Test 81 @Test
95 @SuppressWarnings( "unchecked" ) 82 @SuppressWarnings("unchecked")
96 public void subInt( ) 83 public void subInt() {
97 { 84 BehaviorEntry source = new ConstructorEntry(m_subClass, "(I)V");
98 BehaviorEntry source = new ConstructorEntry( m_subClass, "(I)V" ); 85 assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder(
99 assertThat( m_index.getBehaviorReferences( source ), containsInAnyOrder( 86 newBehaviorReferenceByMethod(source, m_callerClass.getName(), "d", "()V"),
100 newBehaviorReferenceByMethod( source, m_callerClass.getName(), "d", "()V" ), 87 newBehaviorReferenceByConstructor(source, m_subClass.getName(), "(II)V"),
101 newBehaviorReferenceByConstructor( source, m_subClass.getName(), "(II)V" ), 88 newBehaviorReferenceByConstructor(source, m_subsubClass.getName(), "(I)V")
102 newBehaviorReferenceByConstructor( source, m_subsubClass.getName(), "(I)V" ) 89 ));
103 ) );
104 } 90 }
105 91
106 @Test 92 @Test
107 @SuppressWarnings( "unchecked" ) 93 @SuppressWarnings("unchecked")
108 public void subIntInt( ) 94 public void subIntInt() {
109 { 95 BehaviorEntry source = new ConstructorEntry(m_subClass, "(II)V");
110 BehaviorEntry source = new ConstructorEntry( m_subClass, "(II)V" ); 96 assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder(
111 assertThat( m_index.getBehaviorReferences( source ), containsInAnyOrder( 97 newBehaviorReferenceByMethod(source, m_callerClass.getName(), "e", "()V")
112 newBehaviorReferenceByMethod( source, m_callerClass.getName(), "e", "()V" ) 98 ));
113 ) );
114 } 99 }
115 100
116 @Test 101 @Test
117 public void subIntIntInt( ) 102 public void subIntIntInt() {
118 { 103 BehaviorEntry source = new ConstructorEntry(m_subClass, "(III)V");
119 BehaviorEntry source = new ConstructorEntry( m_subClass, "(III)V" ); 104 assertThat(m_index.getBehaviorReferences(source), is(empty()));
120 assertThat( m_index.getBehaviorReferences( source ), is( empty() ) );
121 } 105 }
122 106
123 @Test 107 @Test
124 @SuppressWarnings( "unchecked" ) 108 @SuppressWarnings("unchecked")
125 public void subsubInt( ) 109 public void subsubInt() {
126 { 110 BehaviorEntry source = new ConstructorEntry(m_subsubClass, "(I)V");
127 BehaviorEntry source = new ConstructorEntry( m_subsubClass, "(I)V" ); 111 assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder(
128 assertThat( m_index.getBehaviorReferences( source ), containsInAnyOrder( 112 newBehaviorReferenceByMethod(source, m_callerClass.getName(), "f", "()V")
129 newBehaviorReferenceByMethod( source, m_callerClass.getName(), "f", "()V" ) 113 ));
130 ) );
131 } 114 }
132 115
133 @Test 116 @Test
134 @SuppressWarnings( "unchecked" ) 117 @SuppressWarnings("unchecked")
135 public void defaultConstructable( ) 118 public void defaultConstructable() {
136 { 119 BehaviorEntry source = new ConstructorEntry(m_defaultClass, "()V");
137 BehaviorEntry source = new ConstructorEntry( m_defaultClass, "()V" ); 120 assertThat(m_index.getBehaviorReferences(source), containsInAnyOrder(
138 assertThat( m_index.getBehaviorReferences( source ), containsInAnyOrder( 121 newBehaviorReferenceByMethod(source, m_callerClass.getName(), "g", "()V")
139 newBehaviorReferenceByMethod( source, m_callerClass.getName(), "g", "()V" ) 122 ));
140 ) );
141 } 123 }
142} 124}
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;
30import cuchaz.enigma.mapping.FieldEntry; 30import cuchaz.enigma.mapping.FieldEntry;
31import cuchaz.enigma.mapping.MethodEntry; 31import cuchaz.enigma.mapping.MethodEntry;
32 32
33public class TestJarIndexInheritanceTree 33public class TestJarIndexInheritanceTree {
34{ 34
35 private JarIndex m_index; 35 private JarIndex m_index;
36 36
37 private ClassEntry m_baseClass = new ClassEntry( "none/a" ); 37 private ClassEntry m_baseClass = new ClassEntry("none/a");
38 private ClassEntry m_subClassA = new ClassEntry( "none/b" ); 38 private ClassEntry m_subClassA = new ClassEntry("none/b");
39 private ClassEntry m_subClassAA = new ClassEntry( "none/d" ); 39 private ClassEntry m_subClassAA = new ClassEntry("none/d");
40 private ClassEntry m_subClassB = new ClassEntry( "none/c" ); 40 private ClassEntry m_subClassB = new ClassEntry("none/c");
41 private FieldEntry m_nameField = new FieldEntry( m_baseClass, "a" ); 41 private FieldEntry m_nameField = new FieldEntry(m_baseClass, "a");
42 private FieldEntry m_numThingsField = new FieldEntry( m_subClassB, "a" ); 42 private FieldEntry m_numThingsField = new FieldEntry(m_subClassB, "a");
43 43
44 public TestJarIndexInheritanceTree( ) 44 public TestJarIndexInheritanceTree() throws Exception {
45 throws Exception
46 {
47 m_index = new JarIndex(); 45 m_index = new JarIndex();
48 m_index.indexJar( new JarFile( "build/libs/testInheritanceTree.obf.jar" ), false ); 46 m_index.indexJar(new JarFile("build/libs/testInheritanceTree.obf.jar"), false);
49 } 47 }
50 48
51 @Test 49 @Test
52 public void obfEntries( ) 50 public void obfEntries() {
53 { 51 assertThat(m_index.getObfClassEntries(), containsInAnyOrder(
54 assertThat( m_index.getObfClassEntries(), containsInAnyOrder( 52 newClass("cuchaz/enigma/inputs/Keep"),
55 newClass( "cuchaz/enigma/inputs/Keep" ),
56 m_baseClass, 53 m_baseClass,
57 m_subClassA, 54 m_subClassA,
58 m_subClassAA, 55 m_subClassAA,
59 m_subClassB 56 m_subClassB
60 ) ); 57 ));
61 } 58 }
62 59
63 @Test 60 @Test
64 public void translationIndex( ) 61 public void translationIndex() {
65 { 62
66 TranslationIndex index = m_index.getTranslationIndex(); 63 TranslationIndex index = m_index.getTranslationIndex();
67 64
68 // base class 65 // base class
69 assertThat( index.getSuperclassName( m_baseClass.getName() ), is( nullValue() ) ); 66 assertThat(index.getSuperclassName(m_baseClass.getName()), is(nullValue()));
70 assertThat( index.getAncestry( m_baseClass.getName() ), is( empty() ) ); 67 assertThat(index.getAncestry(m_baseClass.getName()), is(empty()));
71 assertThat( index.getSubclassNames( m_baseClass.getName() ), containsInAnyOrder( 68 assertThat(index.getSubclassNames(m_baseClass.getName()), containsInAnyOrder(
72 m_subClassA.getName(), 69 m_subClassA.getName(),
73 m_subClassB.getName() 70 m_subClassB.getName()
74 ) ); 71 ));
75 72
76 // subclass a 73 // subclass a
77 assertThat( index.getSuperclassName( m_subClassA.getName() ), is( m_baseClass.getName() ) ); 74 assertThat(index.getSuperclassName(m_subClassA.getName()), is(m_baseClass.getName()));
78 assertThat( index.getAncestry( m_subClassA.getName() ), contains( m_baseClass.getName() ) ); 75 assertThat(index.getAncestry(m_subClassA.getName()), contains(m_baseClass.getName()));
79 assertThat( index.getSubclassNames( m_subClassA.getName() ), contains( m_subClassAA.getName() ) ); 76 assertThat(index.getSubclassNames(m_subClassA.getName()), contains(m_subClassAA.getName()));
80 77
81 // subclass aa 78 // subclass aa
82 assertThat( index.getSuperclassName( m_subClassAA.getName() ), is( m_subClassA.getName() ) ); 79 assertThat(index.getSuperclassName(m_subClassAA.getName()), is(m_subClassA.getName()));
83 assertThat( index.getAncestry( m_subClassAA.getName() ), contains( 80 assertThat(index.getAncestry(m_subClassAA.getName()), contains(m_subClassA.getName(), m_baseClass.getName()));
84 m_subClassA.getName(), 81 assertThat(index.getSubclassNames(m_subClassAA.getName()), is(empty()));
85 m_baseClass.getName()
86 ) );
87 assertThat( index.getSubclassNames( m_subClassAA.getName() ), is( empty() ) );
88 82
89 // subclass b 83 // subclass b
90 assertThat( index.getSuperclassName( m_subClassB.getName() ), is( m_baseClass.getName() ) ); 84 assertThat(index.getSuperclassName(m_subClassB.getName()), is(m_baseClass.getName()));
91 assertThat( index.getAncestry( m_subClassB.getName() ), contains( m_baseClass.getName() ) ); 85 assertThat(index.getAncestry(m_subClassB.getName()), contains(m_baseClass.getName()));
92 assertThat( index.getSubclassNames( m_subClassB.getName() ), is( empty() ) ); 86 assertThat(index.getSubclassNames(m_subClassB.getName()), is(empty()));
93 } 87 }
94 88
95 @Test 89 @Test
96 public void access( ) 90 public void access() {
97 { 91 assertThat(m_index.getAccess(m_nameField), is(Access.Private));
98 assertThat( m_index.getAccess( m_nameField ), is( Access.Private ) ); 92 assertThat(m_index.getAccess(m_numThingsField), is(Access.Private));
99 assertThat( m_index.getAccess( m_numThingsField ), is( Access.Private ) );
100 } 93 }
101 94
102 @Test 95 @Test
103 public void relatedMethodImplementations( ) 96 public void relatedMethodImplementations() {
104 { 97
105 Set<MethodEntry> entries; 98 Set<MethodEntry> entries;
106 99
107 // getName() 100 // getName()
108 entries = m_index.getRelatedMethodImplementations( new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ) ); 101 entries = m_index.getRelatedMethodImplementations(new MethodEntry(m_baseClass, "a", "()Ljava/lang/String;"));
109 assertThat( entries, containsInAnyOrder( 102 assertThat(entries, containsInAnyOrder(
110 new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ), 103 new MethodEntry(m_baseClass, "a", "()Ljava/lang/String;"),
111 new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ) 104 new MethodEntry(m_subClassAA, "a", "()Ljava/lang/String;")
112 ) ); 105 ));
113 entries = m_index.getRelatedMethodImplementations( new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ) ); 106 entries = m_index.getRelatedMethodImplementations(new MethodEntry(m_subClassAA, "a", "()Ljava/lang/String;"));
114 assertThat( entries, containsInAnyOrder( 107 assertThat(entries, containsInAnyOrder(
115 new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ), 108 new MethodEntry(m_baseClass, "a", "()Ljava/lang/String;"),
116 new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ) 109 new MethodEntry(m_subClassAA, "a", "()Ljava/lang/String;")
117 ) ); 110 ));
118 111
119 // doBaseThings() 112 // doBaseThings()
120 entries = m_index.getRelatedMethodImplementations( new MethodEntry( m_baseClass, "a", "()V" ) ); 113 entries = m_index.getRelatedMethodImplementations(new MethodEntry(m_baseClass, "a", "()V"));
121 assertThat( entries, containsInAnyOrder( 114 assertThat(entries, containsInAnyOrder(
122 new MethodEntry( m_baseClass, "a", "()V" ), 115 new MethodEntry(m_baseClass, "a", "()V"),
123 new MethodEntry( m_subClassAA, "a", "()V" ), 116 new MethodEntry(m_subClassAA, "a", "()V"),
124 new MethodEntry( m_subClassB, "a", "()V" ) 117 new MethodEntry(m_subClassB, "a", "()V")
125 ) ); 118 ));
126 entries = m_index.getRelatedMethodImplementations( new MethodEntry( m_subClassAA, "a", "()V" ) ); 119 entries = m_index.getRelatedMethodImplementations(new MethodEntry(m_subClassAA, "a", "()V"));
127 assertThat( entries, containsInAnyOrder( 120 assertThat(entries, containsInAnyOrder(
128 new MethodEntry( m_baseClass, "a", "()V" ), 121 new MethodEntry(m_baseClass, "a", "()V"),
129 new MethodEntry( m_subClassAA, "a", "()V" ), 122 new MethodEntry(m_subClassAA, "a", "()V"),
130 new MethodEntry( m_subClassB, "a", "()V" ) 123 new MethodEntry(m_subClassB, "a", "()V")
131 ) ); 124 ));
132 entries = m_index.getRelatedMethodImplementations( new MethodEntry( m_subClassB, "a", "()V" ) ); 125 entries = m_index.getRelatedMethodImplementations(new MethodEntry(m_subClassB, "a", "()V"));
133 assertThat( entries, containsInAnyOrder( 126 assertThat(entries, containsInAnyOrder(
134 new MethodEntry( m_baseClass, "a", "()V" ), 127 new MethodEntry(m_baseClass, "a", "()V"),
135 new MethodEntry( m_subClassAA, "a", "()V" ), 128 new MethodEntry(m_subClassAA, "a", "()V"),
136 new MethodEntry( m_subClassB, "a", "()V" ) 129 new MethodEntry(m_subClassB, "a", "()V")
137 ) ); 130 ));
138 131
139 // doBThings 132 // doBThings
140 entries = m_index.getRelatedMethodImplementations( new MethodEntry( m_subClassB, "b", "()V" ) ); 133 entries = m_index.getRelatedMethodImplementations(new MethodEntry(m_subClassB, "b", "()V"));
141 assertThat( entries, containsInAnyOrder( 134 assertThat(entries, containsInAnyOrder(new MethodEntry(m_subClassB, "b", "()V")));
142 new MethodEntry( m_subClassB, "b", "()V" )
143 ) );
144 } 135 }
145 136
146 @Test 137 @Test
147 @SuppressWarnings( "unchecked" ) 138 @SuppressWarnings("unchecked")
148 public void fieldReferences( ) 139 public void fieldReferences() {
149 {
150 Collection<EntryReference<FieldEntry,BehaviorEntry>> references; 140 Collection<EntryReference<FieldEntry,BehaviorEntry>> references;
151 141
152 // name 142 // name
153 references = m_index.getFieldReferences( m_nameField ); 143 references = m_index.getFieldReferences(m_nameField);
154 assertThat( references, containsInAnyOrder( 144 assertThat(references, containsInAnyOrder(
155 newFieldReferenceByConstructor( m_nameField, m_baseClass.getName(), "(Ljava/lang/String;)V" ), 145 newFieldReferenceByConstructor(m_nameField, m_baseClass.getName(), "(Ljava/lang/String;)V"),
156 newFieldReferenceByMethod( m_nameField, m_baseClass.getName(), "a", "()Ljava/lang/String;" ) 146 newFieldReferenceByMethod(m_nameField, m_baseClass.getName(), "a", "()Ljava/lang/String;")
157 ) ); 147 ));
158 148
159 // numThings 149 // numThings
160 references = m_index.getFieldReferences( m_numThingsField ); 150 references = m_index.getFieldReferences(m_numThingsField);
161 assertThat( references, containsInAnyOrder( 151 assertThat(references, containsInAnyOrder(
162 newFieldReferenceByConstructor( m_numThingsField, m_subClassB.getName(), "()V" ), 152 newFieldReferenceByConstructor(m_numThingsField, m_subClassB.getName(), "()V"),
163 newFieldReferenceByMethod( m_numThingsField, m_subClassB.getName(), "b", "()V" ) 153 newFieldReferenceByMethod(m_numThingsField, m_subClassB.getName(), "b", "()V")
164 ) ); 154 ));
165 } 155 }
166 156
167 @Test 157 @Test
168 @SuppressWarnings( "unchecked" ) 158 @SuppressWarnings("unchecked")
169 public void behaviorReferences( ) 159 public void behaviorReferences() {
170 { 160
171 BehaviorEntry source; 161 BehaviorEntry source;
172 Collection<EntryReference<BehaviorEntry,BehaviorEntry>> references; 162 Collection<EntryReference<BehaviorEntry,BehaviorEntry>> references;
173 163
174 // baseClass constructor 164 // baseClass constructor
175 source = new ConstructorEntry( m_baseClass, "(Ljava/lang/String;)V" ); 165 source = new ConstructorEntry(m_baseClass, "(Ljava/lang/String;)V");
176 references = m_index.getBehaviorReferences( source ); 166 references = m_index.getBehaviorReferences(source);
177 assertThat( references, containsInAnyOrder( 167 assertThat(references, containsInAnyOrder(
178 newBehaviorReferenceByConstructor( source, m_subClassA.getName(), "(Ljava/lang/String;)V" ), 168 newBehaviorReferenceByConstructor(source, m_subClassA.getName(), "(Ljava/lang/String;)V"),
179 newBehaviorReferenceByConstructor( source, m_subClassB.getName(), "()V" ) 169 newBehaviorReferenceByConstructor(source, m_subClassB.getName(), "()V")
180 ) ); 170 ));
181 171
182 // subClassA constructor 172 // subClassA constructor
183 source = new ConstructorEntry( m_subClassA, "(Ljava/lang/String;)V" ); 173 source = new ConstructorEntry(m_subClassA, "(Ljava/lang/String;)V");
184 references = m_index.getBehaviorReferences( source ); 174 references = m_index.getBehaviorReferences(source);
185 assertThat( references, containsInAnyOrder( 175 assertThat(references, containsInAnyOrder(
186 newBehaviorReferenceByConstructor( source, m_subClassAA.getName(), "()V" ) 176 newBehaviorReferenceByConstructor(source, m_subClassAA.getName(), "()V")
187 ) ); 177 ));
188 178
189 // baseClass.getName() 179 // baseClass.getName()
190 source = new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ); 180 source = new MethodEntry(m_baseClass, "a", "()Ljava/lang/String;");
191 references = m_index.getBehaviorReferences( source ); 181 references = m_index.getBehaviorReferences(source);
192 assertThat( references, containsInAnyOrder( 182 assertThat(references, containsInAnyOrder(
193 newBehaviorReferenceByMethod( source, m_subClassAA.getName(), "a", "()Ljava/lang/String;" ), 183 newBehaviorReferenceByMethod(source, m_subClassAA.getName(), "a", "()Ljava/lang/String;"),
194 newBehaviorReferenceByMethod( source, m_subClassB.getName(), "a", "()V" ) 184 newBehaviorReferenceByMethod(source, m_subClassB.getName(), "a", "()V")
195 ) ); 185 ));
196 186
197 // subclassAA.getName() 187 // subclassAA.getName()
198 source = new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ); 188 source = new MethodEntry(m_subClassAA, "a", "()Ljava/lang/String;");
199 references = m_index.getBehaviorReferences( source ); 189 references = m_index.getBehaviorReferences(source);
200 assertThat( references, containsInAnyOrder( 190 assertThat(references, containsInAnyOrder(
201 newBehaviorReferenceByMethod( source, m_subClassAA.getName(), "a", "()V" ) 191 newBehaviorReferenceByMethod(source, m_subClassAA.getName(), "a", "()V")
202 ) ); 192 ));
203 } 193 }
204 194
205 @Test 195 @Test
206 public void containsEntries( ) 196 public void containsEntries() {
207 { 197
208 // classes 198 // classes
209 assertThat( m_index.containsObfClass( m_baseClass ), is( true ) ); 199 assertThat(m_index.containsObfClass(m_baseClass), is(true));
210 assertThat( m_index.containsObfClass( m_subClassA ), is( true ) ); 200 assertThat(m_index.containsObfClass(m_subClassA), is(true));
211 assertThat( m_index.containsObfClass( m_subClassAA ), is( true ) ); 201 assertThat(m_index.containsObfClass(m_subClassAA), is(true));
212 assertThat( m_index.containsObfClass( m_subClassB ), is( true ) ); 202 assertThat(m_index.containsObfClass(m_subClassB), is(true));
213 203
214 // fields 204 // fields
215 assertThat( m_index.containsObfField( m_nameField ), is( true ) ); 205 assertThat(m_index.containsObfField(m_nameField), is(true));
216 assertThat( m_index.containsObfField( m_numThingsField ), is( true ) ); 206 assertThat(m_index.containsObfField(m_numThingsField), is(true));
217 207
218 // methods 208 // methods
219 // getName() 209 // getName()
220 assertThat( m_index.containsObfBehavior( new MethodEntry( m_baseClass, "a", "()Ljava/lang/String;" ) ), is( true ) ); 210 assertThat(m_index.containsObfBehavior(new MethodEntry(m_baseClass, "a", "()Ljava/lang/String;")), is(true));
221 assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassA, "a", "()Ljava/lang/String;" ) ), is( false ) ); 211 assertThat(m_index.containsObfBehavior(new MethodEntry(m_subClassA, "a", "()Ljava/lang/String;")), is(false));
222 assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassAA, "a", "()Ljava/lang/String;" ) ), is( true ) ); 212 assertThat(m_index.containsObfBehavior(new MethodEntry(m_subClassAA, "a", "()Ljava/lang/String;")), is(true));
223 assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassB, "a", "()Ljava/lang/String;" ) ), is( false ) ); 213 assertThat(m_index.containsObfBehavior(new MethodEntry(m_subClassB, "a", "()Ljava/lang/String;")), is(false));
224 214
225 // doBaseThings() 215 // doBaseThings()
226 assertThat( m_index.containsObfBehavior( new MethodEntry( m_baseClass, "a", "()V" ) ), is( true ) ); 216 assertThat(m_index.containsObfBehavior(new MethodEntry(m_baseClass, "a", "()V")), is(true));
227 assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassA, "a", "()V" ) ), is( false ) ); 217 assertThat(m_index.containsObfBehavior(new MethodEntry(m_subClassA, "a", "()V")), is(false));
228 assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassAA, "a", "()V" ) ), is( true ) ); 218 assertThat(m_index.containsObfBehavior(new MethodEntry(m_subClassAA, "a", "()V")), is(true));
229 assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassB, "a", "()V" ) ), is( true ) ); 219 assertThat(m_index.containsObfBehavior(new MethodEntry(m_subClassB, "a", "()V")), is(true));
230 220
231 // doBThings() 221 // doBThings()
232 assertThat( m_index.containsObfBehavior( new MethodEntry( m_baseClass, "b", "()V" ) ), is( false ) ); 222 assertThat(m_index.containsObfBehavior(new MethodEntry(m_baseClass, "b", "()V")), is(false));
233 assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassA, "b", "()V" ) ), is( false ) ); 223 assertThat(m_index.containsObfBehavior(new MethodEntry(m_subClassA, "b", "()V")), is(false));
234 assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassAA, "b", "()V" ) ), is( false ) ); 224 assertThat(m_index.containsObfBehavior(new MethodEntry(m_subClassAA, "b", "()V")), is(false));
235 assertThat( m_index.containsObfBehavior( new MethodEntry( m_subClassB, "b", "()V" ) ), is( true ) ); 225 assertThat(m_index.containsObfBehavior(new MethodEntry(m_subClassB, "b", "()V")), is(true));
236 226
237 } 227 }
238} 228}
diff --git a/test/cuchaz/enigma/TestJarIndexLoneClass.java b/test/cuchaz/enigma/TestJarIndexLoneClass.java
index e2a87d0..0575eec 100644
--- a/test/cuchaz/enigma/TestJarIndexLoneClass.java
+++ b/test/cuchaz/enigma/TestJarIndexLoneClass.java
@@ -33,154 +33,136 @@ import cuchaz.enigma.mapping.FieldEntry;
33import cuchaz.enigma.mapping.MethodEntry; 33import cuchaz.enigma.mapping.MethodEntry;
34import cuchaz.enigma.mapping.Translator; 34import cuchaz.enigma.mapping.Translator;
35 35
36public class TestJarIndexLoneClass 36public class TestJarIndexLoneClass {
37{ 37
38 private JarIndex m_index; 38 private JarIndex m_index;
39 39
40 public TestJarIndexLoneClass( ) 40 public TestJarIndexLoneClass() throws Exception {
41 throws Exception
42 {
43 m_index = new JarIndex(); 41 m_index = new JarIndex();
44 m_index.indexJar( new JarFile( "build/libs/testLoneClass.obf.jar" ), false ); 42 m_index.indexJar(new JarFile("build/libs/testLoneClass.obf.jar"), false);
45 } 43 }
46 44
47 @Test 45 @Test
48 public void obfEntries( ) 46 public void obfEntries() {
49 { 47 assertThat(m_index.getObfClassEntries(), containsInAnyOrder(
50 assertThat( m_index.getObfClassEntries(), containsInAnyOrder( 48 newClass("cuchaz/enigma/inputs/Keep"),
51 newClass( "cuchaz/enigma/inputs/Keep" ), 49 newClass("none/a")
52 newClass( "none/a" ) 50 ));
53 ) );
54 } 51 }
55 52
56 @Test 53 @Test
57 public void translationIndex( ) 54 public void translationIndex() {
58 { 55 assertThat(m_index.getTranslationIndex().getSuperclassName("none/a"), is(nullValue()));
59 assertThat( m_index.getTranslationIndex().getSuperclassName( "none/a" ), is( nullValue() ) ); 56 assertThat(m_index.getTranslationIndex().getSuperclassName("cuchaz/enigma/inputs/Keep"), is(nullValue()));
60 assertThat( m_index.getTranslationIndex().getSuperclassName( "cuchaz/enigma/inputs/Keep" ), is( nullValue() ) ); 57 assertThat(m_index.getTranslationIndex().getAncestry("none/a"), is(empty()));
61 assertThat( m_index.getTranslationIndex().getAncestry( "none/a" ), is( empty() ) ); 58 assertThat(m_index.getTranslationIndex().getAncestry("cuchaz/enigma/inputs/Keep"), is(empty()));
62 assertThat( m_index.getTranslationIndex().getAncestry( "cuchaz/enigma/inputs/Keep" ), is( empty() ) ); 59 assertThat(m_index.getTranslationIndex().getSubclassNames("none/a"), is(empty()));
63 assertThat( m_index.getTranslationIndex().getSubclassNames( "none/a" ), is( empty() ) ); 60 assertThat(m_index.getTranslationIndex().getSubclassNames("cuchaz/enigma/inputs/Keep"), is(empty()));
64 assertThat( m_index.getTranslationIndex().getSubclassNames( "cuchaz/enigma/inputs/Keep" ), is( empty() ) );
65 } 61 }
66 62
67 @Test 63 @Test
68 public void access( ) 64 public void access() {
69 { 65 assertThat(m_index.getAccess(newField("none/a", "a")), is(Access.Private));
70 assertThat( m_index.getAccess( newField( "none/a", "a" ) ), is( Access.Private ) ); 66 assertThat(m_index.getAccess(newMethod("none/a", "a", "()Ljava/lang/String;")), is(Access.Public));
71 assertThat( m_index.getAccess( newMethod( "none/a", "a", "()Ljava/lang/String;" ) ), is( Access.Public ) ); 67 assertThat(m_index.getAccess(newField("none/a", "b")), is(nullValue()));
72 assertThat( m_index.getAccess( newField( "none/a", "b" ) ), is( nullValue() ) );
73 } 68 }
74 69
75 @Test 70 @Test
76 public void classInheritance( ) 71 public void classInheritance() {
77 { 72 ClassInheritanceTreeNode node = m_index.getClassInheritance(new Translator(), newClass("none/a"));
78 ClassInheritanceTreeNode node = m_index.getClassInheritance( new Translator(), newClass( "none/a" ) ); 73 assertThat(node, is(not(nullValue())));
79 assertThat( node, is( not( nullValue() ) ) ); 74 assertThat(node.getObfClassName(), is("none/a"));
80 assertThat( node.getObfClassName(), is( "none/a" ) ); 75 assertThat(node.getChildCount(), is(0));
81 assertThat( node.getChildCount(), is( 0 ) );
82 } 76 }
83 77
84 @Test 78 @Test
85 public void methodInheritance( ) 79 public void methodInheritance() {
86 { 80 MethodEntry source = newMethod("none/a", "a", "()Ljava/lang/String;");
87 MethodEntry source = newMethod( "none/a", "a", "()Ljava/lang/String;" ); 81 MethodInheritanceTreeNode node = m_index.getMethodInheritance(new Translator(), source);
88 MethodInheritanceTreeNode node = m_index.getMethodInheritance( new Translator(), source ); 82 assertThat(node, is(not(nullValue())));
89 assertThat( node, is( not( nullValue() ) ) ); 83 assertThat(node.getMethodEntry(), is(source));
90 assertThat( node.getMethodEntry(), is( source ) ); 84 assertThat(node.getChildCount(), is(0));
91 assertThat( node.getChildCount(), is( 0 ) );
92 } 85 }
93 86
94 @Test 87 @Test
95 public void classImplementations( ) 88 public void classImplementations() {
96 { 89 ClassImplementationsTreeNode node = m_index.getClassImplementations(new Translator(), newClass("none/a"));
97 ClassImplementationsTreeNode node = m_index.getClassImplementations( new Translator(), newClass( "none/a" ) ); 90 assertThat(node, is(nullValue()));
98 assertThat( node, is( nullValue() ) );
99 } 91 }
100 92
101 @Test 93 @Test
102 public void methodImplementations( ) 94 public void methodImplementations() {
103 { 95 MethodEntry source = newMethod("none/a", "a", "()Ljava/lang/String;");
104 MethodEntry source = newMethod( "none/a", "a", "()Ljava/lang/String;" ); 96 MethodImplementationsTreeNode node = m_index.getMethodImplementations(new Translator(), source);
105 MethodImplementationsTreeNode node = m_index.getMethodImplementations( new Translator(), source ); 97 assertThat(node, is(nullValue()));
106 assertThat( node, is( nullValue() ) );
107 } 98 }
108 99
109 @Test 100 @Test
110 public void relatedMethodImplementations( ) 101 public void relatedMethodImplementations() {
111 { 102 Set<MethodEntry> entries = m_index.getRelatedMethodImplementations(newMethod("none/a", "a", "()Ljava/lang/String;"));
112 Set<MethodEntry> entries = m_index.getRelatedMethodImplementations( newMethod( "none/a", "a", "()Ljava/lang/String;" ) ); 103 assertThat(entries, containsInAnyOrder(
113 assertThat( entries, containsInAnyOrder( newMethod( "none/a", "a", "()Ljava/lang/String;" ) ) ); 104 newMethod("none/a", "a", "()Ljava/lang/String;")
105 ));
114 } 106 }
115 107
116 @Test 108 @Test
117 @SuppressWarnings( "unchecked" ) 109 @SuppressWarnings("unchecked")
118 public void fieldReferences( ) 110 public void fieldReferences() {
119 { 111 FieldEntry source = newField("none/a", "a");
120 FieldEntry source = newField( "none/a", "a" ); 112 Collection<EntryReference<FieldEntry,BehaviorEntry>> references = m_index.getFieldReferences(source);
121 Collection<EntryReference<FieldEntry,BehaviorEntry>> references = m_index.getFieldReferences( source ); 113 assertThat(references, containsInAnyOrder(
122 assertThat( references, containsInAnyOrder( 114 newFieldReferenceByConstructor(source, "none/a", "(Ljava/lang/String;)V"),
123 newFieldReferenceByConstructor( source, "none/a", "(Ljava/lang/String;)V" ), 115 newFieldReferenceByMethod(source, "none/a", "a", "()Ljava/lang/String;")
124 newFieldReferenceByMethod( source, "none/a", "a", "()Ljava/lang/String;" ) 116 ));
125 ) );
126 } 117 }
127 118
128 @Test 119 @Test
129 public void behaviorReferences( ) 120 public void behaviorReferences() {
130 { 121 assertThat(m_index.getBehaviorReferences(newMethod("none/a", "a", "()Ljava/lang/String;")), is(empty()));
131 assertThat( m_index.getBehaviorReferences( newMethod( "none/a", "a", "()Ljava/lang/String;" ) ), is( empty() ) );
132 } 122 }
133 123
134 @Test 124 @Test
135 public void innerClasses( ) 125 public void innerClasses() {
136 { 126 assertThat(m_index.getInnerClasses("none/a"), is(empty()));
137 assertThat( m_index.getInnerClasses( "none/a" ), is( empty() ) );
138 } 127 }
139 128
140 @Test 129 @Test
141 public void outerClass( ) 130 public void outerClass() {
142 { 131 assertThat(m_index.getOuterClass("a"), is(nullValue()));
143 assertThat( m_index.getOuterClass( "a" ), is( nullValue() ) );
144 } 132 }
145 133
146 @Test 134 @Test
147 public void isAnonymousClass( ) 135 public void isAnonymousClass() {
148 { 136 assertThat(m_index.isAnonymousClass("none/a"), is(false));
149 assertThat( m_index.isAnonymousClass( "none/a" ), is( false ) );
150 } 137 }
151 138
152 @Test 139 @Test
153 public void interfaces( ) 140 public void interfaces() {
154 { 141 assertThat(m_index.getInterfaces("none/a"), is(empty()));
155 assertThat( m_index.getInterfaces( "none/a" ), is( empty() ) );
156 } 142 }
157 143
158 @Test 144 @Test
159 public void implementingClasses( ) 145 public void implementingClasses() {
160 { 146 assertThat(m_index.getImplementingClasses("none/a"), is(empty()));
161 assertThat( m_index.getImplementingClasses( "none/a" ), is( empty() ) );
162 } 147 }
163 148
164 @Test 149 @Test
165 public void isInterface( ) 150 public void isInterface() {
166 { 151 assertThat(m_index.isInterface("none/a"), is(false));
167 assertThat( m_index.isInterface( "none/a" ), is( false ) );
168 } 152 }
169 153
170 @Test 154 @Test
171 public void bridgeMethods( ) 155 public void bridgeMethods() {
172 { 156 assertThat(m_index.getBridgeMethod(newMethod("none/a", "a", "()Ljava/lang/String;")), is(nullValue()));
173 assertThat( m_index.getBridgeMethod( newMethod( "none/a", "a", "()Ljava/lang/String;" ) ), is( nullValue() ) );
174 } 157 }
175 158
176 @Test 159 @Test
177 public void contains( ) 160 public void contains() {
178 { 161 assertThat(m_index.containsObfClass(newClass("none/a")), is(true));
179 assertThat( m_index.containsObfClass( newClass( "none/a" ) ), is( true ) ); 162 assertThat(m_index.containsObfClass(newClass("none/b")), is(false));
180 assertThat( m_index.containsObfClass( newClass( "none/b" ) ), is( false ) ); 163 assertThat(m_index.containsObfField(newField("none/a", "a")), is(true));
181 assertThat( m_index.containsObfField( newField( "none/a", "a" ) ), is( true ) ); 164 assertThat(m_index.containsObfField(newField("none/a", "b")), is(false));
182 assertThat( m_index.containsObfField( newField( "none/a", "b" ) ), is( false ) ); 165 assertThat(m_index.containsObfBehavior(newMethod("none/a", "a", "()Ljava/lang/String;")), is(true));
183 assertThat( m_index.containsObfBehavior( newMethod( "none/a", "a", "()Ljava/lang/String;" ) ), is( true ) ); 166 assertThat(m_index.containsObfBehavior(newMethod("none/a", "b", "()Ljava/lang/String;")), is(false));
184 assertThat( m_index.containsObfBehavior( newMethod( "none/a", "b", "()Ljava/lang/String;" ) ), is( false ) );
185 } 167 }
186} 168}
diff --git a/test/cuchaz/enigma/TestSourceIndex.java b/test/cuchaz/enigma/TestSourceIndex.java
index dc6ca7e..fb385e0 100644
--- a/test/cuchaz/enigma/TestSourceIndex.java
+++ b/test/cuchaz/enigma/TestSourceIndex.java
@@ -21,35 +21,27 @@ import com.strobel.decompiler.languages.java.ast.CompilationUnit;
21 21
22import cuchaz.enigma.mapping.ClassEntry; 22import cuchaz.enigma.mapping.ClassEntry;
23 23
24public class TestSourceIndex 24public class TestSourceIndex {
25{ 25
26 @Test 26 @Test
27 public void indexEverything( ) 27 public void indexEverything() throws Exception {
28 throws Exception 28 Deobfuscator deobfuscator = new Deobfuscator(new File("input/1.8.jar"));
29 {
30 Deobfuscator deobfuscator = new Deobfuscator( new File( "input/1.8.jar" ) );
31 29
32 // get all classes that aren't inner classes 30 // get all classes that aren't inner classes
33 Set<ClassEntry> classEntries = Sets.newHashSet(); 31 Set<ClassEntry> classEntries = Sets.newHashSet();
34 for( ClassEntry obfClassEntry : deobfuscator.getJarIndex().getObfClassEntries() ) 32 for (ClassEntry obfClassEntry : deobfuscator.getJarIndex().getObfClassEntries()) {
35 { 33 if (!obfClassEntry.isInnerClass()) {
36 if( !obfClassEntry.isInnerClass() ) 34 classEntries.add(obfClassEntry);
37 {
38 classEntries.add( obfClassEntry );
39 } 35 }
40 } 36 }
41 37
42 for( ClassEntry obfClassEntry : classEntries ) 38 for (ClassEntry obfClassEntry : classEntries) {
43 { 39 try {
44 try 40 CompilationUnit tree = deobfuscator.getSourceTree(obfClassEntry.getName());
45 { 41 String source = deobfuscator.getSource(tree);
46 CompilationUnit tree = deobfuscator.getSourceTree( obfClassEntry.getName() ); 42 deobfuscator.getSourceIndex(tree, source);
47 String source = deobfuscator.getSource( tree ); 43 } catch (Throwable t) {
48 deobfuscator.getSourceIndex( tree, source ); 44 throw new Error("Unable to index " + obfClassEntry, t);
49 }
50 catch( Throwable t )
51 {
52 throw new Error( "Unable to index " + obfClassEntry, t );
53 } 45 }
54 } 46 }
55 } 47 }
diff --git a/test/cuchaz/enigma/TestTokensConstructors.java b/test/cuchaz/enigma/TestTokensConstructors.java
index 2409153..f805a65 100644
--- a/test/cuchaz/enigma/TestTokensConstructors.java
+++ b/test/cuchaz/enigma/TestTokensConstructors.java
@@ -24,129 +24,116 @@ import org.junit.Test;
24 24
25import cuchaz.enigma.mapping.BehaviorEntry; 25import cuchaz.enigma.mapping.BehaviorEntry;
26 26
27public class TestTokensConstructors extends TokenChecker 27public class TestTokensConstructors extends TokenChecker {
28{ 28
29 public TestTokensConstructors( ) 29 public TestTokensConstructors() throws Exception {
30 throws Exception 30 super(new File("build/libs/testConstructors.obf.jar"));
31 {
32 super( new File( "build/libs/testConstructors.obf.jar" ) );
33 } 31 }
34 32
35 @Test 33 @Test
36 public void baseDeclarations( ) 34 public void baseDeclarations() {
37 { 35 assertThat(getDeclarationToken(newConstructor("none/a", "()V")), is("a"));
38 assertThat( getDeclarationToken( newConstructor( "none/a", "()V" ) ), is( "a" ) ); 36 assertThat(getDeclarationToken(newConstructor("none/a", "(I)V")), is("a"));
39 assertThat( getDeclarationToken( newConstructor( "none/a", "(I)V" ) ), is( "a" ) );
40 } 37 }
41 38
42 @Test 39 @Test
43 public void subDeclarations( ) 40 public void subDeclarations() {
44 { 41 assertThat(getDeclarationToken(newConstructor("none/d", "()V")), is("d"));
45 assertThat( getDeclarationToken( newConstructor( "none/d", "()V" ) ), is( "d" ) ); 42 assertThat(getDeclarationToken(newConstructor("none/d", "(I)V")), is("d"));
46 assertThat( getDeclarationToken( newConstructor( "none/d", "(I)V" ) ), is( "d" ) ); 43 assertThat(getDeclarationToken(newConstructor("none/d", "(II)V")), is("d"));
47 assertThat( getDeclarationToken( newConstructor( "none/d", "(II)V" ) ), is( "d" ) ); 44 assertThat(getDeclarationToken(newConstructor("none/d", "(III)V")), is("d"));
48 assertThat( getDeclarationToken( newConstructor( "none/d", "(III)V" ) ), is( "d" ) );
49 } 45 }
50 46
51 @Test 47 @Test
52 public void subsubDeclarations( ) 48 public void subsubDeclarations() {
53 { 49 assertThat(getDeclarationToken(newConstructor("none/e", "(I)V")), is("e"));
54 assertThat( getDeclarationToken( newConstructor( "none/e", "(I)V" ) ), is( "e" ) );
55 } 50 }
56 51
57 @Test 52 @Test
58 public void defaultDeclarations( ) 53 public void defaultDeclarations() {
59 { 54 assertThat(getDeclarationToken(newConstructor("none/c", "()V")), nullValue());
60 assertThat( getDeclarationToken( newConstructor( "none/c", "()V" ) ), nullValue() );
61 } 55 }
62 56
63 @Test 57 @Test
64 public void baseDefaultReferences( ) 58 public void baseDefaultReferences() {
65 { 59 BehaviorEntry source = newConstructor("none/a", "()V");
66 BehaviorEntry source = newConstructor( "none/a", "()V" );
67 assertThat( 60 assertThat(
68 getReferenceTokens( newBehaviorReferenceByMethod( source, "none/b", "a", "()V" ) ), 61 getReferenceTokens(newBehaviorReferenceByMethod(source, "none/b", "a", "()V")),
69 containsInAnyOrder( "a" ) 62 containsInAnyOrder("a")
70 ); 63 );
71 assertThat( 64 assertThat(
72 getReferenceTokens( newBehaviorReferenceByConstructor( source, "none/d", "()V" ) ), 65 getReferenceTokens(newBehaviorReferenceByConstructor(source, "none/d", "()V")),
73 containsInAnyOrder( "super" ) // implicit call, decompiled to "super" 66 containsInAnyOrder("super") // implicit call, decompiled to "super"
74 ); 67 );
75 assertThat( 68 assertThat(
76 getReferenceTokens( newBehaviorReferenceByConstructor( source, "none/d", "(III)V" ) ), 69 getReferenceTokens(newBehaviorReferenceByConstructor(source, "none/d", "(III)V")),
77 containsInAnyOrder( "super" ) // implicit call, decompiled to "super" 70 containsInAnyOrder("super") // implicit call, decompiled to "super"
78 ); 71 );
79 } 72 }
80 73
81 @Test 74 @Test
82 public void baseIntReferences( ) 75 public void baseIntReferences() {
83 { 76 BehaviorEntry source = newConstructor("none/a", "(I)V");
84 BehaviorEntry source = newConstructor( "none/a", "(I)V" );
85 assertThat( 77 assertThat(
86 getReferenceTokens( newBehaviorReferenceByMethod( source, "none/b", "b", "()V" ) ), 78 getReferenceTokens(newBehaviorReferenceByMethod(source, "none/b", "b", "()V")),
87 containsInAnyOrder( "a" ) 79 containsInAnyOrder("a")
88 ); 80 );
89 } 81 }
90 82
91 @Test 83 @Test
92 public void subDefaultReferences( ) 84 public void subDefaultReferences() {
93 { 85 BehaviorEntry source = newConstructor("none/d", "()V");
94 BehaviorEntry source = newConstructor( "none/d", "()V" );
95 assertThat( 86 assertThat(
96 getReferenceTokens( newBehaviorReferenceByMethod( source, "none/b", "c", "()V" ) ), 87 getReferenceTokens(newBehaviorReferenceByMethod(source, "none/b", "c", "()V")),
97 containsInAnyOrder( "d" ) 88 containsInAnyOrder("d")
98 ); 89 );
99 assertThat( 90 assertThat(
100 getReferenceTokens( newBehaviorReferenceByConstructor( source, "none/d", "(I)V" ) ), 91 getReferenceTokens(newBehaviorReferenceByConstructor(source, "none/d", "(I)V")),
101 containsInAnyOrder( "this" ) 92 containsInAnyOrder("this")
102 ); 93 );
103 } 94 }
104 95
105 @Test 96 @Test
106 public void subIntReferences( ) 97 public void subIntReferences() {
107 { 98 BehaviorEntry source = newConstructor("none/d", "(I)V");
108 BehaviorEntry source = newConstructor( "none/d", "(I)V" ); 99 assertThat(getReferenceTokens(
109 assertThat( 100 newBehaviorReferenceByMethod(source, "none/b", "d", "()V")),
110 getReferenceTokens( newBehaviorReferenceByMethod( source, "none/b", "d", "()V" ) ), 101 containsInAnyOrder("d")
111 containsInAnyOrder( "d" )
112 ); 102 );
113 assertThat( 103 assertThat(getReferenceTokens(
114 getReferenceTokens( newBehaviorReferenceByConstructor( source, "none/d", "(II)V" ) ), 104 newBehaviorReferenceByConstructor(source, "none/d", "(II)V")),
115 containsInAnyOrder( "this" ) 105 containsInAnyOrder("this")
116 ); 106 );
117 assertThat( 107 assertThat(getReferenceTokens(
118 getReferenceTokens( newBehaviorReferenceByConstructor( source, "none/e", "(I)V" ) ), 108 newBehaviorReferenceByConstructor(source, "none/e", "(I)V")),
119 containsInAnyOrder( "super" ) 109 containsInAnyOrder("super")
120 ); 110 );
121 } 111 }
122 112
123 @Test 113 @Test
124 public void subIntIntReferences( ) 114 public void subIntIntReferences() {
125 { 115 BehaviorEntry source = newConstructor("none/d", "(II)V");
126 BehaviorEntry source = newConstructor( "none/d", "(II)V" );
127 assertThat( 116 assertThat(
128 getReferenceTokens( newBehaviorReferenceByMethod( source, "none/b", "e", "()V" ) ), 117 getReferenceTokens(newBehaviorReferenceByMethod(source, "none/b", "e", "()V")),
129 containsInAnyOrder( "d" ) 118 containsInAnyOrder("d")
130 ); 119 );
131 } 120 }
132 121
133 @Test 122 @Test
134 public void subsubIntReferences( ) 123 public void subsubIntReferences() {
135 { 124 BehaviorEntry source = newConstructor("none/e", "(I)V");
136 BehaviorEntry source = newConstructor( "none/e", "(I)V" );
137 assertThat( 125 assertThat(
138 getReferenceTokens( newBehaviorReferenceByMethod( source, "none/b", "f", "()V" ) ), 126 getReferenceTokens(newBehaviorReferenceByMethod(source, "none/b", "f", "()V")),
139 containsInAnyOrder( "e" ) 127 containsInAnyOrder("e")
140 ); 128 );
141 } 129 }
142 130
143 @Test 131 @Test
144 public void defaultConstructableReferences( ) 132 public void defaultConstructableReferences() {
145 { 133 BehaviorEntry source = newConstructor("none/c", "()V");
146 BehaviorEntry source = newConstructor( "none/c", "()V" );
147 assertThat( 134 assertThat(
148 getReferenceTokens( newBehaviorReferenceByMethod( source, "none/b", "g", "()V" ) ), 135 getReferenceTokens(newBehaviorReferenceByMethod(source, "none/b", "g", "()V")),
149 containsInAnyOrder( "c" ) 136 containsInAnyOrder("c")
150 ); 137 );
151 } 138 }
152} 139}
diff --git a/test/cuchaz/enigma/TokenChecker.java b/test/cuchaz/enigma/TokenChecker.java
index c0852f3..524c5ec 100644
--- a/test/cuchaz/enigma/TokenChecker.java
+++ b/test/cuchaz/enigma/TokenChecker.java
@@ -23,47 +23,41 @@ import cuchaz.enigma.analysis.SourceIndex;
23import cuchaz.enigma.analysis.Token; 23import cuchaz.enigma.analysis.Token;
24import cuchaz.enigma.mapping.Entry; 24import cuchaz.enigma.mapping.Entry;
25 25
26public class TokenChecker 26public class TokenChecker {
27{ 27
28 private Deobfuscator m_deobfuscator; 28 private Deobfuscator m_deobfuscator;
29 29
30 protected TokenChecker( File jarFile ) 30 protected TokenChecker(File jarFile) throws IOException {
31 throws IOException 31 m_deobfuscator = new Deobfuscator(jarFile);
32 {
33 m_deobfuscator = new Deobfuscator( jarFile );
34 } 32 }
35 33
36 protected String getDeclarationToken( Entry entry ) 34 protected String getDeclarationToken(Entry entry) {
37 {
38 // decompile the class 35 // decompile the class
39 CompilationUnit tree = m_deobfuscator.getSourceTree( entry.getClassName() ); 36 CompilationUnit tree = m_deobfuscator.getSourceTree(entry.getClassName());
40 // DEBUG 37 // DEBUG
41 //tree.acceptVisitor( new TreeDumpVisitor( new File( "tree." + entry.getClassName().replace( '/', '.' ) + ".txt" ) ), null ); 38 // tree.acceptVisitor( new TreeDumpVisitor( new File( "tree." + entry.getClassName().replace( '/', '.' ) + ".txt" ) ), null );
42 String source = m_deobfuscator.getSource( tree ); 39 String source = m_deobfuscator.getSource(tree);
43 SourceIndex index = m_deobfuscator.getSourceIndex( tree, source ); 40 SourceIndex index = m_deobfuscator.getSourceIndex(tree, source);
44 41
45 // get the token value 42 // get the token value
46 Token token = index.getDeclarationToken( entry ); 43 Token token = index.getDeclarationToken(entry);
47 if( token == null ) 44 if (token == null) {
48 {
49 return null; 45 return null;
50 } 46 }
51 return source.substring( token.start, token.end ); 47 return source.substring(token.start, token.end);
52 } 48 }
53 49
54 @SuppressWarnings( "unchecked" ) 50 @SuppressWarnings("unchecked")
55 protected Collection<String> getReferenceTokens( EntryReference<? extends Entry,? extends Entry> reference ) 51 protected Collection<String> getReferenceTokens(EntryReference<? extends Entry,? extends Entry> reference) {
56 {
57 // decompile the class 52 // decompile the class
58 CompilationUnit tree = m_deobfuscator.getSourceTree( reference.context.getClassName() ); 53 CompilationUnit tree = m_deobfuscator.getSourceTree(reference.context.getClassName());
59 String source = m_deobfuscator.getSource( tree ); 54 String source = m_deobfuscator.getSource(tree);
60 SourceIndex index = m_deobfuscator.getSourceIndex( tree, source ); 55 SourceIndex index = m_deobfuscator.getSourceIndex(tree, source);
61 56
62 // get the token values 57 // get the token values
63 List<String> values = Lists.newArrayList(); 58 List<String> values = Lists.newArrayList();
64 for( Token token : index.getReferenceTokens( (EntryReference<Entry,Entry>)reference ) ) 59 for (Token token : index.getReferenceTokens((EntryReference<Entry,Entry>)reference)) {
65 { 60 values.add(source.substring(token.start, token.end));
66 values.add( source.substring( token.start, token.end ) );
67 } 61 }
68 return values; 62 return values;
69 } 63 }
diff --git a/test/cuchaz/enigma/inputs/Keep.java b/test/cuchaz/enigma/inputs/Keep.java
index 3c12bae..390e82f 100644
--- a/test/cuchaz/enigma/inputs/Keep.java
+++ b/test/cuchaz/enigma/inputs/Keep.java
@@ -1,9 +1,7 @@
1package cuchaz.enigma.inputs; 1package cuchaz.enigma.inputs;
2 2
3public class Keep 3public class Keep {
4{ 4 public static void main(String[] args) {
5 public static void main( String[] args ) 5 System.out.println("Keep me!");
6 {
7 System.out.println( "Keep me!" );
8 } 6 }
9} 7}
diff --git a/test/cuchaz/enigma/inputs/constructors/BaseClass.java b/test/cuchaz/enigma/inputs/constructors/BaseClass.java
index e6d8768..9345308 100644
--- a/test/cuchaz/enigma/inputs/constructors/BaseClass.java
+++ b/test/cuchaz/enigma/inputs/constructors/BaseClass.java
@@ -1,17 +1,15 @@
1package cuchaz.enigma.inputs.constructors; 1package cuchaz.enigma.inputs.constructors;
2 2
3// none/a 3// none/a
4public class BaseClass 4public class BaseClass {
5{ 5
6 // <init>()V 6 // <init>()V
7 public BaseClass( ) 7 public BaseClass() {
8 { 8 System.out.println("Default constructor");
9 System.out.println( "Default constructor" );
10 } 9 }
11 10
12 // <init>(I)V 11 // <init>(I)V
13 public BaseClass( int i ) 12 public BaseClass(int i) {
14 { 13 System.out.println("Int constructor " + i);
15 System.out.println( "Int constructor " + i );
16 } 14 }
17} 15}
diff --git a/test/cuchaz/enigma/inputs/constructors/Caller.java b/test/cuchaz/enigma/inputs/constructors/Caller.java
index b218619..5727875 100644
--- a/test/cuchaz/enigma/inputs/constructors/Caller.java
+++ b/test/cuchaz/enigma/inputs/constructors/Caller.java
@@ -1,54 +1,47 @@
1package cuchaz.enigma.inputs.constructors; 1package cuchaz.enigma.inputs.constructors;
2 2
3// none/b 3// none/b
4public class Caller 4public class Caller {
5{ 5
6 // a()V 6 // a()V
7 public void callBaseDefault( ) 7 public void callBaseDefault() {
8 {
9 // none/a.<init>()V 8 // none/a.<init>()V
10 System.out.println( new BaseClass() ); 9 System.out.println(new BaseClass());
11 } 10 }
12 11
13 // b()V 12 // b()V
14 public void callBaseInt( ) 13 public void callBaseInt() {
15 {
16 // none/a.<init>(I)V 14 // none/a.<init>(I)V
17 System.out.println( new BaseClass( 5 ) ); 15 System.out.println(new BaseClass(5));
18 } 16 }
19 17
20 // c()V 18 // c()V
21 public void callSubDefault( ) 19 public void callSubDefault() {
22 {
23 // none/d.<init>()V 20 // none/d.<init>()V
24 System.out.println( new SubClass() ); 21 System.out.println(new SubClass());
25 } 22 }
26 23
27 // d()V 24 // d()V
28 public void callSubInt( ) 25 public void callSubInt() {
29 {
30 // none/d.<init>(I)V 26 // none/d.<init>(I)V
31 System.out.println( new SubClass( 6 ) ); 27 System.out.println(new SubClass(6));
32 } 28 }
33 29
34 // e()V 30 // e()V
35 public void callSubIntInt( ) 31 public void callSubIntInt() {
36 {
37 // none/d.<init>(II)V 32 // none/d.<init>(II)V
38 System.out.println( new SubClass( 4, 2 ) ); 33 System.out.println(new SubClass(4, 2));
39 } 34 }
40 35
41 // f()V 36 // f()V
42 public void callSubSubInt( ) 37 public void callSubSubInt() {
43 {
44 // none/e.<init>(I)V 38 // none/e.<init>(I)V
45 System.out.println( new SubSubClass( 3 ) ); 39 System.out.println(new SubSubClass(3));
46 } 40 }
47 41
48 // g()V 42 // g()V
49 public void callDefaultConstructable() 43 public void callDefaultConstructable() {
50 {
51 // none/c.<init>()V 44 // none/c.<init>()V
52 System.out.println( new DefaultConstructable() ); 45 System.out.println(new DefaultConstructable());
53 } 46 }
54} 47}
diff --git a/test/cuchaz/enigma/inputs/constructors/DefaultConstructable.java b/test/cuchaz/enigma/inputs/constructors/DefaultConstructable.java
index 6cfd35e..26a3ddb 100644
--- a/test/cuchaz/enigma/inputs/constructors/DefaultConstructable.java
+++ b/test/cuchaz/enigma/inputs/constructors/DefaultConstructable.java
@@ -1,6 +1,5 @@
1package cuchaz.enigma.inputs.constructors; 1package cuchaz.enigma.inputs.constructors;
2 2
3public class DefaultConstructable 3public class DefaultConstructable {
4{
5 // only default constructor 4 // only default constructor
6} 5}
diff --git a/test/cuchaz/enigma/inputs/constructors/SubClass.java b/test/cuchaz/enigma/inputs/constructors/SubClass.java
index 6ef7732..fecfa2b 100644
--- a/test/cuchaz/enigma/inputs/constructors/SubClass.java
+++ b/test/cuchaz/enigma/inputs/constructors/SubClass.java
@@ -1,32 +1,28 @@
1package cuchaz.enigma.inputs.constructors; 1package cuchaz.enigma.inputs.constructors;
2 2
3// none/d extends none/a 3// none/d extends none/a
4public class SubClass extends BaseClass 4public class SubClass extends BaseClass {
5{ 5
6 // <init>()V 6 // <init>()V
7 public SubClass( ) 7 public SubClass() {
8 {
9 // none/a.<init>()V 8 // none/a.<init>()V
10 } 9 }
11 10
12 // <init>(I)V 11 // <init>(I)V
13 public SubClass( int num ) 12 public SubClass(int num) {
14 {
15 // <init>()V 13 // <init>()V
16 this(); 14 this();
17 System.out.println( "SubClass " + num ); 15 System.out.println("SubClass " + num);
18 } 16 }
19 17
20 // <init>(II)V 18 // <init>(II)V
21 public SubClass( int a, int b ) 19 public SubClass(int a, int b) {
22 {
23 // <init>(I)V 20 // <init>(I)V
24 this( a + b ); 21 this(a + b);
25 } 22 }
26 23
27 // <init>(III)V 24 // <init>(III)V
28 public SubClass( int a, int b, int c ) 25 public SubClass(int a, int b, int c) {
29 {
30 // none/a.<init>()V 26 // none/a.<init>()V
31 } 27 }
32} 28}
diff --git a/test/cuchaz/enigma/inputs/constructors/SubSubClass.java b/test/cuchaz/enigma/inputs/constructors/SubSubClass.java
index 76a0f1f..ab84161 100644
--- a/test/cuchaz/enigma/inputs/constructors/SubSubClass.java
+++ b/test/cuchaz/enigma/inputs/constructors/SubSubClass.java
@@ -1,12 +1,11 @@
1package cuchaz.enigma.inputs.constructors; 1package cuchaz.enigma.inputs.constructors;
2 2
3// none/e extends none/d 3// none/e extends none/d
4public class SubSubClass extends SubClass 4public class SubSubClass extends SubClass {
5{ 5
6 // <init>(I)V 6 // <init>(I)V
7 public SubSubClass( int i ) 7 public SubSubClass(int i) {
8 {
9 // none/c.<init>(I)V 8 // none/c.<init>(I)V
10 super( i ); 9 super(i);
11 } 10 }
12} 11}
diff --git a/test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java b/test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java
index 8402dde..5b416c4 100644
--- a/test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java
+++ b/test/cuchaz/enigma/inputs/inheritanceTree/BaseClass.java
@@ -1,23 +1,21 @@
1package cuchaz.enigma.inputs.inheritanceTree; 1package cuchaz.enigma.inputs.inheritanceTree;
2 2
3// none/a 3// none/a
4public abstract class BaseClass 4public abstract class BaseClass {
5{ 5
6 // a 6 // a
7 private String m_name; 7 private String m_name;
8 8
9 // <init>(Ljava/lang/String;)V 9 // <init>(Ljava/lang/String;)V
10 protected BaseClass( String name ) 10 protected BaseClass(String name) {
11 {
12 m_name = name; 11 m_name = name;
13 } 12 }
14 13
15 // a()Ljava/lang/String; 14 // a()Ljava/lang/String;
16 public String getName( ) 15 public String getName() {
17 {
18 return m_name; 16 return m_name;
19 } 17 }
20 18
21 // a()V 19 // a()V
22 public abstract void doBaseThings( ); 20 public abstract void doBaseThings();
23} 21}
diff --git a/test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java
index ed50709..7a99d51 100644
--- a/test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java
+++ b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassA.java
@@ -1,12 +1,11 @@
1package cuchaz.enigma.inputs.inheritanceTree; 1package cuchaz.enigma.inputs.inheritanceTree;
2 2
3// none/b extends none/a 3// none/b extends none/a
4public abstract class SubclassA extends BaseClass 4public abstract class SubclassA extends BaseClass {
5{ 5
6 // <init>(Ljava/lang/String;)V 6 // <init>(Ljava/lang/String;)V
7 protected SubclassA( String name ) 7 protected SubclassA(String name) {
8 {
9 // call to none/a.<init>(Ljava/lang/String)V 8 // call to none/a.<init>(Ljava/lang/String)V
10 super( name ); 9 super(name);
11 } 10 }
12} 11}
diff --git a/test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java
index fc4c8ee..c9485d3 100644
--- a/test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java
+++ b/test/cuchaz/enigma/inputs/inheritanceTree/SubclassB.java
@@ -1,16 +1,15 @@
1package cuchaz.enigma.inputs.inheritanceTree; 1package cuchaz.enigma.inputs.inheritanceTree;
2 2
3// none/c extends none/a 3// none/c extends none/a
4public class SubclassB extends BaseClass 4public class SubclassB extends BaseClass {
5{ 5
6 // a 6 // a
7 private int m_numThings; 7 private int m_numThings;
8 8
9 // <init>()V 9 // <init>()V
10 protected SubclassB( ) 10 protected SubclassB() {
11 {
12 // none/a.<init>(Ljava/lang/String;)V 11 // none/a.<init>(Ljava/lang/String;)V
13 super( "B" ); 12 super("B");
14 13
15 // access to a 14 // access to a
16 m_numThings = 4; 15 m_numThings = 4;
@@ -18,16 +17,14 @@ public class SubclassB extends BaseClass
18 17
19 @Override 18 @Override
20 // a()V 19 // a()V
21 public void doBaseThings( ) 20 public void doBaseThings() {
22 {
23 // call to none/a.a()Ljava/lang/String; 21 // call to none/a.a()Ljava/lang/String;
24 System.out.println( "Base things by B! " + getName() ); 22 System.out.println("Base things by B! " + getName());
25 } 23 }
26 24
27 // b()V 25 // b()V
28 public void doBThings( ) 26 public void doBThings() {
29 {
30 // access to a 27 // access to a
31 System.out.println( "" + m_numThings + " B things!" ); 28 System.out.println("" + m_numThings + " B things!");
32 } 29 }
33} 30}
diff --git a/test/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java b/test/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java
index b3b8342..afd03ac 100644
--- a/test/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java
+++ b/test/cuchaz/enigma/inputs/inheritanceTree/SubsubclassAA.java
@@ -1,27 +1,24 @@
1package cuchaz.enigma.inputs.inheritanceTree; 1package cuchaz.enigma.inputs.inheritanceTree;
2 2
3// none/d extends none/b 3// none/d extends none/b
4public class SubsubclassAA extends SubclassA 4public class SubsubclassAA extends SubclassA {
5{ 5
6 protected SubsubclassAA( ) 6 protected SubsubclassAA() {
7 {
8 // call to none/b.<init>(Ljava/lang/String;)V 7 // call to none/b.<init>(Ljava/lang/String;)V
9 super( "AA" ); 8 super("AA");
10 } 9 }
11 10
12 @Override 11 @Override
13 // a()Ljava/lang/String; 12 // a()Ljava/lang/String;
14 public String getName( ) 13 public String getName() {
15 {
16 // call to none/b.a()Ljava/lang/String; 14 // call to none/b.a()Ljava/lang/String;
17 return "subsub" + super.getName(); 15 return "subsub" + super.getName();
18 } 16 }
19 17
20 @Override 18 @Override
21 // a()V 19 // a()V
22 public void doBaseThings( ) 20 public void doBaseThings() {
23 {
24 // call to none/d.a()Ljava/lang/String; 21 // call to none/d.a()Ljava/lang/String;
25 System.out.println( "Base things by " + getName() ); 22 System.out.println("Base things by " + getName());
26 } 23 }
27} 24}
diff --git a/test/cuchaz/enigma/inputs/innerClasses/Anonymous.java b/test/cuchaz/enigma/inputs/innerClasses/Anonymous.java
index d36a514..f5d9d1c 100644
--- a/test/cuchaz/enigma/inputs/innerClasses/Anonymous.java
+++ b/test/cuchaz/enigma/inputs/innerClasses/Anonymous.java
@@ -1,14 +1,11 @@
1package cuchaz.enigma.inputs.innerClasses; 1package cuchaz.enigma.inputs.innerClasses;
2 2
3public class Anonymous 3public class Anonymous {
4{ 4
5 public void foo( ) 5 public void foo() {
6 { 6 Runnable runnable = new Runnable() {
7 Runnable runnable = new Runnable( )
8 {
9 @Override 7 @Override
10 public void run( ) 8 public void run() {
11 {
12 // don't care 9 // don't care
13 } 10 }
14 }; 11 };
diff --git a/test/cuchaz/enigma/inputs/innerClasses/AnonymousWithScopeArgs.java b/test/cuchaz/enigma/inputs/innerClasses/AnonymousWithScopeArgs.java
index e0a65e2..b3ba1af 100644
--- a/test/cuchaz/enigma/inputs/innerClasses/AnonymousWithScopeArgs.java
+++ b/test/cuchaz/enigma/inputs/innerClasses/AnonymousWithScopeArgs.java
@@ -1,16 +1,13 @@
1package cuchaz.enigma.inputs.innerClasses; 1package cuchaz.enigma.inputs.innerClasses;
2 2
3public class AnonymousWithScopeArgs 3public class AnonymousWithScopeArgs {
4{ 4
5 public static void foo( final Simple arg ) 5 public static void foo(final Simple arg) {
6 { 6 System.out.println(new Object() {
7 System.out.println( new Object( )
8 {
9 @Override 7 @Override
10 public String toString( ) 8 public String toString() {
11 {
12 return arg.toString(); 9 return arg.toString();
13 } 10 }
14 } ); 11 });
15 } 12 }
16} 13}
diff --git a/test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java b/test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java
index e24395c..08135fe 100644
--- a/test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java
+++ b/test/cuchaz/enigma/inputs/innerClasses/ConstructorArgs.java
@@ -1,22 +1,20 @@
1package cuchaz.enigma.inputs.innerClasses; 1package cuchaz.enigma.inputs.innerClasses;
2 2
3@SuppressWarnings( "unused" ) 3@SuppressWarnings("unused")
4public class ConstructorArgs 4public class ConstructorArgs {
5{ 5
6 class Inner 6 class Inner {
7 { 7
8 private int a; 8 private int a;
9 9
10 public Inner( int a ) 10 public Inner(int a) {
11 {
12 this.a = a; 11 this.a = a;
13 } 12 }
14 } 13 }
15 14
16 Inner i; 15 Inner i;
17 16
18 public void foo( ) 17 public void foo() {
19 { 18 i = new Inner(5);
20 i = new Inner( 5 );
21 } 19 }
22} 20}
diff --git a/test/cuchaz/enigma/inputs/innerClasses/Simple.java b/test/cuchaz/enigma/inputs/innerClasses/Simple.java
index 405c639..cb536fa 100644
--- a/test/cuchaz/enigma/inputs/innerClasses/Simple.java
+++ b/test/cuchaz/enigma/inputs/innerClasses/Simple.java
@@ -1,9 +1,8 @@
1package cuchaz.enigma.inputs.innerClasses; 1package cuchaz.enigma.inputs.innerClasses;
2 2
3public class Simple 3public class Simple {
4{ 4
5 class Inner 5 class Inner {
6 {
7 // nothing to do 6 // nothing to do
8 } 7 }
9} 8}
diff --git a/test/cuchaz/enigma/inputs/loneClass/LoneClass.java b/test/cuchaz/enigma/inputs/loneClass/LoneClass.java
index 961b012..18c716e 100644
--- a/test/cuchaz/enigma/inputs/loneClass/LoneClass.java
+++ b/test/cuchaz/enigma/inputs/loneClass/LoneClass.java
@@ -1,16 +1,14 @@
1package cuchaz.enigma.inputs.loneClass; 1package cuchaz.enigma.inputs.loneClass;
2 2
3public class LoneClass 3public class LoneClass {
4{ 4
5 private String m_name; 5 private String m_name;
6 6
7 public LoneClass( String name ) 7 public LoneClass(String name) {
8 {
9 m_name = name; 8 m_name = name;
10 } 9 }
11 10
12 public String getName( ) 11 public String getName() {
13 {
14 return m_name; 12 return m_name;
15 } 13 }
16} 14}
HIC SVNT DRACONES