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

type-level inclusion/exclusion - test working.

parent 554e650a
No related branches found
No related tags found
No related merge requests found
Pipeline #8237 failed
...@@ -270,31 +270,124 @@ aspect GenerationBackend { ...@@ -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. // 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) { syn boolean DumpAst.isTypeEnabled(String typeName) {
return !matches(getBuildConfig().typeIgnorePattern(), typeName); return !matches(getBuildConfig().typeIgnorePattern(), typeName);
} }
// --- isTokenEnabled ---
syn boolean DumpAst.isTokenEnabled(String parentType, String tokenName) { 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) { 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) { 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) { 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) { 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 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.childPattern() = 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.tokenPattern() = 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.relationPattern() = java.util.regex.Pattern.compile(getRelationPattern());
syn java.util.regex.Pattern PatternCollection.ntaIncludePattern() = java.util.regex.Pattern.compile(getNonterminalAttributePattern()); syn java.util.regex.Pattern PatternCollection.attributePattern() = java.util.regex.Pattern.compile(getAttributePattern());
syn java.util.regex.Pattern PatternCollection.relationIgnorePattern() = java.util.regex.Pattern.compile(getRelationPattern()); 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) { static boolean ASTNode.matches(java.util.regex.Pattern p, String input) {
return p.matcher(input).matches(); return p.matcher(input).matches();
} }
......
...@@ -33,7 +33,7 @@ public class TestTypeLevel3 { ...@@ -33,7 +33,7 @@ public class TestTypeLevel3 {
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME); assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME);
for (String name : Tx_NAMES) { for (String name : Tx_NAMES) {
DumpNode actualTx = TestUtils.findByName(nodes, name); 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 { ...@@ -47,27 +47,27 @@ public class TestTypeLevel3 {
dp -> dp.excludeTokens("Unwanted") dp -> dp.excludeTokens("Unwanted")
.includeTokensFor("T2", "Unwanted")); .includeTokensFor("T2", "Unwanted"));
assertThat(nodesT2).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME); 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)); 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)); 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)); entry("Name", T3_NAME));
List<DumpNode> nodesT2T3 = TestUtils.dumpModel(root, List<DumpNode> nodesT2T3 = TestUtils.dumpModel(root,
dp -> dp.excludeTokens("Unwanted") dp -> dp.excludeTokens("Unwanted")
.includeTokensFor("T2|T3", "Unwanted")); .includeTokensFor("T2|T3", "Unwanted"));
assertThat(nodesT2T3).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME); 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)); 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)); 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)); entry("Name", T3_NAME), entry("Unwanted", 5));
} }
@Test @Test
public void testChildLevel2Excluded() { public void testNormalChildLevel2Excluded() {
Consumer<AbstractT> setB = t -> t.setB(createB(t.getName() + B_NAME)); Consumer<AbstractT> setB = t -> t.setB(createB(t.getName() + B_NAME));
TRoot root = createTRoot(createA(A_NAME), createT1(setB), createT2(setB), createT3(setB)); TRoot root = createTRoot(createA(A_NAME), createT1(setB), createT2(setB), createT3(setB));
Assertions.assertEquals(T2_NAME + B_NAME, root.getT2().getB().getName()); Assertions.assertEquals(T2_NAME + B_NAME, root.getT2().getB().getName());
...@@ -76,12 +76,12 @@ public class TestTypeLevel3 { ...@@ -76,12 +76,12 @@ public class TestTypeLevel3 {
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME); assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME);
for (String name : Tx_NAMES) { for (String name : Tx_NAMES) {
DumpNode actualTx = TestUtils.findByName(nodes, name); DumpNode actualTx = TestUtils.findByName(nodes, name);
assertThat(listChildren(actualTx)).isEmpty(); assertThat(normalChildren(actualTx)).isEmpty();
} }
} }
@Test @Test
public void testChildLevel3SomeIncluded() { public void testNormalChildLevel3SomeIncluded() {
Consumer<AbstractT> setB = t -> t.setB(createB(t.getName() + B_NAME)); Consumer<AbstractT> setB = t -> t.setB(createB(t.getName() + B_NAME));
TRoot root = createTRoot(createA(A_NAME), createT1(setB), createT2(setB), createT3(setB)); TRoot root = createTRoot(createA(A_NAME), createT1(setB), createT2(setB), createT3(setB));
Assertions.assertEquals(T2_NAME + B_NAME, root.getT2().getB().getName()); Assertions.assertEquals(T2_NAME + B_NAME, root.getT2().getB().getName());
...@@ -89,9 +89,39 @@ public class TestTypeLevel3 { ...@@ -89,9 +89,39 @@ public class TestTypeLevel3 {
List<DumpNode> nodes = TestUtils.dumpModel(root, List<DumpNode> nodes = TestUtils.dumpModel(root,
dp -> dp.excludeChildren("B") dp -> dp.excludeChildren("B")
.includeChildrenFor("T2", "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); 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(); 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); T2_NAME + B_NAME);
assertThat(listChildren(TestUtils.findByName(nodes, T3_NAME))).isEmpty(); assertThat(listChildren(TestUtils.findByName(nodes, T3_NAME))).isEmpty();
} }
...@@ -123,7 +153,7 @@ public class TestTypeLevel3 { ...@@ -123,7 +153,7 @@ public class TestTypeLevel3 {
.includeRelationsFor("T2", "OneA")); .includeRelationsFor("T2", "OneA"));
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME); assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME);
assertThat(normalRelationChildren(TestUtils.findByName(nodes, T1_NAME))).isEmpty(); 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)); tuple("OneA", A_NAME));
assertThat(normalRelationChildren(TestUtils.findByName(nodes, T3_NAME))).isEmpty(); assertThat(normalRelationChildren(TestUtils.findByName(nodes, T3_NAME))).isEmpty();
} }
...@@ -137,7 +167,10 @@ public class TestTypeLevel3 { ...@@ -137,7 +167,10 @@ public class TestTypeLevel3 {
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME); assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME);
for (String name : Tx_NAMES) { for (String name : Tx_NAMES) {
DumpNode actualTx = findByName(nodes, name); 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 { ...@@ -149,12 +182,12 @@ public class TestTypeLevel3 {
dp -> dp.includeAttributes("simpleAttr") dp -> dp.includeAttributes("simpleAttr")
.excludeAttributesFor("T2", "simpleAttr")); .excludeAttributesFor("T2", "simpleAttr"));
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME); assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME);
assertThat(valueTokens(findByName(nodes, T1_NAME))).containsExactly( assertThat(valueTokens(findByName(nodes, T1_NAME))).containsOnly(
entry("Name", T1_NAME), entry("simpleAttr", 43)); entry("Name", T1_NAME), entry(TOKEN_LABEL_UNWANTED, 0), entry("simpleAttr", 43));
assertThat(valueTokens(findByName(nodes, T2_NAME))).containsExactly( assertThat(valueTokens(findByName(nodes, T2_NAME))).containsOnly(
entry("Name", T2_NAME)); entry("Name", T2_NAME), entry(TOKEN_LABEL_UNWANTED, 0));
assertThat(valueTokens(findByName(nodes, T3_NAME))).containsExactly( assertThat(valueTokens(findByName(nodes, T3_NAME))).containsOnly(
entry("Name", T3_NAME), entry("simpleAttr", 43)); entry("Name", T3_NAME), entry(TOKEN_LABEL_UNWANTED, 0), entry("simpleAttr", 43));
} }
@Test @Test
...@@ -166,7 +199,7 @@ public class TestTypeLevel3 { ...@@ -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); 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) { for (String name : Tx_NAMES) {
assertThatMapOf(normalChildren(findByName(nodes, name))).containsOnly( assertThatMapOf(normalChildren(findByName(nodes, name))).containsOnly(
tuple("Calculated", "Calculated-" + T3_NAME)); tuple("Calculated", "Calculated-" + name));
} }
} }
......
...@@ -38,7 +38,7 @@ public class TestTypeLevel4 { ...@@ -38,7 +38,7 @@ public class TestTypeLevel4 {
DumpNode actualTx = findByName(nodes, name); DumpNode actualTx = findByName(nodes, name);
assertThat(valueTokens(actualTx)).containsOnly(entry("Name", name), entry(TOKEN_LABEL_UNWANTED, 5)); 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)); entry("Name", C_NAME));
} }
...@@ -55,13 +55,13 @@ public class TestTypeLevel4 { ...@@ -55,13 +55,13 @@ public class TestTypeLevel4 {
.excludeTokensFor("T3", TOKEN_LABEL_UNWANTED)); .excludeTokensFor("T3", TOKEN_LABEL_UNWANTED));
assertThat(nodesT2).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder( assertThat(nodesT2).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(
ROOT_NAME, A_NAME, C_NAME, T1_NAME, T2_NAME, T3_NAME); 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)); 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)); 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)); entry("Name", T3_NAME));
assertThat(valueTokens(findByName(nodesT2, C_NAME))).containsExactly( assertThat(valueTokens(findByName(nodesT2, C_NAME))).containsOnly(
entry("Name", C_NAME)); entry("Name", C_NAME));
List<DumpNode> nodesT2T3 = dumpModel(root, List<DumpNode> nodesT2T3 = dumpModel(root,
...@@ -70,18 +70,18 @@ public class TestTypeLevel4 { ...@@ -70,18 +70,18 @@ public class TestTypeLevel4 {
.excludeTokensFor("T2|T3", TOKEN_LABEL_UNWANTED)); .excludeTokensFor("T2|T3", TOKEN_LABEL_UNWANTED));
assertThat(nodesT2T3).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder( assertThat(nodesT2T3).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(
ROOT_NAME, A_NAME, C_NAME, T1_NAME, T2_NAME, T3_NAME); 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)); 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)); entry("Name", T2_NAME));
assertThat(valueTokens(findByName(nodesT2T3, T3_NAME))).containsExactly( assertThat(valueTokens(findByName(nodesT2T3, T3_NAME))).containsOnly(
entry("Name", T3_NAME)); entry("Name", T3_NAME));
assertThat(valueTokens(findByName(nodesT2T3, C_NAME))).containsExactly( assertThat(valueTokens(findByName(nodesT2T3, C_NAME))).containsOnly(
entry("Name", C_NAME)); entry("Name", C_NAME));
} }
@Test @Test
public void testChildLevel3Included() { public void testNormalChildLevel3Included() {
Consumer<AbstractT> setB = t -> t.setB(createB(t.getName() + B_NAME)); Consumer<AbstractT> setB = t -> t.setB(createB(t.getName() + B_NAME));
TRoot root = createTRoot(createA(A_NAME), createT1(setB), createT2(setB), createT3(setB)); TRoot root = createTRoot(createA(A_NAME), createT1(setB), createT2(setB), createT3(setB));
Assertions.assertEquals(T2_NAME + B_NAME, root.getT2().getB().getName()); Assertions.assertEquals(T2_NAME + B_NAME, root.getT2().getB().getName());
...@@ -91,13 +91,13 @@ public class TestTypeLevel4 { ...@@ -91,13 +91,13 @@ public class TestTypeLevel4 {
.includeChildrenFor("T.", "B")); .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); 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) { for (String name : Tx_NAMES) {
assertThatMapOf(listChildren(findByName(nodes, name)), "B").containsExactly( assertThatMapOf(normalChildren(findByName(nodes, name))).containsOnly(
name + B_NAME); tuple("B", name + B_NAME));
} }
} }
@Test @Test
public void testChildLevel4SomeExcluded() { public void testNormalChildLevel4SomeExcluded() {
Consumer<AbstractT> setB = t -> t.setB(createB(t.getName() + B_NAME)); Consumer<AbstractT> setB = t -> t.setB(createB(t.getName() + B_NAME));
TRoot root = createTRoot(createA(A_NAME), createT1(setB), createT2(setB), createT3(setB)); TRoot root = createTRoot(createA(A_NAME), createT1(setB), createT2(setB), createT3(setB));
Assertions.assertEquals(T2_NAME + B_NAME, root.getT2().getB().getName()); Assertions.assertEquals(T2_NAME + B_NAME, root.getT2().getB().getName());
...@@ -107,9 +107,43 @@ public class TestTypeLevel4 { ...@@ -107,9 +107,43 @@ public class TestTypeLevel4 {
.includeChildrenFor("T.", "B") .includeChildrenFor("T.", "B")
.excludeChildrenFor("T3", "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); 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); T1_NAME + B_NAME);
assertThatMapOf(listChildren(findByName(nodes, T2_NAME)), "B").containsExactly( assertThatMapOf(listChildren(findByName(nodes, T2_NAME)), "Bee").containsOnly(
T2_NAME + B_NAME); T2_NAME + B_NAME);
assertThat(listChildren(findByName(nodes, T3_NAME))).isEmpty(); assertThat(listChildren(findByName(nodes, T3_NAME))).isEmpty();
} }
...@@ -126,7 +160,7 @@ public class TestTypeLevel4 { ...@@ -126,7 +160,7 @@ public class TestTypeLevel4 {
.includeRelationsFor("T2", "OneA")); .includeRelationsFor("T2", "OneA"));
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME); assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME);
assertThat(normalRelationChildren(findByName(nodes, T1_NAME))).isEmpty(); 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)); tuple("OneA", A_NAME));
assertThat(normalRelationChildren(findByName(nodes, T3_NAME))).isEmpty(); assertThat(normalRelationChildren(findByName(nodes, T3_NAME))).isEmpty();
} }
...@@ -143,9 +177,9 @@ public class TestTypeLevel4 { ...@@ -143,9 +177,9 @@ public class TestTypeLevel4 {
.includeRelationsFor("T.", "OneA") .includeRelationsFor("T.", "OneA")
.excludeRelationsFor("T3", "OneA")); .excludeRelationsFor("T3", "OneA"));
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME); 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)); tuple("OneA", A_NAME));
assertThatMapOf(normalRelationChildren(findByName(nodes, T2_NAME))).containsExactly( assertThatMapOf(normalRelationChildren(findByName(nodes, T2_NAME))).containsOnly(
tuple("OneA", A_NAME)); tuple("OneA", A_NAME));
assertThat(normalRelationChildren(findByName(nodes, T3_NAME))).isEmpty(); assertThat(normalRelationChildren(findByName(nodes, T3_NAME))).isEmpty();
} }
...@@ -160,7 +194,8 @@ public class TestTypeLevel4 { ...@@ -160,7 +194,8 @@ public class TestTypeLevel4 {
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME); assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME);
for (String name : Tx_NAMES) { for (String name : Tx_NAMES) {
DumpNode actualTx = TestUtils.findByName(nodes, name); 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 { ...@@ -173,12 +208,12 @@ public class TestTypeLevel4 {
.excludeAttributesFor("T.", "simpleAttr") .excludeAttributesFor("T.", "simpleAttr")
.includeAttributesFor("T3", "simpleAttr")); .includeAttributesFor("T3", "simpleAttr"));
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME); assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME);
assertThat(valueTokens(TestUtils.findByName(nodes, T1_NAME))).containsExactly( assertThat(valueTokens(TestUtils.findByName(nodes, T1_NAME))).containsOnly(
entry("Name", T1_NAME)); entry("Name", T1_NAME), entry(TOKEN_LABEL_UNWANTED, 0));
assertThat(valueTokens(TestUtils.findByName(nodes, T2_NAME))).containsExactly( assertThat(valueTokens(TestUtils.findByName(nodes, T2_NAME))).containsOnly(
entry("Name", T2_NAME)); entry("Name", T2_NAME), entry(TOKEN_LABEL_UNWANTED, 0));
assertThat(valueTokens(TestUtils.findByName(nodes, T3_NAME))).containsExactly( assertThat(valueTokens(TestUtils.findByName(nodes, T3_NAME))).containsOnly(
entry("Name", T3_NAME), entry("simpleAttr", 43)); entry("Name", T3_NAME), entry(TOKEN_LABEL_UNWANTED, 0), entry("simpleAttr", 43));
} }
@Test @Test
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment