merged upstream master in fork-master

.gitlab-ci.yml

@@ -4,6 +4,8 @@ variables:
 stages:
 - build
 # - publish
+# - test
+# - publish
 
 before_script:
   - export GRADLE_USER_HOME=`pwd`/.gradle
@@ -20,7 +22,21 @@ build:
     - ./gradlew --console=plain --no-daemon assemble jar
   artifacts:
     paths:
-      - "/builds/jastadd/ragconnect/build/libs/ragconnect-*.jar"
+      - "/builds/jastadd/ragconnect/ragconnect.base/build/libs/ragconnect-*.jar"
+    expire_in: 1 week
+
+test:
+  image: openjdk:11
+  stage: test
+  services:
+    - name: "eclipse-mosquitto:1.6.9"
+      alias: "mqtt"
+  script:
+    - ./gradlew --console=plain --no-daemon allTests
+  artifacts:
+    reports:
+      junit: "/builds/jastadd/ragconnect/ragconnect.tests/build/test-results/test/TEST-*.xml"
+    expire_in: 1 week
 
 #publish:
 #  image: openjdk:11

ragconnect.base/build.gradle

@@ -46,6 +46,12 @@ try {
     throw new GradleException("File ${versionFile} not found or unreadable. Aborting.", e)
 }
 
