diff --git a/dumpAst/src/main/jastadd/Generation.jadd b/dumpAst/src/main/jastadd/Generation.jadd
index 38c7db06366d76ea4062b8a475e119966bff3388..ee53e202e266792124b1ad83392e281e1d5533ab 100644
--- a/dumpAst/src/main/jastadd/Generation.jadd
+++ b/dumpAst/src/main/jastadd/Generation.jadd
@@ -53,32 +53,61 @@ import java.lang.String;aspect GenerationFrontend {
}
/**
- * Exclude object with types matching at least one of the given regex strings.
- * Exlcuding object won't be included in any output. However, their children are still processed.
+ * Disable all objects with types matching at least one of the given regex strings.
+ * Disabled objects won't be included in any output. However, their children are still processed.
* @param regexes patterns to match type names
* @return this
* @see java.util.regex.Pattern#compile(java.lang.String)
*/
- public DumpBuilder excludeTypes(String... regexes) {
+ public DumpBuilder disableTypes(String... regexes) {
updateIgnored(() -> buildConfig.getTypeIgnore(), s -> buildConfig.setTypeIgnore(s), regexes);
return this;
}
+
+ /**
+ * Exclude tokens and their value if the token name matches at least one of the given regex strings.
+ * @param regexes regex patterns to match token names
+ * @return this
+ * @see java.util.regex.Pattern#compile(java.lang.String)
+ */
public DumpBuilder excludeTokens(String... regexes) {
updateIgnored(() -> buildConfig.getTokenIgnore(), s -> buildConfig.setTokenIgnore(s), regexes);
return this;
}
- public DumpBuilder excludeAttributes(String... regexes) {
+ // not supported yet
+ public DumpBuilder includeAttributes(String... regexes) {
updateIgnored(() -> buildConfig.getAttributeIgnore(), s -> buildConfig.setAttributeIgnore(s), regexes);
return this;
}
+ // not supported yet
+ public DumpBuilder includeNonterminalAttributes(String... regexes) {
+ // TODO
+ return this;
+ }
+
+ /**
+ * Exclude every child whose name (i.e., context) matches at least on of the given regex strings.
+ * Unlike disabling types, the complete object and its (transitive) children won't be included in any output.
+ * @param regexes regex patterns to match child names
+ * @return this
+ * @see java.util.regex.Pattern#compile(java.lang.String)
+ */
public DumpBuilder excludeChildren(String... regexes) {
updateIgnored(() -> buildConfig.getChildIgnore(), s -> buildConfig.setChildIgnore(s), regexes);
return this;
}
+ /**
+ * Exclude every relation whose role-name matches at least on of the given regex strings.
+ * Unlike disabling types, the complete object and its (transitive) children won't be included in any output, except.
+ * @param regexes regex patterns to match child names
+ * @return this
+ * @see java.util.regex.Pattern#compile(java.lang.String)
+ */
public DumpBuilder excludeRelations(String... regexes) {
updateIgnored(() -> buildConfig.getRelationIgnore(), s -> buildConfig.setRelationIgnore(s), regexes);
return this;
}
+
private void updateIgnored(java.util.function.Supplier<String> getter, java.util.function.Consumer<String> setter, String... values) {
for (String value : values) {
if (getter.get().isEmpty()) {
@@ -93,6 +122,7 @@ import java.lang.String;aspect GenerationFrontend {
printConfig.addHeader(new Header(option));
return this;
}
+
public DumpBuilder skinParam(SkinParamStringSetting setting, String value) {
customPreamble("skinparam " + setting.toString() + " " + value);
return this;
@@ -101,6 +131,7 @@ import java.lang.String;aspect GenerationFrontend {
customPreamble("skinparam " + setting.toString() + " " + value);
return this;
}
+
public DumpBuilder setScale(double value) {
printConfig.setScale(value);
return this;
@@ -133,6 +164,13 @@ import java.lang.String;aspect GenerationFrontend {
}
return result;
}
+
+ /**
+ * Write out content as plantuml source code.
+ * @param destination path of destination file
+ * @return this
+ * @throws java.io.IOException if an I/O error happend during opening or writing in that file
+ */
public DumpBuilder dumpAsSource(java.nio.file.Path destination) throws java.io.IOException {
String content = build().toPlantUml();
try (java.io.Writer writer = java.nio.file.Files.newBufferedWriter(destination)) {
@@ -140,12 +178,26 @@ import java.lang.String;aspect GenerationFrontend {
}
return this;
}
+
+ /**
+ * Write out content as PNG image generated by plantuml.
+ * @param destination path of destination file
+ * @return this
+ * @throws java.io.IOException if an I/O error happend during opening or writing in that file
+ */
public DumpBuilder dumpAsPNG(java.nio.file.Path destination) throws java.io.IOException {
String content = build().toPlantUml();
net.sourceforge.plantuml.SourceStringReader reader = new net.sourceforge.plantuml.SourceStringReader(content);
reader.outputImage(java.nio.file.Files.newOutputStream(destination));
return this;
}
+
+ /**
+ * Write out content as SVG image generated by plantuml.
+ * @param destination path of destination file
+ * @return this
+ * @throws java.io.IOException if an I/O error happend during opening or writing in that file
+ */
public DumpBuilder dumpAsSVG(java.nio.file.Path destination) throws java.io.IOException {
String content = build().toPlantUml();
net.sourceforge.plantuml.SourceStringReader reader = new net.sourceforge.plantuml.SourceStringReader(content);
diff --git a/dumpAst/src/main/java/de/tudresden/inf/st/jastadd/dumpAst/SimpleMain.java b/dumpAst/src/main/java/de/tudresden/inf/st/jastadd/dumpAst/SimpleMain.java
index 0d1b70cc6eb18ad6f9d4b75149ebaedcf206481b..454a6ae77f3bd5594b979ef250ab2c1148d3d085 100644
--- a/dumpAst/src/main/java/de/tudresden/inf/st/jastadd/dumpAst/SimpleMain.java
+++ b/dumpAst/src/main/java/de/tudresden/inf/st/jastadd/dumpAst/SimpleMain.java
@@ -116,7 +116,7 @@ public class SimpleMain {
Dumper.read(model.toMustache())
.skinParam(SkinParamBooleanSetting.Monochrome, true)
.enableDebug()
- .excludeTypes(".*Comment")
+ .disableTypes(".*Comment")
.dumpAsSource(Paths.get("temp.plantuml"))
.dumpAsSVG(Paths.get("temp.svg"));
}
diff --git a/testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestExcluded.java b/testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestExcluded.java
index 9e25685b089420f784648c8dddac2540f26722a2..4faf6639b16f68cd1fae55527a9a4a97425cec5f 100644
--- a/testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestExcluded.java
+++ b/testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestExcluded.java
@@ -5,6 +5,7 @@ import de.tudresden.inf.st.jastadd.dumpAst.ast.DumpNode;
import de.tudresden.inf.st.jastadd.dumpAst.ast.Dumper;
import org.jastadd.testDumper.ast.A;
import org.jastadd.testDumper.ast.Root;
+import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import java.io.IOException;
@@ -46,7 +47,7 @@ public class TestExcluded {
assertThat(valueTokens(actualB3)).containsOnly(entry("Name", B3_NAME), entry(TOKEN_LABEL_OTHER_VALUE, ""));
}
- private Root setupTypes() {
+ private Root setupAllRelations() {
Root root = createRoot(createA(A_NAME), createC(C_NAME), createB(B_NAME, "A"));
root.getC().setRawReference(root.getA());
// rel B.oneA -> A ;
@@ -66,14 +67,14 @@ public class TestExcluded {
@Test
public void testTypesDefault() {
- Root root = setupTypes();
+ Root root = setupAllRelations();
List<DumpNode> nodes = TestUtils.dumpModel(root);
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, B_NAME, C_NAME);
- assertTypeDefaultMatches(nodes);
+ assertAllRelationsDefaultMatches(nodes);
}
- private void assertTypeDefaultMatches(List<DumpNode> nodes) {
+ private void assertAllRelationsDefaultMatches(List<DumpNode> nodes) {
// A
assertThatMapOf(normalRelationChildren(findByName(nodes, A_NAME))).containsExactlyInAnyOrder(
tuple("BiC1", C_NAME), tuple("BiC2", C_NAME), tuple("BiC3", C_NAME));
@@ -85,32 +86,32 @@ public class TestExcluded {
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("RawReference", A_NAME));
+ tuple(TOKEN_LABEL_RAW_REFERENCE, A_NAME));
}
@Test
public void testTypesNonMatching() {
- Root root = setupTypes();
+ Root root = setupAllRelations();
- List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.excludeTypes("NonExistingType"));
+ List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.disableTypes("NonExistingType"));
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, B_NAME, C_NAME);
- assertTypeDefaultMatches(nodes);
+ assertAllRelationsDefaultMatches(nodes);
}
@Test
public void testTypesInheritanceNotIncluded() {
- Root root = setupTypes();
+ Root root = setupAllRelations();
- List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.excludeTypes("Nameable"));
+ List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.disableTypes("Nameable"));
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, B_NAME, C_NAME);
- assertTypeDefaultMatches(nodes);
+ assertAllRelationsDefaultMatches(nodes);
}
@Test
public void testTypesExcludeOnlyA() {
- Root root = setupTypes();
+ Root root = setupAllRelations();
- List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.excludeTypes("A"));
+ List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.disableTypes("A"));
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, B_NAME, C_NAME);
// B
assertThatMapOf(normalRelationChildren(findByName(nodes, B_NAME))).containsExactlyInAnyOrder(
@@ -123,60 +124,263 @@ public class TestExcluded {
@Test
public void testTypesExcludeMultipleArguments() {
- Root root = setupTypes();
+ Root root = setupAllRelations();
- List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.excludeTypes("A", "C"));
+ List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.disableTypes("A", "C"));
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, B_NAME);
// B
- assertThatMapOf(normalRelationChildren(findByName(nodes, B_NAME))).isEmpty();
+ assertThat(normalRelationChildren(findByName(nodes, B_NAME))).isEmpty();
}
@Test
public void testTypesExcludeMultipleCalls() {
- Root root = setupTypes();
+ Root root = setupAllRelations();
- List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.excludeTypes("A").excludeTypes("C"));
+ List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.disableTypes("A").disableTypes("C"));
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, B_NAME);
// B
- assertThatMapOf(normalRelationChildren(findByName(nodes, B_NAME))).isEmpty();
+ assertThat(normalRelationChildren(findByName(nodes, B_NAME))).isEmpty();
}
@Test
public void testTypesExcludeRegex() {
- Root root = setupTypes();
+ Root root = setupAllRelations();
- List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.excludeTypes("Ro*t"));
+ List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.disableTypes("Ro*t"));
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(A_NAME, B_NAME, C_NAME);
- assertTypeDefaultMatches(nodes);
+ assertAllRelationsDefaultMatches(nodes);
}
@Test
- public void testTypesInvisiblePath() throws IOException {
+ public void testTypesInvisiblePath() {
final String A2_Name = "a2";
final String A3_Name = "a3";
final String C2_Name = "c2";
- A mostInnerA = createA(A3_Name);
- mostInnerA.setB(createB(B_NAME));
Root root = createRoot(createA(A_NAME,
createC(C_NAME,
createA(A2_Name,
- createC(C2_Name, mostInnerA)))),
+ createC(C2_Name,
+ createA(A3_Name, a -> a.setB(createB(B_NAME))))))),
null);
- List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.excludeTypes("A", "C"));
- Dumper.read(root).excludeTypes("A", "C").dumpAsPNG(Paths.get("test.png"));
+ List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.disableTypes("A", "C"));
DumpNode actualRoot = findByName(nodes, ROOT_NAME);
assertThat(invisiblePath(actualRoot)).flatExtracting(NAME_EXTRACTOR).containsExactly(B_NAME);
}
@Test
public void testTokenDefault() {
+ A a = createA(A_NAME);
+ Root root = createRoot(a, createC(C_NAME, c -> {
+ c.setRawReference(a);
+ c.setUnwanted(5);
+ c.setBiA1(a);
+ }));
+ List<DumpNode> nodes = TestUtils.dumpModel(root);
+ assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, C_NAME);
+ DumpNode actualC = findByName(nodes, C_NAME);
+ assertThat(valueTokens(actualC)).containsOnly(
+ entry("Name", C_NAME),
+ entry(TOKEN_LABEL_UNWANTED, 5));
+ assertThatMapOf(referenceTokens(actualC)).containsOnly(tuple(TOKEN_LABEL_RAW_REFERENCE, A_NAME));
+ assertThatMapOf(normalRelationChildren(findByName(nodes, C_NAME))).containsExactlyInAnyOrder(
+ tuple("BiA1", A_NAME));
+ }
+
+ @Test
+ public void testTokenExcludeValue() {
+ A a = createA(A_NAME);
+ Root root = createRoot(a, createC(C_NAME, c -> {
+ c.setRawReference(a);
+ c.setUnwanted(5);
+ c.setBiA1(a);
+ }));
+
+ List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.excludeTokens(TOKEN_LABEL_UNWANTED));
+ assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, C_NAME);
+ DumpNode actualC = findByName(nodes, C_NAME);
+ assertThat(valueTokens(actualC)).containsOnly(
+ entry("Name", C_NAME));
+ assertThatMapOf(referenceTokens(actualC)).containsOnly(tuple(TOKEN_LABEL_RAW_REFERENCE, A_NAME));
+ assertThatMapOf(normalRelationChildren(findByName(nodes, C_NAME))).containsExactlyInAnyOrder(
+ tuple("BiA1", A_NAME));
+
+ }
+
+ @Test
+ public void testTokenExcludeValueAndReference() {
+ A a = createA(A_NAME);
+ Root root = createRoot(a, createC(C_NAME, c -> {
+ c.setRawReference(a);
+ c.setUnwanted(5);
+ c.setBiA1(a);
+ }));
+
+ List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.excludeTokens(TOKEN_LABEL_UNWANTED, TOKEN_LABEL_RAW_REFERENCE));
+ assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, C_NAME);
+ DumpNode actualC = findByName(nodes, C_NAME);
+ assertThat(valueTokens(actualC)).containsOnly(
+ entry("Name", C_NAME));
+ assertThat(referenceTokens(actualC)).isEmpty();
+ assertThatMapOf(normalRelationChildren(findByName(nodes, C_NAME))).containsExactlyInAnyOrder(
+ tuple("BiA1", A_NAME));
+
+ }
+
+ @Test
+ public void testTokenExcludeRelationNameLowerCase() {
+ A a = createA(A_NAME);
+ Root root = createRoot(a, createC(C_NAME, c -> {
+ c.setRawReference(a);
+ c.setUnwanted(5);
+ c.setBiA1(a);
+ }));
+
+ List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.excludeTokens("bi.*"));
+ assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, C_NAME);
+ DumpNode actualC = findByName(nodes, C_NAME);
+ assertThat(valueTokens(actualC)).containsOnly(
+ entry("Name", C_NAME),
+ entry(TOKEN_LABEL_UNWANTED, 5));
+ assertThatMapOf(referenceTokens(actualC)).containsOnly(tuple(TOKEN_LABEL_RAW_REFERENCE, A_NAME));
+ assertThatMapOf(normalRelationChildren(findByName(nodes, C_NAME))).containsExactlyInAnyOrder(
+ tuple("BiA1", A_NAME));
+ }
+
+ @Test
+ public void testTokenExcludeRelationNameTitleCase() {
+ A a = createA(A_NAME);
+ Root root = createRoot(a, createC(C_NAME, c -> {
+ c.setRawReference(a);
+ c.setUnwanted(5);
+ c.setBiA1(a);
+ }));
+
+ List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.excludeTokens("Bi.*"));
+ assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, C_NAME);
+ DumpNode actualC = findByName(nodes, C_NAME);
+ assertThat(valueTokens(actualC)).containsOnly(
+ entry("Name", C_NAME),
+ entry(TOKEN_LABEL_UNWANTED, 5));
+ assertThatMapOf(referenceTokens(actualC)).containsOnly(tuple(TOKEN_LABEL_RAW_REFERENCE, A_NAME));
+ assertThatMapOf(normalRelationChildren(findByName(nodes, C_NAME))).containsExactlyInAnyOrder(
+ tuple("BiA1", A_NAME));
+
+ }
+
+ @Test
+ public void testChildrenDefault() throws IOException {
+ /* Root
+ |- a
+ |- b - - -.
+ |-MyC: c v
+ |- a2
+ |- b2
+ */
+ final String A2_Name = "a2";
+ Root root = createRoot(createA(A_NAME, a -> {
+ a.setB(createB(B_NAME));
+ a.setMyC(createC(C_NAME,
+ createA(A2_Name, a2 -> a2.setB(createB(B2_NAME)))));
+ }), null);
+ root.getA().getB().setOneA(root.getA().getMyC().getA());
+
+ Dumper.read(root).disableTypes("C").dumpAsPNG(Paths.get("test.png"));
+ List<DumpNode> nodes = TestUtils.dumpModel(root);
+ assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(
+ ROOT_NAME, A_NAME, A2_Name, B_NAME, B2_NAME, C_NAME);
+ DumpNode actualA = findByName(nodes, A_NAME);
+ assertThatMapOf(normalChildren(actualA)).containsExactlyInAnyOrder(
+ tuple("MyC", C_NAME), tuple("B", B_NAME));
+ }
+
+ @Disabled("a2 and b2 are included in output, so currently not working as intended")
+ @Test
+ public void testChildrenExclude() {
+ /* Root
+ |- a
+ |- b - - -.
+ |-MyC: c v
+ |- a2
+ |- b2
+ */
+ final String A2_Name = "a2";
+ Root root = createRoot(createA(A_NAME, a -> {
+ a.setB(createB(B_NAME));
+ a.setMyC(createC(C_NAME,
+ createA(A2_Name, a2 -> a2.setB(createB(B2_NAME)))));
+ }), null);
+ root.getA().getB().setOneA(root.getA().getMyC().getA());
+
+ List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.excludeChildren("MyC"));
+ assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, B_NAME);
+ DumpNode actualA = findByName(nodes, A_NAME);
+ assertThatMapOf(normalChildren(actualA)).containsExactlyInAnyOrder(tuple("B", B_NAME));
+ }
+
+ @Test
+ public void testRelationsDefault() {
+ // actually the same test as #testTypesDefault, but can't hurt to test twice
+ Root root = setupAllRelations();
+
+ List<DumpNode> nodes = TestUtils.dumpModel(root);
+ assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, B_NAME, C_NAME);
+ assertAllRelationsDefaultMatches(nodes);
}
@Test
- public void testTokenExclude() {
+ public void testRelationsExclude() {
+ Root root = setupAllRelations();
+ List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.excludeRelations("BiC1"));
+ // A
+ assertThatMapOf(normalRelationChildren(findByName(nodes, A_NAME))).containsExactlyInAnyOrder(
+ tuple("BiC2", C_NAME), tuple("BiC3", C_NAME));
+ // B
+ assertThatMapOf(normalRelationChildren(findByName(nodes, B_NAME))).containsExactlyInAnyOrder(
+ tuple("OneA", A_NAME), tuple("MaybeC", C_NAME));
+ // C
+ assertThatMapOf(normalRelationChildren(findByName(nodes, C_NAME))).containsExactlyInAnyOrder(
+ 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));
+ }
+
+ @Test
+ public void testRelationsExcludeRegex1() {
+ Root root = setupAllRelations();
+
+ List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.excludeRelations("Bi.*"));
+ // A
+ assertThat(normalRelationChildren(findByName(nodes, A_NAME))).isEmpty();
+ // B
+ assertThatMapOf(normalRelationChildren(findByName(nodes, B_NAME))).containsExactlyInAnyOrder(
+ tuple("OneA", A_NAME), tuple("MaybeC", C_NAME));
+ // C
+ assertThat(normalRelationChildren(findByName(nodes, C_NAME))).isEmpty();
+ assertThat(listRelationChildren(findByName(nodes, C_NAME))).isEmpty();
+ assertThatMapOf(referenceTokens(findByName(nodes, C_NAME))).containsExactlyInAnyOrder(
+ tuple(TOKEN_LABEL_RAW_REFERENCE, A_NAME));
+ }
+
+ @Test
+ public void testRelationsExcludeRegex2() {
+ Root root = setupAllRelations();
+
+ List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.excludeRelations(".*A.*"));
+ // A
+ assertThatMapOf(normalRelationChildren(findByName(nodes, A_NAME))).containsExactlyInAnyOrder(
+ tuple("BiC1", C_NAME), tuple("BiC2", C_NAME), tuple("BiC3", C_NAME));
+ // B
+ assertThatMapOf(normalRelationChildren(findByName(nodes, B_NAME))).containsExactlyInAnyOrder(
+ tuple("MaybeC", C_NAME));
+ // C
+ assertThat(normalRelationChildren(findByName(nodes, C_NAME))).isEmpty();
+ assertThat(listRelationChildren(findByName(nodes, C_NAME))).isEmpty();
+ assertThatMapOf(referenceTokens(findByName(nodes, C_NAME))).containsExactlyInAnyOrder(
+ tuple(TOKEN_LABEL_RAW_REFERENCE, A_NAME));
}
// --- copy from below here ---
diff --git a/testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestSimple.java b/testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestSimple.java
index 4dfb16c46f5ffcea4c75da01183e53cbea6a072d..d40a297d95223a7e989ccdbcdeac08516f53d9a6 100644
--- a/testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestSimple.java
+++ b/testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestSimple.java
@@ -88,8 +88,6 @@ public class TestSimple {
List<DumpNode> nodes = TestUtils.dumpModel(root);
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, A2_NAME, B_NAME, C_NAME);
DumpNode actualB = TestUtils.findByName(nodes, B_NAME);
-// assertThatListMapOf(listRelationChildren(actualB)).containsExactlyInAnyOrder(
-// tuple("ManyA", tuple(A_NAME, A2_NAME)));
assertThatMapOf(listRelationChildren(actualB), "ManyA").containsExactlyInAnyOrder(A_NAME, A2_NAME);
}
@@ -154,7 +152,7 @@ public class TestSimple {
List<DumpNode> nodes = TestUtils.dumpModel(root);
assertEquals(4, nodes.size());
DumpNode actualC = TestUtils.findByName(nodes, C_NAME);
- assertThatMapOf(referenceTokens(actualC)).containsExactlyInAnyOrder(tuple("RawReference", A_NAME));
+ assertThatMapOf(referenceTokens(actualC)).containsExactlyInAnyOrder(tuple(TOKEN_LABEL_RAW_REFERENCE, A_NAME));
}
}
diff --git a/testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestUtils.java b/testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestUtils.java
index 1398494b9b4a3be62f84196285641723f63b529a..b5b1fcf332a68076bb36cefb6fc31e1e82e303f9 100644
--- a/testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestUtils.java
+++ b/testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestUtils.java
@@ -20,6 +20,8 @@ public class TestUtils {
public static final Random rand = new Random();
public static final String TOKEN_LABEL_OTHER_VALUE = "OtherValue";
+ public static final String TOKEN_LABEL_UNWANTED = "Unwanted";
+ public static final String TOKEN_LABEL_RAW_REFERENCE = "RawReference";
public static final String ROOT_NAME = "Root" + Integer.toHexString(rand.nextInt(0xFFFFFF));
public static final String A_NAME = "A" + Integer.toHexString(rand.nextInt(0xFFFFFF));
@@ -45,41 +47,47 @@ public class TestUtils {
}
public static A createA(String name) {
+ return createA(name, a -> {});
+ }
+
+ public static A createA(String name, Consumer<A> additionalSettings) {
A result = new A();
result.setName(name);
+ additionalSettings.accept(result);
return result;
}
public static A createA(String name, C myC) {
- A result = new A();
- result.setName(name);
- result.setMyC(myC);
- return result;
+ return createA(name, a -> a.setMyC(myC));
}
public static B createB(String name) {
- B result = new B();
- result.setName(name);
- return result;
+ return createB(name, b -> {});
}
public static B createB(String name, String otherValue) {
+ return createB(name, b -> b.setOtherValue(otherValue));
+ }
+
+ public static B createB(String name, Consumer<B> additionalSettings) {
B result = new B();
result.setName(name);
- result.setOtherValue(otherValue);
+ additionalSettings.accept(result);
return result;
}
public static C createC(String name) {
- C result = new C();
- result.setName(name);
- return result;
+ return createC(name, c -> {});
}
public static C createC(String name, A optA) {
+ return createC(name, c -> c.setA(optA));
+ }
+
+ public static C createC(String name, Consumer<C> additionalSettings) {
C result = new C();
result.setName(name);
- result.setA(optA);
+ additionalSettings.accept(result);
return result;
}