1 files changed, 39 insertions, 41 deletions

diff --git a/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java b/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java
index edb859a..763639a 100644
--- a/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java
+++ b/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java
@@ -13,22 +13,20 @@ package cuchaz.enigma;
 
 import cuchaz.enigma.analysis.EntryReference;
 import cuchaz.enigma.analysis.JarIndex;
-import cuchaz.enigma.mapping.BehaviorEntry;
-import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.analysis.ParsedJar;
+import cuchaz.enigma.mapping.entry.ClassEntry;
+import cuchaz.enigma.mapping.entry.MethodDefEntry;
+import cuchaz.enigma.mapping.entry.MethodEntry;
+import cuchaz.enigma.mapping.entry.ReferencedEntryPool;
 import org.junit.Test;
 
 import java.io.File;
 import java.util.Collection;
 import java.util.jar.JarFile;
 
-import static cuchaz.enigma.TestEntryFactory.newBehaviorReferenceByConstructor;
-import static cuchaz.enigma.TestEntryFactory.newBehaviorReferenceByMethod;
-import static cuchaz.enigma.TestEntryFactory.newClass;
-import static cuchaz.enigma.TestEntryFactory.newConstructor;
+import static cuchaz.enigma.TestEntryFactory.*;
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.containsInAnyOrder;
-import static org.hamcrest.Matchers.empty;
-import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.*;
 
 public class TestJarIndexConstructorReferences {
 
@@ -41,90 +39,90 @@ public class TestJarIndexConstructorReferences {
         private ClassEntry callerClass = newClass("b");
 
         public TestJarIndexConstructorReferences()
-                throws Exception {
+                        throws Exception {
                 File jarFile = new File("build/test-obf/constructors.jar");
-                index = new JarIndex();
-                index.indexJar(new JarFile(jarFile), false);
+                index = new JarIndex(new ReferencedEntryPool());
+                index.indexJar(new ParsedJar(new JarFile(jarFile)), false);
         }
 
         @Test
         public void obfEntries() {
                 assertThat(index.getObfClassEntries(), containsInAnyOrder(newClass("cuchaz/enigma/inputs/Keep"), baseClass,
-                        subClass, subsubClass, defaultClass, callerClass));
+                                subClass, subsubClass, defaultClass, callerClass));
         }
 
         @Test
         @SuppressWarnings("unchecked")
         public void baseDefault() {
-                BehaviorEntry source = newConstructor(baseClass, "()V");
-                Collection<EntryReference<BehaviorEntry, BehaviorEntry>> references = index.getBehaviorReferences(source);
+                MethodEntry source = newMethod(baseClass, "<init>", "()V");
+                Collection<EntryReference<MethodEntry, MethodDefEntry>> references = index.getMethodsReferencing(source);
                 assertThat(references, containsInAnyOrder(
-                        newBehaviorReferenceByMethod(source, callerClass.getName(), "a", "()V"),
-                        newBehaviorReferenceByConstructor(source, subClass.getName(), "()V"),
-                        newBehaviorReferenceByConstructor(source, subClass.getName(), "(III)V")
+                                newBehaviorReferenceByMethod(source, callerClass.getName(), "a", "()V"),
+                                newBehaviorReferenceByMethod(source, subClass.getName(), "<init>", "()V"),
+                                newBehaviorReferenceByMethod(source, subClass.getName(), "<init>", "(III)V")
                 ));
         }
 
         @Test
         @SuppressWarnings("unchecked")
         public void baseInt() {
-                BehaviorEntry source = newConstructor(baseClass, "(I)V");
-                assertThat(index.getBehaviorReferences(source), containsInAnyOrder(
-                        newBehaviorReferenceByMethod(source, callerClass.getName(), "b", "()V")
+                MethodEntry source = newMethod(baseClass, "<init>", "(I)V");
+                assertThat(index.getMethodsReferencing(source), containsInAnyOrder(
+                                newBehaviorReferenceByMethod(source, callerClass.getName(), "b", "()V")
                 ));
         }
 
         @Test
         @SuppressWarnings("unchecked")
         public void subDefault() {
-                BehaviorEntry source = newConstructor(subClass, "()V");
-                assertThat(index.getBehaviorReferences(source), containsInAnyOrder(
-                        newBehaviorReferenceByMethod(source, callerClass.getName(), "c", "()V"),
-                        newBehaviorReferenceByConstructor(source, subClass.getName(), "(I)V")
+                MethodEntry source = newMethod(subClass, "<init>", "()V");
+                assertThat(index.getMethodsReferencing(source), containsInAnyOrder(
+                                newBehaviorReferenceByMethod(source, callerClass.getName(), "c", "()V"),
+                                newBehaviorReferenceByMethod(source, subClass.getName(), "<init>", "(I)V")
                 ));
         }
 
         @Test
         @SuppressWarnings("unchecked")
         public void subInt() {
-                BehaviorEntry source = newConstructor(subClass, "(I)V");
-                assertThat(index.getBehaviorReferences(source), containsInAnyOrder(
-                        newBehaviorReferenceByMethod(source, callerClass.getName(), "d", "()V"),
-                        newBehaviorReferenceByConstructor(source, subClass.getName(), "(II)V"),
-                        newBehaviorReferenceByConstructor(source, subsubClass.getName(), "(I)V")
+                MethodEntry source = newMethod(subClass, "<init>", "(I)V");
+                assertThat(index.getMethodsReferencing(source), containsInAnyOrder(
+                                newBehaviorReferenceByMethod(source, callerClass.getName(), "d", "()V"),
+                                newBehaviorReferenceByMethod(source, subClass.getName(), "<init>", "(II)V"),
+                                newBehaviorReferenceByMethod(source, subsubClass.getName(), "<init>", "(I)V")
                 ));
         }
 
         @Test
         @SuppressWarnings("unchecked")
         public void subIntInt() {
-                BehaviorEntry source = newConstructor(subClass, "(II)V");
-                assertThat(index.getBehaviorReferences(source), containsInAnyOrder(
-                        newBehaviorReferenceByMethod(source, callerClass.getName(), "e", "()V")
+                MethodEntry source = newMethod(subClass, "<init>", "(II)V");
+                assertThat(index.getMethodsReferencing(source), containsInAnyOrder(
+                                newBehaviorReferenceByMethod(source, callerClass.getName(), "e", "()V")
                 ));
         }
 
         @Test
         public void subIntIntInt() {
-                BehaviorEntry source = newConstructor(subClass, "(III)V");
-                assertThat(index.getBehaviorReferences(source), is(empty()));
+                MethodEntry source = newMethod(subClass, "<init>", "(III)V");
+                assertThat(index.getMethodsReferencing(source), is(empty()));
         }
 
         @Test
         @SuppressWarnings("unchecked")
         public void subsubInt() {
-                BehaviorEntry source = newConstructor(subsubClass, "(I)V");
-                assertThat(index.getBehaviorReferences(source), containsInAnyOrder(
-                        newBehaviorReferenceByMethod(source, callerClass.getName(), "f", "()V")
+                MethodEntry source = newMethod(subsubClass, "<init>", "(I)V");
+                assertThat(index.getMethodsReferencing(source), containsInAnyOrder(
+                                newBehaviorReferenceByMethod(source, callerClass.getName(), "f", "()V")
                 ));
         }
 
         @Test
         @SuppressWarnings("unchecked")
         public void defaultConstructable() {
-                BehaviorEntry source = newConstructor(defaultClass, "()V");
-                assertThat(index.getBehaviorReferences(source), containsInAnyOrder(
-                        newBehaviorReferenceByMethod(source, callerClass.getName(), "g", "()V")
+                MethodEntry source = newMethod(defaultClass, "<init>", "()V");
+                assertThat(index.getMethodsReferencing(source), containsInAnyOrder(
+                                newBehaviorReferenceByMethod(source, callerClass.getName(), "g", "()V")
                 ));
         }
 }