+task printVersion() {
+    doLast {
+        println(version)
+    }
+}
+
 task newVersion() {
     doFirst {
         def props = new Properties()
@@ -61,6 +67,9 @@ idea.module.generatedSourceDirs += genSrc
 jar {
     manifest {
         attributes "Main-Class": 'org.jastadd.ragconnect.compiler.Compiler'
+
+        // Log4J + Java 11 compatibility, see https://stackoverflow.com/q/53049346/2493208
+        attributes "Multi-Release": true
     }
 
     from {

ragconnect.base/src/main/jastadd/intermediate/Generation.jadd

@@ -29,6 +29,17 @@ aspect AttributesForMustache {
 
   syn String MEndpointDefinition.connectParameterName() = "uriString";
   syn String MEndpointDefinition.connectMethod() = "connect" + tokenName();
+
+  syn String MEndpointDefinition.disconnectMethod() {
+    // if both (send and receive) are defined for the token, ensure methods with different names
+    String extra = endpointDef().lookupTokenEndpointDefinitions(token()).size() > 1 ? uniqueSuffix() : "";
+    return "disconnect" + extra + tokenName();
+  }
+  //
+  syn String MEndpointDefinition.uniqueSuffix();
+  eq MSendDefinition.uniqueSuffix() = "Send";
+  eq MReceiveDefinition.uniqueSuffix() = "Receive";
+
   syn TokenComponent MEndpointDefinition.token() = endpointDef().getToken();
   syn boolean MEndpointDefinition.alwaysApply() = endpointDef().getAlwaysApply();
   syn String MEndpointDefinition.parentTypeName() = token().containingTypeDecl().getName();

ragconnect.base/src/main/java/org/jastadd/ragconnect/compiler/Compiler.java

@@ -142,8 +142,10 @@ public class Compiler extends AbstractCompiler {
   }
 
   private void printMessage(String message) {
+    if (optionVerbose.value()) {
       System.out.println(message);
     }
+  }
 
   private void writeToFile(Path path, String str) throws CompilerException {
     try (BufferedWriter writer = Files.newBufferedWriter(path)) {

ragconnect.base/src/main/resources/MqttHandler.jadd

@@ -4,6 +4,7 @@ import java.util.concurrent.TimeUnit;
 aspect MqttHandler {
 public class MqttServerHandler {
   private final java.util.Map<String, MqttHandler> handlers = new java.util.HashMap<>();
+  private final java.util.Map<ConnectToken, Object> tokensForRemoval = new java.util.HashMap<>();
   private long time;
   private java.util.concurrent.TimeUnit unit;
   private String name;
@@ -38,8 +39,16 @@ public class MqttServerHandler {
     return handler;
   }
 
-  public boolean newConnection(java.net.URI uri, java.util.function.Consumer<byte[]> callback) throws IOException {
-    return resolveHandler(uri).newConnection(extractTopic(uri), callback);
+  public ConnectToken newConnection(java.net.URI uri, java.util.function.Consumer<byte[]> callback) throws IOException {
+    ConnectToken connectToken = new ConnectToken(uri);
+    resolveHandler(uri).newConnection(extractTopic(uri), callback);
+    tokensForRemoval.put(connectToken, callback);
+    return connectToken;
+  }
+
+  public boolean disconnect(ConnectToken connectToken) throws IOException {
+    MqttHandler handler = resolveHandler(connectToken.uri);
+    return handler != null ? handler.disconnect(extractTopic(connectToken.uri), tokensForRemoval.get(connectToken)) : false;
   }
 
   public void publish(java.net.URI uri, byte[] bytes) throws IOException {
@@ -146,14 +155,16 @@ public class MqttHandler {
       }
 
       @Override
-      public void onPublish(org.fusesource.hawtbuf.UTF8Buffer topic, org.fusesource.hawtbuf.Buffer body, org.fusesource.mqtt.client.Callback<org.fusesource.mqtt.client.Callback<Void>> ack) {
+      public void onPublish(org.fusesource.hawtbuf.UTF8Buffer topic,
+                            org.fusesource.hawtbuf.Buffer body,
+                            org.fusesource.mqtt.client.Callback<org.fusesource.mqtt.client.Callback<Void>> ack) {
+        // this method is called, whenever a MQTT message is received
         String topicString = topic.toString();
         java.util.List<java.util.function.Consumer<byte[]>> callbackList = callbacks.get(topicString);
         if (callbackList == null || callbackList.isEmpty()) {
           logger.debug("Got a message, but no callback to call. Forgot to subscribe?");
         } else {
           byte[] message = body.toByteArray();
-//          System.out.println("message = " + Arrays.toString(message));
           for (java.util.function.Consumer<byte[]> callback : callbackList) {
             callback.accept(message);
           }
@@ -162,13 +173,15 @@ public class MqttHandler {
       }
 
       @Override
-      public void onPublish(org.fusesource.hawtbuf.UTF8Buffer topicBuffer, org.fusesource.hawtbuf.Buffer body, Runnable ack) {
+      public void onPublish(org.fusesource.hawtbuf.UTF8Buffer topicBuffer,
+                            org.fusesource.hawtbuf.Buffer body,
+                            Runnable ack) {
+        // not used by this type of connection
         logger.warn("onPublish should not be called");
       }
 
       @Override
       public void onFailure(Throwable cause) {
-//        logger.catching(cause);
         error.set(cause);
       }
     });
@@ -179,7 +192,11 @@ public class MqttHandler {
       @Override
       public void onSuccess(Void value) {
         if (MqttHandler.this.sendWelcomeMessage) {
-          connection.publish("components", (name + " is connected").getBytes(), org.fusesource.mqtt.client.QoS.AT_LEAST_ONCE, false, new org.fusesource.mqtt.client.Callback<Void>() {
+          connection.publish("components",
+                             (name + " is connected").getBytes(),
+                             org.fusesource.mqtt.client.QoS.AT_LEAST_ONCE,
+                             false,
+                             new org.fusesource.mqtt.client.Callback<Void>() {
             @Override
             public void onSuccess(Void value) {
               logger.debug("success sending welcome message");
@@ -198,7 +215,6 @@ public class MqttHandler {
 
       @Override
       public void onFailure(Throwable cause) {
-//        logger.error("Could not connect", cause);
         error.set(cause);
       }
     });
@@ -228,8 +244,6 @@ public class MqttHandler {
     if (readyLatch.getCount() > 0) {
       System.err.println("Handler not ready");
       return false;
-//      // should maybe be something more kind than throwing an exception here
-//      throw new IllegalStateException("Updater not ready");
     }
     // register callback
     logger.debug("new connection for {}", topic);
@@ -256,6 +270,35 @@ public class MqttHandler {
     return true;
   }
 
+  public boolean disconnect(String topic, Object callback) {
+    java.util.List<java.util.function.Consumer<byte[]>> callbackList = callbacks.get(topic);
+    if (callbackList == null) {
+      logger.warn("Disconnect for not connected topic '{}'", topic);
+      return false;
+    }
+    java.util.concurrent.atomic.AtomicReference<Boolean> success = new java.util.concurrent.atomic.AtomicReference<>();
+    success.set(callbackList.remove(callback));
+    if (callbackList.isEmpty()) {
+      // no callbacks anymore for this topic, unsubscribe from mqtt
+      connection.getDispatchQueue().execute(() -> {
+        org.fusesource.hawtbuf.UTF8Buffer topicBuffer = org.fusesource.hawtbuf.Buffer.utf8(topic);
+        org.fusesource.hawtbuf.UTF8Buffer[] topicArray = new org.fusesource.hawtbuf.UTF8Buffer[]{topicBuffer};
+        connection.unsubscribe(topicArray, new org.fusesource.mqtt.client.Callback<Void>() {
+          @Override
+          public void onSuccess(Void value) {
+            // empty, all good
+          }
+
+          @Override
+          public void onFailure(Throwable cause) {
+            success.set(false);
+          }
+        });
+      });
+    }
+    return success.get();
+  }
+
   /**
    * Waits until this updater is ready to receive MQTT messages.
    * If it already is ready, return immediately with the value <code>true</code>.

ragconnect.base/src/main/resources/RestHandler.jadd

@@ -2,6 +2,7 @@ import java.util.concurrent.TimeUnit;aspect RestHandler {
 public class RestServerHandler {
   private static final int DEFAULT_PORT = 4567;
   private final java.util.Map<Integer, RestHandler> handlers = new java.util.HashMap<>();
+  private final java.util.Map<ConnectToken, Object> tokensForRemoval = new java.util.HashMap<>();
   private String name;
 
   public RestServerHandler() {
@@ -24,14 +25,23 @@ public class RestServerHandler {
     return handler;
   }
 
-  public boolean newPUTConnection(java.net.URI uri, java.util.function.Consumer<String> callback) {
+  public ConnectToken newPUTConnection(java.net.URI uri, java.util.function.Consumer<String> callback) {
+    ConnectToken connectToken = new ConnectToken(uri);
     resolveHandler(uri).newPUTConnection(uri.getPath(), callback);
-    return true;
+    tokensForRemoval.put(connectToken, callback);
+    return connectToken;
   }
 
-  public boolean newGETConnection(java.net.URI uri, SupplierWithException<String> supplier) {
+  public ConnectToken newGETConnection(java.net.URI uri, SupplierWithException<String> supplier) {
+    ConnectToken connectToken = new ConnectToken(uri);
     resolveHandler(uri).newGETConnection(uri.getPath(), supplier);
-    return true;
+    tokensForRemoval.put(connectToken, supplier);
+    return connectToken;
+  }
+
+  public boolean disconnect(ConnectToken connectToken) {
+    RestHandler handler = resolveHandler(connectToken.uri);
+    return handler != null ? handler.disconnect(connectToken.uri.getPath(), tokensForRemoval.get(connectToken)) : false;
   }
 
   public void close() {
@@ -108,6 +118,7 @@ public class RestHandler {
     suppliers.put(path, supplier);
     spark.Spark.get(path, (request, response) -> {
       try {
+        // we could check for null here in case supplier has been disconnected
         return supplier.get();
       } catch (Exception e) {
         return makeError(response, 500, e.getMessage());
@@ -115,6 +126,12 @@ public class RestHandler {
     });
   }
 
+  public boolean disconnect(String path, Object callbackOrSupplier) {
+    // only one will succeed (or false will be returned)
+    return callbacks.getOrDefault(path, java.util.Collections.emptyList()).remove(callbackOrSupplier) ||
+           suppliers.remove(path, callbackOrSupplier);
+  }
+
   private String makeError(spark.Response response, int statusCode, String message) {
     response.status(statusCode);
     return message;

ragconnect.base/src/main/resources/handler.mustache

@@ -14,4 +14,15 @@ aspect RagConnectHandler {
     {{#InUse}}{{FieldName}}.close();{{/InUse}}
     {{/Handlers}}
   }
+  class ConnectToken {
+    static java.util.concurrent.atomic.AtomicLong counter = new java.util.concurrent.atomic.AtomicLong(0);
+    final long id;
+    final java.net.URI uri;
+    public ConnectToken(java.net.URI uri) {
+      this.id = counter.incrementAndGet();
+      this.uri = uri;
+    }
+
+  }
+  static java.util.Map<ASTNode, java.util.Map<java.net.URI, ConnectToken>> ASTNode.connectTokens = new java.util.HashMap<>();
 }

ragconnect.base/src/main/resources/ragConnectVersion.properties

-#Fri Jan 15 11:45:51 CET 2021
-version=0.2.4
+#Tue Jan 19 12:08:02 CET 2021
+version=0.2.5

ragconnect.base/src/main/resources/receiveDefinition.mustache

@@ -7,17 +7,46 @@ public boolean {{parentTypeName}}.{{connectMethod}}(String {{connectParameterNam
     {{/loggingEnabledForReads}}
     set{{tokenName}}({{lastResult}});
   };
+  ConnectToken connectToken;
   switch (scheme) {
   {{#usesMqtt}}
-    case "mqtt": return {{mqttHandlerAttribute}}().newConnection(uri, consumer);
+    case "mqtt":
+      connectToken = {{mqttHandlerAttribute}}().newConnection(uri, consumer);
+      if (connectToken == null) {
+        return false;
+      }
+      break;
   {{/usesMqtt}}
   {{#usesJava}}
     case "java": return {{javaHandlerAttribute}}().registerCallback(path, consumer);
   {{/usesJava}}
   {{#usesRest}}
-    case "rest": return {{restHandlerAttribute}}().newPUTConnection(uri, input -> {
+    case "rest":
+      connectToken = {{restHandlerAttribute}}().newPUTConnection(uri, input -> {
         consumer.accept(input.getBytes());
       });
+      if (connectToken == null) {
+        return false;
+      }
+      break;
+  {{/usesRest}}
+    default:
+      System.err.println("Unknown protocol '" + scheme + "'.");
+      return false;
+  }
+  connectTokens.computeIfAbsent(this, astNode -> new java.util.HashMap<java.net.URI, ConnectToken>())
+               .put(uri, connectToken);
+  return true;
+}
+
+public boolean {{parentTypeName}}.{{disconnectMethod}}(String {{connectParameterName}}) throws java.io.IOException {
+  {{>handleUri}}
+  switch (scheme) {
+  {{#usesMqtt}}
+    case "mqtt": return {{mqttHandlerAttribute}}().disconnect(connectTokens.get(this).get(uri));
+  {{/usesMqtt}}
+  {{#usesRest}}
+    case "rest": return {{restHandlerAttribute}}().disconnect(connectTokens.get(this).get(uri));
   {{/usesRest}}
     default:
       System.err.println("Unknown protocol '" + scheme + "'.");

ragconnect.base/src/main/resources/sendDefinition.mustache

@@ -35,10 +35,36 @@ public boolean {{parentTypeName}}.{{connectMethod}}(String {{connectParameterNam
   {{/usesJava}}
   {{#usesRest}}
     case "rest":
-      {{restHandlerAttribute}}().newGETConnection(uri, () -> {
+      ConnectToken connectToken = {{restHandlerAttribute}}().newGETConnection(uri, () -> {
         {{updateMethod}}();
         return new String({{lastValue}});
       });
+      if (connectToken == null) {
+        return false;
+      }
+      connectTokens.computeIfAbsent(this, astNode -> new java.util.HashMap<java.net.URI, ConnectToken>())
+                   .put(uri, connectToken);
+      break;
+  {{/usesRest}}
+    default:
+      System.err.println("Unknown protocol '" + scheme + "'.");
+      return false;
+  }
+  return true;
+}
+
+public boolean {{parentTypeName}}.{{disconnectMethod}}(String {{connectParameterName}}) throws java.io.IOException {
+  {{>handleUri}}
+  switch (scheme) {
+  {{#usesMqtt}}
+    case "mqtt":
+      {{sender}} = null;
+      {{lastValue}} = null;
+      break;
+  {{/usesMqtt}}
+  {{#usesRest}}
+    case "rest":
+      {{restHandlerAttribute}}().disconnect(connectTokens.get(this).get(uri));
       break;
   {{/usesRest}}
     default:

ragconnect.tests/.gitignore

+build
+src/gen-res/
+src/gen/
+out/
+*.class

ragconnect.tests/build.gradle

+buildscript {
+    repositories.mavenCentral()
+    dependencies {
+        classpath 'org.jastadd:jastaddgradle:1.13.3'
+        classpath fileTree(include: ['buildSrc.jar'], dir: '../libs')
+    }
+}
+
+import org.jastadd.relast.plugin.RelastPlugin
+import org.jastadd.relast.plugin.RelastTest
+
+plugins {
+    id 'java'
+    id 'java-library'
+    id 'idea'
+    id 'com.github.ben-manes.versions' version '0.36.0'
+    id 'com.google.protobuf' version "0.8.14"
+}
+
+apply plugin: 'jastadd'
+apply plugin: RelastPlugin
+
+group = 'de.tudresden.inf.st'
+
+repositories {
+    mavenCentral()
+    jcenter()
+}
+
+dependencies {
+    implementation project(':ragconnect.base')
+
+    runtime group: 'org.jastadd', name: 'jastadd', version: '2.3.4'
+    testImplementation group: 'org.junit.jupiter', name: 'junit-jupiter-api', version: '5.4.0'
+    testRuntimeOnly group: 'org.junit.jupiter', name: 'junit-jupiter-engine', version: '5.4.0'
+    testImplementation group: 'org.assertj', name: 'assertj-core', version: '3.12.1'
+
+    // mqtt
+    testImplementation group: 'org.fusesource.mqtt-client', name: 'mqtt-client', version: '1.15'
+
+    // rest and client
+    testImplementation group: 'com.sparkjava', name: 'spark-core', version: '2.9.2'
+    testImplementation group: 'org.apache.logging.log4j', name: 'log4j-slf4j-impl', version: '2.11.2'
+    testImplementation group: 'org.glassfish.jersey.core', name: 'jersey-client', version: '2.31'
+    testImplementation group: 'org.glassfish.jersey.inject', name: 'jersey-hk2', version: '2.31'
+
+    testImplementation group: 'net.sf.beaver', name: 'beaver-rt', version: '0.9.11'
+    api group: 'com.google.protobuf', name: 'protobuf-java', version: '3.0.0'
+}
+
+test {
+    useJUnitPlatform {
+        excludeTags 'mqtt'
+    }
+
+    maxHeapSize = '1G'
+}
+
+protobuf {
+    protoc {
+        // The artifact spec for the Protobuf Compiler
+        artifact = 'com.google.protobuf:protoc:3.0.0'
+    }
+}
+
+task allTests(type: Test, dependsOn: testClasses) {
+    description = 'Run every test'
+    group = 'verification'
+
+    useJUnitPlatform {
+        includeTags 'mqtt'
+    }
+}
+
+relastTest {
+    //noinspection GroovyAssignabilityCheck
+    compilerLocation = '../libs/relast.jar'
+}
+
+File genSrc = file("src/test/java-gen")
+sourceSets.test.java.srcDir genSrc
+idea.module.generatedSourceDirs += genSrc
+
+clean {
+    delete 'src/test/02-after-ragconnect/*/', 'src/test/03-after-relast/*/', 'src/test/java-gen/*/'
+}
+
+// --- Test: Example ---
+task preprocessExampleTest(type: JavaExec, group: 'verification') {
+    doFirst {
+        delete 'src/test/02-after-ragconnect/example/Test.relast',
+                'src/test/02-after-ragconnect/example/MqttHandler.jadd',
+                'src/test/02-after-ragconnect/example/RagConnect.jadd'
+    }
+
+    classpath = sourceSets.main.runtimeClasspath
+    main = 'org.jastadd.ragconnect.compiler.Compiler'
+    args '--o=src/test/02-after-ragconnect/example',
+            'src/test/01-input/example/Test.relast',
+            'src/test/01-input/example/Test.connect',
+            '--rootNode=Model',
+            '--logReads', '--logWrites', '--protocols=mqtt'
+}
+
+task compileExampleTest(type: RelastTest) {
+    useJastAddNames = true
+    jastAddList = 'JastAddList'
+    relastFiles 'src/test/02-after-ragconnect/example/Test.relast',
+            'src/test/02-after-ragconnect/example/RagConnect.relast'
+    grammarName = 'src/test/03-after-relast/example/example'
+    packageName = 'example.ast'
+    moreInputFiles 'src/test/01-input/example/Test.jadd',
+            'src/test/02-after-ragconnect/example/MqttHandler.jadd',
+            'src/test/02-after-ragconnect/example/RagConnect.jadd'
+}
+
+compileTestJava.dependsOn compileExampleTest
+compileExampleTest.dependsOn preprocessExampleTest
+
+// --- Test: default-only-read ---
+task preprocessDefaultOnlyReadTest(type: JavaExec, group: 'verification') {
+    doFirst {
+        delete 'src/test/02-after-ragconnect/defaultOnlyRead/Test.relast',
+                'src/test/02-after-ragconnect/defaultOnlyRead/MqttHandler.jadd',
+                'src/test/02-after-ragconnect/defaultOnlyRead/RagConnect.jadd'
+    }
+
+    classpath = sourceSets.main.runtimeClasspath
+    main = 'org.jastadd.ragconnect.compiler.Compiler'
+    args '--o=src/test/02-after-ragconnect/defaultOnlyRead',
+            'src/test/01-input/defaultOnlyRead/Test.relast',
+            'src/test/01-input/defaultOnlyRead/Test.connect',
+            '--rootNode=A', '--protocols=mqtt'
+}
+
+task compileDefaultOnlyReadTest(type: RelastTest) {
+    useJastAddNames = true
+    jastAddList = 'JastAddList'
+    relastFiles 'src/test/02-after-ragconnect/defaultOnlyRead/Test.relast',
+            'src/test/02-after-ragconnect/defaultOnlyRead/RagConnect.relast'
+    grammarName = 'src/test/03-after-relast/defaultOnlyRead/defaultOnlyRead'
+    packageName = 'defaultOnlyRead.ast'
+    moreInputFiles 'src/test/02-after-ragconnect/defaultOnlyRead/MqttHandler.jadd',
+            'src/test/02-after-ragconnect/defaultOnlyRead/RagConnect.jadd'
+}
+
+compileTestJava.dependsOn compileDefaultOnlyReadTest
+compileDefaultOnlyReadTest.dependsOn preprocessDefaultOnlyReadTest
+
+// --- Test: default-only-write ---
+task preprocessDefaultOnlyWriteTest(type: JavaExec, group: 'verification') {
+    doFirst {
+        delete 'src/test/02-after-ragconnect/defaultOnlyWrite/Test.relast',
+                'src/test/02-after-ragconnect/defaultOnlyWrite/MqttHandler.jadd',
+                'src/test/02-after-ragconnect/defaultOnlyWrite/RagConnect.jadd'
+    }
+
+    classpath = sourceSets.main.runtimeClasspath
+    main = 'org.jastadd.ragconnect.compiler.Compiler'
+    args '--o=src/test/02-after-ragconnect/defaultOnlyWrite',
+            'src/test/01-input/defaultOnlyWrite/Test.relast',
+            'src/test/01-input/defaultOnlyWrite/Test.connect',
+            '--rootNode=A', '--protocols=mqtt'
+}
+
+task compileDefaultOnlyWriteTest(type: RelastTest) {
+    useJastAddNames = true
+    jastAddList = 'JastAddList'
+    relastFiles 'src/test/02-after-ragconnect/defaultOnlyWrite/Test.relast',
+            'src/test/02-after-ragconnect/defaultOnlyWrite/RagConnect.relast'
+    grammarName = 'src/test/03-after-relast/defaultOnlyWrite/defaultOnlyWrite'
+    packageName = 'defaultOnlyWrite.ast'
+    moreInputFiles 'src/test/01-input/defaultOnlyWrite/Test.jadd',
+            'src/test/02-after-ragconnect/defaultOnlyWrite/MqttHandler.jadd',
+            'src/test/02-after-ragconnect/defaultOnlyWrite/RagConnect.jadd'
+}
+
+compileTestJava.dependsOn compileDefaultOnlyWriteTest
+compileDefaultOnlyWriteTest.dependsOn preprocessDefaultOnlyWriteTest
+
+// --- Test: read1write2 ---
+task preprocessRead1Write2Test(type: JavaExec, group: 'verification') {
+    doFirst {
+        delete 'src/test/02-after-ragconnect/read1write2/Test.relast',
+                'src/test/02-after-ragconnect/read1write2/MqttHandler.jadd',
+                'src/test/02-after-ragconnect/read1write2/RagConnect.jadd'
+    }
+
+    classpath = sourceSets.main.runtimeClasspath
+    main = 'org.jastadd.ragconnect.compiler.Compiler'
+    args '--o=src/test/02-after-ragconnect/read1write2',
+            'src/test/01-input/read1write2/Test.relast',
+            'src/test/01-input/read1write2/Test.connect',
+            '--rootNode=A', '--protocols=mqtt'
+}
+
+task compileRead1Write2Test(type: RelastTest) {
+    useJastAddNames = true
+    jastAddList = 'JastAddList'
+    relastFiles 'src/test/02-after-ragconnect/read1write2/Test.relast',
+            'src/test/02-after-ragconnect/read1write2/RagConnect.relast'
+    grammarName = 'src/test/03-after-relast/read1write2/read1write2'
+    packageName = 'read1write2.ast'
+    moreInputFiles 'src/test/01-input/read1write2/Test.jadd',
+            'src/test/02-after-ragconnect/read1write2/MqttHandler.jadd',
+            'src/test/02-after-ragconnect/read1write2/RagConnect.jadd'
+}
+
+compileTestJava.dependsOn compileRead1Write2Test
+compileRead1Write2Test.dependsOn preprocessRead1Write2Test
+
+// --- Test: read2write1 ---
+task preprocessRead2Write1Test(type: JavaExec, group: 'verification') {
+    doFirst {
+        delete 'src/test/02-after-ragconnect/read2write1/Test.relast',
+                'src/test/02-after-ragconnect/read2write1/MqttHandler.jadd',
+                'src/test/02-after-ragconnect/read2write1/RagConnect.jadd'
+    }
+
+    classpath = sourceSets.main.runtimeClasspath
+    main = 'org.jastadd.ragconnect.compiler.Compiler'
+    args '--o=src/test/02-after-ragconnect/read2write1',
+            'src/test/01-input/read2write1/Test.relast',
+            'src/test/01-input/read2write1/Test.connect',
+            '--rootNode=A', '--protocols=mqtt'
+}
+
+task compileRead2Write1Test(type: RelastTest) {
+    useJastAddNames = true
+    jastAddList = 'JastAddList'
+    relastFiles 'src/test/02-after-ragconnect/read2write1/Test.relast',
+            'src/test/02-after-ragconnect/read2write1/RagConnect.relast'
+    grammarName = 'src/test/03-after-relast/read2write1/read2write1'
+    packageName = 'read2write1.ast'
+    moreInputFiles 'src/test/01-input/read2write1/Test.jadd',
+            'src/test/02-after-ragconnect/read2write1/MqttHandler.jadd',
+            'src/test/02-after-ragconnect/read2write1/RagConnect.jadd'
+}
+
+compileTestJava.dependsOn compileRead2Write1Test
+compileRead2Write1Test.dependsOn preprocessRead2Write1Test
+
+// --- Test: via ---
+task preprocessViaTest(type: JavaExec, group: 'verification') {
+    doFirst {
+        delete 'src/test/02-after-ragconnect/via/Test.relast',
+                'src/test/02-after-ragconnect/via/MqttHandler.jadd',
+                'src/test/02-after-ragconnect/via/RestHandler.jadd',
+                'src/test/02-after-ragconnect/via/RagConnect.jadd'
+    }
+
+    classpath = sourceSets.main.runtimeClasspath
+    main = 'org.jastadd.ragconnect.compiler.Compiler'
+    args '--o=src/test/02-after-ragconnect/via',
+            'src/test/01-input/via/Test.relast',
+            'src/test/01-input/via/Test.connect',
+            '--rootNode=A',
+            '--protocols=mqtt,rest'
+}
+
+task compileViaTest(type: RelastTest) {
+    useJastAddNames = true
+    jastAddList = 'JastAddList'
+    relastFiles 'src/test/02-after-ragconnect/via/Test.relast',
+            'src/test/02-after-ragconnect/via/RagConnect.relast'
+    grammarName = 'src/test/03-after-relast/via/via'
+    packageName = 'via.ast'
+    moreInputFiles 'src/test/01-input/via/Test.jadd',
+            'src/test/02-after-ragconnect/via/MqttHandler.jadd',
+            'src/test/02-after-ragconnect/via/RestHandler.jadd',
+            'src/test/02-after-ragconnect/via/RagConnect.jadd'
+}
+
+compileTestJava.dependsOn compileViaTest
+compileViaTest.dependsOn preprocessViaTest
+
+// --- Test: token-value-send ---
+task preprocessTokenValueSendTest(type: JavaExec, group: 'verification') {
+    doFirst {
+        delete 'src/test/02-after-ragconnect/tokenValueSend/Test.relast',
+                'src/test/02-after-ragconnect/tokenValueSend/MqttHandler.jadd',
+                'src/test/02-after-ragconnect/tokenValueSend/RestHandler.jadd',
+                'src/test/02-after-ragconnect/tokenValueSend/RagConnect.jadd'
+    }
+
+    classpath = sourceSets.main.runtimeClasspath
+    main = 'org.jastadd.ragconnect.compiler.Compiler'
+    args '--o=src/test/02-after-ragconnect/tokenValueSend',
+            'src/test/01-input/tokenValueSend/Test.relast',
+            'src/test/01-input/tokenValueSend/Test.connect',
+            '--rootNode=A',
+            '--protocols=mqtt'
+}
+
+task compileTokenValueSendTest(type: RelastTest) {
+    useJastAddNames = true
+    jastAddList = 'JastAddList'
+    relastFiles 'src/test/02-after-ragconnect/tokenValueSend/Test.relast',
+            'src/test/02-after-ragconnect/tokenValueSend/RagConnect.relast'
+    grammarName = 'src/test/03-after-relast/tokenValueSend/tokenValueSend'
+    packageName = 'tokenValueSend.ast'
+    moreInputFiles 'src/test/01-input/tokenValueSend/Test.jadd',
+            'src/test/02-after-ragconnect/tokenValueSend/MqttHandler.jadd',
+            'src/test/02-after-ragconnect/tokenValueSend/RagConnect.jadd'
+}
+
+compileTestJava.dependsOn compileTokenValueSendTest
+compileTokenValueSendTest.dependsOn preprocessTokenValueSendTest
+
+// --- Test: tutorial ---
+task preprocessTutorialTest(type: JavaExec, group: 'verification') {
+    doFirst {
+        delete 'src/test/02-after-ragconnect/tutorial/Test.relast',
+                'src/test/02-after-ragconnect/tutorial/MqttHandler.jadd',
+                'src/test/02-after-ragconnect/tutorial/RagConnect.jadd'
+    }
+
+    classpath = sourceSets.main.runtimeClasspath
+    main = 'org.jastadd.ragconnect.compiler.Compiler'
+    args '--o=src/test/02-after-ragconnect/tutorial',
+            'src/test/01-input/tutorial/Test.relast',
+            'src/test/01-input/tutorial/Test.connect',
+            '--rootNode=A',
+            '--protocols=mqtt'
+}
+
+task compileTutorialTest(type: RelastTest) {
+    useJastAddNames = true
+    jastAddList = 'JastAddList'
+    relastFiles 'src/test/02-after-ragconnect/tutorial/Test.relast',
+            'src/test/02-after-ragconnect/tutorial/RagConnect.relast'
+    grammarName = 'src/test/03-after-relast/tutorial/tutorial'
+    packageName = 'tutorial.ast'
+    moreInputFiles 'src/test/01-input/tutorial/Test.jadd',
+            'src/test/02-after-ragconnect/tutorial/MqttHandler.jadd',
+            'src/test/02-after-ragconnect/tutorial/RagConnect.jadd'
+}
+
+compileTestJava.dependsOn compileTutorialTest
+compileTutorialTest.dependsOn preprocessTutorialTest

ragconnect.tests/src/test/01-input/defaultOnlyRead/README.md

+# Default Only Read
+
+Idea: Use only `ReadFromMqttDefinition`, test all default mapping definitions from `byte[]` to primitive (and boxed) types

ragconnect.tests/src/test/01-input/defaultOnlyRead/Test.connect

+// --- update definitions ---
+receive NativeTypes.IntValue;
+receive NativeTypes.ShortValue;
+receive NativeTypes.LongValue;
+receive NativeTypes.FloatValue;
+receive NativeTypes.DoubleValue;
+receive NativeTypes.CharValue;
+receive NativeTypes.StringValue;
+
+receive BoxedTypes.IntValue;
+receive BoxedTypes.ShortValue;
+receive BoxedTypes.LongValue;
+receive BoxedTypes.FloatValue;
+receive BoxedTypes.DoubleValue;
+receive BoxedTypes.CharValue;

ragconnect.tests/src/test/01-input/defaultOnlyRead/Test.relast

+A ::= NativeTypes* BoxedTypes* ;
+NativeTypes ::= <IntValue:int> <ShortValue:short> <LongValue:long> <FloatValue:float> <DoubleValue:double> <CharValue:char> <StringValue:String> ;
+BoxedTypes ::= <IntValue:Integer> <ShortValue:Short> <LongValue:Long> <FloatValue:Float> <DoubleValue:Double> <CharValue:Character> ;

ragconnect.tests/src/test/01-input/defaultOnlyWrite/README.md

+# Default Only Write
+
+Idea: Use only `WriteToMqttDefintion`, test all default mapping definitions from primitive (and boxed) types to `byte[]`.

ragconnect.tests/src/test/01-input/defaultOnlyWrite/Test.connect

+// --- update definitions ---
+// native types, synthesized
+send NativeTypesSyn.IntValue;
+send NativeTypesSyn.ShortValue;
+send NativeTypesSyn.LongValue;
+send NativeTypesSyn.FloatValue;
+send NativeTypesSyn.DoubleValue;
+send NativeTypesSyn.CharValue;
+send NativeTypesSyn.StringValue;
+
+// boxed types, synthesized
+send BoxedTypesSyn.IntValue;
+send BoxedTypesSyn.ShortValue;
+send BoxedTypesSyn.LongValue;
+send BoxedTypesSyn.FloatValue;
+send BoxedTypesSyn.DoubleValue;
+send BoxedTypesSyn.CharValue;
+
+// --- dependency definitions ---
+NativeTypesSyn.IntValue canDependOn NativeTypesSyn.DriverSyn as nativeIntDependency;
+NativeTypesSyn.ShortValue canDependOn NativeTypesSyn.DriverSyn as nativeShortDependency;
+NativeTypesSyn.LongValue canDependOn NativeTypesSyn.DriverSyn as nativeLongDependency;
+NativeTypesSyn.FloatValue canDependOn NativeTypesSyn.DriverSyn as nativeFloatDependency;
+NativeTypesSyn.DoubleValue canDependOn NativeTypesSyn.DriverSyn as nativeDoubleDependency;
+NativeTypesSyn.CharValue canDependOn NativeTypesSyn.DriverSyn as nativeCharDependency;
+NativeTypesSyn.StringValue canDependOn NativeTypesSyn.DriverSyn as nativeStringDependency;
+BoxedTypesSyn.IntValue canDependOn BoxedTypesSyn.DriverSyn as boxedIntDependency;
+BoxedTypesSyn.ShortValue canDependOn BoxedTypesSyn.DriverSyn as boxedShortDependency;
+BoxedTypesSyn.LongValue canDependOn BoxedTypesSyn.DriverSyn as boxedLongDependency;
+BoxedTypesSyn.FloatValue canDependOn BoxedTypesSyn.DriverSyn as boxedFloatDependency;
+BoxedTypesSyn.DoubleValue canDependOn BoxedTypesSyn.DriverSyn as boxedDoubleDependency;
+BoxedTypesSyn.CharValue canDependOn BoxedTypesSyn.DriverSyn as boxedCharDependency;
+
+
+// --- inherited attributes not supported ---
+//// native types, inherited
+//send NativeTypesInh.IntValue;
+//send NativeTypesInh.ShortValue;
+//send NativeTypesInh.LongValue;
+//send NativeTypesInh.FloatValue;
+//send NativeTypesInh.DoubleValue;
+//send NativeTypesInh.CharValue;
+//send NativeTypesInh.StringValue;
+//
+//// boxed types, inherited
+//send BoxedTypesInh.IntValue;
+//send BoxedTypesInh.ShortValue;
+//send BoxedTypesInh.LongValue;
+//send BoxedTypesInh.FloatValue;
+//send BoxedTypesInh.DoubleValue;
+//send BoxedTypesInh.CharValue;

ragconnect.tests/src/test/01-input/defaultOnlyWrite/Test.jadd

+aspect Computation {
+  // native types, synthesized
+  syn int NativeTypesSyn.getIntValue() = Integer.parseInt(getDriverSyn());
+  syn short NativeTypesSyn.getShortValue() = Short.parseShort(getDriverSyn());
+  syn long NativeTypesSyn.getLongValue() = Long.parseLong(getDriverSyn());
+  syn float NativeTypesSyn.getFloatValue() = Float.parseFloat(getDriverSyn());
+  syn double NativeTypesSyn.getDoubleValue() = Double.parseDouble(getDriverSyn());
+  syn char NativeTypesSyn.getCharValue() = getDriverSyn().charAt(0);
+  syn String NativeTypesSyn.getStringValue() = new String(getDriverSyn());
+
+  // boxed types, synthesized
+  syn Integer BoxedTypesSyn.getIntValue() = Integer.valueOf(getDriverSyn());
+  syn Short BoxedTypesSyn.getShortValue() = Short.valueOf(getDriverSyn());
+  syn Long BoxedTypesSyn.getLongValue() = Long.valueOf(getDriverSyn());
+  syn Float BoxedTypesSyn.getFloatValue() = Float.valueOf(getDriverSyn());
+  syn Double BoxedTypesSyn.getDoubleValue() = Double.valueOf(getDriverSyn());
+  syn Character BoxedTypesSyn.getCharValue() = getDriverSyn().charAt(0);
+
+// --- inherited attributes not supported ---
+//  // native types, inherited
+//  inh int NativeTypesInh.getIntValue();
+//  eq A.getNativeTypesInh().getIntValue() = Integer.parseInt(getDriverInh());
+//  inh short NativeTypesInh.getShortValue();
+//  eq A.getNativeTypesInh().getShortValue() = Short.parseShort(getDriverInh());
+//  inh long NativeTypesInh.getLongValue();
+//  eq A.getNativeTypesInh().getLongValue() = Long.parseLong(getDriverInh());
+//  inh float NativeTypesInh.getFloatValue();
+//  eq A.getNativeTypesInh().getFloatValue() = Float.parseFloat(getDriverInh());
+//  inh double NativeTypesInh.getDoubleValue();
+//  eq A.getNativeTypesInh().getDoubleValue() = Double.parseDouble(getDriverInh());
+//  inh char NativeTypesInh.getCharValue();
+//  eq A.getNativeTypesInh().getCharValue() = getDriverInh().charAt(0);
+//  inh String NativeTypesInh.getStringValue();
+//  eq A.getNativeTypesInh().getStringValue() = new String(getDriverInh());
+//
+//  // boxed types, inherited
+//  inh Integer BoxedTypesInh.getIntValue();
+//  eq A.getBoxedTypesInh().getIntValue() = Integer.valueOf(getDriverInh());
+//  inh Short BoxedTypesInh.getShortValue();
+//  eq A.getBoxedTypesInh().getShortValue() = Short.valueOf(getDriverInh());
+//  inh Long BoxedTypesInh.getLongValue();
+//  eq A.getBoxedTypesInh().getLongValue() = Long.valueOf(getDriverInh());
+//  inh Float BoxedTypesInh.getFloatValue();
+//  eq A.getBoxedTypesInh().getFloatValue() = Float.valueOf(getDriverInh());
+//  inh Double BoxedTypesInh.getDoubleValue();
+//  eq A.getBoxedTypesInh().getDoubleValue() = Double.valueOf(getDriverInh());
+//  inh Character BoxedTypesInh.getCharValue();
+//  eq A.getBoxedTypesInh().getCharValue() = getDriverInh().charAt(0);
+}

ragconnect.tests/src/test/01-input/defaultOnlyWrite/Test.relast

+A ::= NativeTypesSyn* BoxedTypesSyn* <DriverInh:String>;
+// native types, synthesized
+NativeTypesSyn ::= <DriverSyn:String> /<IntValue:int>/ /<ShortValue:short>/ /<LongValue:long>/ /<FloatValue:float>/ /<DoubleValue:double>/ /<CharValue:char>/ /<StringValue:String>/ ;
+// boxed types, synthesized
+BoxedTypesSyn ::= <DriverSyn:String> /<IntValue:Integer>/ /<ShortValue:Short>/ /<LongValue:Long>/ /<FloatValue:Float>/ /<DoubleValue:Double>/ /<CharValue:Character>/ ;
+
+// --- inherited attributes not supported ---
+//// native types, inherited
+//NativeTypesInh ::= /<IntValue:int>/ /<ShortValue:short>/ /<LongValue:long>/ /<FloatValue:float>/ /<DoubleValue:double>/ /<CharValue:char>/ /<StringValue:String>/ ;
+//// boxed types, inherited
+//BoxedTypesInh ::= /<IntValue:Integer>/ /<ShortValue:Short>/ /<LongValue:Long>/ /<FloatValue:Float>/ /<DoubleValue:Double>/ /<CharValue:Character>/ ;