diff --git a/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestExcluded.java b/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestExcluded.java
index 23d161c3f760e74ec0e2f398ef7f4fd7e73185bd..c3f6c1100a5f3af74ace6404af360aa3421c4005 100644
--- a/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestExcluded.java
+++ b/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestExcluded.java
@@ -81,10 +81,10 @@ public class TestExcluded {
         tuple("BiC1", C_NAME), tuple("BiC2", C_NAME), tuple("BiC3", C_NAME));
     // B
     assertThatMapOf(normalRelationChildren(findByName(nodes, B_NAME))).containsExactlyInAnyOrder(
-        tuple("OneA", A_NAME), tuple("MaybeC", C_NAME));
+        tuple("OneA", A_NAME), tuple("MaybeC?", C_NAME));
     // C
     assertThatMapOf(normalRelationChildren(findByName(nodes, C_NAME))).containsExactlyInAnyOrder(
-        tuple("BiA1", A_NAME), tuple("BiA3", A_NAME));
+        tuple("BiA1", A_NAME), tuple("BiA3?", A_NAME));
     assertThatMapOf(listRelationChildren(findByName(nodes, C_NAME)), "BiA2").containsExactlyInAnyOrder(A_NAME);
     assertThatMapOf(referenceTokens(findByName(nodes, C_NAME))).containsExactlyInAnyOrder(
         tuple(TOKEN_LABEL_RAW_REFERENCE, A_NAME));
@@ -116,7 +116,7 @@ public class TestExcluded {
     assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, B_NAME, C_NAME);
     // B
     assertThatMapOf(normalRelationChildren(findByName(nodes, B_NAME))).containsExactlyInAnyOrder(
-        tuple("MaybeC", (C_NAME)));
+        tuple("MaybeC?", (C_NAME)));
     // C
     assertThat(normalRelationChildren(findByName(nodes, C_NAME))).isEmpty();
     assertThat(listRelationChildren(findByName(nodes, C_NAME))).isEmpty();
@@ -339,10 +339,10 @@ public class TestExcluded {
         tuple("BiC2", C_NAME), tuple("BiC3", C_NAME));
     // B
     assertThatMapOf(normalRelationChildren(findByName(nodes, B_NAME))).containsExactlyInAnyOrder(
-        tuple("OneA", A_NAME), tuple("MaybeC", C_NAME));
+        tuple("OneA", A_NAME), tuple("MaybeC?", C_NAME));
     // C
     assertThatMapOf(normalRelationChildren(findByName(nodes, C_NAME))).containsExactlyInAnyOrder(
-        tuple("BiA1", A_NAME), tuple("BiA3", A_NAME));
+        tuple("BiA1", A_NAME), tuple("BiA3?", A_NAME));
     assertThatMapOf(listRelationChildren(findByName(nodes, C_NAME)), "BiA2").containsExactlyInAnyOrder(A_NAME);
     assertThatMapOf(referenceTokens(findByName(nodes, C_NAME))).containsExactlyInAnyOrder(
         tuple(TOKEN_LABEL_RAW_REFERENCE, A_NAME));
@@ -357,10 +357,10 @@ public class TestExcluded {
     assertThat(normalRelationChildren(findByName(nodes, A_NAME))).isEmpty();
     // B
     assertThatMapOf(normalRelationChildren(findByName(nodes, B_NAME))).containsExactlyInAnyOrder(
-        tuple("OneA", A_NAME), tuple("MaybeC", C_NAME));
+        tuple("OneA", A_NAME), tuple("MaybeC?", C_NAME));
     // C
     assertThat(normalRelationChildren(findByName(nodes, C_NAME))).isEmpty();
-    assertThat(listRelationChildren(findByName(nodes, C_NAME))).isEmpty();
+    assertEmpty(TestUtils.findByName(nodes, C_NAME).getDumpRelation(0));
     assertThatMapOf(referenceTokens(findByName(nodes, C_NAME))).containsExactlyInAnyOrder(
         tuple(TOKEN_LABEL_RAW_REFERENCE, A_NAME));
   }
@@ -375,10 +375,10 @@ public class TestExcluded {
         tuple("BiC1", C_NAME), tuple("BiC2", C_NAME), tuple("BiC3", C_NAME));
     // B
     assertThatMapOf(normalRelationChildren(findByName(nodes, B_NAME))).containsExactlyInAnyOrder(
-        tuple("MaybeC", C_NAME));
+        tuple("MaybeC?", C_NAME));
     // C
     assertThat(normalRelationChildren(findByName(nodes, C_NAME))).isEmpty();
