Merge branch 'release-0.3.1' into 'master'

Version 0.3.1

See merge request !8

ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/IncrementalDependencyTest.java

@@ -3,6 +3,7 @@ package org.jastadd.ragconnect.tests;
 import incremental.ast.A;
 import incremental.ast.B;
 import incremental.ast.MqttHandler;
+import org.junit.jupiter.api.Tag;
 
 import java.io.IOException;
 import java.util.concurrent.TimeUnit;
@@ -16,6 +17,7 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
  *
  * @author rschoene - Initial contribution
  */
+@Tag("Incremental")
 public class IncrementalDependencyTest extends AbstractMqttTest {
 
   private static final String TOPIC_IN = "in/a";
@@ -71,10 +73,10 @@ public class IncrementalDependencyTest extends AbstractMqttTest {
       dataB2.lastStringValue = TestUtils.DefaultMappings.BytesToString(bytes);
     });
 
-    model.connectInput(mqttUri(TOPIC_IN));
-    model.connectOutputOnA(mqttUri(TOPIC_OUT_A), writeCurrentValue);
-    b1.connectOutputOnB(mqttUri(TOPIC_OUT_B1), writeCurrentValue);
-    b2.connectOutputOnB(mqttUri(TOPIC_OUT_B2), writeCurrentValue);
+    assertTrue(model.connectInput(mqttUri(TOPIC_IN)));
+    assertTrue(model.connectOutputOnA(mqttUri(TOPIC_OUT_A), writeCurrentValue));
+    assertTrue(b1.connectOutputOnB(mqttUri(TOPIC_OUT_B1), writeCurrentValue));
+    assertTrue(b2.connectOutputOnB(mqttUri(TOPIC_OUT_B2), writeCurrentValue));
   }
 
   @Override

ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/MappingTest.java

@@ -89,29 +89,29 @@ public class MappingTest extends AbstractMqttTest {
       data.lastNativeBooleanValue = TestUtils.DefaultMappings.BytesToBool(bytes);
     });
 
