Skip to content
Snippets Groups Projects
Commit 5faedb0c authored by René Schöne's avatar René Schöne
Browse files

WIP dumpAst 0.3.1 

- more documentation, more tests, one more bug
parent f2796519
No related branches found
No related tags found
No related merge requests found
Pipeline #7865 passed
Stage: build
Stage: test
Show whitespace changes
Inline Side-by-side
Showing
with 311 additions and 49 deletions
dumpAst/src/main/jastadd/Generation.jadd
+ 56
− 4
View file @ 5faedb0c
...@@ -53,32 +53,61 @@ import java.lang.String;aspect GenerationFrontend { ...@@ -53,32 +53,61 @@ import java.lang.String;aspect GenerationFrontend {
} }
/** /**
* Exclude object with types matching at least one of the given regex strings. * Disable all objects 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. * Disabled objects won't be included in any output. However, their children are still processed.
* @param regexes patterns to match type names * @param regexes patterns to match type names
* @return this * @return this
* @see java.util.regex.Pattern#compile(java.lang.String) * @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); updateIgnored(() -> buildConfig.getTypeIgnore(), s -> buildConfig.setTypeIgnore(s), regexes);
return this; 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) { public DumpBuilder excludeTokens(String... regexes) {
updateIgnored(() -> buildConfig.getTokenIgnore(), s -> buildConfig.setTokenIgnore(s), regexes); updateIgnored(() -> buildConfig.getTokenIgnore(), s -> buildConfig.setTokenIgnore(s), regexes);
return this; return this;
} }
public DumpBuilder excludeAttributes(String... regexes) { // not supported yet
public DumpBuilder includeAttributes(String... regexes) {
updateIgnored(() -> buildConfig.getAttributeIgnore(), s -> buildConfig.setAttributeIgnore(s), regexes); updateIgnored(() -> buildConfig.getAttributeIgnore(), s -> buildConfig.setAttributeIgnore(s), regexes);
return this; 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) { public DumpBuilder excludeChildren(String... regexes) {
updateIgnored(() -> buildConfig.getChildIgnore(), s -> buildConfig.setChildIgnore(s), regexes); updateIgnored(() -> buildConfig.getChildIgnore(), s -> buildConfig.setChildIgnore(s), regexes);
return this; 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) { public DumpBuilder excludeRelations(String... regexes) {
updateIgnored(() -> buildConfig.getRelationIgnore(), s -> buildConfig.setRelationIgnore(s), regexes); updateIgnored(() -> buildConfig.getRelationIgnore(), s -> buildConfig.setRelationIgnore(s), regexes);
return this; return this;
} }
private void updateIgnored(java.util.function.Supplier<String> getter, java.util.function.Consumer<String> setter, String... values) { private void updateIgnored(java.util.function.Supplier<String> getter, java.util.function.Consumer<String> setter, String... values) {
for (String value : values) { for (String value : values) {
if (getter.get().isEmpty()) { if (getter.get().isEmpty()) {
...@@ -93,6 +122,7 @@ import java.lang.String;aspect GenerationFrontend { ...@@ -93,6 +122,7 @@ import java.lang.String;aspect GenerationFrontend {
printConfig.addHeader(new Header(option)); printConfig.addHeader(new Header(option));
return this; return this;
} }
public DumpBuilder skinParam(SkinParamStringSetting setting, String value) { public DumpBuilder skinParam(SkinParamStringSetting setting, String value) {
customPreamble("skinparam " + setting.toString() + " " + value); customPreamble("skinparam " + setting.toString() + " " + value);
return this; return this;
...@@ -101,6 +131,7 @@ import java.lang.String;aspect GenerationFrontend { ...@@ -101,6 +131,7 @@ import java.lang.String;aspect GenerationFrontend {
customPreamble("skinparam " + setting.toString() + " " + value); customPreamble("skinparam " + setting.toString() + " " + value);
return this; return this;
} }
public DumpBuilder setScale(double value) { public DumpBuilder setScale(double value) {
printConfig.setScale(value); printConfig.setScale(value);
return this; return this;
...@@ -133,6 +164,13 @@ import java.lang.String;aspect GenerationFrontend { ...@@ -133,6 +164,13 @@ import java.lang.String;aspect GenerationFrontend {
} }
return result; 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 { public DumpBuilder dumpAsSource(java.nio.file.Path destination) throws java.io.IOException {
String content = build().toPlantUml(); String content = build().toPlantUml();
try (java.io.Writer writer = java.nio.file.Files.newBufferedWriter(destination)) { try (java.io.Writer writer = java.nio.file.Files.newBufferedWriter(destination)) {
...@@ -140,12 +178,26 @@ import java.lang.String;aspect GenerationFrontend { ...@@ -140,12 +178,26 @@ import java.lang.String;aspect GenerationFrontend {
} }
return this; 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 { public DumpBuilder dumpAsPNG(java.nio.file.Path destination) throws java.io.IOException {
String content = build().toPlantUml(); String content = build().toPlantUml();
net.sourceforge.plantuml.SourceStringReader reader = new net.sourceforge.plantuml.SourceStringReader(content); net.sourceforge.plantuml.SourceStringReader reader = new net.sourceforge.plantuml.SourceStringReader(content);
reader.outputImage(java.nio.file.Files.newOutputStream(destination)); reader.outputImage(java.nio.file.Files.newOutputStream(destination));
return this; 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 { public DumpBuilder dumpAsSVG(java.nio.file.Path destination) throws java.io.IOException {
String content = build().toPlantUml(); String content = build().toPlantUml();
net.sourceforge.plantuml.SourceStringReader reader = new net.sourceforge.plantuml.SourceStringReader(content); net.sourceforge.plantuml.SourceStringReader reader = new net.sourceforge.plantuml.SourceStringReader(content);
......
dumpAst/src/main/java/de/tudresden/inf/st/jastadd/dumpAst/SimpleMain.java
+ 1
− 1
View file @ 5faedb0c
...@@ -116,7 +116,7 @@ public class SimpleMain { ...@@ -116,7 +116,7 @@ public class SimpleMain {
Dumper.read(model.toMustache()) Dumper.read(model.toMustache())
.skinParam(SkinParamBooleanSetting.Monochrome, true) .skinParam(SkinParamBooleanSetting.Monochrome, true)
.enableDebug() .enableDebug()
.excludeTypes(".*Comment") .disableTypes(".*Comment")
.dumpAsSource(Paths.get("temp.plantuml")) .dumpAsSource(Paths.get("temp.plantuml"))
.dumpAsSVG(Paths.get("temp.svg")); .dumpAsSVG(Paths.get("temp.svg"));
} }
......
testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestExcluded.java
+ 233
− 29
View file @ 5faedb0c
...@@ -5,6 +5,7 @@ import de.tudresden.inf.st.jastadd.dumpAst.ast.DumpNode; ...@@ -5,6 +5,7 @@ import de.tudresden.inf.st.jastadd.dumpAst.ast.DumpNode;
import de.tudresden.inf.st.jastadd.dumpAst.ast.Dumper; import de.tudresden.inf.st.jastadd.dumpAst.ast.Dumper;
import org.jastadd.testDumper.ast.A; import org.jastadd.testDumper.ast.A;
import org.jastadd.testDumper.ast.Root; import org.jastadd.testDumper.ast.Root;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import java.io.IOException; import java.io.IOException;
...@@ -46,7 +47,7 @@ public class TestExcluded { ...@@ -46,7 +47,7 @@ public class TestExcluded {
assertThat(valueTokens(actualB3)).containsOnly(entry("Name", B3_NAME), entry(TOKEN_LABEL_OTHER_VALUE, "")); 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 root = createRoot(createA(A_NAME), createC(C_NAME), createB(B_NAME, "A"));
root.getC().setRawReference(root.getA()); root.getC().setRawReference(root.getA());
// rel B.oneA -> A ; // rel B.oneA -> A ;
...@@ -66,14 +67,14 @@ public class TestExcluded { ...@@ -66,14 +67,14 @@ public class TestExcluded {
@Test @Test
public void testTypesDefault() { public void testTypesDefault() {
Root root = setupTypes(); Root root = setupAllRelations();
List<DumpNode> nodes = TestUtils.dumpModel(root); List<DumpNode> nodes = TestUtils.dumpModel(root);
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, B_NAME, C_NAME); 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 // A
assertThatMapOf(normalRelationChildren(findByName(nodes, A_NAME))).containsExactlyInAnyOrder( assertThatMapOf(normalRelationChildren(findByName(nodes, A_NAME))).containsExactlyInAnyOrder(
tuple("BiC1", C_NAME), tuple("BiC2", C_NAME), tuple("BiC3", C_NAME)); tuple("BiC1", C_NAME), tuple("BiC2", C_NAME), tuple("BiC3", C_NAME));
...@@ -85,32 +86,32 @@ public class TestExcluded { ...@@ -85,32 +86,32 @@ public class TestExcluded {
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(listRelationChildren(findByName(nodes, C_NAME)), "BiA2").containsExactlyInAnyOrder(A_NAME);
assertThatMapOf(referenceTokens(findByName(nodes, C_NAME))).containsExactlyInAnyOrder( assertThatMapOf(referenceTokens(findByName(nodes, C_NAME))).containsExactlyInAnyOrder(
tuple("RawReference", A_NAME)); tuple(TOKEN_LABEL_RAW_REFERENCE, A_NAME));
} }
@Test @Test
public void testTypesNonMatching() { 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); assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, B_NAME, C_NAME);
assertTypeDefaultMatches(nodes); assertAllRelationsDefaultMatches(nodes);
} }
@Test @Test
public void testTypesInheritanceNotIncluded() { 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); assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, B_NAME, C_NAME);
assertTypeDefaultMatches(nodes); assertAllRelationsDefaultMatches(nodes);
} }
@Test @Test
public void testTypesExcludeOnlyA() { 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); assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, B_NAME, C_NAME);
// B // B
assertThatMapOf(normalRelationChildren(findByName(nodes, B_NAME))).containsExactlyInAnyOrder( assertThatMapOf(normalRelationChildren(findByName(nodes, B_NAME))).containsExactlyInAnyOrder(
...@@ -123,60 +124,263 @@ public class TestExcluded { ...@@ -123,60 +124,263 @@ public class TestExcluded {
@Test @Test
public void testTypesExcludeMultipleArguments() { 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); assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, B_NAME);
// B // B
assertThatMapOf(normalRelationChildren(findByName(nodes, B_NAME))).isEmpty(); assertThat(normalRelationChildren(findByName(nodes, B_NAME))).isEmpty();
} }
@Test @Test
public void testTypesExcludeMultipleCalls() { 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); assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, B_NAME);
// B // B
assertThatMapOf(normalRelationChildren(findByName(nodes, B_NAME))).isEmpty(); assertThat(normalRelationChildren(findByName(nodes, B_NAME))).isEmpty();
} }
@Test @Test
public void testTypesExcludeRegex() { 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); assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(A_NAME, B_NAME, C_NAME);
assertTypeDefaultMatches(nodes); assertAllRelationsDefaultMatches(nodes);
} }
@Test @Test
public void testTypesInvisiblePath() throws IOException { public void testTypesInvisiblePath() {
final String A2_Name = "a2"; final String A2_Name = "a2";
final String A3_Name = "a3"; final String A3_Name = "a3";
final String C2_Name = "c2"; final String C2_Name = "c2";
A mostInnerA = createA(A3_Name);
mostInnerA.setB(createB(B_NAME));
Root root = createRoot(createA(A_NAME, Root root = createRoot(createA(A_NAME,
createC(C_NAME, createC(C_NAME,
createA(A2_Name, createA(A2_Name,
createC(C2_Name, mostInnerA)))), createC(C2_Name,
createA(A3_Name, a -> a.setB(createB(B_NAME))))))),
null); null);
List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.excludeTypes("A", "C")); List<DumpNode> nodes = TestUtils.dumpModel(root, db -> db.disableTypes("A", "C"));
Dumper.read(root).excludeTypes("A", "C").dumpAsPNG(Paths.get("test.png"));
DumpNode actualRoot = findByName(nodes, ROOT_NAME); DumpNode actualRoot = findByName(nodes, ROOT_NAME);
assertThat(invisiblePath(actualRoot)).flatExtracting(NAME_EXTRACTOR).containsExactly(B_NAME); assertThat(invisiblePath(actualRoot)).flatExtracting(NAME_EXTRACTOR).containsExactly(B_NAME);
} }
@Test @Test
public void testTokenDefault() { 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 @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 --- // --- copy from below here ---
......
testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestSimple.java
+ 1
− 3
View file @ 5faedb0c
...@@ -88,8 +88,6 @@ public class TestSimple { ...@@ -88,8 +88,6 @@ public class TestSimple {
List<DumpNode> nodes = TestUtils.dumpModel(root); List<DumpNode> nodes = TestUtils.dumpModel(root);
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, A2_NAME, B_NAME, C_NAME); assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, A2_NAME, B_NAME, C_NAME);
DumpNode actualB = TestUtils.findByName(nodes, B_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); assertThatMapOf(listRelationChildren(actualB), "ManyA").containsExactlyInAnyOrder(A_NAME, A2_NAME);
} }
...@@ -154,7 +152,7 @@ public class TestSimple { ...@@ -154,7 +152,7 @@ public class TestSimple {
List<DumpNode> nodes = TestUtils.dumpModel(root); List<DumpNode> nodes = TestUtils.dumpModel(root);
assertEquals(4, nodes.size()); assertEquals(4, nodes.size());
DumpNode actualC = TestUtils.findByName(nodes, C_NAME); 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));
} }
} }
testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestUtils.java
+ 20
− 12
View file @ 5faedb0c
...@@ -20,6 +20,8 @@ public class TestUtils { ...@@ -20,6 +20,8 @@ public class TestUtils {
public static final Random rand = new Random(); public static final Random rand = new Random();
public static final String TOKEN_LABEL_OTHER_VALUE = "OtherValue"; 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 ROOT_NAME = "Root" + Integer.toHexString(rand.nextInt(0xFFFFFF));
public static final String A_NAME = "A" + Integer.toHexString(rand.nextInt(0xFFFFFF)); public static final String A_NAME = "A" + Integer.toHexString(rand.nextInt(0xFFFFFF));
...@@ -45,41 +47,47 @@ public class TestUtils { ...@@ -45,41 +47,47 @@ public class TestUtils {
} }
public static A createA(String name) { public static A createA(String name) {
return createA(name, a -> {});
}
public static A createA(String name, Consumer<A> additionalSettings) {
A result = new A(); A result = new A();
result.setName(name); result.setName(name);
additionalSettings.accept(result);
return result; return result;
} }
public static A createA(String name, C myC) { public static A createA(String name, C myC) {
A result = new A(); return createA(name, a -> a.setMyC(myC));
result.setName(name);
result.setMyC(myC);
return result;
} }
public static B createB(String name) { public static B createB(String name) {
B result = new B(); return createB(name, b -> {});
result.setName(name);
return result;
} }
public static B createB(String name, String otherValue) { 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(); B result = new B();
result.setName(name); result.setName(name);
result.setOtherValue(otherValue); additionalSettings.accept(result);
return result; return result;
} }
public static C createC(String name) { public static C createC(String name) {
C result = new C(); return createC(name, c -> {});
result.setName(name);
return result;
} }
public static C createC(String name, A optA) { 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(); C result = new C();
result.setName(name); result.setName(name);
result.setA(optA); additionalSettings.accept(result);
return result; return result;
} }
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment