From 0ff324b10c82071165fa673dc294fc648ce8f49b Mon Sep 17 00:00:00 2001 From: Johannes Mey <johannes.mey@tu-dresden.de> Date: Fri, 22 Feb 2019 13:54:45 +0100 Subject: [PATCH] test for multiple files --- tests/Makefile | 1 + tests/multipleFiles/.gitignore | 3 + tests/multipleFiles/AbstractTests.java | 25 ++ tests/multipleFiles/All.java | 555 +++++++++++++++++++++++++ tests/multipleFiles/Makefile | 17 + tests/multipleFiles/Rules1.relast | 5 + tests/multipleFiles/Rules2.relast | 7 + tests/multipleFiles/Rules3.relast | 7 + tests/multipleFiles/Utils.jadd | 9 + 9 files changed, 629 insertions(+) create mode 100644 tests/multipleFiles/.gitignore create mode 100644 tests/multipleFiles/AbstractTests.java create mode 100644 tests/multipleFiles/All.java create mode 100644 tests/multipleFiles/Makefile create mode 100644 tests/multipleFiles/Rules1.relast create mode 100644 tests/multipleFiles/Rules2.relast create mode 100644 tests/multipleFiles/Rules3.relast create mode 100644 tests/multipleFiles/Utils.jadd diff --git a/tests/Makefile b/tests/Makefile index f68b217..0b9d326 100644 --- a/tests/Makefile +++ b/tests/Makefile @@ -2,3 +2,4 @@ all: cd ../ && ./gradlew jar cd valid && make test cd errors && make test + cd multipleFiles && make test diff --git a/tests/multipleFiles/.gitignore b/tests/multipleFiles/.gitignore new file mode 100644 index 0000000..670d442 --- /dev/null +++ b/tests/multipleFiles/.gitignore @@ -0,0 +1,3 @@ +/AST/* +/*Gen.ast +/*Gen.jadd diff --git a/tests/multipleFiles/AbstractTests.java b/tests/multipleFiles/AbstractTests.java new file mode 100644 index 0000000..3b86096 --- /dev/null +++ b/tests/multipleFiles/AbstractTests.java @@ -0,0 +1,25 @@ +public class AbstractTests { + protected void assertException() { + check(false, "should throw exception"); + } + protected void assertTrue(boolean b) { + check(b, "value should be true (is false)"); + } + protected void assertFalse(boolean b) { + check(!b, "value should be flase (is true)"); + } + protected void assertNull(Object obj) { + check(obj == null, "Object not null: " + obj); + } + protected void assertSame(Object o1, Object o2) { + check(o1 == o2, "Objects not same: " + o1 + ", " + o2); + } + protected void assertEquals(Object o1, Object o2) { + check(o1.equals(o2), "Objects not equals: " + o1 + ", " + o2); + } + protected void check(boolean b, String message) { + if (!b) { + throw new RuntimeException(message); + } + } +} \ No newline at end of file diff --git a/tests/multipleFiles/All.java b/tests/multipleFiles/All.java new file mode 100644 index 0000000..80bddea --- /dev/null +++ b/tests/multipleFiles/All.java @@ -0,0 +1,555 @@ +import AST.*; +import java.util.*; + +@SuppressWarnings("ArraysAsListWithZeroOrOneArgument") +public class All extends AbstractTests { + private Root r; + private A a1; + private A a2; + private A a3; + private B b1; + private B b2; + private B b3; + + public static void main(String args[]) { + new All().test(); + } + + public void test() { + testDi1(); + testDi2(); + testDi3(); + + testBi1(); + testBi2(); + testBi3(); + testBi4(); + testBi5(); + testBi6(); + testBi7(); + testBi8(); + testBi9(); + + testImmutableList(); + } + + /** + * rel A.di1 -> B; + */ + private 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); + assertException(); + } catch (Exception e) { + // OK + } + } + + + /** + * rel A.di2? -> B; + */ + private 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; + */ + private 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; + */ + private void testBi1() { + testBi11(); + testBi12(); + } + private 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()); + } + private 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?; + */ + private void testBi2() { + testBi21(); + testBi22(); + } + private 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()); + } + private 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*; + */ + private 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); + assertException(); + } catch (Exception e) { + // OK + } + } + + + + /** + * rel A.bi4? <-> B.bi4; + */ + private void testBi4() { + testBi41(); + testBi42(); + } + private 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()); + } + private 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?; + */ + private void testBi5() { + testBi51(); + testBi52(); + } + private 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()); + } + private 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*; + */ + private 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; + */ + private 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?; + */ + private 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*; + */ + private 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)); + } + + + public void testImmutableList() { + setup(); + + a1.addToDi3(b1); + a1.addToDi3(b2); + try { + a1.di3().add(b3); + assertException(); + } catch (Exception e) { + // OK + } + + a1.addToBi7(b1); + a1.addToBi7(b2); + try { + a1.bi7().add(b3); + assertException(); + } catch (Exception e) { + // OK + } + + a1.addToBi9(b1); + a1.addToBi9(b2); + try { + a1.bi9().add(b3); + assertException(); + } catch (Exception e) { + // OK + } + } + + private 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); + } +} \ No newline at end of file diff --git a/tests/multipleFiles/Makefile b/tests/multipleFiles/Makefile new file mode 100644 index 0000000..d4564fe --- /dev/null +++ b/tests/multipleFiles/Makefile @@ -0,0 +1,17 @@ +all: build-jar test +test: test1 + @echo "#" + @echo "# MULTIPLE FILES TESTS OK" + @echo "#" + +build-jar: + (cd ../../ && ./gradlew jar) +test1: + java -jar ../../build/libs/relast.jar Rules1.relast Rules2.relast Rules3.relast --file + rm -rf AST + rm -rf *.class + java -jar ../../tools/jastadd2.jar --package=AST Rules1Gen.ast Rules1Gen.jadd Utils.jadd + javac AST/*.java All.java + java All + java -jar ../../build/libs/relast.jar Rules1Gen.ast --file + diff Rules1Gen.ast Rules1GenGen.ast \ No newline at end of file diff --git a/tests/multipleFiles/Rules1.relast b/tests/multipleFiles/Rules1.relast new file mode 100644 index 0000000..a296c99 --- /dev/null +++ b/tests/multipleFiles/Rules1.relast @@ -0,0 +1,5 @@ +B ::= <Name>; + +rel A.di1 -> B; +rel A.di2? -> B; +rel A.di3* -> B; diff --git a/tests/multipleFiles/Rules2.relast b/tests/multipleFiles/Rules2.relast new file mode 100644 index 0000000..1733a70 --- /dev/null +++ b/tests/multipleFiles/Rules2.relast @@ -0,0 +1,7 @@ +Root ::= A* B*; +A ::= <Name>; + + +rel A.bi1 <-> B.bi1; +rel A.bi2 <-> B.bi2?; +rel A.bi3 <-> B.bi3*; diff --git a/tests/multipleFiles/Rules3.relast b/tests/multipleFiles/Rules3.relast new file mode 100644 index 0000000..1c94d76 --- /dev/null +++ b/tests/multipleFiles/Rules3.relast @@ -0,0 +1,7 @@ +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*; diff --git a/tests/multipleFiles/Utils.jadd b/tests/multipleFiles/Utils.jadd new file mode 100644 index 0000000..d7acb1b --- /dev/null +++ b/tests/multipleFiles/Utils.jadd @@ -0,0 +1,9 @@ +aspect Utils { + public String A.toString() { + return getName(); + } + + public String B.toString() { + return getName(); + } +} \ No newline at end of file -- GitLab