-    assertThat(listRelationChildren(findByName(nodes, C_NAME))).isEmpty();
+    assertEmpty(TestUtils.findByName(nodes, C_NAME).getDumpRelation(0));
     assertThatMapOf(referenceTokens(findByName(nodes, C_NAME))).containsExactlyInAnyOrder(
         tuple(TOKEN_LABEL_RAW_REFERENCE, A_NAME));
   }
diff --git a/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestSimple.java b/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestSimple.java
index 6d6294bea952209adffda3e65963e297e07f51dd..abdf25d92b2e2e40413894cc5e4b3c29a0bf8535 100644
--- a/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestSimple.java
+++ b/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestSimple.java
@@ -28,7 +28,7 @@ public class TestSimple {
     assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactly(ROOT_NAME);
     DumpNode actualRoot = TestUtils.findByName(nodes, ROOT_NAME);
     assertEquals(1, actualRoot.getNumDumpToken());
-    assertEquals(0, actualRoot.getNumDumpChildNode());
+    assertEmpty(actualRoot.getDumpChildNode(0));
     assertEquals(0, actualRoot.getNumDumpRelation());
   }
 
@@ -64,7 +64,8 @@ public class TestSimple {
     assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME);
     DumpNode actualRoot = TestUtils.findByName(nodes, ROOT_NAME);
     assertEquals(1, actualRoot.getNumDumpToken());
-    assertEquals(1, actualRoot.getNumDumpChildNode());
+    assertEquals(2, actualRoot.getNumDumpChildNode());
+    assertEmpty(actualRoot.getDumpChildNode(1));
     assertEquals(0, actualRoot.getNumDumpRelation());
     assertThatMapOf(normalChildren(actualRoot)).containsExactlyInAnyOrder(tuple("A", A_NAME));
   }
@@ -86,7 +87,8 @@ public class TestSimple {
     );
     DumpNode actualRoot = TestUtils.findByName(nodes, ROOT_NAME);
     assertEquals(1, actualRoot.getNumDumpToken());
-    assertEquals(2, actualRoot.getNumDumpChildNode());
+    assertEquals(3, actualRoot.getNumDumpChildNode());
+    assertEmpty(actualRoot.getDumpChildNode(1));
     assertEquals(0, actualRoot.getNumDumpRelation());
 
     DumpNode actualA = TestUtils.findByName(nodes, A_NAME);
@@ -152,7 +154,7 @@ public class TestSimple {
     assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME);
     DumpNode actualRoot = TestUtils.findByName(nodes, ROOT_NAME);
     assertEquals(1, actualRoot.getNumDumpToken());
-    assertEquals(0, actualRoot.getNumDumpChildNode());
+    assertEmpty(actualRoot.getDumpChildNode(0));
     assertEquals(0, actualRoot.getNumDumpRelation());
     assertThatMapOf(normalChildren(actualRoot)).isEmpty();
   }
@@ -165,9 +167,10 @@ public class TestSimple {
     assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, C_NAME);
     DumpNode actualRoot = TestUtils.findByName(nodes, ROOT_NAME);
     assertEquals(1, actualRoot.getNumDumpToken());
-    assertEquals(1, actualRoot.getNumDumpChildNode());
+    assertEquals(2, actualRoot.getNumDumpChildNode());
+    assertEmpty(actualRoot.getDumpChildNode(0));
     assertEquals(0, actualRoot.getNumDumpRelation());
-    assertThatMapOf(normalChildren(actualRoot)).containsExactlyInAnyOrder(tuple("C", C_NAME));
+    assertThatMapOf(normalChildren(actualRoot)).containsExactlyInAnyOrder(tuple("C?", C_NAME));
   }
 
   @Test
@@ -203,7 +206,7 @@ public class TestSimple {
     List<DumpNode> nodes = TestUtils.dumpModel(root);
     assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, B_NAME, C_NAME);
     DumpNode actualB = TestUtils.findByName(nodes, B_NAME);
-    assertThatMapOf(normalRelationChildren(actualB)).containsExactlyInAnyOrder(tuple("MaybeC", C_NAME));
+    assertThatMapOf(normalRelationChildren(actualB)).containsExactlyInAnyOrder(tuple("MaybeC?", C_NAME));
   }
 
   @Test
