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
Stage: build
Stage: test
Show whitespace changes
Inline Side-by-side
dumpAst/src/main/jastadd/GenerationBackend.jadd
+ 103
− 10
View file @ 657e0f1c
......@@ -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();
}
......
testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestTypeLevel3.java
+ 53
− 20
View file @ 657e0f1c
......@@ -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));
}
}
......
testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestTypeLevel4.java
+ 60
− 25
View file @ 657e0f1c
......@@ -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
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment