feat(store): DataRepresentation reflective type

1 files changed, 23 insertions, 27 deletions

diff --git a/subprojects/store/src/test/java/tools/refinery/store/model/tests/ModelTest.java b/subprojects/store/src/test/java/tools/refinery/store/model/tests/ModelTest.java
index 61dd7c74..a9c2e3f7 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/model/tests/ModelTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/model/tests/ModelTest.java
@@ -1,26 +1,22 @@
 package tools.refinery.store.model.tests;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-import java.util.Set;
-
-import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
-
 import tools.refinery.store.model.Model;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.model.ModelStoreImpl;
-import tools.refinery.store.tuple.Tuple;
 import tools.refinery.store.model.representation.Relation;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.Set;
+
+import static org.junit.jupiter.api.Assertions.*;
 
 class ModelTest {
 
         @Test
         void modelConstructionTest() {
-                Relation<Boolean> person = new Relation<>("Person", 1, false);
-                Relation<Boolean> friend = new Relation<>("friend", 2, false);
+                Relation<Boolean> person = new Relation<>("Person", 1, Boolean.class, false);
+                Relation<Boolean> friend = new Relation<>("friend", 2, Boolean.class, false);
 
                 ModelStore store = new ModelStoreImpl(Set.of(person, friend));
                 Model model = store.createModel();
@@ -30,15 +26,15 @@ class ModelTest {
                 assertTrue(model.getDataRepresentations().contains(person));
                 assertTrue(model.getDataRepresentations().contains(friend));
 
-                Relation<Integer> other = new Relation<Integer>("other", 2, null);
+                Relation<Integer> other = new Relation<Integer>("other", 2, Integer.class, null);
                 assertFalse(model.getDataRepresentations().contains(other));
         }
 
         @Test
         void modelBuildingTest() {
-                Relation<Boolean> person = new Relation<>("Person", 1, false);
-                Relation<Integer> age = new Relation<Integer>("age", 1, null);
-                Relation<Boolean> friend = new Relation<>("friend", 2, false);
+                Relation<Boolean> person = new Relation<>("Person", 1, Boolean.class, false);
+                Relation<Integer> age = new Relation<Integer>("age", 1, Integer.class, null);
+                Relation<Boolean> friend = new Relation<>("friend", 2, Boolean.class, false);
 
                 ModelStore store = new ModelStoreImpl(Set.of(person, age, friend));
                 Model model = store.createModel();
@@ -56,7 +52,7 @@ class ModelTest {
 
                 assertEquals(3, model.get(age, Tuple.of(0)));
                 assertEquals(1, model.get(age, Tuple.of(1)));
-                assertEquals(null, model.get(age, Tuple.of(2)));
+                assertNull(model.get(age, Tuple.of(2)));
 
                 assertTrue(model.get(friend, Tuple.of(0, 1)));
                 assertFalse(model.get(friend, Tuple.of(0, 5)));
@@ -64,32 +60,32 @@ class ModelTest {
 
         @Test
         void modelBuildingArityFailTest() {
-                Relation<Boolean> person = new Relation<>("Person", 1, false);
+                Relation<Boolean> person = new Relation<>("Person", 1, Boolean.class, false);
                 ModelStore store = new ModelStoreImpl(Set.of(person));
                 Model model = store.createModel();
 
                 final Tuple tuple3 = Tuple.of(1, 1, 1);
-                Assertions.assertThrows(IllegalArgumentException.class, () -> model.put(person, tuple3, true));
-                Assertions.assertThrows(IllegalArgumentException.class, () -> model.get(person, tuple3));
+                assertThrows(IllegalArgumentException.class, () -> model.put(person, tuple3, true));
+                assertThrows(IllegalArgumentException.class, () -> model.get(person, tuple3));
         }
 
         @Test
         void modelBuildingNullFailTest() {
-                Relation<Integer> age = new Relation<Integer>("age", 1, null);
+                Relation<Integer> age = new Relation<Integer>("age", 1, Integer.class, null);
                 ModelStore store = new ModelStoreImpl(Set.of(age));
                 Model model = store.createModel();
 
                 model.put(age, Tuple.of(1), null); // valid
-                Assertions.assertThrows(IllegalArgumentException.class, () -> model.put(age, null, 1));
-                Assertions.assertThrows(IllegalArgumentException.class, () -> model.get(age, null));
+                assertThrows(IllegalArgumentException.class, () -> model.put(age, null, 1));
+                assertThrows(IllegalArgumentException.class, () -> model.get(age, null));
 
         }
 
         @Test
         void modelUpdateTest() {
-                Relation<Boolean> person = new Relation<>("Person", 1, false);
-                Relation<Integer> age = new Relation<Integer>("age", 1, null);
-                Relation<Boolean> friend = new Relation<>("friend", 2, false);
+                Relation<Boolean> person = new Relation<>("Person", 1, Boolean.class, false);
+                Relation<Integer> age = new Relation<Integer>("age", 1, Integer.class, null);
+                Relation<Boolean> friend = new Relation<>("friend", 2, Boolean.class, false);
 
                 ModelStore store = new ModelStoreImpl(Set.of(person, age, friend));
                 Model model = store.createModel();
@@ -113,8 +109,8 @@ class ModelTest {
 
         @Test
         void restoreTest() {
-                Relation<Boolean> person = new Relation<Boolean>("Person", 1, false);
-                Relation<Boolean> friend = new Relation<Boolean>("friend", 2, false);
+                Relation<Boolean> person = new Relation<Boolean>("Person", 1, Boolean.class, false);
+                Relation<Boolean> friend = new Relation<Boolean>("friend", 2, Boolean.class, false);
 
                 ModelStore store = new ModelStoreImpl(Set.of(person, friend));
                 Model model = store.createModel();