Commit d525231a authored by René Schöne's avatar René Schöne
Browse files

WIP: add support for receiving single elements of lists

- resolved weird bug, that causes errors when nonterminal A (in the singleList-test) has no children.
- add new testcase for different structure/variants of some node to be sent/received
parent bce7c5c6
Pipeline #10598 passed with stages
in 10 minutes and 57 seconds
......@@ -102,8 +102,8 @@ aspect AttributesForMustache {
return preemptiveExpectedValue() + " == " + lastResult();
}
if (endpointDef().isReceiveTypeEndpointDefinition() && endpointDef().asReceiveTypeEndpointDefinition().getWithAdd()) {
// only check if received list is empty (may also be skipped, since addAll would not do anything anyways)
return lastResult() + " == null || " + lastResult() + ".numChildren() == 0";
// only check if received list is not null
return lastResult() + " == null";
}
if (endpointDef().isTypeEndpointDefinition() && type().isOptComponent()) {
// use "hasX()" instead of "getX() != null" for optionals
......
......@@ -503,3 +503,62 @@ task compileSingleListIncremental(type: RagConnectTest, dependsOn: ':ragconnect.
'--flush=full']
}
}
// --- Test: singleListVariant-manual ---
task compileSingleListVariantManual(type: RagConnectTest, dependsOn: ':ragconnect.base:jar') {
ragconnect {
outputDir = file('src/test/02-after-ragconnect/singleListVariant')
inputFiles = [file('src/test/01-input/singleListVariant/Test.relast'),
file('src/test/01-input/singleListVariant/Test.connect'),
file('src/test/01-input/singleListVariant/TestDependencies.connect')]
rootNode = 'Root'
}
relast {
useJastAddNames = true
grammarName = 'src/test/03-after-relast/singleListVariant/singleListVariant'
serializer = 'jackson'
}
jastadd {
jastAddList = 'JastAddList'
packageName = 'singleListVariant.ast'
inputFiles = [file('src/test/01-input/singleListVariant/Test.jadd')]
}
}
// --- Test: singleListVariant-incremental ---
task compileSingleListVariantIncremental(type: RagConnectTest, dependsOn: ':ragconnect.base:jar') {
ragconnect {
outputDir = file('src/test/02-after-ragconnect/singleListVariantInc')
inputFiles = [file('src/test/01-input/singleListVariant/Test.relast'),
file('src/test/01-input/singleListVariant/Test.connect')]
rootNode = 'Root'
}
relast {
useJastAddNames = true
grammarName = 'src/test/03-after-relast/singleListVariantInc/singleListVariantInc'
serializer = 'jackson'
}
jastadd {
jastAddList = 'JastAddList'
packageName = 'singleListVariantInc.ast'
inputFiles = [file('src/test/01-input/singleListVariant/Test.jadd')]
extraOptions = ['--tracing=cache,flush',
'--incremental=param',
'--cache=all',
'--rewrite=cnta',
'--flush=full']
}
}
//task cleanCurrentManualTest(type: Delete) {
// delete "src/test/02-after-ragconnect/singleListVariant"
// delete "src/test/03-after-relast/singleListVariant"
// delete "src/test/java-gen/singleListVariant/ast"
//}
//task cleanCurrentIncrementalTest(type: Delete) {
// delete "src/test/02-after-ragconnect/singleListVariantInc"
// delete "src/test/03-after-relast/singleListVariantInc"
// delete "src/test/java-gen/singleListVariantInc/ast"
//}
//compileSingleListVariantManual.dependsOn cleanCurrentManualTest
//compileSingleListVariantIncremental.dependsOn cleanCurrentIncrementalTest
......@@ -8,5 +8,4 @@ SenderRoot : Nameable ::= <Input1:int> /A1:A/
<InOutput:int> ;
ReceiverRoot : Nameable ::= A* UsingWildcardA:A* WithAddA:A* UsingWildcardWithAddA:A* ;
A : Nameable ::= ;
B : Nameable ;
A : Nameable ;
# Single List
Idea: send and receive single values for lists of subtrees.
Test different variants of the structure/shape of the send/received value.
## Execution-Model
TODO: check again (old model copied from `singleList`)
```
SenderRoot/ReceiverRoot
|- T_Empty ::= /* empty */ ;
|- T_Token ::= <Value:String> ;
|- T_OneChild ::= Other ;
|- T_OneOpt ::= [Other] ;
|- T_OneList ::= Other* ;
|- T_TwoChildren ::= Left:Other Right:Other ;
|- T_OneOfEach ::= First:Other [Second:Other] Third:Other* <Fourth:String> ;
|- abstract T_Abstract ::= <ValueAbstract> ;
```
## Computation
```
T.ID = Input
T.token = Input
T.Other.ID = Input + 1
```
## Execution-Trace (SendInitialValue)
Inputs:
- 1
- 1
- 2
- 3
| Input | [A1,A2,A3,A4,IO] | # | A* | UsingWcA | WithAddA | UsingWcWithAddA:A |
|---|---|---|---|---|---|---|
| * | [1,2,3,4,0] | 5 | [1,2,3,4,0] | [1,2,3,4,0] | [1,2,3,4,0] | [1,2,3,4,0] |
| I1:1 | [2,2,3,4,0] | 6 | [2,2,3,4,0] | [2,2,3,4,0] | [1,2,3,4,0,2] | [1,2,3,4,0,2] |
| I1:1 | [2,2,3,4,0] | 6 | [2,2,3,4,0] | [2,2,3,4,0] | [1,2,3,4,0,2] | [1,2,3,4,0,2] |
| I1:2 | [3,2,3,4,0] | 7 | [3,2,3,4,0] | [3,2,3,4,0] | [1,2,3,4,0,2,3] | [1,2,3,4,0,2,3] |
| IO:5 | [3,2,3,4,5] | 8 | [3,2,3,4,5] | [3,2,3,4,5] | [1,2,3,4,0,2,3,5] | [1,2,3,4,0,2,3,5]
| I3:4 | [3,2,7,4,5] | 9 | [3,2,7,4,5] | [3,2,7,4,5] | [1,2,3,4,0,2,3,5,7] | [1,2,3,4,0,2,3,5,7] |
*: (1:0, 2:0, 3:0, 4:0, 5:0)
## Execution-Trace (OnlyUpdate)
| Input | [A1,A2,A3,A4,IO] | # | A* | UsingWcA | WithAddA | UsingWcWithAddA:A |
|---|---|---|---|---|---|---|
| * | [-,-,-,-,-] | 0 | [0,0,0,0,0] | [] | [] | [] |
| I1:1 | [2,-,-,-,-] | 1 | [2,0,0,0,0] | [2] | [2] | [2] |
| I1:1 | [2,-,-,-,-] | 1 | [2,0,0,0,0] | [2] | [2] | [2] |
| I1:2 | [3,-,-,-,-] | 2 | [3,0,0,0,0] | [3] | [2,3] | [2,3] |
| IO:5 | [2,-,-,-,5] | 3 | [3,0,0,0,5] | [3,5] | [2,3,5] | [2,3,5]
| I3:4 | [2,-,7,-,5] | 4 | [3,0,7,0,5] | [3,5,7] | [2,3,5,7] | [2,3,5,7] |
*: (1:0, 2:0, 3:0, 4:0, 5:0)
send tree SenderRoot.T_Empty ;
send tree SenderRoot.T_Token ;
send tree SenderRoot.T_OneChild ;
send tree SenderRoot.T_OneOpt ;
send tree SenderRoot.T_OneList ;
send tree SenderRoot.T_TwoChildren ;
send tree SenderRoot.T_OneOfEach ;
send tree SenderRoot.T_Abstract ;
receive tree ReceiverRoot.T_Empty ;
receive tree ReceiverRoot.T_Token ;
receive tree ReceiverRoot.T_OneChild ;
receive tree ReceiverRoot.T_OneOpt ;
receive tree ReceiverRoot.T_OneList ;
receive tree ReceiverRoot.T_TwoChildren ;
receive tree ReceiverRoot.T_OneOfEach ;
receive tree ReceiverRoot.T_Abstract ;
receive tree ReceiverRoot.MyEmpty ;
receive tree with add ReceiverRoot.EmptyWithAdd ;
receive tree with add ReceiverRoot.TokenWithAdd ;
receive tree with add ReceiverRoot.OneChildWithAdd ;
receive tree with add ReceiverRoot.OneOptWithAdd ;
receive tree with add ReceiverRoot.OneListWithAdd ;
receive tree with add ReceiverRoot.TwoChildrenWithAdd ;
receive tree with add ReceiverRoot.OneOfEachWithAdd ;
receive tree with add ReceiverRoot.AbstractWithAdd ;
aspect Computation {
syn T_Empty SenderRoot.getT_Empty() = new T_Empty().setID(getInput());
syn T_Token SenderRoot.getT_Token() = new T_Token().setID(getInput())
.setValue(Integer.toString(getInput()));
syn T_OneChild SenderRoot.getT_OneChild() {
T_OneChild result = new T_OneChild().setID(getInput());
result.setOther(createOther());
return result;
}
syn T_OneOpt SenderRoot.getT_OneOpt() {
T_OneOpt result = new T_OneOpt().setID(getInput());
if (getShouldSetOptAndList()) {
result.setOther(createOther());
}
return result;
}
syn T_OneList SenderRoot.getT_OneList() {
T_OneList result = new T_OneList().setID(getInput());
if (getShouldSetOptAndList()) {
result.addOther(createOther());
}
return result;
}
syn T_TwoChildren SenderRoot.getT_TwoChildren() {
T_TwoChildren result = new T_TwoChildren().setID(getInput());
result.setLeft(createOther());
result.setRight(createOther());
return result;
}
syn T_OneOfEach SenderRoot.getT_OneOfEach() {
T_OneOfEach result = new T_OneOfEach().setID(getInput());
result.setFirst(createOther());
if (getShouldSetOptAndList()) {
result.setSecond(createOther());
result.addThird(createOther());
}
result.setFourth(Integer.toString(getInput()));
return result;
}
syn T_Abstract SenderRoot.getT_Abstract() = new T_SubClass()
.setValueSub(Integer.toString(getInput()))
.setID(getInput())
.setValueAbstract(Integer.toString(getInput()));
private Other SenderRoot.createOther() {
return new Other().setID(getInput() + 1);
}
syn boolean ASTNode.isNameable() = false;
eq Nameable.isNameable() = true;
}
aspect Testing {
class SenderRoot implements org.jastadd.ragconnect.tests.singleListVariant.AbstractSingleListVariantTest.TestWrapperSenderRoot {}
class ReceiverRoot implements org.jastadd.ragconnect.tests.singleListVariant.AbstractSingleListVariantTest.TestWrapperReceiverRoot {}
class Other implements org.jastadd.ragconnect.tests.singleListVariant.AbstractSingleListVariantTest.TestWrapperOther {}
class T_Empty implements org.jastadd.ragconnect.tests.singleListVariant.AbstractSingleListVariantTest.TestWrapperT_Empty {}
class T_Token implements org.jastadd.ragconnect.tests.singleListVariant.AbstractSingleListVariantTest.TestWrapperT_Token {}
class T_OneChild implements org.jastadd.ragconnect.tests.singleListVariant.AbstractSingleListVariantTest.TestWrapperT_OneChild {}
class T_OneOpt implements org.jastadd.ragconnect.tests.singleListVariant.AbstractSingleListVariantTest.TestWrapperT_OneOpt {}
class T_OneList implements org.jastadd.ragconnect.tests.singleListVariant.AbstractSingleListVariantTest.TestWrapperT_OneList {}
class T_TwoChildren implements org.jastadd.ragconnect.tests.singleListVariant.AbstractSingleListVariantTest.TestWrapperT_TwoChildren {}
class T_OneOfEach implements org.jastadd.ragconnect.tests.singleListVariant.AbstractSingleListVariantTest.TestWrapperT_OneOfEach {}
class T_Abstract implements org.jastadd.ragconnect.tests.singleListVariant.AbstractSingleListVariantTest.TestWrapperT_Abstract {}
class JastAddList<T> implements org.jastadd.ragconnect.tests.singleListVariant.AbstractSingleListVariantTest.TestWrapperJastAddList<T> {}
}
aspect NameResolution {
// overriding customID guarantees to produce the same JSON representation for equal lists
// otherwise, the value for id is different each time
@Override
protected String Nameable.customID() {
return getClass().getSimpleName() + getID();
}
}
Root ::= SenderRoot* ReceiverRoot* ;
Nameable ::= <ID:int> ;
SenderRoot : Nameable ::= <Input:int> <ShouldSetOptAndList:boolean>
/T_Empty/
/T_Token/
/T_OneChild/
/T_OneOpt/
/T_OneList/
/T_TwoChildren/
/T_OneOfEach/
/T_Abstract/
;
ReceiverRoot : Nameable ::=
T_Empty*
T_Token*
T_OneChild*
T_OneOpt*
T_OneList*
T_TwoChildren*
T_OneOfEach*
T_Abstract*
MyEmpty:T_Empty*
EmptyWithAdd:T_Empty*
TokenWithAdd:T_Token*
OneChildWithAdd:T_OneChild*
OneOptWithAdd:T_OneOpt*
OneListWithAdd:T_OneList*
TwoChildrenWithAdd:T_TwoChildren*
OneOfEachWithAdd:T_OneOfEach*
AbstractWithAdd:T_Abstract*
;
T_Empty : Nameable ::= /* empty */ ;
T_Token : Nameable ::= <Value:String> ;
T_OneChild : Nameable ::= Other ;
T_OneOpt : Nameable ::= [Other] ;
T_OneList : Nameable ::= Other* ;
T_TwoChildren : Nameable ::= Left:Other Right:Other ;
T_OneOfEach : Nameable ::= First:Other [Second:Other] Third:Other* <Fourth:String> ;
abstract T_Abstract : Nameable ::= <ValueAbstract>;
T_SubClass : T_Abstract ::= <ValueSub> ;
Other : Nameable ;
SenderRoot.T_Empty canDependOn SenderRoot.Input as InputDependencyToT_Empty ;
SenderRoot.T_Token canDependOn SenderRoot.Input as InputDependencyToT_Token ;
SenderRoot.T_OneChild canDependOn SenderRoot.Input as InputDependencyToT_OneChild ;
SenderRoot.T_OneOpt canDependOn SenderRoot.ShouldSetOptAndList as ShouldSetOptAndListDependencyToT_OneOpt ;
SenderRoot.T_OneOpt canDependOn SenderRoot.Input as InputDependencyToT_OneOpt ;
SenderRoot.T_OneList canDependOn SenderRoot.ShouldSetOptAndList as ShouldSetOptAndListDependencyToT_OneList ;
SenderRoot.T_OneList canDependOn SenderRoot.Input as InputDependencyToT_OneList ;
SenderRoot.T_TwoChildren canDependOn SenderRoot.Input as InputDependencyToT_TwoChildren ;
SenderRoot.T_OneOfEach canDependOn SenderRoot.ShouldSetOptAndList as ShouldSetOptAndListDependencyToT_OneOfEach ;
SenderRoot.T_OneOfEach canDependOn SenderRoot.Input as InputDependencyToT_OneOfEach ;
SenderRoot.T_Abstract canDependOn SenderRoot.Input as InputDependencyToT_Abstract ;
package org.jastadd.ragconnect.tests.singleListVariant;
import org.jastadd.ragconnect.tests.AbstractMqttTest;
import org.jastadd.ragconnect.tests.TestUtils;
import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.nio.file.Paths;
import java.util.List;
import java.util.function.BiConsumer;
import static java.lang.Math.abs;
import static java.util.Collections.addAll;
import static org.assertj.core.util.Lists.newArrayList;
import static org.jastadd.ragconnect.tests.TestUtils.mqttUri;
import static org.jastadd.ragconnect.tests.TestUtils.testJaddContainReferenceToJackson;
import static org.jastadd.ragconnect.tests.singleListVariant.AbstractSingleListVariantTest.IntList.list;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* Base class for test cases "singleList manual" and "singleList incremental".
*
* @author rschoene - Initial contribution
*/
@Tag("List")
@Tag("SingleList")
public abstract class AbstractSingleListVariantTest extends AbstractMqttTest {
public interface TestWrapperJastAddList<T> extends Iterable<T> {
int getNumChild();
}
public interface TestWrapperReceiverRoot {
TestWrapperJastAddList<? extends TestWrapperT_Empty> getT_EmptyList();
TestWrapperJastAddList<? extends TestWrapperT_Token> getT_TokenList();
TestWrapperJastAddList<? extends TestWrapperT_OneChild> getT_OneChildList();
TestWrapperJastAddList<? extends TestWrapperT_OneOpt> getT_OneOptList();
TestWrapperJastAddList<? extends TestWrapperT_OneList> getT_OneListList();
TestWrapperJastAddList<? extends TestWrapperT_TwoChildren> getT_TwoChildrenList();
TestWrapperJastAddList<? extends TestWrapperT_OneOfEach> getT_OneOfEachList();
TestWrapperJastAddList<? extends TestWrapperT_Abstract> getT_AbstractList();
TestWrapperJastAddList<? extends TestWrapperT_Empty> getMyEmptyList();
TestWrapperJastAddList<? extends TestWrapperT_Empty> getEmptyWithAddList();
TestWrapperJastAddList<? extends TestWrapperT_Token> getTokenWithAddList();
TestWrapperJastAddList<? extends TestWrapperT_OneChild> getOneChildWithAddList();
TestWrapperJastAddList<? extends TestWrapperT_OneOpt> getOneOptWithAddList();
TestWrapperJastAddList<? extends TestWrapperT_OneList> getOneListWithAddList();
TestWrapperJastAddList<? extends TestWrapperT_TwoChildren> getTwoChildrenWithAddList();
TestWrapperJastAddList<? extends TestWrapperT_OneOfEach> getOneOfEachWithAddList();
TestWrapperJastAddList<? extends TestWrapperT_Abstract> getAbstractWithAddList();
boolean connectT_Empty(String mqttUri) throws IOException;
boolean connectT_Token(String mqttUri) throws IOException;
boolean connectT_OneChild(String mqttUri) throws IOException;
boolean connectT_OneOpt(String mqttUri) throws IOException;
boolean connectT_OneList(String mqttUri) throws IOException;
boolean connectT_TwoChildren(String mqttUri) throws IOException;
boolean connectT_OneOfEach(String mqttUri) throws IOException;
boolean connectT_Abstract(String mqttUri) throws IOException;
boolean connectMyEmpty(String mqttUri) throws IOException;
boolean connectEmptyWithAdd(String mqttUri) throws IOException;
boolean connectTokenWithAdd(String mqttUri) throws IOException;
boolean connectOneChildWithAdd(String mqttUri) throws IOException;
boolean connectOneOptWithAdd(String mqttUri) throws IOException;
boolean connectOneListWithAdd(String mqttUri) throws IOException;
boolean connectTwoChildrenWithAdd(String mqttUri) throws IOException;
boolean connectOneOfEachWithAdd(String mqttUri) throws IOException;
boolean connectAbstractWithAdd(String mqttUri) throws IOException;
}
@SuppressWarnings("UnusedReturnValue")
public interface TestWrapperSenderRoot {
boolean connectT_Empty(String mqttUri, boolean writeCurrentValue) throws IOException;
boolean connectT_Token(String mqttUri, boolean writeCurrentValue) throws IOException;
boolean connectT_OneChild(String mqttUri, boolean writeCurrentValue) throws IOException;
boolean connectT_OneOpt(String mqttUri, boolean writeCurrentValue) throws IOException;
boolean connectT_OneList(String mqttUri, boolean writeCurrentValue) throws IOException;
boolean connectT_TwoChildren(String mqttUri, boolean writeCurrentValue) throws IOException;
boolean connectT_OneOfEach(String mqttUri, boolean writeCurrentValue) throws IOException;
boolean connectT_Abstract(String mqttUri, boolean writeCurrentValue) throws IOException;
TestWrapperSenderRoot setInput(int input);
TestWrapperSenderRoot setShouldSetOptAndList(boolean shouldSetOptAndList);
TestWrapperT_Empty getT_Empty();
TestWrapperT_OneOpt getT_OneOpt();
}
public interface TestWrapperNameable {
int getID();
}
public interface TestWrapperOther extends TestWrapperNameable {}
public interface TestWrapperT_Empty extends TestWrapperNameable {}
public interface TestWrapperT_Token extends TestWrapperNameable {
String getValue();
}
public interface TestWrapperT_OneChild extends TestWrapperNameable {
TestWrapperNameable getOther();
}
public interface TestWrapperT_OneOpt extends TestWrapperNameable {
boolean hasOther();
TestWrapperNameable getOther();
}
public interface TestWrapperT_OneList extends TestWrapperNameable {
int getNumOther();
TestWrapperNameable getOther(int index);
}
public interface TestWrapperT_TwoChildren extends TestWrapperNameable {
TestWrapperNameable getLeft();
TestWrapperNameable getRight();
}
public interface TestWrapperT_OneOfEach extends TestWrapperNameable {
TestWrapperNameable getFirst();
boolean hasSecond();
TestWrapperNameable getSecond();
int getNumThird();
TestWrapperNameable getThird(int index);
String getFourth();
}
public interface TestWrapperT_Abstract extends TestWrapperNameable {
String getValueAbstract();
String getValueSub();
}
AbstractSingleListVariantTest(String shortName) {
this.shortName = shortName;
}
protected static final String TOPIC_T_Empty = "t/Empty";
protected static final String TOPIC_T_Token = "t/Token";
protected static final String TOPIC_T_OneChild = "t/OneChild";
protected static final String TOPIC_T_OneOpt = "t/OneOpt";
protected static final String TOPIC_T_OneList = "t/OneList";
protected static final String TOPIC_T_TwoChildren = "t/TwoChildren";
protected static final String TOPIC_T_OneOfEach = "t/OneOfEach";
protected static final String TOPIC_T_Abstract = "t/Abstract";
protected static final String TOPIC_T_all = "t/#";
protected TestWrapperSenderRoot senderRoot;
protected TestWrapperReceiverRoot receiverRoot;
protected ReceiverData data;
private final String shortName;
@Test
public void checkJacksonReference() {
testJaddContainReferenceToJackson(
Paths.get("src", "test",
"02-after-ragconnect", shortName, "RagConnect.jadd"), true);
}
@Override
protected void setupReceiverAndConnect(boolean writeCurrentValue) throws IOException, InterruptedException {
// late model initialization
setInput(0);
setShouldSetOptAndList(false);
setupReceiverAndConnectPart();
// connect. important: first receivers, then senders. to not miss initial value.
// receive: unnamed
assertTrue(receiverRoot.connectT_Empty(mqttUri(TOPIC_T_Empty)));
assertTrue(receiverRoot.connectT_Token(mqttUri(TOPIC_T_Token)));
assertTrue(receiverRoot.connectT_OneChild(mqttUri(TOPIC_T_OneChild)));
assertTrue(receiverRoot.connectT_OneOpt(mqttUri(TOPIC_T_OneOpt)));
assertTrue(receiverRoot.connectT_OneList(mqttUri(TOPIC_T_OneList)));
assertTrue(receiverRoot.connectT_TwoChildren(mqttUri(TOPIC_T_TwoChildren)));
assertTrue(receiverRoot.connectT_OneOfEach(mqttUri(TOPIC_T_OneOfEach)));
assertTrue(receiverRoot.connectT_Abstract(mqttUri(TOPIC_T_Abstract)));
// receive: named
assertTrue(receiverRoot.connectMyEmpty(mqttUri(TOPIC_T_Empty)));
// receive: with add
assertTrue(receiverRoot.connectEmptyWithAdd(mqttUri(TOPIC_T_Empty)));
assertTrue(receiverRoot.connectTokenWithAdd(mqttUri(TOPIC_T_Token)));
assertTrue(receiverRoot.connectOneChildWithAdd(mqttUri(TOPIC_T_OneChild)));
assertTrue(receiverRoot.connectOneOptWithAdd(mqttUri(TOPIC_T_OneOpt)));
assertTrue(receiverRoot.connectOneListWithAdd(mqttUri(TOPIC_T_OneList)));
assertTrue(receiverRoot.connectTwoChildrenWithAdd(mqttUri(TOPIC_T_TwoChildren)));
assertTrue(receiverRoot.connectOneOfEachWithAdd(mqttUri(TOPIC_T_OneOfEach)));
assertTrue(receiverRoot.connectAbstractWithAdd(mqttUri(TOPIC_T_Abstract)));
// send
assertTrue(senderRoot.connectT_Empty(mqttUri(TOPIC_T_Empty), writeCurrentValue));
assertTrue(senderRoot.connectT_Token(mqttUri(TOPIC_T_Token), writeCurrentValue));
assertTrue(senderRoot.connectT_OneChild(mqttUri(TOPIC_T_OneChild), writeCurrentValue));
assertTrue(senderRoot.connectT_OneOpt(mqttUri(TOPIC_T_OneOpt), writeCurrentValue));
assertTrue(senderRoot.connectT_OneList(mqttUri(TOPIC_T_OneList), writeCurrentValue));
assertTrue(senderRoot.connectT_TwoChildren(mqttUri(TOPIC_T_TwoChildren), writeCurrentValue));
assertTrue(senderRoot.connectT_OneOfEach(mqttUri(TOPIC_T_OneOfEach), writeCurrentValue));
assertTrue(senderRoot.connectT_Abstract(mqttUri(TOPIC_T_Abstract), writeCurrentValue));
}
abstract protected void setupReceiverAndConnectPart() throws IOException;
@Override
protected void communicateSendInitialValue() throws InterruptedException {
// transmissions: 8 * 1 = 8
checkTree(8, list(-0), list(0), list(-0));
setInput(1);
// transmissions: 8 + 8 = 16
checkTree(16, list(-1), list(0, 1), list(-0, -1));
setInput(1);
// transmissions: 16
checkTree(16, list(-1), list(0, 1), list(-0, -1));
setShouldSetOptAndList(true);
// transmissions: 16 + 3 = 19
checkTree(19, list(1), list(0, 1), list(-0, -1, 1));
setShouldSetOptAndList(true);
// transmissions: 19
checkTree(19, list(1), list(0, 1), list(-0, -1, 1));
setInput(2);
// transmissions: 19 + 8 = 27
checkTree(27, list(2), list(0, 1, 2), list(-0, -1, 1, 2));
setInput(5);
// transmissions: 27 + 8 = 35
checkTree(35, list(5), list(0, 1, 2, 5), list(-0, -1, 1, 2, 5));
}
@Override
protected void communicateOnlyUpdatedValue() throws InterruptedException {
// transmissions: 0
checkTree(0, list(), list(), list());
setInput(1);
// transmissions: 8 * 1 = 0
checkTree(8, list(-1), list(1), list(-1));
setInput(1);
// transmissions: 8
checkTree(8, list(-1), list(1), list(-1));
setShouldSetOptAndList(true);
// transmissions: 8 + 3 = 11
checkTree(11, list(1), list(1), list(-1, 1));
setShouldSetOptAndList(true);
// transmissions: 11
checkTree(11, list(1), list(1), list(-1, 1));
setInput(2);
// transmissions: 11 + 8 = 19
checkTree(19, list(2), list(1, 2), list(-1, 1, 2));
setInput(5);
// transmissions: 19 + 8 = 27
checkTree(27, list(5), list(1, 2, 5), list(-1, 1, 2, 5));
}