From 2d2f77614f453a246e01a68607cd7a7617fc647a Mon Sep 17 00:00:00 2001
From: rschoene <rene.schoene@tu-dresden.de>
Date: Tue, 23 Apr 2019 14:54:51 +0200
Subject: [PATCH] Allow interleaving of AST rules and relations.
- Simplified lexer, dropping lexical state String
- Added test case for this scenario (copied from MultipleFiles)
---
build.gradle | 10 +
src/main/jastadd/RelAst.flex | 64 +-
src/main/jastadd/RelAst.parser | 15 +-
src/test/jastadd/multiple-mixed/Part1.relast | 6 +
src/test/jastadd/multiple-mixed/Part2.relast | 4 +
src/test/jastadd/multiple-mixed/Part3.relast | 9 +
.../relast/tests/MultipleMixedFiles.java | 618 ++++++++++++++++++
7 files changed, 674 insertions(+), 52 deletions(-)
create mode 100644 src/test/jastadd/multiple-mixed/Part1.relast
create mode 100644 src/test/jastadd/multiple-mixed/Part2.relast
create mode 100644 src/test/jastadd/multiple-mixed/Part3.relast
create mode 100644 src/test/java/org/jastadd/relast/tests/MultipleMixedFiles.java
diff --git a/build.gradle b/build.gradle
index df19329..3804964 100644
--- a/build.gradle
+++ b/build.gradle
@@ -188,6 +188,16 @@ task compileMultipleTest(type: RelastTest) {
moreInputFiles 'src/test/jastadd/Utils.jadd'
}
+task compileMultipleMixedTest(type: RelastTest) {
+ relastFiles 'src/test/jastadd/multiple-mixed/Part1.relast',
+ 'src/test/jastadd/multiple-mixed/Part2.relast',
+ 'src/test/jastadd/multiple-mixed/Part3.relast'
+ grammarName = 'src/test/jastadd/multiple/Multiple'
+ useJastAddNames = true
+ packageName = 'mixed.multiple.ast'
+ moreInputFiles 'src/test/jastadd/Utils.jadd'
+}
+
task compileResolverTest(type: RelastTest) {
relastFiles 'src/test/jastadd/resolver/Resolver.relast'
grammarName = 'src/test/jastadd/resolver/Resolver'
diff --git a/src/main/jastadd/RelAst.flex b/src/main/jastadd/RelAst.flex
index d224f8d..68b2ebf 100644
--- a/src/main/jastadd/RelAst.flex
+++ b/src/main/jastadd/RelAst.flex
@@ -42,46 +42,30 @@ Comment = {TraditionalComment} | {EndOfLineComment}
ID = [a-zA-Z$_][a-zA-Z0-9$_]*
-%state STRING
-
%%
-<YYINITIAL> {
- {WhiteSpace} { /* ignore */ }
- {Comment} { /* ignore */ }
-
- "abstract" { return sym(Terminals.ABSTRACT); }
- "rel" { return sym(Terminals.RELATION); }
-
- ";" { return sym(Terminals.SCOL); }
- ":" { return sym(Terminals.COL); }
- "::=" { return sym(Terminals.ASSIGN); }
- "*" { return sym(Terminals.STAR); }
- "." { return sym(Terminals.DOT); }
- "," { return sym(Terminals.COMMA); }
- "<" { return sym(Terminals.LT); }
- ">" { return sym(Terminals.GT); }
- "[" { return sym(Terminals.LBRACKET); }
- "]" { return sym(Terminals.RBRACKET); }
- "/" { return sym(Terminals.SLASH); }
- "?" { return sym(Terminals.QUESTION_MARK); }
- "->" { return sym(Terminals.RIGHT); }
- "<->" { return sym(Terminals.BIDIRECTIONAL); }
-
- // ID
- {ID} { return sym(Terminals.ID); }
- \" { stringLitSb.setLength(0); yybegin(STRING); }
- <<EOF>> { return sym(Terminals.EOF); }
-}
-
-<STRING> {
- \" { yybegin(YYINITIAL); return sym(Terminals.STRING_LITERAL, stringLitSb.toString()); }
- [^\n\r\"\\]+ { stringLitSb.append( yytext() ); }
- \\t { stringLitSb.append('\t'); }
- \\n { stringLitSb.append('\n'); }
- \\r { stringLitSb.append('\r'); }
- \\\" { stringLitSb.append('\"'); }
- \\ { stringLitSb.append('\\'); }
-}
-
+{WhiteSpace} { /* ignore */ }
+{Comment} { /* ignore */ }
+
+"abstract" { return sym(Terminals.ABSTRACT); }
+"rel" { return sym(Terminals.RELATION); }
+
+";" { return sym(Terminals.SCOL); }
+":" { return sym(Terminals.COL); }
+"::=" { return sym(Terminals.ASSIGN); }
+"*" { return sym(Terminals.STAR); }
+"." { return sym(Terminals.DOT); }
+"," { return sym(Terminals.COMMA); }
+"<" { return sym(Terminals.LT); }
+">" { return sym(Terminals.GT); }
+"[" { return sym(Terminals.LBRACKET); }
+"]" { return sym(Terminals.RBRACKET); }
+"/" { return sym(Terminals.SLASH); }
+"?" { return sym(Terminals.QUESTION_MARK); }
+"->" { return sym(Terminals.RIGHT); }
+"<->" { return sym(Terminals.BIDIRECTIONAL); }
+
+// ID
+{ID} { return sym(Terminals.ID); }
+<<EOF>> { return sym(Terminals.EOF); }
[^] { throw new ScannerError((yyline+1) +"," + (yycolumn+1) + ": Illegal character <"+yytext()+">"); }
diff --git a/src/main/jastadd/RelAst.parser b/src/main/jastadd/RelAst.parser
index 27e0e7e..631b89c 100644
--- a/src/main/jastadd/RelAst.parser
+++ b/src/main/jastadd/RelAst.parser
@@ -1,11 +1,7 @@
Program goal =
- type_decls.t relations.r {: return new Program(t, r); :}
- | STRING_LITERAL STAR {: return new Program(); :}
- ;
-
-List type_decls =
- /* empty */ {: return new List(); :}
- | type_decls.l type_decl.d {: return l.add(d); :}
+ /* empty */ {: return new Program(); :}
+ | type_decl.t goal.p {: p.getTypeDeclList().insertChild(t, 0); return p; :}
+ | relation.r goal.p {: p.getRelationList().insertChild(r, 0); return p; :}
;
TypeDecl type_decl =
@@ -66,11 +62,6 @@ Component component =
| LT ID GT {: return new TokenComponent(ID, new SimpleTypeUse("String")); :}
;
-List relations =
- /* empty */ {: return new List(); :}
- | relations.l relation.r {: return l.add(r); :}
- ;
-
Relation relation =
RELATION relation_comp.l direction relation_comp.r SCOL
{: return new Relation(l, direction, r); :}
diff --git a/src/test/jastadd/multiple-mixed/Part1.relast b/src/test/jastadd/multiple-mixed/Part1.relast
new file mode 100644
index 0000000..04cf6ee
--- /dev/null
+++ b/src/test/jastadd/multiple-mixed/Part1.relast
@@ -0,0 +1,6 @@
+rel A.Di1 -> B;
+
+B ::= <Name>;
+
+rel A.Di2? -> B;
+rel A.Di3* -> B;
diff --git a/src/test/jastadd/multiple-mixed/Part2.relast b/src/test/jastadd/multiple-mixed/Part2.relast
new file mode 100644
index 0000000..2ce0608
--- /dev/null
+++ b/src/test/jastadd/multiple-mixed/Part2.relast
@@ -0,0 +1,4 @@
+Root ::= A* B*;
+rel A.Bi1 <-> B.Bi1;
+rel A.Bi2 <-> B.Bi2?;
+rel A.Bi3 <-> B.Bi3*;
diff --git a/src/test/jastadd/multiple-mixed/Part3.relast b/src/test/jastadd/multiple-mixed/Part3.relast
new file mode 100644
index 0000000..41c36d9
--- /dev/null
+++ b/src/test/jastadd/multiple-mixed/Part3.relast
@@ -0,0 +1,9 @@
+rel A.Bi4? <-> B.Bi4;
+rel A.Bi5? <-> B.Bi5?;
+rel A.Bi6? <-> B.Bi6*;
+
+rel A.Bi7* <-> B.Bi7;
+rel A.Bi8* <-> B.Bi8?;
+rel A.Bi9* <-> B.Bi9*;
+
+A ::= <Name>;
diff --git a/src/test/java/org/jastadd/relast/tests/MultipleMixedFiles.java b/src/test/java/org/jastadd/relast/tests/MultipleMixedFiles.java
new file mode 100644
index 0000000..975ee2a
--- /dev/null
+++ b/src/test/java/org/jastadd/relast/tests/MultipleMixedFiles.java
@@ -0,0 +1,618 @@
+package org.jastadd.relast.tests;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import mixed.multiple.ast.A;
+import mixed.multiple.ast.B;
+import mixed.multiple.ast.Root;
+
+import java.util.Arrays;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+
+@SuppressWarnings("ArraysAsListWithZeroOrOneArgument")
+class MultipleMixedFiles {
+ 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 testDi1() {
+ setup();
+ a1.setDi1(b2);
+ a2.setDi1(b1);
+
+ assertSame(a1.getDi1(), b2);
+ assertSame(a2.getDi1(), b1);
+
+ a2.setDi1(b2);
+
+ assertSame(a1.getDi1(), b2);
+ assertSame(a2.getDi1(), 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.getDi2(), b2);
+ assertSame(a2.getDi2(), b1);
+
+ a2.setDi2(b2);
+
+ assertSame(a1.getDi2(), b2);
+ assertSame(a2.getDi2(), b2);
+
+ a2.clearDi2();
+
+ assertSame(a1.getDi2(), b2);
+ assertNull(a2.getDi2());
+
+ assertTrue(a1.hasDi2());
+ assertFalse(a2.hasDi2());
+ assertFalse(a3.hasDi2());
+ }
+
+
+ /**
+ * rel A.Di3* -> B;
+ */
+ @Test
+ void testDi3() {
+ setup();
+ a1.addDi3(b1);
+ a1.addDi3(b2);
+ a1.addDi3(b3);
+ a2.addDi3(b2);
+
+ assertEquals(a1.getDi3s(), Arrays.asList(b1, b2, b3));
+ assertEquals(a1.getDi3List(), Arrays.asList(b1, b2, b3));
+ assertEquals(a2.getDi3s(), Arrays.asList(b2));
+ assertEquals(a2.getDi3List(), Arrays.asList(b2));
+ assertEquals(a3.getDi3s(), Arrays.asList());
+ assertEquals(a3.getDi3List(), Arrays.asList());
+
+ a1.addDi3(b1);
+ a2.addDi3(b1);
+ a2.addDi3(b2);
+
+ assertEquals(a1.getDi3s(), Arrays.asList(b1, b2, b3, b1));
+ assertEquals(a1.getDi3List(), Arrays.asList(b1, b2, b3, b1));
+ assertEquals(a2.getDi3s(), Arrays.asList(b2, b1, b2));
+ assertEquals(a2.getDi3List(), Arrays.asList(b2, b1, b2));
+ assertEquals(a3.getDi3s(), Arrays.asList());
+ assertEquals(a3.getDi3List(), Arrays.asList());
+
+ a1.removeDi3(b1);
+ a2.removeDi3(b2);
+
+ assertEquals(a1.getDi3s(), Arrays.asList(b2, b3, b1));
+ assertEquals(a1.getDi3List(), Arrays.asList(b2, b3, b1));
+ assertEquals(a2.getDi3s(), Arrays.asList(b1, b2));
+ assertEquals(a2.getDi3List(), Arrays.asList(b1, b2));
+ assertEquals(a3.getDi3s(), Arrays.asList());
+ assertEquals(a3.getDi3List(), Arrays.asList());
+ }
+
+
+ /**
+ * rel A.Bi1 <-> B.Bi1;
+ */
+
+
+ @Test
+ void testBi11() {
+ // Init
+ setup();
+ a1.setBi1(b1);
+ a2.setBi1(b2);
+
+ // Change
+ a2.setBi1(b1);
+
+ assertNull(a1.getBi1());
+ assertSame(a2.getBi1(), b1);
+ assertSame(b1.getBi1(), a2);
+ assertNull(b2.getBi1());
+ }
+
+ @Test
+ void testBi12() {
+ // Init
+ setup();
+ a1.setBi1(b2);
+
+ // Change
+ a2.setBi1(b2);
+
+ assertNull(a1.getBi1());
+ assertSame(a2.getBi1(), b2);
+ assertNull(b1.getBi1());
+ assertSame(b2.getBi1(), a2);
+ }
+
+
+ /**
+ * rel A.Bi2 <-> B.Bi2?;
+ */
+
+ @Test
+ void testBi21() {
+ // Init
+ setup();
+ a1.setBi2(b1);
+ a2.setBi2(b2);
+
+ // Change
+ a2.setBi2(b1);
+
+ assertNull(a1.getBi2());
+ assertSame(a2.getBi2(), b1);
+ assertSame(b1.getBi2(), a2);
+ assertNull(b2.getBi2());
+ }
+
+ @Test
+ void testBi22() {
+ // Init
+ setup();
+ a1.setBi2(b2);
+
+ // Change
+ a2.setBi2(b2);
+
+ assertNull(a1.getBi2());
+ assertSame(a2.getBi2(), b2);
+ assertNull(b1.getBi2());
+ assertSame(b2.getBi2(), a2);
+ }
+
+
+ /**
+ * rel A.Bi3 <-> B.Bi3*;
+ */
+ @Test
+ void testBi3() {
+ setup();
+ a2.setBi3(b2);
+
+ assertNull(a1.getBi3());
+ assertSame(a2.getBi3(), b2);
+ assertEquals(b1.getBi3s(), Arrays.asList());
+ assertEquals(b1.getBi3List(), Arrays.asList());
+ assertEquals(b2.getBi3s(), Arrays.asList(a2));
+ assertEquals(b2.getBi3List(), Arrays.asList(a2));
+ assertEquals(b3.getBi3s(), Arrays.asList());
+ assertEquals(b3.getBi3List(), Arrays.asList());
+
+ a2.setBi3(b3);
+
+ assertNull(a1.getBi3());
+ assertSame(a2.getBi3(), b3);
+ assertEquals(b1.getBi3s(), Arrays.asList());
+ assertEquals(b1.getBi3List(), Arrays.asList());
+ assertEquals(b2.getBi3s(), Arrays.asList());
+ assertEquals(b2.getBi3List(), Arrays.asList());
+ assertEquals(b3.getBi3s(), Arrays.asList(a2));
+ assertEquals(b3.getBi3List(), Arrays.asList(a2));
+
+ a1.setBi3(b3);
+ a3.setBi3(b3);
+
+ assertSame(a1.getBi3(), b3);
+ assertSame(a2.getBi3(), b3);
+ assertSame(a3.getBi3(), b3);
+ assertEquals(b1.getBi3s(), Arrays.asList());
+ assertEquals(b1.getBi3List(), Arrays.asList());
+ assertEquals(b2.getBi3s(), Arrays.asList());
+ assertEquals(b2.getBi3List(), Arrays.asList());
+ assertEquals(b3.getBi3s(), Arrays.asList(a2, a1, a3));
+ assertEquals(b3.getBi3List(), Arrays.asList(a2, a1, a3));
+
+ a2.setBi3(b1);
+
+ assertSame(a1.getBi3(), b3);
+ assertSame(a2.getBi3(), b1);
+ assertSame(a3.getBi3(), b3);
+ assertEquals(b1.getBi3s(), Arrays.asList(a2));
+ assertEquals(b1.getBi3List(), Arrays.asList(a2));
+ assertEquals(b2.getBi3s(), Arrays.asList());
+ assertEquals(b2.getBi3List(), Arrays.asList());
+ assertEquals(b3.getBi3s(), Arrays.asList(a1, a3));
+ assertEquals(b3.getBi3List(), 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.getBi4());
+ assertSame(a2.getBi4(), b1);
+ assertSame(b1.getBi4(), a2);
+ assertNull(b2.getBi4());
+ }
+
+ @Test
+ void testBi42() {
+ // Init
+ setup();
+ a1.setBi4(b2);
+
+ // Change
+ a2.setBi4(b2);
+
+ assertNull(a1.getBi4());
+ assertSame(a2.getBi4(), b2);
+ assertNull(b1.getBi4());
+ assertSame(b2.getBi4(), a2);
+ }
+
+
+ /**
+ * rel A.Bi5? <-> B.Bi5?;
+ */
+ @Test
+ void testBi51() {
+ // Init
+ setup();
+ a1.setBi5(b1);
+ a2.setBi5(b2);
+
+ // Change
+ a2.setBi5(b1);
+
+ assertNull(a1.getBi5());
+ assertSame(a2.getBi5(), b1);
+ assertSame(b1.getBi5(), a2);
+ assertNull(b2.getBi5());
+ }
+
+ @Test
+ void testBi52() {
+ // Init
+ setup();
+ a1.setBi5(b2);
+
+ // Change
+ a2.setBi5(b2);
+
+ assertNull(a1.getBi5());
+ assertSame(a2.getBi5(), b2);
+ assertNull(b1.getBi5());
+ assertSame(b2.getBi5(), a2);
+ }
+
+
+ /**
+ * rel A.Bi6? <-> B.Bi6*;
+ */
+ @Test
+ void testBi6() {
+ setup();
+ a2.setBi6(b2);
+
+ assertNull(a1.getBi6());
+ assertSame(a2.getBi6(), b2);
+ assertEquals(b1.getBi6s(), Arrays.asList());
+ assertEquals(b1.getBi6List(), Arrays.asList());
+ assertEquals(b2.getBi6s(), Arrays.asList(a2));
+ assertEquals(b2.getBi6List(), Arrays.asList(a2));
+ assertEquals(b3.getBi6s(), Arrays.asList());
+ assertEquals(b3.getBi6List(), Arrays.asList());
+
+ a2.setBi6(b3);
+
+ assertNull(a1.getBi6());
+ assertSame(a2.getBi6(), b3);
+ assertEquals(b1.getBi6s(), Arrays.asList());
+ assertEquals(b1.getBi6List(), Arrays.asList());
+ assertEquals(b2.getBi6s(), Arrays.asList());
+ assertEquals(b2.getBi6List(), Arrays.asList());
+ assertEquals(b3.getBi6s(), Arrays.asList(a2));
+ assertEquals(b3.getBi6List(), Arrays.asList(a2));
+
+ a1.setBi6(b3);
+ a3.setBi6(b3);
+
+ assertSame(a1.getBi6(), b3);
+ assertSame(a2.getBi6(), b3);
+ assertSame(a3.getBi6(), b3);
+ assertEquals(b1.getBi6s(), Arrays.asList());
+ assertEquals(b1.getBi6List(), Arrays.asList());
+ assertEquals(b2.getBi6s(), Arrays.asList());
+ assertEquals(b2.getBi6List(), Arrays.asList());
+ assertEquals(b3.getBi6s(), Arrays.asList(a2, a1, a3));
+ assertEquals(b3.getBi6List(), Arrays.asList(a2, a1, a3));
+
+ a2.setBi6(b1);
+
+ assertSame(a1.getBi6(), b3);
+ assertSame(a2.getBi6(), b1);
+ assertSame(a3.getBi6(), b3);
+ assertEquals(b1.getBi6s(), Arrays.asList(a2));
+ assertEquals(b1.getBi6List(), Arrays.asList(a2));
+ assertEquals(b2.getBi6s(), Arrays.asList());
+ assertEquals(b2.getBi6List(), Arrays.asList());
+ assertEquals(b3.getBi6s(), Arrays.asList(a1, a3));
+ assertEquals(b3.getBi6List(), Arrays.asList(a1, a3));
+
+ a2.clearBi6();
+
+ assertSame(a1.getBi6(), b3);
+ assertNull(a2.getBi6());
+ assertSame(a3.getBi6(), b3);
+ assertEquals(b1.getBi6s(), Arrays.asList());
+ assertEquals(b1.getBi6List(), Arrays.asList());
+ assertEquals(b2.getBi6s(), Arrays.asList());
+ assertEquals(b2.getBi6List(), Arrays.asList());
+ assertEquals(b3.getBi6s(), Arrays.asList(a1, a3));
+ assertEquals(b3.getBi6List(), Arrays.asList(a1, a3));
+
+ assertTrue(a1.hasBi6());
+ assertFalse(a2.hasBi6());
+ assertTrue(a3.hasBi6());
+ }
+
+
+ /**
+ * rel A.Bi7* <-> B.Bi7;
+ */
+ @Test
+ void testBi7() {
+ setup();
+ a2.addBi7(b2);
+
+ assertEquals(a1.getBi7s(), Arrays.asList());
+ assertEquals(a1.getBi7List(), Arrays.asList());
+ assertEquals(a2.getBi7s(), Arrays.asList(b2));
+ assertEquals(a2.getBi7List(), Arrays.asList(b2));
+ assertNull(b1.getBi7());
+ assertSame(b2.getBi7(), a2);
+ assertNull(b3.getBi7());
+
+ a2.addBi7(b3);
+ a1.addBi7(b2);
+
+ assertEquals(a1.getBi7s(), Arrays.asList(b2));
+ assertEquals(a1.getBi7List(), Arrays.asList(b2));
+ assertEquals(a2.getBi7s(), Arrays.asList(b3));
+ assertEquals(a2.getBi7List(), Arrays.asList(b3));
+ assertNull(b1.getBi7());
+ assertSame(b2.getBi7(), a1);
+ assertSame(b3.getBi7(), a2);
+
+ a1.addBi7(b1);
+
+ assertEquals(a1.getBi7s(), Arrays.asList(b2, b1));
+ assertEquals(a1.getBi7List(), Arrays.asList(b2, b1));
+ assertEquals(a2.getBi7s(), Arrays.asList(b3));
+ assertEquals(a2.getBi7List(), Arrays.asList(b3));
+ assertSame(b1.getBi7(), a1);
+ assertSame(b2.getBi7(), a1);
+ assertSame(b3.getBi7(), a2);
+
+ a1.addBi7(b1);
+
+ assertEquals(a1.getBi7s(), Arrays.asList(b2, b1));
+ assertEquals(a1.getBi7List(), Arrays.asList(b2, b1));
+ assertEquals(a2.getBi7s(), Arrays.asList(b3));
+ assertEquals(a2.getBi7List(), Arrays.asList(b3));
+ assertSame(b1.getBi7(), a1);
+ assertSame(b2.getBi7(), a1);
+ assertSame(b3.getBi7(), a2);
+
+ a1.removeBi7(b1);
+
+ assertEquals(a1.getBi7s(), Arrays.asList(b2));
+ assertEquals(a1.getBi7List(), Arrays.asList(b2));
+ assertEquals(a2.getBi7s(), Arrays.asList(b3));
+ assertEquals(a2.getBi7List(), Arrays.asList(b3));
+ assertNull(b1.getBi7());
+ assertSame(b2.getBi7(), a1);
+ assertSame(b3.getBi7(), a2);
+ }
+
+
+ /**
+ * rel A.Bi8* <-> B.Bi8?;
+ */
+ @Test
+ void testBi8() {
+ setup();
+ a2.addBi8(b2);
+
+ assertEquals(a1.getBi8s(), Arrays.asList());
+ assertEquals(a1.getBi8List(), Arrays.asList());
+ assertEquals(a2.getBi8s(), Arrays.asList(b2));
+ assertEquals(a2.getBi8List(), Arrays.asList(b2));
+ assertNull(b1.getBi8());
+ assertSame(b2.getBi8(), a2);
+ assertNull(b3.getBi8());
+
+ a2.addBi8(b3);
+ a1.addBi8(b2);
+
+ assertEquals(a1.getBi8s(), Arrays.asList(b2));
+ assertEquals(a1.getBi8List(), Arrays.asList(b2));
+ assertEquals(a2.getBi8s(), Arrays.asList(b3));
+ assertEquals(a2.getBi8List(), Arrays.asList(b3));
+ assertNull(b1.getBi8());
+ assertSame(b2.getBi8(), a1);
+ assertSame(b3.getBi8(), a2);
+
+ a1.addBi8(b1);
+
+ assertEquals(a1.getBi8s(), Arrays.asList(b2, b1));
+ assertEquals(a1.getBi8List(), Arrays.asList(b2, b1));
+ assertEquals(a2.getBi8s(), Arrays.asList(b3));
+ assertEquals(a2.getBi8List(), Arrays.asList(b3));
+ assertSame(b1.getBi8(), a1);
+ assertSame(b2.getBi8(), a1);
+ assertSame(b3.getBi8(), a2);
+
+ a1.addBi8(b1);
+
+ assertEquals(a1.getBi8s(), Arrays.asList(b2, b1));
+ assertEquals(a1.getBi8List(), Arrays.asList(b2, b1));
+ assertEquals(a2.getBi8s(), Arrays.asList(b3));
+ assertEquals(a2.getBi8List(), Arrays.asList(b3));
+ assertSame(b1.getBi8(), a1);
+ assertSame(b2.getBi8(), a1);
+ assertSame(b3.getBi8(), a2);
+
+ a1.removeBi8(b1);
+
+ assertEquals(a1.getBi8s(), Arrays.asList(b2));
+ assertEquals(a1.getBi8List(), Arrays.asList(b2));
+ assertEquals(a2.getBi8s(), Arrays.asList(b3));
+ assertEquals(a2.getBi8List(), Arrays.asList(b3));
+ assertNull(b1.getBi8());
+ assertSame(b2.getBi8(), a1);
+ assertSame(b3.getBi8(), a2);
+ }
+
+
+ /**
+ * rel A.Bi9* <-> B.Bi9*;
+ */
+ @Test
+ void testBi9() {
+ setup();
+ a1.addBi9(b1);
+ a1.addBi9(b2);
+
+ assertEquals(a1.getBi9s(), Arrays.asList(b1, b2));
+ assertEquals(a1.getBi9List(), Arrays.asList(b1, b2));
+ assertEquals(a2.getBi9s(), Arrays.asList());
+ assertEquals(a2.getBi9List(), Arrays.asList());
+ assertEquals(a3.getBi9s(), Arrays.asList());
+ assertEquals(a3.getBi9List(), Arrays.asList());
+ assertEquals(b1.getBi9s(), Arrays.asList(a1));
+ assertEquals(b1.getBi9List(), Arrays.asList(a1));
+ assertEquals(b2.getBi9s(), Arrays.asList(a1));
+ assertEquals(b2.getBi9List(), Arrays.asList(a1));
+ assertEquals(b3.getBi9s(), Arrays.asList());
+ assertEquals(b3.getBi9List(), Arrays.asList());
+
+ b3.addBi9(a1);
+ b3.addBi9(a3);
+ b3.addBi9(a1);
+
+ assertEquals(a1.getBi9s(), Arrays.asList(b1, b2, b3, b3));
+ assertEquals(a1.getBi9List(), Arrays.asList(b1, b2, b3, b3));
+ assertEquals(a2.getBi9s(), Arrays.asList());
+ assertEquals(a2.getBi9List(), Arrays.asList());
+ assertEquals(a3.getBi9s(), Arrays.asList(b3));
+ assertEquals(a3.getBi9List(), Arrays.asList(b3));
+ assertEquals(b1.getBi9s(), Arrays.asList(a1));
+ assertEquals(b1.getBi9List(), Arrays.asList(a1));
+ assertEquals(b2.getBi9s(), Arrays.asList(a1));
+ assertEquals(b2.getBi9List(), Arrays.asList(a1));
+ assertEquals(b3.getBi9s(), Arrays.asList(a1, a3, a1));
+ assertEquals(b3.getBi9List(), Arrays.asList(a1, a3, a1));
+
+ b3.removeBi9(a1);
+
+ assertEquals(a1.getBi9s(), Arrays.asList(b1, b2, b3));
+ assertEquals(a1.getBi9List(), Arrays.asList(b1, b2, b3));
+ assertEquals(a2.getBi9s(), Arrays.asList());
+ assertEquals(a2.getBi9List(), Arrays.asList());
+ assertEquals(a3.getBi9s(), Arrays.asList(b3));
+ assertEquals(a3.getBi9List(), Arrays.asList(b3));
+ assertEquals(b1.getBi9s(), Arrays.asList(a1));
+ assertEquals(b1.getBi9List(), Arrays.asList(a1));
+ assertEquals(b2.getBi9s(), Arrays.asList(a1));
+ assertEquals(b2.getBi9List(), Arrays.asList(a1));
+ assertEquals(b3.getBi9s(), Arrays.asList(a3, a1));
+ assertEquals(b3.getBi9List(), Arrays.asList(a3, a1));
+ }
+
+
+ @Test
+ void testImmutableList() {
+ setup();
+
+ a1.addDi3(b1);
+ a1.addDi3(b2);
+ try {
+ a1.getDi3s().add(b3);
+ fail("should throw an exception");
+ } catch (Exception e) {
+ // OK
+ }
+
+ a1.addBi7(b1);
+ a1.addBi7(b2);
+ try {
+ a1.getBi7s().add(b3);
+ fail("should throw an exception");
+ } catch (Exception e) {
+ // OK
+ }
+
+ a1.addBi9(b1);
+ a1.addBi9(b2);
+ try {
+ a1.getBi9s().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);
+ }
+}
--
GitLab