summaryrefslogtreecommitdiff
path: root/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java
diff options
context:
space:
mode:
Diffstat (limited to 'src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java')
-rw-r--r--src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java227
1 files changed, 0 insertions, 227 deletions
diff --git a/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java b/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java
deleted file mode 100644
index 76e379c..0000000
--- a/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java
+++ /dev/null
@@ -1,227 +0,0 @@
1/*******************************************************************************
2 * Copyright (c) 2015 Jeff Martin.
3 * All rights reserved. This program and the accompanying materials
4 * are made available under the terms of the GNU Lesser General Public
5 * License v3.0 which accompanies this distribution, and is available at
6 * http://www.gnu.org/licenses/lgpl.html
7 *
8 * Contributors:
9 * Jeff Martin - initial API and implementation
10 ******************************************************************************/
11
12package cuchaz.enigma;
13
14import cuchaz.enigma.analysis.ClassCache;
15import cuchaz.enigma.analysis.EntryReference;
16import cuchaz.enigma.analysis.index.EntryIndex;
17import cuchaz.enigma.analysis.index.InheritanceIndex;
18import cuchaz.enigma.analysis.index.JarIndex;
19import cuchaz.enigma.translation.mapping.EntryResolver;
20import cuchaz.enigma.translation.mapping.IndexEntryResolver;
21import cuchaz.enigma.translation.representation.AccessFlags;
22import cuchaz.enigma.translation.representation.entry.ClassEntry;
23import cuchaz.enigma.translation.representation.entry.FieldEntry;
24import cuchaz.enigma.translation.representation.entry.MethodDefEntry;
25import cuchaz.enigma.translation.representation.entry.MethodEntry;
26import org.junit.Test;
27import org.objectweb.asm.Opcodes;
28
29import java.nio.file.Paths;
30import java.util.Collection;
31
32import static cuchaz.enigma.TestEntryFactory.*;
33import static org.hamcrest.MatcherAssert.assertThat;
34import static org.hamcrest.Matchers.*;
35
36public class TestJarIndexInheritanceTree {
37
38 private JarIndex index;
39
40 private ClassEntry baseClass = newClass("a");
41 private ClassEntry subClassA = newClass("b");
42 private ClassEntry subClassAA = newClass("d");
43 private ClassEntry subClassB = newClass("c");
44 private FieldEntry nameField = newField(baseClass, "a", "Ljava/lang/String;");
45 private FieldEntry numThingsField = newField(subClassB, "a", "I");
46
47 public TestJarIndexInheritanceTree()
48 throws Exception {
49 ClassCache classCache = ClassCache.of(Paths.get("build/test-obf/inheritanceTree.jar"));
50 index = classCache.index(ProgressListener.none());
51 }
52
53 @Test
54 public void obfEntries() {
55 assertThat(index.getEntryIndex().getClasses(), containsInAnyOrder(
56 newClass("cuchaz/enigma/inputs/Keep"), baseClass, subClassA, subClassAA, subClassB
57 ));
58 }
59
60 @Test
61 public void translationIndex() {
62
63 InheritanceIndex index = this.index.getInheritanceIndex();
64
65 // base class
66 assertThat(index.getParents(baseClass), is(empty()));
67 assertThat(index.getAncestors(baseClass), is(empty()));
68 assertThat(index.getChildren(baseClass), containsInAnyOrder(subClassA, subClassB
69 ));
70
71 // subclass a
72 assertThat(index.getParents(subClassA), contains(baseClass));
73 assertThat(index.getAncestors(subClassA), containsInAnyOrder(baseClass));
74 assertThat(index.getChildren(subClassA), contains(subClassAA));
75
76 // subclass aa
77 assertThat(index.getParents(subClassAA), contains(subClassA));
78 assertThat(index.getAncestors(subClassAA), containsInAnyOrder(subClassA, baseClass));
79 assertThat(index.getChildren(subClassAA), is(empty()));
80
81 // subclass b
82 assertThat(index.getParents(subClassB), contains(baseClass));
83 assertThat(index.getAncestors(subClassB), containsInAnyOrder(baseClass));
84 assertThat(index.getChildren(subClassB), is(empty()));
85 }
86
87 @Test
88 public void access() {
89 assertThat(index.getEntryIndex().getFieldAccess(nameField), is(new AccessFlags(Opcodes.ACC_PRIVATE)));
90 assertThat(index.getEntryIndex().getFieldAccess(numThingsField), is(new AccessFlags(Opcodes.ACC_PRIVATE)));
91 }
92
93 @Test
94 public void relatedMethodImplementations() {
95
96 Collection<MethodEntry> entries;
97
98 EntryResolver resolver = new IndexEntryResolver(index);
99 // getName()
100 entries = resolver.resolveEquivalentMethods(newMethod(baseClass, "a", "()Ljava/lang/String;"));
101 assertThat(entries, containsInAnyOrder(
102 newMethod(baseClass, "a", "()Ljava/lang/String;"),
103 newMethod(subClassAA, "a", "()Ljava/lang/String;")
104 ));
105 entries = resolver.resolveEquivalentMethods(newMethod(subClassAA, "a", "()Ljava/lang/String;"));
106 assertThat(entries, containsInAnyOrder(
107 newMethod(baseClass, "a", "()Ljava/lang/String;"),
108 newMethod(subClassAA, "a", "()Ljava/lang/String;")
109 ));
110
111 // doBaseThings()
112 entries = resolver.resolveEquivalentMethods(newMethod(baseClass, "a", "()V"));
113 assertThat(entries, containsInAnyOrder(
114 newMethod(baseClass, "a", "()V"),
115 newMethod(subClassAA, "a", "()V"),
116 newMethod(subClassB, "a", "()V")
117 ));
118 entries = resolver.resolveEquivalentMethods(newMethod(subClassAA, "a", "()V"));
119 assertThat(entries, containsInAnyOrder(
120 newMethod(baseClass, "a", "()V"),
121 newMethod(subClassAA, "a", "()V"),
122 newMethod(subClassB, "a", "()V")
123 ));
124 entries = resolver.resolveEquivalentMethods(newMethod(subClassB, "a", "()V"));
125 assertThat(entries, containsInAnyOrder(
126 newMethod(baseClass, "a", "()V"),
127 newMethod(subClassAA, "a", "()V"),
128 newMethod(subClassB, "a", "()V")
129 ));
130
131 // doBThings
132 entries = resolver.resolveEquivalentMethods(newMethod(subClassB, "b", "()V"));
133 assertThat(entries, containsInAnyOrder(newMethod(subClassB, "b", "()V")));
134 }
135
136 @Test
137 @SuppressWarnings("unchecked")
138 public void fieldReferences() {
139 Collection<EntryReference<FieldEntry, MethodDefEntry>> references;
140
141 // name
142 references = index.getReferenceIndex().getReferencesToField(nameField);
143 assertThat(references, containsInAnyOrder(
144 newFieldReferenceByMethod(nameField, baseClass.getName(), "<init>", "(Ljava/lang/String;)V"),
145 newFieldReferenceByMethod(nameField, baseClass.getName(), "a", "()Ljava/lang/String;")
146 ));
147
148 // numThings
149 references = index.getReferenceIndex().getReferencesToField(numThingsField);
150 assertThat(references, containsInAnyOrder(
151 newFieldReferenceByMethod(numThingsField, subClassB.getName(), "<init>", "()V"),
152 newFieldReferenceByMethod(numThingsField, subClassB.getName(), "b", "()V")
153 ));
154 }
155
156 @Test
157 @SuppressWarnings("unchecked")
158 public void behaviorReferences() {
159
160 MethodEntry source;
161 Collection<EntryReference<MethodEntry, MethodDefEntry>> references;
162
163 // baseClass constructor
164 source = newMethod(baseClass, "<init>", "(Ljava/lang/String;)V");
165 references = index.getReferenceIndex().getReferencesToMethod(source);
166 assertThat(references, containsInAnyOrder(
167 newBehaviorReferenceByMethod(source, subClassA.getName(), "<init>", "(Ljava/lang/String;)V"),
168 newBehaviorReferenceByMethod(source, subClassB.getName(), "<init>", "()V")
169 ));
170
171 // subClassA constructor
172 source = newMethod(subClassA, "<init>", "(Ljava/lang/String;)V");
173 references = index.getReferenceIndex().getReferencesToMethod(source);
174 assertThat(references, containsInAnyOrder(
175 newBehaviorReferenceByMethod(source, subClassAA.getName(), "<init>", "()V")
176 ));
177
178 // baseClass.getName()
179 source = newMethod(baseClass, "a", "()Ljava/lang/String;");
180 references = index.getReferenceIndex().getReferencesToMethod(source);
181 assertThat(references, containsInAnyOrder(
182 newBehaviorReferenceByMethod(source, subClassAA.getName(), "a", "()Ljava/lang/String;"),
183 newBehaviorReferenceByMethod(source, subClassB.getName(), "a", "()V")
184 ));
185
186 // subclassAA.getName()
187 source = newMethod(subClassAA, "a", "()Ljava/lang/String;");
188 references = index.getReferenceIndex().getReferencesToMethod(source);
189 assertThat(references, containsInAnyOrder(
190 newBehaviorReferenceByMethod(source, subClassAA.getName(), "a", "()V")
191 ));
192 }
193
194 @Test
195 public void containsEntries() {
196 EntryIndex entryIndex = index.getEntryIndex();
197 // classes
198 assertThat(entryIndex.hasClass(baseClass), is(true));
199 assertThat(entryIndex.hasClass(subClassA), is(true));
200 assertThat(entryIndex.hasClass(subClassAA), is(true));
201 assertThat(entryIndex.hasClass(subClassB), is(true));
202
203 // fields
204 assertThat(entryIndex.hasField(nameField), is(true));
205 assertThat(entryIndex.hasField(numThingsField), is(true));
206
207 // methods
208 // getName()
209 assertThat(entryIndex.hasMethod(newMethod(baseClass, "a", "()Ljava/lang/String;")), is(true));
210 assertThat(entryIndex.hasMethod(newMethod(subClassA, "a", "()Ljava/lang/String;")), is(false));
211 assertThat(entryIndex.hasMethod(newMethod(subClassAA, "a", "()Ljava/lang/String;")), is(true));
212 assertThat(entryIndex.hasMethod(newMethod(subClassB, "a", "()Ljava/lang/String;")), is(false));
213
214 // doBaseThings()
215 assertThat(entryIndex.hasMethod(newMethod(baseClass, "a", "()V")), is(true));
216 assertThat(entryIndex.hasMethod(newMethod(subClassA, "a", "()V")), is(false));
217 assertThat(entryIndex.hasMethod(newMethod(subClassAA, "a", "()V")), is(true));
218 assertThat(entryIndex.hasMethod(newMethod(subClassB, "a", "()V")), is(true));
219
220 // doBThings()
221 assertThat(entryIndex.hasMethod(newMethod(baseClass, "b", "()V")), is(false));
222 assertThat(entryIndex.hasMethod(newMethod(subClassA, "b", "()V")), is(false));
223 assertThat(entryIndex.hasMethod(newMethod(subClassAA, "b", "()V")), is(false));
224 assertThat(entryIndex.hasMethod(newMethod(subClassB, "b", "()V")), is(true));
225
226 }
227}
HIC SVNT DRACONES