@@ -245,7 +248,7 @@ public class TestSimple {
     DumpNode actualA = TestUtils.findByName(nodes, A_NAME);
     assertThatMapOf(normalRelationChildren(actualA)).containsExactlyInAnyOrder(tuple("BiC3", C_NAME));
     DumpNode actualC = TestUtils.findByName(nodes, C_NAME);
-    assertThatMapOf(normalRelationChildren(actualC)).containsExactlyInAnyOrder(tuple("BiA3", A_NAME));
+    assertThatMapOf(normalRelationChildren(actualC)).containsExactlyInAnyOrder(tuple("BiA3?", A_NAME));
   }
 
   @Test
diff --git a/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestTypeLevel3.java b/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestTypeLevel3.java
index 50f27583960648d90ed9434df90f39729c49ae7d..1e6759d147b88430fc5cd5ba7009d030fc63565e 100644
--- a/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestTypeLevel3.java
+++ b/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestTypeLevel3.java
@@ -107,7 +107,7 @@ public class TestTypeLevel3 {
         dp -> dp.excludeChildren("Bee"));
     assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME);
     for (String name : Tx_NAMES) {
-      assertThat(listChildren(TestUtils.findByName(nodes, name))).isEmpty();
+      assertEmpty(findByName(nodes, name).getDumpChildNode(0));
     }
   }
 
@@ -121,10 +121,10 @@ public class TestTypeLevel3 {
         dp -> dp.excludeChildren("Bee")
                 .includeChildrenFor("T2", "Bee"));
     assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME, T2_NAME + B_NAME);
-    assertThat(listChildren(TestUtils.findByName(nodes, T1_NAME))).isEmpty();
+    assertEmpty(findByName(nodes, T1_NAME).getDumpChildNode(0));
     assertThatMapOf(listChildren(TestUtils.findByName(nodes, T2_NAME)), "Bee").containsOnly(
         T2_NAME + B_NAME);
-    assertThat(listChildren(TestUtils.findByName(nodes, T3_NAME))).isEmpty();
+    assertEmpty(TestUtils.findByName(nodes, T3_NAME).getDumpChildNode(0));
   }
 
   @Test
diff --git a/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestTypeLevel4.java b/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestTypeLevel4.java
index 8e9220a270c3fe96df2a767d37b565f077c64d55..78f4bc9ccb466f07210a54aecafaf8a80d5eac94 100644
--- a/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestTypeLevel4.java
+++ b/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestTypeLevel4.java
@@ -146,7 +146,7 @@ public class TestTypeLevel4 {
         T1_NAME + B_NAME);
     assertThatMapOf(listChildren(findByName(nodes, T2_NAME)), "Bee").containsOnly(
         T2_NAME + B_NAME);
-    assertThat(listChildren(findByName(nodes, T3_NAME))).isEmpty();
+    assertEmpty(findByName(nodes, T3_NAME).getDumpChildNode(0));
   }
 
   @Test
diff --git a/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestUtils.java b/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestUtils.java
index 70213c50de832d945eca1cb8afa891656fc78896..b421a6fe1c3554b4c7a627044e16a58c12f607b7 100644
--- a/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestUtils.java
+++ b/dumpAst.tests/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestUtils.java
@@ -11,7 +11,7 @@ import java.util.*;
 import java.util.function.Consumer;
 import java.util.function.Function;
 
-import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class TestUtils {
   public static final Random rand = new Random();
@@ -150,6 +150,16 @@ public class TestUtils {
     return Assertions.assertThat(map.get(key)).flatExtracting(NAME_EXTRACTOR);
   }
 
+  public static void assertEmpty(DumpChildNode node) {
+    assertEquals(1, node.asDumpListChildNode().getNumInnerDumpNode());
+    assertTrue(node.asDumpListChildNode().getInnerDumpNode(0).getDumpNode().isEmpty());
+  }
+
+  public static void assertEmpty(DumpRelation node) {
+    assertEquals(1, node.asDumpListRelation().getNumInnerRelationDumpNode());
+    assertTrue(node.asDumpListRelation().getInnerRelationDumpNode(0).getDumpNode().isEmpty());
+  }
+
   public static List<DumpNode> dumpModel(Object target) throws TransformationException {
     return dumpModel(target, db -> {});
   }