-    natives.connectWriteIntValue(mqttUri(TOPIC_WRITE_NATIVE_INT), writeCurrentValue);
-    natives.connectWriteShortValue(mqttUri(TOPIC_WRITE_NATIVE_SHORT), writeCurrentValue);
-    natives.connectWriteLongValue(mqttUri(TOPIC_WRITE_NATIVE_LONG), writeCurrentValue);
-    natives.connectWriteFloatValue(mqttUri(TOPIC_WRITE_NATIVE_FLOAT), writeCurrentValue);
-    natives.connectWriteDoubleValue(mqttUri(TOPIC_WRITE_NATIVE_DOUBLE), writeCurrentValue);
-    natives.connectWriteCharValue(mqttUri(TOPIC_WRITE_NATIVE_CHAR), writeCurrentValue);
-    natives.connectWriteBooleanValue(mqttUri(TOPIC_WRITE_NATIVE_BOOLEAN), writeCurrentValue);
-
-    natives.connectIntValue(mqttUri(TOPIC_INPUT));
-    natives.connectShortValue(mqttUri(TOPIC_INPUT));
-    natives.connectLongValue(mqttUri(TOPIC_INPUT));
-    natives.connectFloatValue(mqttUri(TOPIC_INPUT));
-    natives.connectDoubleValue(mqttUri(TOPIC_INPUT));
-    natives.connectCharValue(mqttUri(TOPIC_INPUT));
-    natives.connectBooleanValue(mqttUri(TOPIC_INPUT));
-
-    boxes.connectIntValue(mqttUri(TOPIC_INPUT));
-    boxes.connectShortValue(mqttUri(TOPIC_INPUT));
-    boxes.connectLongValue(mqttUri(TOPIC_INPUT));
-    boxes.connectFloatValue(mqttUri(TOPIC_INPUT));
-    boxes.connectDoubleValue(mqttUri(TOPIC_INPUT));
-    boxes.connectCharValue(mqttUri(TOPIC_INPUT));
-    boxes.connectBooleanValue(mqttUri(TOPIC_INPUT));
+    assertTrue(natives.connectWriteIntValue(mqttUri(TOPIC_WRITE_NATIVE_INT), writeCurrentValue));
+    assertTrue(natives.connectWriteShortValue(mqttUri(TOPIC_WRITE_NATIVE_SHORT), writeCurrentValue));
+    assertTrue(natives.connectWriteLongValue(mqttUri(TOPIC_WRITE_NATIVE_LONG), writeCurrentValue));
+    assertTrue(natives.connectWriteFloatValue(mqttUri(TOPIC_WRITE_NATIVE_FLOAT), writeCurrentValue));
+    assertTrue(natives.connectWriteDoubleValue(mqttUri(TOPIC_WRITE_NATIVE_DOUBLE), writeCurrentValue));
+    assertTrue(natives.connectWriteCharValue(mqttUri(TOPIC_WRITE_NATIVE_CHAR), writeCurrentValue));
+    assertTrue(natives.connectWriteBooleanValue(mqttUri(TOPIC_WRITE_NATIVE_BOOLEAN), writeCurrentValue));
+
+    assertTrue(natives.connectIntValue(mqttUri(TOPIC_INPUT)));
+    assertTrue(natives.connectShortValue(mqttUri(TOPIC_INPUT)));
+    assertTrue(natives.connectLongValue(mqttUri(TOPIC_INPUT)));
+    assertTrue(natives.connectFloatValue(mqttUri(TOPIC_INPUT)));
+    assertTrue(natives.connectDoubleValue(mqttUri(TOPIC_INPUT)));
+    assertTrue(natives.connectCharValue(mqttUri(TOPIC_INPUT)));
+    assertTrue(natives.connectBooleanValue(mqttUri(TOPIC_INPUT)));
+
+    assertTrue(boxes.connectIntValue(mqttUri(TOPIC_INPUT)));
+    assertTrue(boxes.connectShortValue(mqttUri(TOPIC_INPUT)));
+    assertTrue(boxes.connectLongValue(mqttUri(TOPIC_INPUT)));
+    assertTrue(boxes.connectFloatValue(mqttUri(TOPIC_INPUT)));
+    assertTrue(boxes.connectDoubleValue(mqttUri(TOPIC_INPUT)));
+    assertTrue(boxes.connectCharValue(mqttUri(TOPIC_INPUT)));
+    assertTrue(boxes.connectBooleanValue(mqttUri(TOPIC_INPUT)));
   }
 
   @Override

ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/MqttHandlerTest.java

+package org.jastadd.ragconnect.tests;
+
+import example.ast.MqttHandler;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Testing the {@link MqttHandler} used in the "example" test case.
+ *
+ * @author rschoene - Initial contribution
+ */
+@Tag("mqtt")
+public class MqttHandlerTest {
+
+  @Test
+  public void defaultBehaviour() {
+    MqttHandler handler = new MqttHandler();
+    try {
+      handler.setHost(TestUtils.getMqttHost());
+    } catch (IOException e) {
+      fail("Fail during setHost", e);
+    }
+    boolean ready = handler.waitUntilReady(2, TimeUnit.SECONDS);
+    assertTrue(ready);
+    handler.close();
+  }
+
+  @Test
+  public void testWelcomeMessage() throws Exception {
+    MqttHandler welcomeMessageSubscriber = new MqttHandler();
+    List<String> receivedMessages = new ArrayList<>();
+    welcomeMessageSubscriber.setHost(TestUtils.getMqttHost());
+    assertTrue(welcomeMessageSubscriber.waitUntilReady(2, TimeUnit.SECONDS));
+    welcomeMessageSubscriber.newConnection("components", bytes -> receivedMessages.add(new String(bytes)));
+    assertThat(receivedMessages).isEmpty();
+
+    MqttHandler handler = new MqttHandler();
+    handler.setHost(TestUtils.getMqttHost());
+    assertTrue(handler.waitUntilReady(2, TimeUnit.SECONDS));
+    TestUtils.waitForMqtt();
+
+    assertEquals(1, receivedMessages.size());
+  }
+
+  @Test
+  public void testDontSendWelcomeMessage() throws Exception {
+    MqttHandler welcomeMessageSubscriber = new MqttHandler();
+    List<String> receivedMessages = new ArrayList<>();
+    welcomeMessageSubscriber.setHost(TestUtils.getMqttHost());
+    assertTrue(welcomeMessageSubscriber.waitUntilReady(2, TimeUnit.SECONDS));
+    welcomeMessageSubscriber.newConnection("components", bytes -> receivedMessages.add(new String(bytes)));
+    assertThat(receivedMessages).isEmpty();
+
+    MqttHandler handler = new MqttHandler().dontSendWelcomeMessage();
+    handler.setHost(TestUtils.getMqttHost());
+    assertTrue(handler.waitUntilReady(2, TimeUnit.SECONDS));
+    TestUtils.waitForMqtt();
+
+    assertThat(receivedMessages).isEmpty();
+  }
+
+}

ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/Read1Write2Test.java

