diff --git a/dumpAst/src/main/jastadd/GenerationBackend.jadd b/dumpAst/src/main/jastadd/GenerationBackend.jadd
index c59d1cc444f46b65ba76f6e9161138ee1f991780..06be2080f4539fbdcecbcd1762c79ce28f93d73f 100644
--- a/dumpAst/src/main/jastadd/GenerationBackend.jadd
+++ b/dumpAst/src/main/jastadd/GenerationBackend.jadd
@@ -270,31 +270,124 @@ aspect GenerationBackend {
}
// TODO: add new attributes for: {token,child,relation,attribute,nta}Enabled(String parentType, String name). 1) just move implementation into this attribute. 2) add include/exclude on type-level to it.
+
+ // --- isTypeEnabled ---
syn boolean DumpAst.isTypeEnabled(String typeName) {
return !matches(getBuildConfig().typeIgnorePattern(), typeName);
}
+ // --- isTokenEnabled ---
syn boolean DumpAst.isTokenEnabled(String parentType, String tokenName) {
- return !matches(getBuildConfig().getGlobalPatternCollection().tokenIgnorePattern(), tokenName);
+ // level 4: excluded for type? -> return no
+ PatternCollection excludeOnType = getBuildConfig().matchExcludePatternCollection(parentType);
+ if (excludeOnType != null && matches(excludeOnType.tokenPattern(), tokenName)) {
+ return false;
+ }
+ // level 3: included for type? -> return yes
+ PatternCollection includeOnType = getBuildConfig().matchIncludePatternCollection(parentType);
+ if (includeOnType != null && matches(includeOnType.tokenPattern(), tokenName)) {
+ return true;
+ }
+ // level 2: globally excluded? -> return no
+ // level 1: otherwise return yes
+ return !matches(getBuildConfig().getGlobalPatternCollection().tokenPattern(), tokenName);
}
+
+ // --- isChildEnabled ---
syn boolean DumpAst.isChildEnabled(String parentType, String childName) {
- return !matches(getBuildConfig().getGlobalPatternCollection().childIgnorePattern(), childName);
+ // level 4: excluded for type? -> return no
+ PatternCollection excludeOnType = getBuildConfig().matchExcludePatternCollection(parentType);
+ if (excludeOnType != null && matches(excludeOnType.childPattern(), childName)) {
+ return false;
+ }
+ // level 3: included for type? -> return yes
+ PatternCollection includeOnType = getBuildConfig().matchIncludePatternCollection(parentType);
+ if (includeOnType != null && matches(includeOnType.childPattern(), childName)) {
+ return true;
+ }
+ // level 2: globally excluded? -> return no
+ // level 1: otherwise return yes
+ return !matches(getBuildConfig().getGlobalPatternCollection().childPattern(), childName);
}
+
+ // --- isRelationEnabled ---
syn boolean DumpAst.isRelationEnabled(String parentType, String relationName) {
- return !matches(getBuildConfig().getGlobalPatternCollection().relationIgnorePattern(), relationName);
+ // level 4: excluded for type? -> return no
+ PatternCollection excludeOnType = getBuildConfig().matchExcludePatternCollection(parentType);
+ if (excludeOnType != null && matches(excludeOnType.relationPattern(), relationName)) {
+ return false;
+ }
+ // level 3: included for type? -> return yes
+ PatternCollection includeOnType = getBuildConfig().matchIncludePatternCollection(parentType);
+ if (includeOnType != null && matches(includeOnType.relationPattern(), relationName)) {
+ return true;
+ }
+ // level 2: globally excluded? -> return no
+ // level 1: otherwise return yes
+ return !matches(getBuildConfig().getGlobalPatternCollection().relationPattern(), relationName);
}
+
+ // --- isAttributeEnabled ---
syn boolean DumpAst.isAttributeEnabled(String parentType, String attributeName) {
- return matches(getBuildConfig().getGlobalPatternCollection().attributeIncludePattern(), attributeName);
+ // level 4: included for type? -> return yes
+ PatternCollection includeOnType = getBuildConfig().matchIncludePatternCollection(parentType);
+ if (includeOnType != null && matches(includeOnType.attributePattern(), attributeName)) {
+ return true;
+ }
+ // level 3: excluded for type? -> return no
+ PatternCollection excludeOnType = getBuildConfig().matchExcludePatternCollection(parentType);
+ if (excludeOnType != null && matches(excludeOnType.attributePattern(), attributeName)) {
+ return false;
+ }
+ // level 2: globally included? -> return yes
+ // level 1: otherwise return no
+ return matches(getBuildConfig().getGlobalPatternCollection().attributePattern(), attributeName);
}
+
+ // --- isNonterminalAttributeEnabled ---
syn boolean DumpAst.isNonterminalAttributeEnabled(String parentType, String ntaName) {
- return matches(getBuildConfig().getGlobalPatternCollection().ntaIncludePattern(), ntaName);
+ // level 4: included for type? -> return yes
+ PatternCollection includeOnType = getBuildConfig().matchIncludePatternCollection(parentType);
+ if (includeOnType != null && matches(includeOnType.ntaPattern(), ntaName)) {
+ return true;
+ }
+ // level 3: excluded for type? -> return no
+ PatternCollection excludeOnType = getBuildConfig().matchExcludePatternCollection(parentType);
+ if (excludeOnType != null && matches(excludeOnType.ntaPattern(), ntaName)) {
+ return false;
+ }
+ // level 2: globally included? -> return yes
+ // level 1: otherwise return no
+ return matches(getBuildConfig().getGlobalPatternCollection().ntaPattern(), ntaName);
}
+ // --- match{In,Ex}cludePatternCollection ---
+ syn PatternCollection BuildConfig.matchIncludePatternCollection(String typeName) {
+ for (TypePatternCollectionMapping mapping : getIncludeTypePatternList()) {
+ if (matches(mapping.typePattern(), typeName)) {
+ return mapping.getPatternCollection();
+ }
+ }
+ return null;
+ }
+ syn PatternCollection BuildConfig.matchExcludePatternCollection(String typeName) {
+ for (TypePatternCollectionMapping mapping : getExcludeTypePatternList()) {
+ if (matches(mapping.typePattern(), typeName)) {
+ return mapping.getPatternCollection();
+ }
+ }
+ return null;
+ }
+
+ // --- {typeIgnore,child,token,relation,attribute,nta}Pattern ---
syn java.util.regex.Pattern BuildConfig.typeIgnorePattern() = java.util.regex.Pattern.compile(getTypeIgnorePattern());
- syn java.util.regex.Pattern PatternCollection.childIgnorePattern() = java.util.regex.Pattern.compile(getChildPattern());
- syn java.util.regex.Pattern PatternCollection.tokenIgnorePattern() = java.util.regex.Pattern.compile(getTokenPattern());
- syn java.util.regex.Pattern PatternCollection.attributeIncludePattern() = java.util.regex.Pattern.compile(getAttributePattern());
- syn java.util.regex.Pattern PatternCollection.ntaIncludePattern() = java.util.regex.Pattern.compile(getNonterminalAttributePattern());
- syn java.util.regex.Pattern PatternCollection.relationIgnorePattern() = java.util.regex.Pattern.compile(getRelationPattern());
+ syn java.util.regex.Pattern PatternCollection.childPattern() = java.util.regex.Pattern.compile(getChildPattern());
+ syn java.util.regex.Pattern PatternCollection.tokenPattern() = java.util.regex.Pattern.compile(getTokenPattern());
+ syn java.util.regex.Pattern PatternCollection.relationPattern() = java.util.regex.Pattern.compile(getRelationPattern());
+ syn java.util.regex.Pattern PatternCollection.attributePattern() = java.util.regex.Pattern.compile(getAttributePattern());
+ syn java.util.regex.Pattern PatternCollection.ntaPattern() = java.util.regex.Pattern.compile(getNonterminalAttributePattern());
+ syn java.util.regex.Pattern TypePatternCollectionMapping.typePattern() = java.util.regex.Pattern.compile(getTypeRegex());
+
+ // --- matches ---
static boolean ASTNode.matches(java.util.regex.Pattern p, String input) {
return p.matcher(input).matches();
}
diff --git a/testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestTypeLevel3.java b/testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestTypeLevel3.java
index 023ffdb2977ff034acc712a8ef8d00c54dbfec99..3d37a56a6e25751f38d1bd96daa48b4ec8f16db2 100644
--- a/testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestTypeLevel3.java
+++ b/testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestTypeLevel3.java
@@ -33,7 +33,7 @@ public class TestTypeLevel3 {
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME);
for (String name : Tx_NAMES) {
DumpNode actualTx = TestUtils.findByName(nodes, name);
- assertThat(valueTokens(actualTx)).containsExactly(entry("Name", name));
+ assertThat(valueTokens(actualTx)).containsOnly(entry("Name", name));
}
}
@@ -47,27 +47,27 @@ public class TestTypeLevel3 {
dp -> dp.excludeTokens("Unwanted")
.includeTokensFor("T2", "Unwanted"));
assertThat(nodesT2).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME);
- assertThat(valueTokens(TestUtils.findByName(nodesT2, T1_NAME))).containsExactly(
+ assertThat(valueTokens(TestUtils.findByName(nodesT2, T1_NAME))).containsOnly(
entry("Name", T1_NAME));
- assertThat(valueTokens(TestUtils.findByName(nodesT2, T2_NAME))).containsExactly(
+ assertThat(valueTokens(TestUtils.findByName(nodesT2, T2_NAME))).containsOnly(
entry("Name", T2_NAME), entry("Unwanted", 5));
- assertThat(valueTokens(TestUtils.findByName(nodesT2, T3_NAME))).containsExactly(
+ assertThat(valueTokens(TestUtils.findByName(nodesT2, T3_NAME))).containsOnly(
entry("Name", T3_NAME));
List<DumpNode> nodesT2T3 = TestUtils.dumpModel(root,
dp -> dp.excludeTokens("Unwanted")
.includeTokensFor("T2|T3", "Unwanted"));
assertThat(nodesT2T3).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME);
- assertThat(valueTokens(TestUtils.findByName(nodesT2T3, T1_NAME))).containsExactly(
+ assertThat(valueTokens(TestUtils.findByName(nodesT2T3, T1_NAME))).containsOnly(
entry("Name", T1_NAME));
- assertThat(valueTokens(TestUtils.findByName(nodesT2T3, T2_NAME))).containsExactly(
+ assertThat(valueTokens(TestUtils.findByName(nodesT2T3, T2_NAME))).containsOnly(
entry("Name", T2_NAME), entry("Unwanted", 5));
- assertThat(valueTokens(TestUtils.findByName(nodesT2T3, T3_NAME))).containsExactly(
+ assertThat(valueTokens(TestUtils.findByName(nodesT2T3, T3_NAME))).containsOnly(
entry("Name", T3_NAME), entry("Unwanted", 5));
}
@Test
- public void testChildLevel2Excluded() {
+ public void testNormalChildLevel2Excluded() {
Consumer<AbstractT> setB = t -> t.setB(createB(t.getName() + B_NAME));
TRoot root = createTRoot(createA(A_NAME), createT1(setB), createT2(setB), createT3(setB));
Assertions.assertEquals(T2_NAME + B_NAME, root.getT2().getB().getName());
@@ -76,12 +76,12 @@ public class TestTypeLevel3 {
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME);
for (String name : Tx_NAMES) {
DumpNode actualTx = TestUtils.findByName(nodes, name);
- assertThat(listChildren(actualTx)).isEmpty();
+ assertThat(normalChildren(actualTx)).isEmpty();
}
}
@Test
- public void testChildLevel3SomeIncluded() {
+ public void testNormalChildLevel3SomeIncluded() {
Consumer<AbstractT> setB = t -> t.setB(createB(t.getName() + B_NAME));
TRoot root = createTRoot(createA(A_NAME), createT1(setB), createT2(setB), createT3(setB));
Assertions.assertEquals(T2_NAME + B_NAME, root.getT2().getB().getName());
@@ -89,9 +89,39 @@ public class TestTypeLevel3 {
List<DumpNode> nodes = TestUtils.dumpModel(root,
dp -> dp.excludeChildren("B")
.includeChildrenFor("T2", "B"));
+ assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME, T2_NAME + B_NAME);
+ assertThat(normalChildren(TestUtils.findByName(nodes, T1_NAME))).isEmpty();
+ assertThatMapOf(normalChildren(TestUtils.findByName(nodes, T2_NAME))).containsOnly(
+ tuple("B", T2_NAME + B_NAME));
+ assertThat(normalChildren(TestUtils.findByName(nodes, T3_NAME))).isEmpty();
+ }
+
+ @Test
+ public void testListChildLevel2Excluded() {
+ Consumer<AbstractT> addBee = t -> t.addBee(createB(t.getName() + B_NAME));
+ TRoot root = createTRoot(createA(A_NAME), createT1(addBee), createT2(addBee), createT3(addBee));
+ Assertions.assertEquals(T2_NAME + B_NAME, root.getT2().getBee(0).getName());
+
+ List<DumpNode> nodes = TestUtils.dumpModel(root,
+ 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();
+ }
+ }
+
+ @Test
+ public void testListChildLevel3SomeIncluded() {
+ Consumer<AbstractT> addBee = t -> t.addBee(createB(t.getName() + B_NAME));
+ TRoot root = createTRoot(createA(A_NAME), createT1(addBee), createT2(addBee), createT3(addBee));
+ Assertions.assertEquals(T2_NAME + B_NAME, root.getT2().getBee(0).getName());
+
+ List<DumpNode> nodes = TestUtils.dumpModel(root,
+ 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();
- assertThatMapOf(listChildren(TestUtils.findByName(nodes, T2_NAME)), "B").containsExactly(
+ assertThatMapOf(listChildren(TestUtils.findByName(nodes, T2_NAME)), "Bee").containsOnly(
T2_NAME + B_NAME);
assertThat(listChildren(TestUtils.findByName(nodes, T3_NAME))).isEmpty();
}
@@ -123,7 +153,7 @@ public class TestTypeLevel3 {
.includeRelationsFor("T2", "OneA"));
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME);
assertThat(normalRelationChildren(TestUtils.findByName(nodes, T1_NAME))).isEmpty();
- assertThatMapOf(normalRelationChildren(TestUtils.findByName(nodes, T2_NAME))).containsExactly(
+ assertThatMapOf(normalRelationChildren(TestUtils.findByName(nodes, T2_NAME))).containsOnly(
tuple("OneA", A_NAME));
assertThat(normalRelationChildren(TestUtils.findByName(nodes, T3_NAME))).isEmpty();
}
@@ -137,7 +167,10 @@ public class TestTypeLevel3 {
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME);
for (String name : Tx_NAMES) {
DumpNode actualTx = findByName(nodes, name);
- assertThat(valueTokens(actualTx)).containsExactly(entry("Name", name), entry("simpleAttr", 43));
+ assertThat(valueTokens(actualTx)).containsOnly(
+ entry("Name", name),
+ entry(TOKEN_LABEL_UNWANTED, 0),
+ entry("simpleAttr", 43));
}
}
@@ -149,12 +182,12 @@ public class TestTypeLevel3 {
dp -> dp.includeAttributes("simpleAttr")
.excludeAttributesFor("T2", "simpleAttr"));
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME);
- assertThat(valueTokens(findByName(nodes, T1_NAME))).containsExactly(
- entry("Name", T1_NAME), entry("simpleAttr", 43));
- assertThat(valueTokens(findByName(nodes, T2_NAME))).containsExactly(
- entry("Name", T2_NAME));
- assertThat(valueTokens(findByName(nodes, T3_NAME))).containsExactly(
- entry("Name", T3_NAME), entry("simpleAttr", 43));
+ assertThat(valueTokens(findByName(nodes, T1_NAME))).containsOnly(
+ entry("Name", T1_NAME), entry(TOKEN_LABEL_UNWANTED, 0), entry("simpleAttr", 43));
+ assertThat(valueTokens(findByName(nodes, T2_NAME))).containsOnly(
+ entry("Name", T2_NAME), entry(TOKEN_LABEL_UNWANTED, 0));
+ assertThat(valueTokens(findByName(nodes, T3_NAME))).containsOnly(
+ entry("Name", T3_NAME), entry(TOKEN_LABEL_UNWANTED, 0), entry("simpleAttr", 43));
}
@Test
@@ -166,7 +199,7 @@ public class TestTypeLevel3 {
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME, "Calculated-" + T1_NAME, "Calculated-" + T2_NAME, "Calculated-" + T3_NAME);
for (String name : Tx_NAMES) {
assertThatMapOf(normalChildren(findByName(nodes, name))).containsOnly(
- tuple("Calculated", "Calculated-" + T3_NAME));
+ tuple("Calculated", "Calculated-" + name));
}
}
diff --git a/testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestTypeLevel4.java b/testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestTypeLevel4.java
index 95679b86aa37af97c200bc0f4bb959de28d1e558..489a296a2777cca1c42dda7a391ae5921ea939df 100644
--- a/testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestTypeLevel4.java
+++ b/testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestTypeLevel4.java
@@ -38,7 +38,7 @@ public class TestTypeLevel4 {
DumpNode actualTx = findByName(nodes, name);
assertThat(valueTokens(actualTx)).containsOnly(entry("Name", name), entry(TOKEN_LABEL_UNWANTED, 5));
}
- assertThat(valueTokens(findByName(nodes, C_NAME))).containsExactly(
+ assertThat(valueTokens(findByName(nodes, C_NAME))).containsOnly(
entry("Name", C_NAME));
}
@@ -55,13 +55,13 @@ public class TestTypeLevel4 {
.excludeTokensFor("T3", TOKEN_LABEL_UNWANTED));
assertThat(nodesT2).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(
ROOT_NAME, A_NAME, C_NAME, T1_NAME, T2_NAME, T3_NAME);
- assertThat(valueTokens(findByName(nodesT2, T1_NAME))).containsExactly(
+ assertThat(valueTokens(findByName(nodesT2, T1_NAME))).containsOnly(
entry("Name", T1_NAME), entry(TOKEN_LABEL_UNWANTED, 5));
- assertThat(valueTokens(findByName(nodesT2, T2_NAME))).containsExactly(
+ assertThat(valueTokens(findByName(nodesT2, T2_NAME))).containsOnly(
entry("Name", T2_NAME), entry(TOKEN_LABEL_UNWANTED, 5));
- assertThat(valueTokens(findByName(nodesT2, T3_NAME))).containsExactly(
+ assertThat(valueTokens(findByName(nodesT2, T3_NAME))).containsOnly(
entry("Name", T3_NAME));
- assertThat(valueTokens(findByName(nodesT2, C_NAME))).containsExactly(
+ assertThat(valueTokens(findByName(nodesT2, C_NAME))).containsOnly(
entry("Name", C_NAME));
List<DumpNode> nodesT2T3 = dumpModel(root,
@@ -70,18 +70,18 @@ public class TestTypeLevel4 {
.excludeTokensFor("T2|T3", TOKEN_LABEL_UNWANTED));
assertThat(nodesT2T3).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(
ROOT_NAME, A_NAME, C_NAME, T1_NAME, T2_NAME, T3_NAME);
- assertThat(valueTokens(findByName(nodesT2T3, T1_NAME))).containsExactly(
+ assertThat(valueTokens(findByName(nodesT2T3, T1_NAME))).containsOnly(
entry("Name", T1_NAME), entry(TOKEN_LABEL_UNWANTED, 5));
- assertThat(valueTokens(findByName(nodesT2T3, T2_NAME))).containsExactly(
+ assertThat(valueTokens(findByName(nodesT2T3, T2_NAME))).containsOnly(
entry("Name", T2_NAME));
- assertThat(valueTokens(findByName(nodesT2T3, T3_NAME))).containsExactly(
+ assertThat(valueTokens(findByName(nodesT2T3, T3_NAME))).containsOnly(
entry("Name", T3_NAME));
- assertThat(valueTokens(findByName(nodesT2T3, C_NAME))).containsExactly(
+ assertThat(valueTokens(findByName(nodesT2T3, C_NAME))).containsOnly(
entry("Name", C_NAME));
}
@Test
- public void testChildLevel3Included() {
+ public void testNormalChildLevel3Included() {
Consumer<AbstractT> setB = t -> t.setB(createB(t.getName() + B_NAME));
TRoot root = createTRoot(createA(A_NAME), createT1(setB), createT2(setB), createT3(setB));
Assertions.assertEquals(T2_NAME + B_NAME, root.getT2().getB().getName());
@@ -91,13 +91,13 @@ public class TestTypeLevel4 {
.includeChildrenFor("T.", "B"));
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME, T1_NAME + B_NAME, T2_NAME + B_NAME, T3_NAME + B_NAME);
for (String name : Tx_NAMES) {
- assertThatMapOf(listChildren(findByName(nodes, name)), "B").containsExactly(
- name + B_NAME);
+ assertThatMapOf(normalChildren(findByName(nodes, name))).containsOnly(
+ tuple("B", name + B_NAME));
}
}
@Test
- public void testChildLevel4SomeExcluded() {
+ public void testNormalChildLevel4SomeExcluded() {
Consumer<AbstractT> setB = t -> t.setB(createB(t.getName() + B_NAME));
TRoot root = createTRoot(createA(A_NAME), createT1(setB), createT2(setB), createT3(setB));
Assertions.assertEquals(T2_NAME + B_NAME, root.getT2().getB().getName());
@@ -107,9 +107,43 @@ public class TestTypeLevel4 {
.includeChildrenFor("T.", "B")
.excludeChildrenFor("T3", "B"));
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME, T1_NAME + B_NAME, T2_NAME + B_NAME);
- assertThatMapOf(listChildren(findByName(nodes, T1_NAME)), "B").containsExactly(
+ assertThatMapOf(normalChildren(findByName(nodes, T1_NAME))).containsOnly(
+ tuple("B", T1_NAME + B_NAME));
+ assertThatMapOf(normalChildren(findByName(nodes, T2_NAME))).containsOnly(
+ tuple("B", T2_NAME + B_NAME));
+ assertThat(normalChildren(findByName(nodes, T3_NAME))).isEmpty();
+ }
+
+ @Test
+ public void testListChildLevel3Included() {
+ Consumer<AbstractT> addBee = t -> t.addBee(createB(t.getName() + B_NAME));
+ TRoot root = createTRoot(createA(A_NAME), createT1(addBee), createT2(addBee), createT3(addBee));
+ Assertions.assertEquals(T3_NAME + B_NAME, root.getT3().getBee(0).getName());
+
+ List<DumpNode> nodes = dumpModel(root,
+ dp -> dp.excludeChildren("Bee")
+ .includeChildrenFor("T.", "Bee"));
+ assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME, T1_NAME + B_NAME, T2_NAME + B_NAME, T3_NAME + B_NAME);
+ for (String name : Tx_NAMES) {
+ assertThatMapOf(listChildren(findByName(nodes, name)), "Bee").containsOnly(
+ name + B_NAME);
+ }
+ }
+
+ @Test
+ public void testListChildLevel4SomeExcluded() {
+ Consumer<AbstractT> addBee = t -> t.addBee(createB(t.getName() + B_NAME));
+ TRoot root = createTRoot(createA(A_NAME), createT1(addBee), createT2(addBee), createT3(addBee));
+ Assertions.assertEquals(T3_NAME + B_NAME, root.getT3().getBee(0).getName());
+
+ List<DumpNode> nodes = dumpModel(root,
+ dp -> dp.excludeChildren("Bee")
+ .includeChildrenFor("T.", "Bee")
+ .excludeChildrenFor("T3", "Bee"));
+ assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME, T1_NAME + B_NAME, T2_NAME + B_NAME);
+ assertThatMapOf(listChildren(findByName(nodes, T1_NAME)), "Bee").containsOnly(
T1_NAME + B_NAME);
- assertThatMapOf(listChildren(findByName(nodes, T2_NAME)), "B").containsExactly(
+ assertThatMapOf(listChildren(findByName(nodes, T2_NAME)), "Bee").containsOnly(
T2_NAME + B_NAME);
assertThat(listChildren(findByName(nodes, T3_NAME))).isEmpty();
}
@@ -126,7 +160,7 @@ public class TestTypeLevel4 {
.includeRelationsFor("T2", "OneA"));
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME);
assertThat(normalRelationChildren(findByName(nodes, T1_NAME))).isEmpty();
- assertThatMapOf(normalRelationChildren(findByName(nodes, T2_NAME))).containsExactly(
+ assertThatMapOf(normalRelationChildren(findByName(nodes, T2_NAME))).containsOnly(
tuple("OneA", A_NAME));
assertThat(normalRelationChildren(findByName(nodes, T3_NAME))).isEmpty();
}
@@ -143,9 +177,9 @@ public class TestTypeLevel4 {
.includeRelationsFor("T.", "OneA")
.excludeRelationsFor("T3", "OneA"));
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME);
- assertThatMapOf(normalRelationChildren(findByName(nodes, T1_NAME))).containsExactly(
+ assertThatMapOf(normalRelationChildren(findByName(nodes, T1_NAME))).containsOnly(
tuple("OneA", A_NAME));
- assertThatMapOf(normalRelationChildren(findByName(nodes, T2_NAME))).containsExactly(
+ assertThatMapOf(normalRelationChildren(findByName(nodes, T2_NAME))).containsOnly(
tuple("OneA", A_NAME));
assertThat(normalRelationChildren(findByName(nodes, T3_NAME))).isEmpty();
}
@@ -160,7 +194,8 @@ public class TestTypeLevel4 {
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME);
for (String name : Tx_NAMES) {
DumpNode actualTx = TestUtils.findByName(nodes, name);
- assertThat(valueTokens(actualTx)).containsExactly(entry("Name", name));
+ assertThat(valueTokens(actualTx)).containsOnly(
+ entry("Name", name), entry(TOKEN_LABEL_UNWANTED, 0));
}
}
@@ -173,12 +208,12 @@ public class TestTypeLevel4 {
.excludeAttributesFor("T.", "simpleAttr")
.includeAttributesFor("T3", "simpleAttr"));
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME);
- assertThat(valueTokens(TestUtils.findByName(nodes, T1_NAME))).containsExactly(
- entry("Name", T1_NAME));
- assertThat(valueTokens(TestUtils.findByName(nodes, T2_NAME))).containsExactly(
- entry("Name", T2_NAME));
- assertThat(valueTokens(TestUtils.findByName(nodes, T3_NAME))).containsExactly(
- entry("Name", T3_NAME), entry("simpleAttr", 43));
+ assertThat(valueTokens(TestUtils.findByName(nodes, T1_NAME))).containsOnly(
+ entry("Name", T1_NAME), entry(TOKEN_LABEL_UNWANTED, 0));
+ assertThat(valueTokens(TestUtils.findByName(nodes, T2_NAME))).containsOnly(
+ entry("Name", T2_NAME), entry(TOKEN_LABEL_UNWANTED, 0));
+ assertThat(valueTokens(TestUtils.findByName(nodes, T3_NAME))).containsOnly(
+ entry("Name", T3_NAME), entry(TOKEN_LABEL_UNWANTED, 0), entry("simpleAttr", 43));
}
@Test