diff --git a/build.gradle b/build.gradle
index 0383ec1426d52eb248d733b7fd55a1d748f8a07b..a52e75e647098516d58ab31270c0c8a81bd2e160 100644
--- a/build.gradle
+++ b/build.gradle
@@ -110,7 +110,7 @@ task preprocessRelationTest(type: JavaExec, group: 'verification') {
classpath = sourceSets.main.runtimeClasspath
main = 'org.jastadd.relast.compiler.Compiler'
- args 'src/test/jastadd/relations/Relations.relast', '--file', '--grammarName=src/test/jastadd/relations/Relations'
+ args 'src/test/jastadd/relations/Relations.relast', '--useJastAddNames', '--file', '--grammarName=src/test/jastadd/relations/Relations'
}
task doublePreprocessRelationTest(type: JavaExec, group: 'verification') {
@@ -121,7 +121,7 @@ task doublePreprocessRelationTest(type: JavaExec, group: 'verification') {
classpath = sourceSets.main.runtimeClasspath
main = 'org.jastadd.relast.compiler.Compiler'
- args 'src/test/jastadd/relations/Relations.ast', '--file', '--grammarName=src/test/jastadd/relations/Relations2'
+ args 'src/test/jastadd/relations/Relations.ast', '--useJastAddNames', '--file', '--grammarName=src/test/jastadd/relations/Relations2'
}
task compileRelationTest(type: JavaExec, group: 'verification') {
@@ -135,6 +135,50 @@ task compileRelationTest(type: JavaExec, group: 'verification') {
args '--o=src/test/java-gen/', '--package=relations.ast', 'src/test/jastadd/relations/Relations.ast', 'src/test/jastadd/relations/Relations.jadd', 'src/test/jastadd/Utils.jadd'
}
+task preprocessDefaultNamesTest(type: JavaExec, group: 'verification') {
+
+ doFirst {
+ delete 'src/test/jastadd/relations/Relations.ast', 'src/test/jastadd/relations/Relations.jadd'
+ }
+
+ classpath = sourceSets.main.runtimeClasspath
+ main = 'org.jastadd.relast.compiler.Compiler'
+ args 'src/test/jastadd/relations/Relations.relast', '--file', '--grammarName=src/test/jastadd/relations/Relations'
+}
+
+task compileDefaultNamesTest(type: JavaExec, group: 'verification') {
+
+ doFirst {
+ delete 'src/test/java-gen/relations'
+ }
+
+ classpath = sourceSets.main.runtimeClasspath
+ main = 'org.jastadd.JastAdd'
+ args '--o=src/test/java-gen/', '--package=defaultnames.ast', 'src/test/jastadd/relations/Relations.ast', 'src/test/jastadd/relations/Relations.jadd', 'src/test/jastadd/Utils.jadd'
+}
+
+task preprocessDefaultNamesResolverTest(type: JavaExec, group: 'verification') {
+
+ doFirst {
+ delete 'src/test/jastadd/resolver/Resolver.ast', 'src/test/jastadd/resolver/Resolver.jadd', 'src/test/jastadd/resolver/ResolverRefResolver.jadd'
+ }
+
+ classpath = sourceSets.main.runtimeClasspath
+ main = 'org.jastadd.relast.compiler.Compiler'
+ args 'src/test/jastadd/resolver/Resolver.relast', '--file', '--grammarName=src/test/jastadd/resolver/Resolver', '--resolverHelper'
+}
+
+task compileDefaultNamesResolverTest(type: JavaExec, group: 'verification') {
+
+ doFirst {
+ delete 'src/test/java-gen/resolver'
+ }
+
+ classpath = sourceSets.main.runtimeClasspath
+ main = 'org.jastadd.JastAdd'
+ args '--o=src/test/java-gen/', '--package=defaultnames.resolver.ast', 'src/test/jastadd/resolver/Resolver.ast', 'src/test/jastadd/resolver/Resolver.jadd', 'src/test/jastadd/resolver/ResolverUtils.jadd', 'src/test/jastadd/resolver/ResolverRefResolver.jadd', 'src/test/jastadd/resolver/MyRefResolver.jadd', 'src/test/jastadd/Utils.jadd'
+}
+
task preprocessLowerBoundsTest(type: JavaExec, group: 'verification') {
doFirst {
@@ -143,7 +187,7 @@ task preprocessLowerBoundsTest(type: JavaExec, group: 'verification') {
classpath = sourceSets.main.runtimeClasspath
main = 'org.jastadd.relast.compiler.Compiler'
- args 'src/test/jastadd/lowerbounds/LowerBounds.relast', '--file', '--grammarName=src/test/jastadd/lowerbounds/LowerBounds'
+ args 'src/test/jastadd/lowerbounds/LowerBounds.relast', '--useJastAddNames', '--file', '--grammarName=src/test/jastadd/lowerbounds/LowerBounds'
}
task compileLowerBoundsTest(type: JavaExec, group: 'verification') {
@@ -165,7 +209,7 @@ task preprocessMultipleTest(type: JavaExec, group: 'verification') {
classpath = sourceSets.main.runtimeClasspath
main = 'org.jastadd.relast.compiler.Compiler'
- args 'src/test/jastadd/multiple/Part1.relast', 'src/test/jastadd/multiple/Part2.relast', 'src/test/jastadd/multiple/Part3.relast', '--file', '--grammarName=src/test/jastadd/multiple/Multiple'
+ args 'src/test/jastadd/multiple/Part1.relast', '--useJastAddNames', 'src/test/jastadd/multiple/Part2.relast', 'src/test/jastadd/multiple/Part3.relast', '--file', '--grammarName=src/test/jastadd/multiple/Multiple'
}
task compileMultipleTest(type: JavaExec, group: 'verification') {
@@ -187,7 +231,7 @@ task preprocessResolverTest(type: JavaExec, group: 'verification') {
classpath = sourceSets.main.runtimeClasspath
main = 'org.jastadd.relast.compiler.Compiler'
- args 'src/test/jastadd/resolver/Resolver.relast', '--file', '--grammarName=src/test/jastadd/resolver/Resolver', '--resolverHelper'
+ args 'src/test/jastadd/resolver/Resolver.relast', '--useJastAddNames', '--file', '--grammarName=src/test/jastadd/resolver/Resolver', '--resolverHelper'
}
task compileResolverTest(type: JavaExec, group: 'verification') {
@@ -210,7 +254,7 @@ task preprocessResolver2Test(type: JavaExec, group: 'verification') {
classpath = sourceSets.main.runtimeClasspath
main = 'org.jastadd.relast.compiler.Compiler'
- args 'src/test/jastadd/resolver2/Resolver.relast', '--file', '--grammarName=src/test/jastadd/resolver2/Resolver', '--resolverHelper'
+ args 'src/test/jastadd/resolver2/Resolver.relast', '--useJastAddNames', '--file', '--grammarName=src/test/jastadd/resolver2/Resolver', '--resolverHelper'
}
task compileResolver2Test(type: JavaExec, group: 'verification') {
@@ -232,7 +276,7 @@ task preprocessListNamesTest(type: JavaExec, group: 'verification') {
classpath = sourceSets.main.runtimeClasspath
main = 'org.jastadd.relast.compiler.Compiler'
- args 'src/test/jastadd/listnames/ListNames.relast', '--file', '--grammarName=src/test/jastadd/listnames/ListNames', '--jastAddList=ListyMcListface'
+ args 'src/test/jastadd/listnames/ListNames.relast', '--useJastAddNames', '--file', '--grammarName=src/test/jastadd/listnames/ListNames', '--jastAddList=ListyMcListface'
}
task compileListNamesTest(type: JavaExec, group: 'verification') {
@@ -257,6 +301,11 @@ test.dependsOn compileRelationTest
compileRelationTest.dependsOn doublePreprocessRelationTest
doublePreprocessRelationTest.dependsOn preprocessRelationTest
+test.dependsOn compileDefaultNamesTest
+compileDefaultNamesTest.dependsOn preprocessDefaultNamesTest
+test.dependsOn compileDefaultNamesResolverTest
+compileDefaultNamesResolverTest.dependsOn preprocessDefaultNamesResolverTest
+
test.dependsOn compileLowerBoundsTest
compileLowerBoundsTest.dependsOn preprocessLowerBoundsTest
@@ -270,4 +319,4 @@ test.dependsOn compileResolver2Test
compileResolver2Test.dependsOn preprocessResolver2Test
test.dependsOn compileListNamesTest
-compileListNamesTest.dependsOn preprocessListNamesTest
\ No newline at end of file
+compileListNamesTest.dependsOn preprocessListNamesTest
diff --git a/src/main/jastadd/Backend.jadd b/src/main/jastadd/Backend.jadd
index e6ae314b933ccf226f56ffb82e1a0ade2faa5b03..2dd22bfb21a0f5c923e840bbab2323a13c4a4929 100644
--- a/src/main/jastadd/Backend.jadd
+++ b/src/main/jastadd/Backend.jadd
@@ -2,8 +2,8 @@ aspect BackendAbstractGrammar {
public static String ASTNode.listClass = "ArrayList";
public static String ASTNode.jastAddListType = "List";
-
-public static boolean ASTNode.resolverHelper = false;
+ public static boolean ASTNode.resolverHelper = false;
+ public static boolean ASTNode.useJastAddNames = false;
public String Program.generateAbstractGrammar() {
StringBuilder sb = new StringBuilder();
@@ -188,15 +188,19 @@ aspect BackendDirectedAPI {
public void ManyRelationComponent.generateDirectedAPI(StringBuilder sb) {
// Get
- // getXs
- sb.append(ind(1) + "public java.util.List<" + ofTypeDecl() + "> " + toTypeDecl());
- sb.append(".get" + nameCapitalized() + "s() {\n");
- sb.append(ind(2) + "return get" + nameCapitalized() + "List();\n");
- sb.append(ind(1) + "}\n");
+ sb.append(ind(1) + "public java.util.List<" + ofTypeDecl() + "> " + toTypeDecl() + ".");
+ if (useJastAddNames) {
+ // getXs
+ sb.append("get" + nameCapitalized() + "s() {\n");
+ sb.append(ind(2) + "return get" + nameCapitalized() + "List();\n");
+ sb.append(ind(1) + "}\n");
- // getXList
- sb.append(ind(1) + "public java.util.List<" + ofTypeDecl() + "> " + toTypeDecl());
- sb.append(".get" + nameCapitalized() + "List() {\n");
+ // getXList
+ sb.append(ind(1) + "public java.util.List<" + ofTypeDecl() + "> " + toTypeDecl());
+ sb.append(".get" + nameCapitalized() + "List() {\n");
+ } else {
+ sb.append(name() + "() {\n");
+ }
sb.append(ind(2) + ASTNode.listClass + "<" + ofTypeDecl() + "> l = get" + getImplAttributeName() + "();\n");
// resolve the entire list
if (resolverHelper) {
@@ -220,6 +224,9 @@ aspect BackendDirectedAPI {
// Add
sb.append(ind(1) + "public void " + toTypeDecl() + ".add");
+ if (!useJastAddNames) {
+ sb.append("To");
+ }
sb.append(nameCapitalized() + "(" + ofTypeDecl() + " o) {\n");
sb.append(ind(2) + "assertNotNull(o);\n");
sb.append(ind(2) + ASTNode.listClass + "<" + ofTypeDecl() + "> list = get" + getImplAttributeName() + "();\n");
@@ -231,7 +238,11 @@ aspect BackendDirectedAPI {
sb.append(ind(1) + "}\n");
// Insert / add at specific position
- sb.append(ind(1) + "public void " + toTypeDecl() + ".add" + nameCapitalized() + "(int index, " + ofTypeDecl() + " o) {\n");
+ sb.append(ind(1) + "public void " + toTypeDecl() + ".add");
+ if (!useJastAddNames) {
+ sb.append("To");
+ }
+ sb.append(nameCapitalized() + "(int index, " + ofTypeDecl() + " o) {\n");
sb.append(ind(2) + "assertNotNull(o);\n");
sb.append(ind(2) + ASTNode.listClass + "<" + ofTypeDecl() + "> list = get" + getImplAttributeName() + "();\n");
sb.append(ind(2) + "if (list == null) {\n");
@@ -243,6 +254,9 @@ aspect BackendDirectedAPI {
// Remove
sb.append(ind(1) + "public void " + toTypeDecl() + ".remove");
+ if (!useJastAddNames) {
+ sb.append("From");
+ }
sb.append(nameCapitalized() + "(" + ofTypeDecl() + " o) {\n");
sb.append(ind(2) + "assertNotNull(o);\n");
sb.append(ind(2) + ASTNode.listClass + "<" + ofTypeDecl() + "> list = get" + getImplAttributeName() + "();\n");
@@ -253,8 +267,13 @@ aspect BackendDirectedAPI {
}
public void RelationComponent.generateGetOne(StringBuilder sb) {
- sb.append(ind(1) + "public " + ofTypeDecl() + " " + toTypeDecl());
- sb.append(".get" + nameCapitalized() + "() {\n");
+ sb.append(ind(1) + "public " + ofTypeDecl() + " " + toTypeDecl() + ".");
+ if (useJastAddNames) {
+ sb.append("get" + nameCapitalized());
+ } else {
+ sb.append(name());
+ }
+ sb.append("() {\n");
if (resolverHelper) {
sb.append(ind(2) + "if (get" + getImplAttributeName() + "() != null && get" + getImplAttributeName() + "().unresolved()) {\n");
sb.append(ind(3) + "set" + nameCapitalized() + "(resolve" + nameCapitalized() + "ByToken(get" + getImplAttributeName() + "().asUnresolved().get__token()));\n");
@@ -268,7 +287,13 @@ aspect BackendDirectedAPI {
// has
sb.append(ind(1) + "public boolean " + toTypeDecl());
sb.append(".has" + nameCapitalized() + "() {\n");
- sb.append(ind(2) + "return get" + nameCapitalized() + "() != null;\n");
+ sb.append(ind(2) + "return ");
+ if (useJastAddNames) {
+ sb.append("get" + nameCapitalized());
+ } else {
+ sb.append(name());
+ }
+ sb.append("() != null;\n");
sb.append(ind(1) + "}\n");
// clear
@@ -372,15 +397,19 @@ aspect BackendBidirectionalAPI {
public void RelationComponent.generateBiManyMany(StringBuilder sb, RelationComponent opposite) {
// Get
- // getXs
- sb.append(ind(1) + "public java.util.List<" + ofTypeDecl() + "> " + toTypeDecl());
- sb.append(".get" + nameCapitalized() + "s() {\n");
- sb.append(ind(2) + "return get" + nameCapitalized() + "List();\n");
- sb.append(ind(1) + "}\n");
+ sb.append(ind(1) + "public java.util.List<" + ofTypeDecl() + "> " + toTypeDecl() + ".");
+ if (useJastAddNames) {
+ // getXs
+ sb.append("get" + nameCapitalized() + "s() {\n");
+ sb.append(ind(2) + "return get" + nameCapitalized() + "List();\n");
+ sb.append(ind(1) + "}\n");
- // getXList
- sb.append(ind(1) + "public java.util.List<" + ofTypeDecl() + "> " + toTypeDecl());
- sb.append(".get" + nameCapitalized() + "List() {\n");
+ // getXList
+ sb.append(ind(1) + "public java.util.List<" + ofTypeDecl() + "> " + toTypeDecl());
+ sb.append(".get" + nameCapitalized() + "List() {\n");
+ } else {
+ sb.append(name() + "() {\n");
+ }
sb.append(ind(2) + ASTNode.listClass + "<" + ofTypeDecl() + "> l = get" + getImplAttributeName() + "();\n");
// resolve the entire list
if (resolverHelper) {
@@ -412,6 +441,9 @@ aspect BackendBidirectionalAPI {
// Add
sb.append(ind(1) + "public void " + toTypeDecl() + ".add");
+ if (!useJastAddNames) {
+ sb.append("To");
+ }
sb.append(nameCapitalized() + "(" + ofTypeDecl() + " o) {\n");
sb.append(ind(2) + "assertNotNull(o);\n");
sb.append(ind(2) + ASTNode.listClass + "<" + ofTypeDecl() + "> list = get" + getImplAttributeName() + "();\n");
@@ -430,7 +462,11 @@ aspect BackendBidirectionalAPI {
sb.append(ind(1) + "}\n");
// Insert / add at specific position
- sb.append(ind(1) + "public void " + toTypeDecl() + ".add" + nameCapitalized() + "(int index, " + ofTypeDecl() + " o) {\n");
+ sb.append(ind(1) + "public void " + toTypeDecl() + ".add");
+ if (!useJastAddNames) {
+ sb.append("To");
+ }
+ sb.append(nameCapitalized() + "(int index, " + ofTypeDecl() + " o) {\n");
sb.append(ind(2) + "assertNotNull(o);\n");
sb.append(ind(2) + ASTNode.listClass + "<" + ofTypeDecl() + "> list = get" + getImplAttributeName() + "();\n");
sb.append(ind(2) + "if (list == null) {\n");
@@ -449,6 +485,9 @@ aspect BackendBidirectionalAPI {
// Remove
sb.append(ind(1) + "public void " + toTypeDecl() + ".remove");
+ if (!useJastAddNames) {
+ sb.append("From");
+ }
sb.append(nameCapitalized() + "(" + ofTypeDecl() + " o) {\n");
sb.append(ind(2) + "assertNotNull(o);\n");
sb.append(ind(2) + ASTNode.listClass + "<" + ofTypeDecl() + "> list = get" + getImplAttributeName() + "();\n");
@@ -465,15 +504,19 @@ aspect BackendBidirectionalAPI {
public void RelationComponent.generateBiManyOne(StringBuilder sb, RelationComponent opposite) {
// Get
- // getXs
- sb.append(ind(1) + "public java.util.List<" + ofTypeDecl() + "> " + toTypeDecl());
- sb.append(".get" + nameCapitalized() + "s() {\n");
- sb.append(ind(2) + "return get" + nameCapitalized() + "List();\n");
- sb.append(ind(1) + "}\n");
+ sb.append(ind(1) + "public java.util.List<" + ofTypeDecl() + "> " + toTypeDecl() + ".");
+ if (useJastAddNames) {
+ // getXs
+ sb.append("get" + nameCapitalized() + "s() {\n");
+ sb.append(ind(2) + "return get" + nameCapitalized() + "List();\n");
+ sb.append(ind(1) + "}\n");
- // getXList
- sb.append(ind(1) + "public java.util.List<" + ofTypeDecl() + "> " + toTypeDecl());
- sb.append(".get" + nameCapitalized() + "List() {\n");
+ // getXList
+ sb.append(ind(1) + "public java.util.List<" + ofTypeDecl() + "> " + toTypeDecl());
+ sb.append(".get" + nameCapitalized() + "List() {\n");
+ } else {
+ sb.append(name() + "() {\n");
+ }
sb.append(ind(2) + ASTNode.listClass + "<" + ofTypeDecl() + "> l = get" + getImplAttributeName() + "();\n");
// resolve the entire list
if (resolverHelper) {
@@ -507,6 +550,9 @@ aspect BackendBidirectionalAPI {
// Add
sb.append(ind(1) + "public void " + toTypeDecl() + ".add");
+ if (!useJastAddNames) {
+ sb.append("To");
+ }
sb.append(nameCapitalized() + "(" + ofTypeDecl() + " o) {\n");
sb.append(ind(2) + "assertNotNull(o);\n");
sb.append(ind(2) + "if (o != null && o.get" + otherSide().getImplAttributeName() + "() != null) {\n");
@@ -526,7 +572,11 @@ aspect BackendBidirectionalAPI {
sb.append(ind(1) + "}\n");
// Insert / add at specific position
- sb.append(ind(1) + "public void " + toTypeDecl() + ".add" + nameCapitalized() + "(int index, " + ofTypeDecl() + " o) {\n");
+ sb.append(ind(1) + "public void " + toTypeDecl() + ".add");
+ if (!useJastAddNames) {
+ sb.append("To");
+ }
+ sb.append(nameCapitalized() + "(int index, " + ofTypeDecl() + " o) {\n");
sb.append(ind(2) + "assertNotNull(o);\n");
sb.append(ind(2) + "if (o != null && o.get" + otherSide().getImplAttributeName() + "() != null) {\n");
sb.append(ind(3) + ASTNode.listClass + "<" + ofTypeDecl() + "> list2 = o.get" + otherSide().getImplAttributeName() + "().get" + getImplAttributeName() + "();\n");
@@ -544,6 +594,9 @@ aspect BackendBidirectionalAPI {
// Remove
sb.append(ind(1) + "public void " + toTypeDecl() + ".remove");
+ if (!useJastAddNames) {
+ sb.append("From");
+ }
sb.append(nameCapitalized() + "(" + ofTypeDecl() + " o) {\n");
sb.append(ind(2) + "assertNotNull(o);\n");
sb.append(ind(2) + ASTNode.listClass + "<" + ofTypeDecl() + "> list = get" + getImplAttributeName() + "();\n");
@@ -638,7 +691,13 @@ aspect LowerBoundCheck {
}
public void OneRelationComponent.generateLowerBoundCheck(StringBuilder sb) {
- sb.append(ind(2) + "if (get" + nameCapitalized() + "() == null) {\n");
+ sb.append(ind(2) + "if (");
+ if (useJastAddNames) {
+ sb.append("get" + nameCapitalized());
+ } else {
+ sb.append(name());
+ }
+ sb.append("() == null) {\n");
sb.append(ind(3) + "list.add(new Pair<>(this, \"" + name() + "\"));\n");
sb.append(ind(2) + "}\n");
}
@@ -847,7 +906,13 @@ aspect NameResolutionHelper {
sb.append(ind(1) + "// enforce resolving of all non-containment relations of the current non-terminal\n");
sb.append(ind(1) + "public void " + getID() + ".resolveAll() {\n");
for (RelationComponent relationComponent : relationComponents()) {
- sb.append(ind(2) + "get" + relationComponent.nameCapitalized() + (relationComponent.isMany()?"List":"") + "();\n");
+ sb.append(ind(2));
+ if (useJastAddNames) {
+ sb.append("get" + relationComponent.nameCapitalized());
+ } else {
+ sb.append(relationComponent.name());
+ }
+ sb.append(relationComponent.isMany() && useJastAddNames ? "List" : "").append("();\n");
}
sb.append(ind(2) + "super.resolveAll();\n");
sb.append(ind(1) + "}\n");
diff --git a/src/main/java/org/jastadd/relast/compiler/Compiler.java b/src/main/java/org/jastadd/relast/compiler/Compiler.java
index ab8b0b531929a0f687f80977d2caec9761503d01..995200f049bad1e4a4071ed46748804d6aa9e04a 100644
--- a/src/main/java/org/jastadd/relast/compiler/Compiler.java
+++ b/src/main/java/org/jastadd/relast/compiler/Compiler.java
@@ -22,6 +22,7 @@ public class Compiler {
private StringOption optionJastAddList;
private StringOption optionGrammarName;
private FlagOption optionResolverHelper;
+ private FlagOption optionUseJastaddNames;
private CommandLine commandLine;
public Compiler(String[] args) throws CommandLineException {
@@ -80,6 +81,11 @@ public class Compiler {
ASTNode.listClass = optionListClass.getValue();
}
+ if (optionUseJastaddNames.isSet()) {
+ System.out.println("Using JastAdd names");
+ ASTNode.useJastAddNames = true;
+ }
+
String grammarName = "Grammar";
if (optionGrammarName.isSet()) {
grammarName = optionGrammarName.getValue();
@@ -130,7 +136,7 @@ public class Compiler {
optionGrammarName = addOption(new StringOption("grammarName", "name of the generated grammar and aspect (without file extension)"));
optionResolverHelper = addOption(new FlagOption("resolverHelper", "create a subtype for each type containing a string that can be used to resolve the type later"));
optionJastAddList = addOption(new StringOption("jastAddList", "set the name of the List type in JastAdd (has to match the option '--List' or its default List)"));
-
+ optionUseJastaddNames = addOption(new FlagOption("useJastAddNames", "generate names in the form of addX, removeX and setX. If omitted, the default, original naming scheme resulting in addToX, removeFromX and setX will be used."));
}
private <OptionType extends Option<?>> OptionType addOption(OptionType option) {
diff --git a/src/test/java/org/jastadd/relast/tests/DefaultNames.java b/src/test/java/org/jastadd/relast/tests/DefaultNames.java
new file mode 100644
index 0000000000000000000000000000000000000000..1335e1ef1ba7b7fabf340b716b0d7e9a87a64a3f
--- /dev/null
+++ b/src/test/java/org/jastadd/relast/tests/DefaultNames.java
@@ -0,0 +1,561 @@
+package org.jastadd.relast.tests;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import defaultnames.ast.A;
+import defaultnames.ast.B;
+import defaultnames.ast.Root;
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.util.Arrays;
+
+import static org.jastadd.relast.tests.TestHelpers.readFile;
+import static org.junit.jupiter.api.Assertions.*;
+
+
+@SuppressWarnings({"ArraysAsListWithZeroOrOneArgument", "Duplicates"})
+class DefaultNames {
+ private Root r;
+ private A a1;
+ private A a2;
+ private A a3;
+ private B b1;
+ private B b2;
+ private B b3;
+
+ @Test
+ void doubleRelastRun() throws IOException {
+
+ String firstRun = "./src/test/jastadd/relations/Relations.ast";
+ String secondRun = "./src/test/jastadd/relations/Relations2.ast";
+
+
+ String first = readFile(firstRun, Charset.defaultCharset());
+ String second = readFile(secondRun, Charset.defaultCharset());
+
+ Assertions.assertEquals(first, second);
+ }
+
+ /**
+ * rel A.Di1 -> B;
+ */
+ @Test
+ void testDi1() {
+ setup();
+ a1.setDi1(b2);
+ a2.setDi1(b1);
+
+ assertSame(a1.Di1(), b2);
+ assertSame(a2.Di1(), b1);
+
+ a2.setDi1(b2);
+
+ assertSame(a1.Di1(), b2);
+ assertSame(a2.Di1(), b2);
+
+ try {
+ a3.setDi1(null);
+ fail("should throw an exception");
+ } catch (Exception e) {
+ // OK
+ }
+ }
+
+
+ /**
+ * rel A.Di2? -> B;
+ */
+ @Test
+ void testDi2() {
+ setup();
+ a1.setDi2(b2);
+ a2.setDi2(b1);
+
+ assertSame(a1.Di2(), b2);
+ assertSame(a2.Di2(), b1);
+
+ a2.setDi2(b2);
+
+ assertSame(a1.Di2(), b2);
+ assertSame(a2.Di2(), b2);
+
+ a2.clearDi2();
+
+ assertSame(a1.Di2(), b2);
+ assertNull(a2.Di2());
+
+ assertTrue(a1.hasDi2());
+ assertFalse(a2.hasDi2());
+ assertFalse(a3.hasDi2());
+ }
+
+
+ /**
+ * rel A.Di3* -> B;
+ */
+ @Test
+ void testDi3() {
+ setup();
+ a1.addToDi3(b1);
+ a1.addToDi3(b2);
+ a1.addToDi3(b3);
+ a2.addToDi3(b2);
+
+ assertEquals(a1.Di3(), Arrays.asList(b1, b2, b3));
+ assertEquals(a2.Di3(), Arrays.asList(b2));
+ assertEquals(a3.Di3(), Arrays.asList());
+
+ a1.addToDi3(b1);
+ a2.addToDi3(b1);
+ a2.addToDi3(b2);
+
+ assertEquals(a1.Di3(), Arrays.asList(b1, b2, b3, b1));
+ assertEquals(a2.Di3(), Arrays.asList(b2, b1, b2));
+ assertEquals(a3.Di3(), Arrays.asList());
+
+ a1.removeFromDi3(b1);
+ a2.removeFromDi3(b2);
+
+ assertEquals(a1.Di3(), Arrays.asList(b2, b3, b1));
+ assertEquals(a2.Di3(), Arrays.asList(b1, b2));
+ assertEquals(a3.Di3(), Arrays.asList());
+ }
+
+
+ /**
+ * rel A.Bi1 <-> B.Bi1;
+ */
+
+
+ @Test
+ void testBi11() {
+ // Init
+ setup();
+ a1.setBi1(b1);
+ a2.setBi1(b2);
+
+ // Change
+ a2.setBi1(b1);
+
+ assertNull(a1.Bi1());
+ assertSame(a2.Bi1(), b1);
+ assertSame(b1.Bi1(), a2);
+ assertNull(b2.Bi1());
+ }
+
+ @Test
+ void testBi12() {
+ // Init
+ setup();
+ a1.setBi1(b2);
+
+ // Change
+ a2.setBi1(b2);
+
+ assertNull(a1.Bi1());
+ assertSame(a2.Bi1(), b2);
+ assertNull(b1.Bi1());
+ assertSame(b2.Bi1(), a2);
+ }
+
+
+ /**
+ * rel A.Bi2 <-> B.Bi2?;
+ */
+
+ @Test
+ void testBi21() {
+ // Init
+ setup();
+ a1.setBi2(b1);
+ a2.setBi2(b2);
+
+ // Change
+ a2.setBi2(b1);
+
+ assertNull(a1.Bi2());
+ assertSame(a2.Bi2(), b1);
+ assertSame(b1.Bi2(), a2);
+ assertNull(b2.Bi2());
+ }
+
+ @Test
+ void testBi22() {
+ // Init
+ setup();
+ a1.setBi2(b2);
+
+ // Change
+ a2.setBi2(b2);
+
+ assertNull(a1.Bi2());
+ assertSame(a2.Bi2(), b2);
+ assertNull(b1.Bi2());
+ assertSame(b2.Bi2(), a2);
+ }
+
+
+ /**
+ * rel A.Bi3 <-> B.Bi3*;
+ */
+ @Test
+ void testBi3() {
+ setup();
+ a2.setBi3(b2);
+
+ assertNull(a1.Bi3());
+ assertSame(a2.Bi3(), b2);
+ assertEquals(b1.Bi3(), Arrays.asList());
+ assertEquals(b2.Bi3(), Arrays.asList(a2));
+ assertEquals(b3.Bi3(), Arrays.asList());
+
+ a2.setBi3(b3);
+
+ assertNull(a1.Bi3());
+ assertSame(a2.Bi3(), b3);
+ assertEquals(b1.Bi3(), Arrays.asList());
+ assertEquals(b2.Bi3(), Arrays.asList());
+ assertEquals(b3.Bi3(), Arrays.asList(a2));
+
+ a1.setBi3(b3);
+ a3.setBi3(b3);
+
+ assertSame(a1.Bi3(), b3);
+ assertSame(a2.Bi3(), b3);
+ assertSame(a3.Bi3(), b3);
+ assertEquals(b1.Bi3(), Arrays.asList());
+ assertEquals(b2.Bi3(), Arrays.asList());
+ assertEquals(b3.Bi3(), Arrays.asList(a2, a1, a3));
+
+ a2.setBi3(b1);
+
+ assertSame(a1.Bi3(), b3);
+ assertSame(a2.Bi3(), b1);
+ assertSame(a3.Bi3(), b3);
+ assertEquals(b1.Bi3(), Arrays.asList(a2));
+ assertEquals(b2.Bi3(), Arrays.asList());
+ assertEquals(b3.Bi3(), Arrays.asList(a1, a3));
+
+ try {
+ a2.setBi3(null);
+ fail("should throw an exception");
+ } catch (Exception e) {
+ // OK
+ }
+ }
+
+
+ /**
+ * rel A.Bi4? <-> B.Bi4;
+ */
+ @Test
+ void testBi41() {
+ // Init
+ setup();
+ a1.setBi4(b1);
+ a2.setBi4(b2);
+
+ // Change
+ a2.setBi4(b1);
+
+ assertNull(a1.Bi4());
+ assertSame(a2.Bi4(), b1);
+ assertSame(b1.Bi4(), a2);
+ assertNull(b2.Bi4());
+ }
+
+ @Test
+ void testBi42() {
+ // Init
+ setup();
+ a1.setBi4(b2);
+
+ // Change
+ a2.setBi4(b2);
+
+ assertNull(a1.Bi4());
+ assertSame(a2.Bi4(), b2);
+ assertNull(b1.Bi4());
+ assertSame(b2.Bi4(), a2);
+ }
+
+
+ /**
+ * rel A.Bi5? <-> B.Bi5?;
+ */
+ @Test
+ void testBi51() {
+ // Init
+ setup();
+ a1.setBi5(b1);
+ a2.setBi5(b2);
+
+ // Change
+ a2.setBi5(b1);
+
+ assertNull(a1.Bi5());
+ assertSame(a2.Bi5(), b1);
+ assertSame(b1.Bi5(), a2);
+ assertNull(b2.Bi5());
+ }
+
+ @Test
+ void testBi52() {
+ // Init
+ setup();
+ a1.setBi5(b2);
+
+ // Change
+ a2.setBi5(b2);
+
+ assertNull(a1.Bi5());
+ assertSame(a2.Bi5(), b2);
+ assertNull(b1.Bi5());
+ assertSame(b2.Bi5(), a2);
+ }
+
+
+ /**
+ * rel A.Bi6? <-> B.Bi6*;
+ */
+ @Test
+ void testBi6() {
+ setup();
+ a2.setBi6(b2);
+
+ assertNull(a1.Bi6());
+ assertSame(a2.Bi6(), b2);
+ assertEquals(b1.Bi6(), Arrays.asList());
+ assertEquals(b2.Bi6(), Arrays.asList(a2));
+ assertEquals(b3.Bi6(), Arrays.asList());
+
+ a2.setBi6(b3);
+
+ assertNull(a1.Bi6());
+ assertSame(a2.Bi6(), b3);
+ assertEquals(b1.Bi6(), Arrays.asList());
+ assertEquals(b2.Bi6(), Arrays.asList());
+ assertEquals(b3.Bi6(), Arrays.asList(a2));
+
+ a1.setBi6(b3);
+ a3.setBi6(b3);
+
+ assertSame(a1.Bi6(), b3);
+ assertSame(a2.Bi6(), b3);
+ assertSame(a3.Bi6(), b3);
+ assertEquals(b1.Bi6(), Arrays.asList());
+ assertEquals(b2.Bi6(), Arrays.asList());
+ assertEquals(b3.Bi6(), Arrays.asList(a2, a1, a3));
+
+ a2.setBi6(b1);
+
+ assertSame(a1.Bi6(), b3);
+ assertSame(a2.Bi6(), b1);
+ assertSame(a3.Bi6(), b3);
+ assertEquals(b1.Bi6(), Arrays.asList(a2));
+ assertEquals(b2.Bi6(), Arrays.asList());
+ assertEquals(b3.Bi6(), Arrays.asList(a1, a3));
+
+ a2.clearBi6();
+
+ assertSame(a1.Bi6(), b3);
+ assertNull(a2.Bi6());
+ assertSame(a3.Bi6(), b3);
+ assertEquals(b1.Bi6(), Arrays.asList());
+ assertEquals(b2.Bi6(), Arrays.asList());
+ assertEquals(b3.Bi6(), Arrays.asList(a1, a3));
+
+ assertTrue(a1.hasBi6());
+ assertFalse(a2.hasBi6());
+ assertTrue(a3.hasBi6());
+ }
+
+
+ /**
+ * rel A.Bi7* <-> B.Bi7;
+ */
+ @Test
+ void testBi7() {
+ setup();
+ a2.addToBi7(b2);
+
+ assertEquals(a1.Bi7(), Arrays.asList());
+ assertEquals(a2.Bi7(), Arrays.asList(b2));
+ assertNull(b1.Bi7());
+ assertSame(b2.Bi7(), a2);
+ assertNull(b3.Bi7());
+
+ a2.addToBi7(b3);
+ a1.addToBi7(b2);
+
+ assertEquals(a1.Bi7(), Arrays.asList(b2));
+ assertEquals(a2.Bi7(), Arrays.asList(b3));
+ assertNull(b1.Bi7());
+ assertSame(b2.Bi7(), a1);
+ assertSame(b3.Bi7(), a2);
+
+ a1.addToBi7(b1);
+
+ assertEquals(a1.Bi7(), Arrays.asList(b2, b1));
+ assertEquals(a2.Bi7(), Arrays.asList(b3));
+ assertSame(b1.Bi7(), a1);
+ assertSame(b2.Bi7(), a1);
+ assertSame(b3.Bi7(), a2);
+
+ a1.addToBi7(b1);
+
+ assertEquals(a1.Bi7(), Arrays.asList(b2, b1));
+ assertEquals(a2.Bi7(), Arrays.asList(b3));
+ assertSame(b1.Bi7(), a1);
+ assertSame(b2.Bi7(), a1);
+ assertSame(b3.Bi7(), a2);
+
+ a1.removeFromBi7(b1);
+
+ assertEquals(a1.Bi7(), Arrays.asList(b2));
+ assertEquals(a2.Bi7(), Arrays.asList(b3));
+ assertNull(b1.Bi7());
+ assertSame(b2.Bi7(), a1);
+ assertSame(b3.Bi7(), a2);
+ }
+
+
+ /**
+ * rel A.Bi8* <-> B.Bi8?;
+ */
+ @Test
+ void testBi8() {
+ setup();
+ a2.addToBi8(b2);
+
+ assertEquals(a1.Bi8(), Arrays.asList());
+ assertEquals(a2.Bi8(), Arrays.asList(b2));
+ assertNull(b1.Bi8());
+ assertSame(b2.Bi8(), a2);
+ assertNull(b3.Bi8());
+
+ a2.addToBi8(b3);
+ a1.addToBi8(b2);
+
+ assertEquals(a1.Bi8(), Arrays.asList(b2));
+ assertEquals(a2.Bi8(), Arrays.asList(b3));
+ assertNull(b1.Bi8());
+ assertSame(b2.Bi8(), a1);
+ assertSame(b3.Bi8(), a2);
+
+ a1.addToBi8(b1);
+
+ assertEquals(a1.Bi8(), Arrays.asList(b2, b1));
+ assertEquals(a2.Bi8(), Arrays.asList(b3));
+ assertSame(b1.Bi8(), a1);
+ assertSame(b2.Bi8(), a1);
+ assertSame(b3.Bi8(), a2);
+
+ a1.addToBi8(b1);
+
+ assertEquals(a1.Bi8(), Arrays.asList(b2, b1));
+ assertEquals(a2.Bi8(), Arrays.asList(b3));
+ assertSame(b1.Bi8(), a1);
+ assertSame(b2.Bi8(), a1);
+ assertSame(b3.Bi8(), a2);
+
+ a1.removeFromBi8(b1);
+
+ assertEquals(a1.Bi8(), Arrays.asList(b2));
+ assertEquals(a2.Bi8(), Arrays.asList(b3));
+ assertNull(b1.Bi8());
+ assertSame(b2.Bi8(), a1);
+ assertSame(b3.Bi8(), a2);
+ }
+
+
+ /**
+ * rel A.Bi9* <-> B.Bi9*;
+ */
+ @Test
+ void testBi9() {
+ setup();
+ a1.addToBi9(b1);
+ a1.addToBi9(b2);
+
+ assertEquals(a1.Bi9(), Arrays.asList(b1, b2));
+ assertEquals(a2.Bi9(), Arrays.asList());
+ assertEquals(a3.Bi9(), Arrays.asList());
+ assertEquals(b1.Bi9(), Arrays.asList(a1));
+ assertEquals(b2.Bi9(), Arrays.asList(a1));
+ assertEquals(b3.Bi9(), Arrays.asList());
+
+ b3.addToBi9(a1);
+ b3.addToBi9(a3);
+ b3.addToBi9(a1);
+
+ assertEquals(a1.Bi9(), Arrays.asList(b1, b2, b3, b3));
+ assertEquals(a2.Bi9(), Arrays.asList());
+ assertEquals(a3.Bi9(), Arrays.asList(b3));
+ assertEquals(b1.Bi9(), Arrays.asList(a1));
+ assertEquals(b2.Bi9(), Arrays.asList(a1));
+ assertEquals(b3.Bi9(), Arrays.asList(a1, a3, a1));
+
+ b3.removeFromBi9(a1);
+
+ assertEquals(a1.Bi9(), Arrays.asList(b1, b2, b3));
+ assertEquals(a2.Bi9(), Arrays.asList());
+ assertEquals(a3.Bi9(), Arrays.asList(b3));
+ assertEquals(b1.Bi9(), Arrays.asList(a1));
+ assertEquals(b2.Bi9(), Arrays.asList(a1));
+ assertEquals(b3.Bi9(), Arrays.asList(a3, a1));
+ }
+
+
+ @Test
+ void testImmutableList() {
+ setup();
+
+ a1.addToDi3(b1);
+ a1.addToDi3(b2);
+ try {
+ a1.Di3().add(b3);
+ fail("should throw an exception");
+ } catch (Exception e) {
+ // OK
+ }
+
+ a1.addToBi7(b1);
+ a1.addToBi7(b2);
+ try {
+ a1.Bi7().add(b3);
+ fail("should throw an exception");
+ } catch (Exception e) {
+ // OK
+ }
+
+ a1.addToBi9(b1);
+ a1.addToBi9(b2);
+ try {
+ a1.Bi9().add(b3);
+ fail("should throw an exception");
+ } catch (Exception e) {
+ // OK
+ }
+ }
+
+ @BeforeEach
+ void setup() {
+ r = new Root();
+ a1 = new A("a1");
+ a2 = new A("a2");
+ a3 = new A("a3");
+ b1 = new B("b1");
+ b2 = new B("b2");
+ b3 = new B("b3");
+
+ r.addA(a1);
+ r.addA(a2);
+ r.addA(a3);
+ r.addB(b1);
+ r.addB(b2);
+ r.addB(b3);
+ }
+}
diff --git a/src/test/java/org/jastadd/relast/tests/DefaultNamesResolverHelper.java b/src/test/java/org/jastadd/relast/tests/DefaultNamesResolverHelper.java
new file mode 100644
index 0000000000000000000000000000000000000000..defcbfa826be16abe6533e61b115944c707516fc
--- /dev/null
+++ b/src/test/java/org/jastadd/relast/tests/DefaultNamesResolverHelper.java
@@ -0,0 +1,694 @@
+package org.jastadd.relast.tests;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import defaultnames.resolver.ast.A;
+import defaultnames.resolver.ast.B;
+import defaultnames.resolver.ast.NamedElement;
+import defaultnames.resolver.ast.Root;
+
+import java.util.Arrays;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@SuppressWarnings("ArraysAsListWithZeroOrOneArgument")
+class DefaultNamesResolverHelper {
+ private Root r;
+ private A a1;
+ private A a2;
+ private A a3;
+ private B b1;
+ private B b2;
+ private B b3;
+
+
+ /**
+ * rel A.Di1 -> B;
+ */
+ @Test
+ void testNameRes1() {
+ setup();
+ a1.setRel1(NamedElement.createRef("b2"));
+ System.out.println("Rel 1 of a1 has type " + a1.Rel1().getClass().getSimpleName());
+ assertSame(a1.Rel1(), b2);
+ }
+
+ /**
+ * rel A.Di1 -> B;
+ */
+ @Test
+ void testDi1() {
+ setup();
+ a1.setDi1(B.createRef("b2"));
+ a2.setDi1(B.createRef("b1"));
+
+ assertSame(a1.Di1(), b2);
+ assertSame(a2.Di1(), b1);
+
+ a2.setDi1(b2);
+
+ assertSame(a1.Di1(), b2);
+ assertSame(a2.Di1(), b2);
+
+ try {
+ a3.setDi1(null);
+ fail("should throw an exception");
+ } catch (Exception e) {
+ // OK
+ }
+ }
+
+
+ /**
+ * rel A.Di2? -> B;
+ */
+ @Test
+ void testDi2() {
+ setup();
+ a1.setDi2(B.createRef("b2"));
+ a2.setDi2(B.createRef("b1"));
+
+ assertSame(a1.Di2(), b2);
+ assertSame(a2.Di2(), b1);
+
+ a2.setDi2(b2);
+
+ assertSame(a1.Di2(), b2);
+ assertSame(a2.Di2(), b2);
+
+ a2.clearDi2();
+
+ assertSame(a1.Di2(), b2);
+ assertNull(a2.Di2());
+
+ assertTrue(a1.hasDi2());
+ assertFalse(a2.hasDi2());
+ assertFalse(a3.hasDi2());
+ }
+
+
+ /**
+ * rel A.Di3* -> B;
+ */
+ @Test
+ void testDi3() {
+ setup();
+ a1.addToDi3(B.createRef("b1"));
+ a1.addToDi3(B.createRef("b2"));
+ a1.addToDi3(B.createRef("b3"));
+ a2.addToDi3(B.createRef("b2"));
+
+ assertEquals(a1.Di3(), Arrays.asList(b1, b2, b3));
+ assertEquals(a2.Di3(), Arrays.asList(b2));
+ assertEquals(a3.Di3(), Arrays.asList());
+
+ a1.addToDi3(B.createRef("b1"));
+ a2.addToDi3(B.createRef("b1"));
+ a2.addToDi3(B.createRef("b2"));
+
+ assertEquals(a1.Di3(), Arrays.asList(b1, b2, b3, b1));
+ assertEquals(a2.Di3(), Arrays.asList(b2, b1, b2));
+ assertEquals(a3.Di3(), Arrays.asList());
+
+ a1.removeFromDi3(b1);
+ a2.removeFromDi3(b2);
+
+ assertEquals(a1.Di3(), Arrays.asList(b2, b3, b1));
+ assertEquals(a2.Di3(), Arrays.asList(b1, b2));
+ assertEquals(a3.Di3(), Arrays.asList());
+ }
+
+
+ /**
+ * rel A.Bi1 <-> B.Bi1;
+ */
+
+ @Test
+ void testBi11() {
+ // Init
+ setup();
+ a1.setBi1(B.createRef("b1"));
+
+ // before a1.Bi1() is resolved, the opposite direction is null
+ assertNull(b1.Bi1());
+
+ // now, the relation is resolved, and thus the opposite direction is also set
+ assertSame(b1, a1.Bi1());
+ assertSame(a1, b1.Bi1());
+
+ // create another, unrelated relation, perform the same tests
+ a2.setBi1(B.createRef("b2"));
+ assertNull(b2.Bi1());
+ assertSame(b2, a2.Bi1());
+ assertSame(a2, b2.Bi1());
+
+ // change the relation of a2 to overwrite the existing one in a1<->b1
+ a2.setBi1(B.createRef("b1"));
+
+ // as long as no resolution took place, the old reference still exists
+ assertSame(b1, a1.Bi1());
+ assertSame(a1, b1.Bi1());
+
+ // now, we resolve a2->b1
+ assertSame(b1, a2.Bi1());
+
+ // now the final situation should be a2<->b1, a1->null, b2->null
+ assertSame(a2.Bi1(), b1);
+ assertSame(b1.Bi1(), a2);
+ assertNull(a1.Bi1());
+ assertNull(b2.Bi1());
+ }
+
+ @Test
+ void testBi12() {
+ // Init
+ setup();
+ a1.setBi1(B.createRef("b2"));
+
+ // Change
+ a2.setBi1(B.createRef("b2"));
+
+ // unresolved
+ assertNull(b2.Bi1());
+
+ assertSame(b2, a1.Bi1());
+ // a1 resolved
+ assertSame(a1, b2.Bi1());
+
+ // now resolve the change:
+ assertSame(b2, a2.Bi1());
+
+ // now finally, a1->null
+ assertNull(a1.Bi1());
+ assertSame(a2.Bi1(), b2);
+ assertNull(b1.Bi1());
+ assertSame(b2.Bi1(), a2);
+ }
+
+
+ /**
+ * rel A.Bi2 <-> B.Bi2?;
+ */
+
+ @Test
+ void testBi21() {
+ // Init
+ setup();
+ a1.setBi2(B.createRef("b1"));
+
+ // before a1.Bi2() is resolved, the opposite direction is null
+ assertNull(b1.Bi2());
+
+ // now, the relation is resolved, and thus the opposite direction is also set
+ assertSame(b1, a1.Bi2());
+ assertSame(a1, b1.Bi2());
+
+ // create another, unrelated relation, perform the same tests
+ a2.setBi2(B.createRef("b2"));
+ assertNull(b2.Bi2());
+ assertSame(b2, a2.Bi2());
+ assertSame(a2, b2.Bi2());
+
+ // change the relation of a2 to overwrite the existing one in a1<->b1
+ a2.setBi2(B.createRef("b1"));
+
+ // as long as no resolution took place, the old reference still exists
+ assertSame(b1, a1.Bi2());
+ assertSame(a1, b1.Bi2());
+
+ // now, we resolve a2->b1
+ assertSame(b1, a2.Bi2());
+
+ // now the final situation should be a2<->b1, a1->null, b2->null
+ assertSame(a2.Bi2(), b1);
+ assertSame(b1.Bi2(), a2);
+ assertNull(a1.Bi2());
+ assertNull(b2.Bi2());
+ }
+
+ @Test
+ void testBi22() {
+ // Init
+ setup();
+ a1.setBi2(B.createRef("b2"));
+
+ // Change
+ a2.setBi2(B.createRef("b2"));
+
+ // unresolved
+ assertNull(b2.Bi2());
+
+ assertSame(b2, a1.Bi2());
+ // a1 resolved
+ assertSame(a1, b2.Bi2());
+
+ // now resolve the change:
+ assertSame(b2, a2.Bi2());
+
+ // now finally, a1->null
+ assertNull(a1.Bi2());
+ assertSame(a2.Bi2(), b2);
+ assertNull(b1.Bi2());
+ assertSame(b2.Bi2(), a2);
+ }
+
+
+
+ /**
+ * rel A.Bi3 <-> B.Bi3*;
+ */
+ @Test
+ void testBi3() {
+ setup();
+ a2.setBi3(B.createRef("b2"));
+
+ assertNull(a1.Bi3());
+ assertSame(a2.Bi3(), b2);
+ assertEquals(b1.Bi3(), Arrays.asList());
+ assertEquals(b2.Bi3(), Arrays.asList(a2));
+ assertEquals(b3.Bi3(), Arrays.asList());
+
+ a2.setBi3(B.createRef("b3"));
+
+ assertNull(a1.Bi3());
+ assertSame(a2.Bi3(), b3);
+ assertEquals(b1.Bi3(), Arrays.asList());
+ assertEquals(b2.Bi3(), Arrays.asList());
+ assertEquals(b3.Bi3(), Arrays.asList(a2));
+
+ a1.setBi3(B.createRef("b3"));
+ a3.setBi3(B.createRef("b3"));
+
+ assertSame(a1.Bi3(), b3);
+ assertSame(a2.Bi3(), b3);
+ assertSame(a3.Bi3(), b3);
+ assertEquals(b1.Bi3(), Arrays.asList());
+ assertEquals(b2.Bi3(), Arrays.asList());
+ assertEquals(b3.Bi3(), Arrays.asList(a2, a1, a3));
+
+ a2.setBi3(B.createRef("b1"));
+
+ assertSame(a1.Bi3(), b3);
+ assertSame(a2.Bi3(), b1);
+ assertSame(a3.Bi3(), b3);
+ assertEquals(b1.Bi3(), Arrays.asList(a2));
+ assertEquals(b2.Bi3(), Arrays.asList());
+ assertEquals(b3.Bi3(), Arrays.asList(a1, a3));
+
+ try {
+ a2.setBi3(null);
+ fail("should throw an exception");
+ } catch (Exception e) {
+ // OK
+ }
+ }
+
+
+ /**
+ * rel A.Bi4? <-> B.Bi4;
+ */
+ @Test
+ void testBi41() {
+ // Init
+ setup();
+ a1.setBi4(B.createRef("b1"));
+
+ // before a1.Bi4() is resolved, the opposite direction is null
+ assertNull(b1.Bi4());
+
+ // now, the relation is resolved, and thus the opposite direction is also set
+ assertSame(b1, a1.Bi4());
+ assertSame(a1, b1.Bi4());
+
+ // create another, unrelated relation, perform the same tests
+ a2.setBi4(B.createRef("b2"));
+ assertNull(b2.Bi4());
+ assertSame(b2, a2.Bi4());
+ assertSame(a2, b2.Bi4());
+
+ // change the relation of a2 to overwrite the existing one in a1<->b1
+ a2.setBi4(B.createRef("b1"));
+
+ // as long as no resolution took place, the old reference still exists
+ assertSame(b1, a1.Bi4());
+ assertSame(a1, b1.Bi4());
+
+ // now, we resolve a2->b1
+ assertSame(b1, a2.Bi4());
+
+ // now the final situation should be a2<->b1, a1->null, b2->null
+ assertSame(a2.Bi4(), b1);
+ assertSame(b1.Bi4(), a2);
+ assertNull(a1.Bi4());
+ assertNull(b2.Bi4());
+ }
+
+ @Test
+ void testBi42() {
+ // Init
+ setup();
+ a1.setBi4(B.createRef("b2"));
+
+ // Change
+ a2.setBi4(B.createRef("b2"));
+
+ // unresolved
+ assertNull(b2.Bi4());
+
+ assertSame(b2, a1.Bi4());
+ // a1 resolved
+ assertSame(a1, b2.Bi4());
+
+ // now resolve the change:
+ assertSame(b2, a2.Bi4());
+
+ // now finally, a1->null
+ assertNull(a1.Bi4());
+ assertSame(a2.Bi4(), b2);
+ assertNull(b1.Bi4());
+ assertSame(b2.Bi4(), a2);
+ }
+
+
+ /**
+ * rel A.Bi5? <-> B.Bi5?;
+ */
+ @Test
+ void testBi51() {
+ // Init
+ setup();
+ a1.setBi5(B.createRef("b1"));
+
+ // before a1.Bi5() is resolved, the opposite direction is null
+ assertNull(b1.Bi5());
+
+ // now, the relation is resolved, and thus the opposite direction is also set
+ assertSame(b1, a1.Bi5());
+ assertSame(a1, b1.Bi5());
+
+ // create another, unrelated relation, perform the same tests
+ a2.setBi5(B.createRef("b2"));
+ assertNull(b2.Bi5());
+ assertSame(b2, a2.Bi5());
+ assertSame(a2, b2.Bi5());
+
+ // change the relation of a2 to overwrite the existing one in a1<->b1
+ a2.setBi5(B.createRef("b1"));
+
+ // as long as no resolution took place, the old reference still exists
+ assertSame(b1, a1.Bi5());
+ assertSame(a1, b1.Bi5());
+
+ // now, we resolve a2->b1
+ assertSame(b1, a2.Bi5());
+
+ // now the final situation should be a2<->b1, a1->null, b2->null
+ assertSame(a2.Bi5(), b1);
+ assertSame(b1.Bi5(), a2);
+ assertNull(a1.Bi5());
+ assertNull(b2.Bi5());
+ }
+
+ @Test
+ void testBi52() {
+ // Init
+ setup();
+ a1.setBi5(B.createRef("b2"));
+
+ // Change
+ a2.setBi5(B.createRef("b2"));
+
+ // unresolved
+ assertNull(b2.Bi5());
+
+ assertSame(b2, a1.Bi5());
+ // a1 resolved
+ assertSame(a1, b2.Bi5());
+
+ // now resolve the change:
+ assertSame(b2, a2.Bi5());
+
+ // now finally, a1->null
+ assertNull(a1.Bi5());
+ assertSame(a2.Bi5(), b2);
+ assertNull(b1.Bi5());
+ assertSame(b2.Bi5(), a2);
+ }
+
+
+ /**
+ * rel A.Bi6? <-> B.Bi6*;
+ */
+ @Test
+ void testBi6() {
+ setup();
+ a2.setBi6(B.createRef("b2"));
+
+ assertNull(a1.Bi6());
+ assertSame(a2.Bi6(), b2);
+ assertEquals(b1.Bi6(), Arrays.asList());
+ assertEquals(b2.Bi6(), Arrays.asList(a2));
+ assertEquals(b3.Bi6(), Arrays.asList());
+
+ a2.setBi6(B.createRef("b3"));
+
+ assertNull(a1.Bi6());
+ assertSame(a2.Bi6(), b3);
+ assertEquals(b1.Bi6(), Arrays.asList());
+ assertEquals(b2.Bi6(), Arrays.asList());
+ assertEquals(b3.Bi6(), Arrays.asList(a2));
+
+ a1.setBi6(B.createRef("b3"));
+ a3.setBi6(B.createRef("b3"));
+
+ assertSame(a1.Bi6(), b3);
+ assertSame(a2.Bi6(), b3);
+ assertSame(a3.Bi6(), b3);
+ assertEquals(b1.Bi6(), Arrays.asList());
+ assertEquals(b2.Bi6(), Arrays.asList());
+ assertEquals(b3.Bi6(), Arrays.asList(a2, a1, a3));
+
+ a2.setBi6(B.createRef("b1"));
+
+ assertSame(a1.Bi6(), b3);
+ assertSame(a2.Bi6(), b1);
+ assertSame(a3.Bi6(), b3);
+ assertEquals(b1.Bi6(), Arrays.asList(a2));
+ assertEquals(b2.Bi6(), Arrays.asList());
+ assertEquals(b3.Bi6(), Arrays.asList(a1, a3));
+
+ a2.clearBi6();
+
+ assertSame(a1.Bi6(), b3);
+ assertNull(a2.Bi6());
+ assertSame(a3.Bi6(), b3);
+ assertEquals(b1.Bi6(), Arrays.asList());
+ assertEquals(b2.Bi6(), Arrays.asList());
+ assertEquals(b3.Bi6(), Arrays.asList(a1, a3));
+
+ assertTrue(a1.hasBi6());
+ assertFalse(a2.hasBi6());
+ assertTrue(a3.hasBi6());
+ }
+
+
+ /**
+ * rel A.Bi7* <-> B.Bi7;
+ */
+ @Test
+ void testBi7() {
+ setup();
+ a2.addToBi7(B.createRef("b2"));
+
+ // a1 list is empty
+ assertEquals(a1.Bi7(), Arrays.asList());
+
+ // a2 list contains b2 (because resolution took place)
+ assertEquals(a2.Bi7(), Arrays.asList(b2));
+
+ // of all the bs, only b2 contains a back ref to a2
+ assertNull(b1.Bi7());
+ assertSame(b2.Bi7(), a2);
+ assertNull(b3.Bi7());
+
+ a2.addToBi7(B.createRef("b3"));
+ a1.addToBi7(B.createRef("b2"));
+
+ assertEquals(a1.Bi7(), Arrays.asList(b2));
+ assertEquals(a2.Bi7(), Arrays.asList(b3));
+ assertNull(b1.Bi7());
+ assertSame(b2.Bi7(), a1);
+ assertSame(b3.Bi7(), a2);
+
+ a1.addToBi7(B.createRef("b1"));
+
+ assertEquals(a1.Bi7(), Arrays.asList(b2, b1));
+ assertEquals(a2.Bi7(), Arrays.asList(b3));
+ assertSame(b1.Bi7(), a1);
+ assertSame(b2.Bi7(), a1);
+ assertSame(b3.Bi7(), a2);
+
+ a1.addToBi7(B.createRef("b1"));
+
+ assertEquals(a1.Bi7(), Arrays.asList(b2, b1));
+ assertEquals(a2.Bi7(), Arrays.asList(b3));
+ assertSame(b1.Bi7(), a1);
+ assertSame(b2.Bi7(), a1);
+ assertSame(b3.Bi7(), a2);
+
+ a1.removeFromBi7(b1);
+
+ assertEquals(a1.Bi7(), Arrays.asList(b2));
+ assertEquals(a2.Bi7(), Arrays.asList(b3));
+ assertNull(b1.Bi7());
+ assertSame(b2.Bi7(), a1);
+ assertSame(b3.Bi7(), a2);
+ }
+
+
+ /**
+ * rel A.Bi8* <-> B.Bi8?;
+ */
+ @Test
+ void testBi8() {
+ setup();
+ a2.addToBi8(B.createRef("b2"));
+
+ assertEquals(a1.Bi8(), Arrays.asList());
+ assertEquals(a2.Bi8(), Arrays.asList(b2));
+ assertNull(b1.Bi8());
+ assertSame(b2.Bi8(), a2);
+ assertNull(b3.Bi8());
+
+ a2.addToBi8(B.createRef("b3"));
+ a1.addToBi8(B.createRef("b2"));
+
+ assertEquals(a1.Bi8(), Arrays.asList(b2));
+ assertEquals(a2.Bi8(), Arrays.asList(b3));
+ assertNull(b1.Bi8());
+ assertSame(b2.Bi8(), a1);
+ assertSame(b3.Bi8(), a2);
+
+ a1.addToBi8(B.createRef("b1"));
+
+ assertEquals(a1.Bi8(), Arrays.asList(b2, b1));
+ assertEquals(a2.Bi8(), Arrays.asList(b3));
+ assertSame(b1.Bi8(), a1);
+ assertSame(b2.Bi8(), a1);
+ assertSame(b3.Bi8(), a2);
+
+ a1.addToBi8(B.createRef("b1"));
+
+ assertEquals(a1.Bi8(), Arrays.asList(b2, b1));
+ assertEquals(a2.Bi8(), Arrays.asList(b3));
+ assertSame(b1.Bi8(), a1);
+ assertSame(b2.Bi8(), a1);
+ assertSame(b3.Bi8(), a2);
+
+ a1.removeFromBi8(b1);
+
+ assertEquals(a1.Bi8(), Arrays.asList(b2));
+ assertEquals(a2.Bi8(), Arrays.asList(b3));
+ assertNull(b1.Bi8());
+ assertSame(b2.Bi8(), a1);
+ assertSame(b3.Bi8(), a2);
+ }
+
+
+ /**
+ * rel A.Bi9* <-> B.Bi9*;
+ */
+ @Test
+ void testBi9() {
+ setup();
+ a1.addToBi9(B.createRef("b1"));
+ a1.addToBi9(B.createRef("b2"));
+
+ assertEquals(a1.Bi9(), Arrays.asList(b1, b2));
+ assertEquals(a2.Bi9(), Arrays.asList());
+ assertEquals(a3.Bi9(), Arrays.asList());
+ assertEquals(b1.Bi9(), Arrays.asList(a1));
+ assertEquals(b2.Bi9(), Arrays.asList(a1));
+ assertEquals(b3.Bi9(), Arrays.asList());
+
+ b3.addToBi9(A.createRef("a1"));
+ b3.addToBi9(A.createRef("a3"));
+ b3.addToBi9(A.createRef("a1"));
+
+ // b3 is not resolved yet, so the as look like before
+ assertEquals(a1.Bi9(), Arrays.asList(b1, b2));
+ assertEquals(a2.Bi9(), Arrays.asList());
+ assertEquals(a3.Bi9(), Arrays.asList());
+
+ // let's resolve b3
+ assertEquals(b1.Bi9(), Arrays.asList(a1));
+ assertEquals(b2.Bi9(), Arrays.asList(a1));
+ assertEquals(b3.Bi9(), Arrays.asList(a1, a3, a1));
+
+ // now the as are updated
+ assertEquals(a1.Bi9(), Arrays.asList(b1, b2, b3, b3));
+ assertEquals(a2.Bi9(), Arrays.asList());
+ assertEquals(a3.Bi9(), Arrays.asList(b3));
+
+ b3.removeFromBi9(a1);
+
+ assertEquals(a1.Bi9(), Arrays.asList(b1, b2, b3));
+ assertEquals(a2.Bi9(), Arrays.asList());
+ assertEquals(a3.Bi9(), Arrays.asList(b3));
+ assertEquals(b1.Bi9(), Arrays.asList(a1));
+ assertEquals(b2.Bi9(), Arrays.asList(a1));
+ assertEquals(b3.Bi9(), Arrays.asList(a3, a1));
+ }
+
+
+ @Test
+ void testImmutableList() {
+ setup();
+
+ a1.addToDi3(B.createRef("b1"));
+ a1.addToDi3(B.createRef("b2"));
+ try {
+ a1.Di3().add(b3);
+ fail("should throw an exception");
+ } catch (Exception e) {
+ // OK
+ }
+
+ a1.addToBi7(B.createRef("b1"));
+ a1.addToBi7(B.createRef("b2"));
+ try {
+ a1.Bi7().add(B.createRef("b3"));
+ fail("should throw an exception");
+ } catch (Exception e) {
+ // OK
+ }
+
+ a1.addToBi9(B.createRef("b1"));
+ a1.addToBi9(B.createRef("b2"));
+ try {
+ a1.Bi9().add(B.createRef("b3"));
+ fail("should throw an exception");
+ } catch (Exception e) {
+ // OK
+ }
+ }
+
+ @BeforeEach
+ void setup() {
+ r = new Root();
+ a1 = new A("a1");
+ a2 = new A("a2");
+ a3 = new A("a3");
+ b1 = new B("b1");
+ b2 = new B("b2");
+ b3 = new B("b3");
+
+ r.addA(a1);
+ r.addA(a2);
+ r.addA(a3);
+ r.addB(b1);
+ r.addB(b2);
+ r.addB(b3);
+ }
+
+}