@@ -100,15 +100,15 @@ public class Read1Write2Test extends AbstractMqttTest {
       dataOther2.lastStringValue = TestUtils.DefaultMappings.BytesToString(bytes);
     });
 
-    onSameNonterminal.connectInput(mqttUri(TOPIC_SAME_READ));
-    onSameNonterminal.connectOutInteger(mqttUri(TOPIC_SAME_WRITE_INT), writeCurrentValue);
-    onSameNonterminal.connectOutString(mqttUri(TOPIC_SAME_WRITE_STRING), writeCurrentValue);
-
-    onDifferentNonterminal.connectInput(mqttUri(TOPIC_DIFFERENT_READ));
-    other1.connectOutInteger(mqttUri(TOPIC_DIFFERENT_WRITE1_INT), writeCurrentValue);
-    other1.connectOutString(mqttUri(TOPIC_DIFFERENT_WRITE1_STRING), writeCurrentValue);
-    other2.connectOutInteger(mqttUri(TOPIC_DIFFERENT_WRITE2_INT), writeCurrentValue);
-    other2.connectOutString(mqttUri(TOPIC_DIFFERENT_WRITE2_STRING), writeCurrentValue);
+    assertTrue(onSameNonterminal.connectInput(mqttUri(TOPIC_SAME_READ)));
+    assertTrue(onSameNonterminal.connectOutInteger(mqttUri(TOPIC_SAME_WRITE_INT), writeCurrentValue));
+    assertTrue(onSameNonterminal.connectOutString(mqttUri(TOPIC_SAME_WRITE_STRING), writeCurrentValue));
+
+    assertTrue(onDifferentNonterminal.connectInput(mqttUri(TOPIC_DIFFERENT_READ)));
+    assertTrue(other1.connectOutInteger(mqttUri(TOPIC_DIFFERENT_WRITE1_INT), writeCurrentValue));
+    assertTrue(other1.connectOutString(mqttUri(TOPIC_DIFFERENT_WRITE1_STRING), writeCurrentValue));
+    assertTrue(other2.connectOutInteger(mqttUri(TOPIC_DIFFERENT_WRITE2_INT), writeCurrentValue));
+    assertTrue(other2.connectOutString(mqttUri(TOPIC_DIFFERENT_WRITE2_STRING), writeCurrentValue));
   }
 
   @Override

ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/Read2Write1Test.java

@@ -89,14 +89,14 @@ public class Read2Write1Test extends AbstractMqttTest {
       dataOther2.lastIntValue = TestUtils.DefaultMappings.BytesToInt(bytes);
     });
 
-    onSameNonterminal.connectInput1(mqttUri(TOPIC_SAME_READ1));
-    onSameNonterminal.connectInput2(mqttUri(TOPIC_SAME_READ2));
-    onSameNonterminal.connectOutInteger(mqttUri(TOPIC_SAME_WRITE_INT), writeCurrentValue);
-
-    onDifferentNonterminal.connectInput1(mqttUri(TOPIC_DIFFERENT_READ1));
-    onDifferentNonterminal.connectInput2(mqttUri(TOPIC_DIFFERENT_READ2));
-    other1.connectOutInteger(mqttUri(TOPIC_DIFFERENT_WRITE1_INT), writeCurrentValue);
-    other2.connectOutInteger(mqttUri(TOPIC_DIFFERENT_WRITE2_INT), writeCurrentValue);
+    assertTrue(onSameNonterminal.connectInput1(mqttUri(TOPIC_SAME_READ1)));
+    assertTrue(onSameNonterminal.connectInput2(mqttUri(TOPIC_SAME_READ2)));
+    assertTrue(onSameNonterminal.connectOutInteger(mqttUri(TOPIC_SAME_WRITE_INT), writeCurrentValue));
+
+    assertTrue(onDifferentNonterminal.connectInput1(mqttUri(TOPIC_DIFFERENT_READ1)));
+    assertTrue(onDifferentNonterminal.connectInput2(mqttUri(TOPIC_DIFFERENT_READ2)));
+    assertTrue(other1.connectOutInteger(mqttUri(TOPIC_DIFFERENT_WRITE1_INT), writeCurrentValue));
+    assertTrue(other2.connectOutInteger(mqttUri(TOPIC_DIFFERENT_WRITE2_INT), writeCurrentValue));
   }
 
   @Override

ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/RegressionTests.java

