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

WIP: type-level inclusion/exclusion - added tests.

parent cc85101d
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Showing
with 466 additions and 13 deletions
grammar2uml/src/main/java/de/tudresden/inf/st/jastadd/grammar2uml/compiler/Compiler.java
+ 1
− 2
View file @ da2f1f42
......@@ -47,8 +47,7 @@ public class Compiler extends AbstractCompiler {
*/
private String readVersion() {
try {
ResourceBundle resources = ResourceBundle.getBundle("grammar2umlVersion");
return resources.getString("version");
return ResourceBundle.getBundle("grammar2umlVersion").getString("version");
} catch (MissingResourceException e) {
return "version ?";
}
......
testDumper/src/main/jastadd/testDumper.jrag
+ 10
− 1
View file @ da2f1f42
aspect Grammar {
aspect GrammarGlobal {
syn A C.getCalculated() {
A result = new A();
result.setName("Calculated-" + getName());
......@@ -30,3 +30,12 @@ aspect Grammar {
syn int Root.simpleAttr() = 42;
syn A Root.referenceAttr() = getA();
}
aspect GrammarTypeLevel {
syn int AbstractT.simpleAttr() = 43;
syn nta A AbstractT.getCalculated() {
A result = new A();
result.setName("Calculated-" + getName());
return result;
}
}
testDumper/src/main/jastadd/testDumper.relast
+ 12
− 0
View file @ da2f1f42
// testcases with global inclusion/exclusion
Nameable ::= <Name> ;
Root : Nameable ::= A B* [C] ;
A : Nameable ::= B MyC:C ;
......@@ -11,3 +12,14 @@ rel B.manyA* -> A ;
rel C.biA1 <-> A.biC1 ;
rel C.biA2* <-> A.biC2 ;
rel C.biA3? <-> A.biC3 ;
// testcases with type-level inclusion/exclusion
TRoot : Nameable ::= A T1 T2 T3 ;
abstract AbstractT : Nameable ::= B Bee:B* <SomeValue> <Unwanted:int> ;
T1 : AbstractT ;
T2 : AbstractT ;
T3 : AbstractT ;
rel AbstractT.oneA -> A ;
rel AbstractT.maybeA? -> A ;
rel AbstractT.manyA* -> A ;
testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestIncluded.java
+ 0
− 1
View file @ da2f1f42
......@@ -2,7 +2,6 @@ package de.tudresden.inf.st.jastadd.testDumper;
import de.tudresden.inf.st.jastadd.dumpAst.ast.DumpNode;
import org.jastadd.testDumper.ast.Root;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import java.util.List;
......
testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestTypeLevel3.java 0 → 100644
+ 188
− 0
View file @ da2f1f42
package de.tudresden.inf.st.jastadd.testDumper;
import de.tudresden.inf.st.jastadd.dumpAst.ast.DumpNode;
import org.jastadd.testDumper.ast.A;
import org.jastadd.testDumper.ast.AbstractT;
import org.jastadd.testDumper.ast.TRoot;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import java.util.List;
import java.util.function.Consumer;
import static de.tudresden.inf.st.jastadd.testDumper.TestUtils.*;
import static org.assertj.core.api.Assertions.*;
/**
* Testing type-level exclusions.
* <p>
* Refer to {@link de.tudresden.inf.st.jastadd.dumpAst.ast.DumpBuilder DumpBuilder} for levels of inclusion/exclusion.
*
* @author rschoene - Initial contribution
*/
public class TestTypeLevel3 {
@Test
public void testTokenLevel2Excluded() {
Consumer<AbstractT> setUnwanted = t -> t.setUnwanted(5);
TRoot root = createTRoot(createA(A_NAME), createT1(setUnwanted), createT2(setUnwanted), createT3(setUnwanted));
Assertions.assertEquals(5, root.getT2().getUnwanted());
List<DumpNode> nodes = TestUtils.dumpModel(root, dp -> dp.excludeTokens("Unwanted"));
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));
}
}
@Test
public void testTokenLevel3SomeIncluded() {
Consumer<AbstractT> setUnwanted = t -> t.setUnwanted(5);
TRoot root = createTRoot(createA(A_NAME), createT1(setUnwanted), createT2(setUnwanted), createT3(setUnwanted));
Assertions.assertEquals(5, root.getT2().getUnwanted());
List<DumpNode> nodesT2 = TestUtils.dumpModel(root,
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(
entry("Name", T1_NAME));
assertThat(valueTokens(TestUtils.findByName(nodesT2, T2_NAME))).containsExactly(
entry("Name", T2_NAME), entry("Unwanted", 5));
assertThat(valueTokens(TestUtils.findByName(nodesT2, T3_NAME))).containsExactly(
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(
entry("Name", T1_NAME));
assertThat(valueTokens(TestUtils.findByName(nodesT2T3, T2_NAME))).containsExactly(
entry("Name", T2_NAME), entry("Unwanted", 5));
assertThat(valueTokens(TestUtils.findByName(nodesT2T3, T3_NAME))).containsExactly(
entry("Name", T3_NAME), entry("Unwanted", 5));
}
@Test
public void testChildLevel2Excluded() {
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());
List<DumpNode> nodes = TestUtils.dumpModel(root, dp -> dp.excludeChildren("B"));
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();
}
}
@Test
public void testChildLevel3SomeIncluded() {
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());
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);
assertThat(listChildren(TestUtils.findByName(nodes, T1_NAME))).isEmpty();
assertThatMapOf(listChildren(TestUtils.findByName(nodes, T2_NAME)), "B").containsExactly(
T2_NAME + B_NAME);
assertThat(listChildren(TestUtils.findByName(nodes, T3_NAME))).isEmpty();
}
@Test
public void testRelationLevel2Excluded() {
final A a = createA(A_NAME);
Consumer<AbstractT> setOneA = t -> t.setOneA(a);
TRoot root = createTRoot(a, createT1(setOneA), createT2(setOneA), createT3(setOneA));
Assertions.assertEquals(a, root.getT2().getOneA());
List<DumpNode> nodes = TestUtils.dumpModel(root, dp -> dp.excludeRelations("OneA"));
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(normalRelationChildren(actualTx)).isEmpty();
}
}
@Test
public void testRelationLevel3SomeIncluded() {
final A a = createA(A_NAME);
Consumer<AbstractT> setOneA = t -> t.setOneA(a);
TRoot root = createTRoot(a, createT1(setOneA), createT2(setOneA), createT3(setOneA));
Assertions.assertEquals(a, root.getT2().getOneA());
List<DumpNode> nodes = TestUtils.dumpModel(root,
dp -> dp.excludeRelations("OneA")
.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(
tuple("OneA", A_NAME));
assertThat(normalRelationChildren(TestUtils.findByName(nodes, T3_NAME))).isEmpty();
}
@Test
public void testAttributeLevel2Included() {
TRoot root = createTRoot(createA(A_NAME), createT1(), createT2(), createT3());
List<DumpNode> nodes = dumpModel(root,
dp -> dp.includeAttributes("simpleAttr"));
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));
}
}
@Test
public void testAttributeLevel3SomeExcluded() {
TRoot root = createTRoot(createA(A_NAME), createT1(), createT2(), createT3());
List<DumpNode> nodes = dumpModel(root,
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));
}
@Test
public void testNTALevel2Included() {
TRoot root = createTRoot(createA(A_NAME), createT1(), createT2(), createT3());
List<DumpNode> nodes = dumpModel(root,
dp -> dp.includeNonterminalAttributes("Calculated"));
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));
}
}
@Test
public void testNTALevel3SomeExcluded() {
TRoot root = createTRoot(createA(A_NAME), createT1(), createT2(), createT3());
List<DumpNode> nodes = dumpModel(root,
dp -> dp.includeNonterminalAttributes("Calculated")
.excludeNonterminalAttributesFor("T2", "Calculated"));
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME, "Calculated-" + T1_NAME, "Calculated-" + T3_NAME);
assertThatMapOf(normalChildren(findByName(nodes, T1_NAME))).containsOnly(
tuple("Calculated", "Calculated-" + T1_NAME));
assertThat(normalChildren(findByName(nodes, T2_NAME))).isEmpty();
assertThatMapOf(normalChildren(findByName(nodes, T3_NAME))).containsOnly(
tuple("Calculated", "Calculated-" + T3_NAME));
}
}
testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestTypeLevel4.java 0 → 100644
+ 209
− 0
View file @ da2f1f42
package de.tudresden.inf.st.jastadd.testDumper;
import de.tudresden.inf.st.jastadd.dumpAst.ast.DumpNode;
import org.jastadd.testDumper.ast.A;
import org.jastadd.testDumper.ast.AbstractT;
import org.jastadd.testDumper.ast.TRoot;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.List;
import java.util.function.Consumer;
import static de.tudresden.inf.st.jastadd.testDumper.TestUtils.*;
import static org.assertj.core.api.Assertions.*;
/**
* Testing type-level inclusions.
* <p>
* Refer to {@link de.tudresden.inf.st.jastadd.dumpAst.ast.DumpBuilder DumpBuilder} for levels of inclusion/exclusion.
*
* @author rschoene - Initial contribution
*/
public class TestTypeLevel4 {
@Test
public void testTokenLevel3Included() {
Consumer<AbstractT> setUnwanted = t -> t.setUnwanted(5);
TRoot root = createTRoot(createA(A_NAME, createC(C_NAME, c -> c.setUnwanted(6))),
createT1(setUnwanted), createT2(setUnwanted), createT3(setUnwanted));
Assertions.assertEquals(5, root.getT2().getUnwanted());
List<DumpNode> nodes = dumpModel(root,
dp -> dp.excludeTokens(TOKEN_LABEL_UNWANTED)
.includeTokensFor("T.", TOKEN_LABEL_UNWANTED));
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(
ROOT_NAME, A_NAME, C_NAME, T1_NAME, T2_NAME, T3_NAME);
for (String name : Tx_NAMES) {
DumpNode actualTx = findByName(nodes, name);
assertThat(valueTokens(actualTx)).containsOnly(entry("Name", name), entry(TOKEN_LABEL_UNWANTED, 5));
}
assertThat(valueTokens(findByName(nodes, C_NAME))).containsExactly(
entry("Name", C_NAME));
}
@Test
public void testTokenLevel4SomeExcluded() {
Consumer<AbstractT> setUnwanted = t -> t.setUnwanted(5);
TRoot root = createTRoot(createA(A_NAME, createC(C_NAME, c -> c.setUnwanted(6))),
createT1(setUnwanted), createT2(setUnwanted), createT3(setUnwanted));
Assertions.assertEquals(5, root.getT2().getUnwanted());
List<DumpNode> nodesT2 = dumpModel(root,
dp -> dp.excludeTokens(TOKEN_LABEL_UNWANTED)
.includeTokensFor("T.", TOKEN_LABEL_UNWANTED)
.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(
entry("Name", T1_NAME), entry(TOKEN_LABEL_UNWANTED, 5));
assertThat(valueTokens(findByName(nodesT2, T2_NAME))).containsExactly(
entry("Name", T2_NAME), entry(TOKEN_LABEL_UNWANTED, 5));
assertThat(valueTokens(findByName(nodesT2, T3_NAME))).containsExactly(
entry("Name", T3_NAME));
assertThat(valueTokens(findByName(nodesT2, C_NAME))).containsExactly(
entry("Name", C_NAME));
List<DumpNode> nodesT2T3 = dumpModel(root,
dp -> dp.excludeTokens(TOKEN_LABEL_UNWANTED)
.includeTokensFor("T.", TOKEN_LABEL_UNWANTED)
.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(
entry("Name", T1_NAME), entry(TOKEN_LABEL_UNWANTED, 5));
assertThat(valueTokens(findByName(nodesT2T3, T2_NAME))).containsExactly(
entry("Name", T2_NAME));
assertThat(valueTokens(findByName(nodesT2T3, T3_NAME))).containsExactly(
entry("Name", T3_NAME));
assertThat(valueTokens(findByName(nodesT2T3, C_NAME))).containsExactly(
entry("Name", C_NAME));
}
@Test
public void testChildLevel3Included() {
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());
List<DumpNode> nodes = dumpModel(root,
dp -> dp.excludeChildren("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);
for (String name : Tx_NAMES) {
assertThatMapOf(listChildren(findByName(nodes, name)), "B").containsExactly(
name + B_NAME);
}
}
@Test
public void testChildLevel4SomeExcluded() {
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());
List<DumpNode> nodes = dumpModel(root,
dp -> dp.excludeChildren("B")
.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(
T1_NAME + B_NAME);
assertThatMapOf(listChildren(findByName(nodes, T2_NAME)), "B").containsExactly(
T2_NAME + B_NAME);
assertThat(listChildren(findByName(nodes, T3_NAME))).isEmpty();
}
@Test
public void testRelationLevel3Included() {
final A a = createA(A_NAME);
Consumer<AbstractT> setOneA = t -> t.setOneA(a);
TRoot root = createTRoot(a, createT1(setOneA), createT2(setOneA), createT3(setOneA));
Assertions.assertEquals(a, root.getT2().getOneA());
List<DumpNode> nodes = dumpModel(root,
dp -> dp.excludeRelations("OneA")
.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(
tuple("OneA", A_NAME));
assertThat(normalRelationChildren(findByName(nodes, T3_NAME))).isEmpty();
}
@Test
public void testRelationLevel4SomeExcluded() {
final A a = createA(A_NAME);
Consumer<AbstractT> setOneA = t -> t.setOneA(a);
TRoot root = createTRoot(a, createT1(setOneA), createT2(setOneA), createT3(setOneA));
Assertions.assertEquals(a, root.getT2().getOneA());
List<DumpNode> nodes = dumpModel(root,
dp -> dp.excludeRelations("OneA")
.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(
tuple("OneA", A_NAME));
assertThatMapOf(normalRelationChildren(findByName(nodes, T2_NAME))).containsExactly(
tuple("OneA", A_NAME));
assertThat(normalRelationChildren(findByName(nodes, T3_NAME))).isEmpty();
}
@Test
public void testAttributeLevel3Excluded() {
TRoot root = createTRoot(createA(A_NAME), createT1(), createT2(), createT3());
List<DumpNode> nodes = TestUtils.dumpModel(root,
dp -> dp.includeAttributes("simpleAttr")
.excludeAttributesFor("T.", "simpleAttr"));
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));
}
}
@Test
public void testAttributeLevel4SomeIncluded() {
TRoot root = createTRoot(createA(A_NAME), createT1(), createT2(), createT3());
List<DumpNode> nodes = TestUtils.dumpModel(root,
dp -> dp.includeAttributes("simpleAttr")
.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));
}
@Test
public void testNTALevel3Excluded() {
TRoot root = createTRoot(createA(A_NAME), createT1(), createT2(), createT3());
List<DumpNode> nodes = TestUtils.dumpModel(root,
dp -> dp.includeNonterminalAttributes("Calculated")
.excludeNonterminalAttributesFor("T.", "Calculated"));
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME);
DumpNode actualT3 = TestUtils.findByName(nodes, T3_NAME);
assertThat(normalChildren(actualT3)).isEmpty();
}
@Test
public void testNTALevel4SomeIncluded() {
TRoot root = createTRoot(createA(A_NAME), createT1(), createT2(), createT3());
List<DumpNode> nodes = TestUtils.dumpModel(root,
dp -> dp.includeNonterminalAttributes("Calculated")
.excludeNonterminalAttributesFor("T.", "Calculated")
.includeNonterminalAttributesFor("T3", "Calculated"));
assertThat(nodes).flatExtracting(NAME_EXTRACTOR).containsExactlyInAnyOrder(ROOT_NAME, A_NAME, T1_NAME, T2_NAME, T3_NAME, "Calculated-" + T3_NAME);
DumpNode actualT3 = TestUtils.findByName(nodes, T3_NAME);
assertThatMapOf(normalChildren(actualT3)).containsOnly(tuple("Calculated", "Calculated-" + T3_NAME));
}
}
testDumper/src/test/java/de/tudresden/inf/st/jastadd/testDumper/TestUtils.java
+ 46
− 9
View file @ da2f1f42
......@@ -5,10 +5,7 @@ import org.assertj.core.api.AbstractListAssert;
import org.assertj.core.api.Assertions;
import org.assertj.core.api.ObjectAssert;
import org.assertj.core.groups.Tuple;
import org.jastadd.testDumper.ast.A;
import org.jastadd.testDumper.ast.B;
import org.jastadd.testDumper.ast.C;
import org.jastadd.testDumper.ast.Root;
import org.jastadd.testDumper.ast.*;
import java.util.*;
import java.util.function.Consumer;
......@@ -30,6 +27,10 @@ public class TestUtils {
public static final String B2_NAME = "B2" + Integer.toHexString(rand.nextInt(0xFFFFFF));
public static final String B3_NAME = "B3" + Integer.toHexString(rand.nextInt(0xFFFFFF));
public static final String C_NAME = "C" + Integer.toHexString(rand.nextInt(0xFFFFFF));
public static final String T1_NAME = "T1" + Integer.toHexString(rand.nextInt(0xFFFFFF));
public static final String T2_NAME = "T2" + Integer.toHexString(rand.nextInt(0xFFFFFF));
public static final String T3_NAME = "T3" + Integer.toHexString(rand.nextInt(0xFFFFFF));
public static final String[] Tx_NAMES = {T1_NAME, T2_NAME, T3_NAME};
public static Root createRoot(A a, C c, B... bs) {
Root result = new Root();
......@@ -91,6 +92,47 @@ public class TestUtils {
return result;
}
public static TRoot createTRoot(A a, T1 t1, T2 t2, T3 t3) {
TRoot result = new TRoot();
result.setName(ROOT_NAME);
if (a != null) {
result.setA(a);
}
if (t1 != null) {
result.setT1(t1);
}
if (t2 != null) {
result.setT2(t2);
}
if (t3 != null) {
result.setT3(t3);
}
return result;
}
@SafeVarargs
public static T1 createT1(Consumer<AbstractT>... additionalSettings) {
return setupAbstractT(new T1(), T1_NAME, additionalSettings);
}
@SafeVarargs
public static T2 createT2(Consumer<AbstractT>... additionalSettings) {
return setupAbstractT(new T2(), T2_NAME, additionalSettings);
}
@SafeVarargs
public static T3 createT3(Consumer<AbstractT>... additionalSettings) {
return setupAbstractT(new T3(), T3_NAME, additionalSettings);
}
private static <T extends AbstractT> T setupAbstractT(T t, String name, Consumer<AbstractT>[] additionalSettings) {
t.setName(name);
for (Consumer<AbstractT> setting : additionalSettings) {
setting.accept(t);
}
return t;
}
public static final Function<DumpNode, String> NAME_EXTRACTOR = node -> {
for (DumpToken dumpToken : node.getDumpTokenList()) {
if (dumpToken.getName().equals("Name")) {
......@@ -106,11 +148,6 @@ public class TestUtils {
public static AbstractListAssert<?, List<?>, Object, ObjectAssert<Object>> assertThatMapOf(Map<String, List<DumpNode>> map, String key) {
return Assertions.assertThat(map.get(key)).flatExtracting(NAME_EXTRACTOR);
// return Assertions.assertThat(map).extractingFromEntries(Map.Entry::getKey, e -> {
// List<Object> result = new ArrayList<>();
// e.getValue().stream().map(NAME_EXTRACTOR).forEach(result::add);
// return tuple(result.toArray());
// });
}
public static List<DumpNode> dumpModel(Object target) {
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment