Add tests to this repo again.

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

+// --- update definitions ---
+// OnSameNonterminal
+receive OnSameNonterminal.Input;
+send OnSameNonterminal.OutInteger;
+send OnSameNonterminal.OutString;
+
+// OnDifferentNonterminal
+receive OnDifferentNonterminal.Input;
+send TheOther.OutInteger;
+send TheOther.OutString;
+
+// --- dependency definitions ---
+// OnSameNonterminal
+OnSameNonterminal.OutInteger canDependOn OnSameNonterminal.Input as IntDependency;
+OnSameNonterminal.OutString canDependOn OnSameNonterminal.Input as StringDependency;
+// OnDifferentNonterminal
+TheOther.OutInteger canDependOn OnDifferentNonterminal.Input as IntDependency;
+TheOther.OutString canDependOn OnDifferentNonterminal.Input as StringDependency;

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

+aspect Computation{
+  // OnSameNonterminal
+  syn int OnSameNonterminal.getOutInteger() = Integer.parseInt(getInput());
+  syn String OnSameNonterminal.getOutString() = "prefix" + getInput();
+
+  // OnDifferentNonterminal
+  syn int TheOther.getOutInteger() = Integer.parseInt(input());
+  syn String TheOther.getOutString() = "prefix" + input();
+  inh String TheOther.input();
+  eq OnDifferentNonterminal.getTheOther().input() = getInput();
+}

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

+A ::= OnSameNonterminal OnDifferentNonterminal ;
+OnSameNonterminal ::= <Input:String> /<OutInteger:int>/ /<OutString:String>/ ;
+OnDifferentNonterminal ::= <Input:String> TheOther* ;
+TheOther ::= /<OutInteger:int>/ /<OutString:String>/ ;

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

+// --- update definitions ---
+// OnSameNonterminal
+receive OnSameNonterminal.Input1;
+receive OnSameNonterminal.Input2;
+send OnSameNonterminal.OutInteger;
+
+// OnDifferentNonterminal
+receive OnDifferentNonterminal.Input1;
+receive OnDifferentNonterminal.Input2;
+send TheOther.OutInteger;
+
+// --- dependency definitions ---
+// OnSameNonterminal
+OnSameNonterminal.OutInteger canDependOn OnSameNonterminal.Input1 as Int1Dependency;
+OnSameNonterminal.OutInteger canDependOn OnSameNonterminal.Input2 as Int2Dependency;
+// OnDifferentNonterminal
+TheOther.OutInteger canDependOn OnDifferentNonterminal.Input1 as Int1Dependency;
+TheOther.OutInteger canDependOn OnDifferentNonterminal.Input2 as Int2Dependency;

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

+aspect Computation{
+  // OnSameNonterminal
+  syn int OnSameNonterminal.getOutInteger() = Integer.parseInt(getInput1() + getInput2());
+
+  // OnDifferentNonterminal
+  syn int TheOther.getOutInteger() = Integer.parseInt(input1() + input2());
+  inh String TheOther.input1();
+  eq OnDifferentNonterminal.getTheOther().input1() = getInput1();
+  inh String TheOther.input2();
+  eq OnDifferentNonterminal.getTheOther().input2() = getInput2();
+}

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

+A ::= OnSameNonterminal OnDifferentNonterminal ;
+OnSameNonterminal ::= <Input1:String> <Input2:String> /<OutInteger:int>/ ;
+OnDifferentNonterminal ::= <Input1:String> <Input2:String> TheOther* ;
+TheOther ::= /<OutInteger:int>/ ;

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

+# Token Value Send
+
+Idea: 1) Test normal token send, 2) Test combined receive and send on same token, 3) Test combined receive, send and a dependency

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

+// OnlySend
+send OnlySend.Value using AddPostfix ;
+
+// ReceiveAndSend
+receive ReceiveAndSend.Value using AddPrefix ;
+send ReceiveAndSend.Value using AddPostfix ;
+
+// ReceiveSendAndDepend
+receive ReceiveSendAndDepend.Value using AddPrefix ;
+send ReceiveSendAndDepend.Value using AddPostfix ;
+send ReceiveSendAndDepend.OtherOutput using AddPostfix ;
+
+ReceiveSendAndDepend.OtherOutput canDependOn ReceiveSendAndDepend.Value as dependency1 ;
+
+AddPrefix maps String s to String {:
+  System.out.println("receive " + s);
+  return "Pre-" + s;
+:}
+
+AddPostfix maps String s to String {:
+  System.out.println("send " + s);
+  return s + "-Post";
+:}

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

+aspect Computation{
+  // ReceiveSendAndDepend
+  syn String ReceiveSendAndDepend.getOtherOutput() = getValue() + "-T";
+}

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

+A ::= OnlySend ReceiveAndSend ReceiveSendAndDepend ;
+OnlySend ::= <Value:String> ;
+ReceiveAndSend ::= <Value:String> ;
+ReceiveSendAndDepend ::= <Value:String> /<OtherOutput:String>/ ;

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

+# Tutorial
+
+Idea: Test the example from the [documentation](https://jastadd.pages.st.inf.tu-dresden.de/ragconnect/using.html)

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

+// endpoint definitions
+receive A.Input ;
+send A.OutputOnA ;
+send B.OutputOnB using Transformation ;
+
+// mapping definitions
+Transformation maps String s to String {:
+  return s + "postfix";
+:}
+
+// dependency definitions
+A.OutputOnA canDependOn A.Input as dependencyA ;
+B.OutputOnB canDependOn A.Input as dependencyB ;

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

+aspect Computation {
+  syn String A.getOutputOnA() = "a" + getInput();
+
+  syn String B.getOutputOnB() = "b" + input();
+  inh String B.input();
+  eq A.getB().input() = getInput();
+}

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

+A ::= <Input:String> /<OutputOnA:String>/ B* ;
+B ::= /<OutputOnB:String>/ ;

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

+receive A.Mqtt2MqttInput using MarkMqttInput ;
+receive A.Rest2RestInput using MarkRestInput ;
+receive A.Mqtt2RestInput using MarkMqttInput ;
+receive A.Rest2MqttInput using MarkRestInput ;
+receive A.Both2BothInput ;
+
+send A.Mqtt2MqttOutput using MarkMqttOutput ;
+send A.Rest2RestOutput using MarkRestOutput ;
+send A.Mqtt2RestOutput using MarkRestOutput ;
+send A.Rest2MqttOutput using MarkMqttOutput ;
+send A.Both2RestOutput using MarkRestOutput ;
+send A.Both2MqttOutput using MarkMqttOutput ;
+
+A.Mqtt2MqttOutput canDependOn A.Mqtt2MqttInput as dependencyMqtt2Mqtt ;
+A.Rest2RestOutput canDependOn A.Rest2RestInput as dependencyRest2Rest ;
+A.Mqtt2RestOutput canDependOn A.Mqtt2RestInput as dependencyMqtt2Rest ;
+A.Rest2MqttOutput canDependOn A.Rest2MqttInput as dependencyRest2Mqtt ;
+A.Both2RestOutput canDependOn A.Both2BothInput as dependencyBoth2Rest ;
+A.Both2MqttOutput canDependOn A.Both2BothInput as dependencyBoth2Mqtt ;
+
+MarkMqttInput maps String s to String {:
+  return "FromMqtt-" + s;
+:}
+MarkRestInput maps String s to String {:
+  return "FromRest-" + s;
+:}
+
+MarkMqttOutput maps String s to String {:
+  return s + "-ToMqtt";
+:}
+MarkRestOutput maps String s to String {:
+  return s + "-ToRest";
+:}

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

+aspect Computation {
+  syn lazy String A.getMqtt2MqttOutput() = getMqtt2MqttInput() + "-M2M" ;
+  syn lazy String A.getRest2RestOutput() = getRest2RestInput() + "-R2R" ;
+  syn lazy String A.getMqtt2RestOutput() = getMqtt2RestInput() + "-M2R" ;
+  syn lazy String A.getRest2MqttOutput() = getRest2MqttInput() + "-R2M" ;
+  syn lazy String A.getBoth2MqttOutput() = getBoth2BothInput() + "-B2M" ;
+  syn lazy String A.getBoth2RestOutput() = getBoth2BothInput() + "-B2R" ;
+}

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

+A ::= <Mqtt2MqttInput> /<Mqtt2MqttOutput>/
+      <Rest2RestInput> /<Rest2RestOutput>/
+      <Mqtt2RestInput> /<Mqtt2RestOutput>/
+      <Rest2MqttInput> /<Rest2MqttOutput>/
+      <Both2BothInput> /<Both2MqttOutput>/ /<Both2RestOutput>/;

ragconnect.tests/src/test/02-after-ragconnect/.gitignore

+*
+!.gitignore

ragconnect.tests/src/test/03-after-relast/.gitignore

+*
+!.gitignore

ragconnect.tests/src/test/java-gen/.gitignore

+*
+!.gitignore