+package org.jastadd.ragconnect.tests;
+
+import org.junit.jupiter.api.Test;
+import via.ast.A;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+import java.util.Collections;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Regression tests for fixed issues.
+ *
+ * @author rschoene - Initial contribution
+ */
+public class RegressionTests {
+
+  private static final String REGRESSION_TEST_OUTPUT_DIRECTORY = "regression-test/";
+
+  @Test
+  public void issue22() {
+    // use model of "via" test case as it uses both mqtt and rest as protocols
+    A a = new A();
+    try {
+      // should fail because of missing scheme
+      assertFalse(a.connectBoth2BothInput("missing/scheme"));
+
+      // should fail because of missing host
+      assertFalse(a.connectBoth2BothInput("mqtt://"));
+
+      // should fail because of missing part
+      assertFalse(a.connectBoth2BothInput("mqtt://localhost"));
+
+      // should fail because of unknown scheme
+      assertFalse(a.connectBoth2BothInput("badScheme://host/some/topic"));
+    } catch (IOException e) {
+      fail(e);
+    }
+  }
+
+  @Test
+  public void issue27() throws IOException {
+    String grammarFile = "regression-tests/issue27/Test.relast";
+    String connectFile = "regression-tests/issue27/Test.connect";
+    grammarFile = ensureNoTrailingNewLine(grammarFile);
+    connectFile = ensureNoTrailingNewLine(connectFile);
+    TestUtils.runCompiler(grammarFile, Collections.singletonList(connectFile), "A", REGRESSION_TEST_OUTPUT_DIRECTORY, 0);
+  }
+
+  private String ensureNoTrailingNewLine(String inputFileSuffix) throws IOException {
+    int dotIndex = inputFileSuffix.lastIndexOf('.');
+    String outFileSuffix = inputFileSuffix.substring(0, dotIndex) + ".noNewLine" + inputFileSuffix.substring(dotIndex);
+    Path inputPath = Paths.get(TestUtils.INPUT_DIRECTORY_PREFIX).resolve(inputFileSuffix);
+    Path outputPath = Paths.get(TestUtils.INPUT_DIRECTORY_PREFIX).resolve(outFileSuffix);
+
+    String content = Files.readString(inputPath);
+    Files.writeString(outputPath, content.stripTrailing(), StandardOpenOption.CREATE);
+
+    return outFileSuffix;
+  }
+}

ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/TestUtils.java

 package org.jastadd.ragconnect.tests;
 
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.jastadd.ragconnect.compiler.Compiler;
+import org.junit.jupiter.api.Assertions;
+
 import java.io.File;
 import java.io.IOException;
 import java.nio.charset.Charset;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.concurrent.TimeUnit;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 
 /**
@@ -17,7 +26,10 @@ import static org.junit.jupiter.api.Assertions.fail;
  */
 public class TestUtils {
 
+  private static final Logger logger = LogManager.getLogger(TestUtils.class);
   public static final double DELTA = 0.001d;
+  public static final String INPUT_DIRECTORY_PREFIX = "./src/test/01-input/";
+  public static final String OUTPUT_DIRECTORY_PREFIX = "./src/test/02-after-ragconnect/";
 
   public static String getMqttHost() {
     if (System.getenv("GITLAB_CI") != null) {
@@ -41,6 +53,41 @@ public class TestUtils {
     return 1883;
   }
 
+  public static Path runCompiler(String grammarFile, Iterable<String> connectFiles, String rootNode, String outputDirectory, int expectedReturnValue) {
+
+    assertThat(connectFiles).isNotEmpty();
+
+    Path outPath = Paths.get(OUTPUT_DIRECTORY_PREFIX)
+        .resolve(outputDirectory)
+        .resolve("Compiler.out");
+    ensureCreated(outPath.getParent());
+
+    try {
+      logger.debug("user.dir: {}", System.getProperty("user.dir"));
+      List<String> args = new ArrayList<>() {{
+        add("--o=" + OUTPUT_DIRECTORY_PREFIX + outputDirectory);
+        add("--rootNode=" + rootNode);
+        add("--verbose");
+        add(INPUT_DIRECTORY_PREFIX + grammarFile);
+      }};
+      connectFiles.forEach(connectFile -> args.add(INPUT_DIRECTORY_PREFIX + connectFile));
+
+      int returnValue = exec(Compiler.class, args.toArray(new String[0]), outPath.toFile());
+      Assertions.assertEquals(expectedReturnValue, returnValue, "RagConnect did not return with value " + expectedReturnValue);
+    } catch (IOException | InterruptedException e) {
+      fail(e);
+    }
+    return outPath;
+  }
+
+  private static void ensureCreated(Path directory) {
+    File directoryFile = directory.toFile();
+    if (directoryFile.exists() && directoryFile.isDirectory()) {
+      return;
+    }
+    assertTrue(directoryFile.mkdirs());
+  }
+
   public static int exec(Class<?> klass, String[] args, File err) throws IOException,
       InterruptedException {
     String javaHome = System.getProperty("java.home");
@@ -79,14 +126,14 @@ public class TestUtils {
     }
   }
 
-  public static String readFile(String path, Charset encoding)
+  public static String readFile(Path path, Charset encoding)
       throws IOException {
-    byte[] encoded = Files.readAllBytes(Paths.get(path));
+    byte[] encoded = Files.readAllBytes(path);
     return new String(encoded, encoding);
   }
 
   static void waitForMqtt() throws InterruptedException {
-    TimeUnit.SECONDS.sleep(2);
+    TimeUnit.MILLISECONDS.sleep(1500);
   }
 
   @SuppressWarnings({"unused", "rawtypes"})

ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/TokenValueSendTest.java

@@ -87,12 +87,12 @@ public class TokenValueSendTest extends AbstractMqttTest {
       dataThreeOther.lastStringValue = TestUtils.DefaultMappings.BytesToString(bytes);
     });
 
-    one.connectValue(mqttUri(TOPIC_SEND_ONE), writeCurrentValue);
-    two.connectValue(mqttUri(TOPIC_RECEIVE_TWO));
-    two.connectValue(mqttUri(TOPIC_SEND_TWO), writeCurrentValue);
-    three.connectValue(mqttUri(TOPIC_RECEIVE_THREE_VALUE));
-    three.connectValue(mqttUri(TOPIC_SEND_THREE_VALUE), writeCurrentValue);
-    three.connectOtherOutput(mqttUri(TOPIC_SEND_THREE_OTHER), writeCurrentValue);
+    assertTrue(one.connectValue(mqttUri(TOPIC_SEND_ONE), writeCurrentValue));
+    assertTrue(two.connectValue(mqttUri(TOPIC_RECEIVE_TWO)));
+    assertTrue(two.connectValue(mqttUri(TOPIC_SEND_TWO), writeCurrentValue));
+    assertTrue(three.connectValue(mqttUri(TOPIC_RECEIVE_THREE_VALUE)));
+    assertTrue(three.connectValue(mqttUri(TOPIC_SEND_THREE_VALUE), writeCurrentValue));
+    assertTrue(three.connectOtherOutput(mqttUri(TOPIC_SEND_THREE_OTHER), writeCurrentValue));
   }
 
   @Override

ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/TreeAllowedTokensIncrementalTest.java

@@ -18,7 +18,8 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
  *
  * @author rschoene - Initial contribution
  */
-@Tag("SpecificTest")
+@Tag("Incremental")
+@Tag("Tree")
 public class TreeAllowedTokensIncrementalTest extends AbstractTreeAllowedTokensTest {
 
   private Root model;
@@ -42,6 +43,8 @@ public class TreeAllowedTokensIncrementalTest extends AbstractTreeAllowedTokensT
 
     receiverRoot = new ReceiverRoot();
     model.addReceiverRoot((ReceiverRoot) receiverRoot);
+
+    model.ragconnectCheckIncremental();
   }
 
   @Override
@@ -58,14 +61,14 @@ public class TreeAllowedTokensIncrementalTest extends AbstractTreeAllowedTokensT
     handler.newConnection(TOPIC_ALFA_PRIMITIVE, bytes -> data.numberOfPrimitiveTrees += 1);
 
     // connect. important: first receiver, then sender. to not miss initial value.
-    senderRoot.connectInput1WhenFlagIsFalse(mqttUri(TOPIC_INPUT1FALSE));
-    senderRoot.connectInput1WhenFlagIsTrue(mqttUri(TOPIC_INPUT1TRUE));
-    senderRoot.connectInput2(mqttUri(TOPIC_INPUT2));
-    senderRoot.connectInput3(mqttUri(TOPIC_INPUT3));
-    receiverRoot.connectAlfa(mqttUri(TOPIC_ALFA));
-    receiverRoot.connectAlfaPrimitive(mqttUri(TOPIC_ALFA_PRIMITIVE));
-    senderRoot.connectAlfa(mqttUri(TOPIC_ALFA), writeCurrentValue);
-    senderRoot.connectAlfaPrimitive(mqttUri(TOPIC_ALFA_PRIMITIVE), writeCurrentValue);
+    assertTrue(senderRoot.connectInput1WhenFlagIsFalse(mqttUri(TOPIC_INPUT1FALSE)));
+    assertTrue(senderRoot.connectInput1WhenFlagIsTrue(mqttUri(TOPIC_INPUT1TRUE)));
+    assertTrue(senderRoot.connectInput2(mqttUri(TOPIC_INPUT2)));
+    assertTrue(senderRoot.connectInput3(mqttUri(TOPIC_INPUT3)));
+    assertTrue(receiverRoot.connectAlfa(mqttUri(TOPIC_ALFA)));
+    assertTrue(receiverRoot.connectAlfaPrimitive(mqttUri(TOPIC_ALFA_PRIMITIVE)));
+    assertTrue(senderRoot.connectAlfa(mqttUri(TOPIC_ALFA), writeCurrentValue));
+    assertTrue(senderRoot.connectAlfaPrimitive(mqttUri(TOPIC_ALFA_PRIMITIVE), writeCurrentValue));
   }
 
   @Override

ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/TreeAllowedTokensManualTest.java

 package org.jastadd.ragconnect.tests;
 
+import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
 import treeAllowedTokens.ast.*;
 
@@ -18,6 +19,7 @@ import static org.junit.jupiter.api.Assertions.*;
  *
  * @author rschoene - Initial contribution
  */
+@Tag("Tree")
 public class TreeAllowedTokensManualTest extends AbstractTreeAllowedTokensTest {
 
   private Root model;
@@ -63,14 +65,14 @@ public class TreeAllowedTokensManualTest extends AbstractTreeAllowedTokensTest {
     handler.newConnection(TOPIC_ALFA_PRIMITIVE, bytes -> data.numberOfPrimitiveTrees += 1);
 
     // connect. important: first receiver, then sender. to not miss initial value.
-    senderRoot.connectInput1WhenFlagIsFalse(mqttUri(TOPIC_INPUT1FALSE));
-    senderRoot.connectInput1WhenFlagIsTrue(mqttUri(TOPIC_INPUT1TRUE));
-    senderRoot.connectInput2(mqttUri(TOPIC_INPUT2));
-    senderRoot.connectInput3(mqttUri(TOPIC_INPUT3));
-    receiverRoot.connectAlfa(mqttUri(TOPIC_ALFA));
-    receiverRoot.connectAlfaPrimitive(mqttUri(TOPIC_ALFA_PRIMITIVE));
-    senderRoot.connectAlfa(mqttUri(TOPIC_ALFA), writeCurrentValue);
-    senderRoot.connectAlfaPrimitive(mqttUri(TOPIC_ALFA_PRIMITIVE), writeCurrentValue);
+    assertTrue(senderRoot.connectInput1WhenFlagIsFalse(mqttUri(TOPIC_INPUT1FALSE)));
+    assertTrue(senderRoot.connectInput1WhenFlagIsTrue(mqttUri(TOPIC_INPUT1TRUE)));
+    assertTrue(senderRoot.connectInput2(mqttUri(TOPIC_INPUT2)));
+    assertTrue(senderRoot.connectInput3(mqttUri(TOPIC_INPUT3)));
+    assertTrue(receiverRoot.connectAlfa(mqttUri(TOPIC_ALFA)));
+    assertTrue(receiverRoot.connectAlfaPrimitive(mqttUri(TOPIC_ALFA_PRIMITIVE)));
+    assertTrue(senderRoot.connectAlfa(mqttUri(TOPIC_ALFA), writeCurrentValue));
+    assertTrue(senderRoot.connectAlfaPrimitive(mqttUri(TOPIC_ALFA_PRIMITIVE), writeCurrentValue));
   }
 
   @Override

ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/TreeIncrementalTest.java

 package org.jastadd.ragconnect.tests;
 
+import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
 import treeInc.ast.*;
 
@@ -17,6 +18,8 @@ import static org.junit.jupiter.api.Assertions.*;
  *
  * @author rschoene - Initial contribution
  */
+@Tag("Tree")
+@Tag("Incremental")
 public class TreeIncrementalTest extends AbstractTreeTest {
 
   private Root model;
@@ -53,8 +56,8 @@ public class TreeIncrementalTest extends AbstractTreeTest {
     handler.newConnection(TOPIC_ALFA, bytes -> data.numberOfTrees += 1);
 
     // connect. important: first receiver, then sender. to not miss initial value.
-    receiverRoot.connectAlfa(mqttUri(TOPIC_ALFA));
-    senderRoot.connectAlfa(mqttUri(TOPIC_ALFA), writeCurrentValue);
+    assertTrue(receiverRoot.connectAlfa(mqttUri(TOPIC_ALFA)));
+    assertTrue(senderRoot.connectAlfa(mqttUri(TOPIC_ALFA), writeCurrentValue));
   }
 
   @Override

ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/TreeManualTest.java

 package org.jastadd.ragconnect.tests;
 
+import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
 import tree.ast.MqttHandler;
 import tree.ast.ReceiverRoot;
@@ -19,6 +20,7 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
  *
  * @author rschoene - Initial contribution
  */
+@Tag("Tree")
 public class TreeManualTest extends AbstractTreeTest {
 
   private Root model;
@@ -56,8 +58,8 @@ public class TreeManualTest extends AbstractTreeTest {
     handler.newConnection(TOPIC_ALFA, bytes -> data.numberOfTrees += 1);
 
     // connect. important: first receiver, then sender. to not miss initial value.
-    receiverRoot.connectAlfa(mqttUri(TOPIC_ALFA));
-    senderRoot.connectAlfa(mqttUri(TOPIC_ALFA), writeCurrentValue);
+    assertTrue(receiverRoot.connectAlfa(mqttUri(TOPIC_ALFA)));
+    assertTrue(senderRoot.connectAlfa(mqttUri(TOPIC_ALFA), writeCurrentValue));
   }
 
   @Override

ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/TutorialTest.java

@@ -6,6 +6,7 @@ import tutorial.ast.B;
 import java.io.IOException;
 
 import static org.jastadd.ragconnect.tests.TestUtils.mqttUri;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
  * Testcase "Tutorial".
@@ -38,10 +39,10 @@ public class TutorialTest extends AbstractMqttTest {
     // b2.OutputOnB -> a.Input
     b2.addDependencyB(a);
 
-    a.connectInput(mqttUri("topic/for/input"));
-    a.connectOutputOnA(mqttUri("a/out"), true);
-    b1.connectOutputOnB(mqttUri("b1/out"), true);
-    b2.connectOutputOnB(mqttUri("b2/out"), false);
+    assertTrue(a.connectInput(mqttUri("topic/for/input")));
+    assertTrue(a.connectOutputOnA(mqttUri("a/out"), true));
+    assertTrue(b1.connectOutputOnB(mqttUri("b1/out"), true));
+    assertTrue(b2.connectOutputOnB(mqttUri("b2/out"), false));
   }
 
   @Override

ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/ViaTest.java

@@ -106,18 +106,18 @@ public class ViaTest extends AbstractMqttTest {
     senderRest2Mqtt = client.target(REST_SERVER_BASE_URL + PATH_REST_2_MQTT_RECEIVE);
     senderBoth2Rest = client.target(REST_SERVER_BASE_URL + PATH_BOTH_REST_RECEIVE);
 
-    model.connectMqtt2MqttInput(mqttUri(TOPIC_MQTT_2_MQTT_RECEIVE));
-    model.connectMqtt2MqttOutput(mqttUri(TOPIC_MQTT_2_MQTT_SEND), writeCurrentValue);
-    model.connectMqtt2RestInput(mqttUri(TOPIC_MQTT_2_REST_RECEIVE));
-    model.connectMqtt2RestOutput(restUri(PATH_MQTT_2_REST_SEND, REST_PORT), writeCurrentValue);
-    model.connectRest2MqttInput(restUri(PATH_REST_2_MQTT_RECEIVE, REST_PORT));
-    model.connectRest2MqttOutput(mqttUri(TOPIC_REST_2_MQTT_SEND), writeCurrentValue);
-    model.connectRest2RestInput(restUri(PATH_REST_2_REST_RECEIVE, REST_PORT));
-    model.connectRest2RestOutput(restUri(PATH_REST_2_REST_SEND, REST_PORT), writeCurrentValue);
-    model.connectBoth2BothInput(mqttUri(TOPIC_BOTH_MQTT_RECEIVE));
-    model.connectBoth2BothInput(restUri(PATH_BOTH_REST_RECEIVE, REST_PORT));
-    model.connectBoth2MqttOutput(mqttUri(TOPIC_BOTH_2_MQTT_SEND), writeCurrentValue);
-    model.connectBoth2RestOutput(restUri(PATH_BOTH_2_REST_SEND, REST_PORT), writeCurrentValue);
+    assertTrue(model.connectMqtt2MqttInput(mqttUri(TOPIC_MQTT_2_MQTT_RECEIVE)));
+    assertTrue(model.connectMqtt2MqttOutput(mqttUri(TOPIC_MQTT_2_MQTT_SEND), writeCurrentValue));
+    assertTrue(model.connectMqtt2RestInput(mqttUri(TOPIC_MQTT_2_REST_RECEIVE)));
+    assertTrue(model.connectMqtt2RestOutput(restUri(PATH_MQTT_2_REST_SEND, REST_PORT), writeCurrentValue));
+    assertTrue(model.connectRest2MqttInput(restUri(PATH_REST_2_MQTT_RECEIVE, REST_PORT)));
+    assertTrue(model.connectRest2MqttOutput(mqttUri(TOPIC_REST_2_MQTT_SEND), writeCurrentValue));
+    assertTrue(model.connectRest2RestInput(restUri(PATH_REST_2_REST_RECEIVE, REST_PORT)));
+    assertTrue(model.connectRest2RestOutput(restUri(PATH_REST_2_REST_SEND, REST_PORT), writeCurrentValue));
+    assertTrue(model.connectBoth2BothInput(mqttUri(TOPIC_BOTH_MQTT_RECEIVE)));
+    assertTrue(model.connectBoth2BothInput(restUri(PATH_BOTH_REST_RECEIVE, REST_PORT)));
+    assertTrue(model.connectBoth2MqttOutput(mqttUri(TOPIC_BOTH_2_MQTT_SEND), writeCurrentValue));
+    assertTrue(model.connectBoth2RestOutput(restUri(PATH_BOTH_2_REST_SEND, REST_PORT), writeCurrentValue));
   }
 
   @Override

relast-preprocessor @ 02f8e359

-Subproject commit b538a7f709167c5f56fe65e6d9e9f02179cacaef
+Subproject commit 02f8e35993dc3f62ab49e94f69a6dc27170660da

settings.gradle

+pluginManagement {
+    plugins {
+        id 'org.jastadd' version '1.13.3'
+    }
+}
+
 rootProject.name = 'ragconnect'
 
 include 'relast-preprocessor'