diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 34d4b879179990ab1ff26faf7d5e13d14aa11eda..ea5b480b26afda4f096ae0b19a961e9e15858b11 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -21,7 +21,7 @@ build: - ./gradlew --console=plain --no-daemon assemble jar artifacts: paths: - - "/builds/jastadd/ragconnect/ragconnect.base/build/libs/ragconnect-*.jar" + - "ragconnect.base/build/libs/ragconnect-*.jar" expire_in: 1 week test: @@ -34,7 +34,7 @@ test: - ./gradlew --console=plain --no-daemon allTests artifacts: reports: - junit: "/builds/jastadd/ragconnect/ragconnect.tests/build/test-results/test/TEST-*.xml" + junit: "ragconnect.tests/build/test-results/test/**/TEST-*.xml" expire_in: 1 week publish: diff --git a/ragconnect.base/src/main/jastadd/Analysis.jrag b/ragconnect.base/src/main/jastadd/Analysis.jrag index a1367a9c21bf2f293dd33216ea20a8941f5411b5..f3724eab6217b2e76472ee57f8f341ab31730861 100644 --- a/ragconnect.base/src/main/jastadd/Analysis.jrag +++ b/ragconnect.base/src/main/jastadd/Analysis.jrag @@ -12,6 +12,19 @@ aspect Analysis { return result; } + // --- lookupTypeEndpointDefinition --- + inh java.util.List<TypeEndpointDefinition> TypeEndpointDefinition.lookupTypeEndpointDefinitions(TypeComponent type); + eq RagConnect.getEndpointDefinition().lookupTypeEndpointDefinitions(TypeComponent type) = lookupTypeEndpointDefinitions(type); + syn java.util.List<TypeEndpointDefinition> RagConnect.lookupTypeEndpointDefinitions(TypeComponent type) { + java.util.List<TypeEndpointDefinition> result = new java.util.ArrayList<>(); + for (EndpointDefinition def : getEndpointDefinitionList()) { + if (def.isTypeEndpointDefinition() && def.asTypeEndpointDefinition().getType().equals(type)) { + result.add(def.asTypeEndpointDefinition()); + } + } + return result; + } + // --- lookupDependencyDefinition --- inh DependencyDefinition DependencyDefinition.lookupDependencyDefinition(TypeDecl source, String id); eq RagConnect.getDependencyDefinition().lookupDependencyDefinition(TypeDecl source, String id) { @@ -31,10 +44,12 @@ aspect Analysis { } syn boolean DependencyDefinition.isAlreadyDefined() = lookupDependencyDefinition(getSource().containingTypeDecl(), getID()) != this; + // --- matchesType --- syn boolean TokenEndpointDefinition.matchesType(TokenEndpointDefinition other); eq ReceiveTokenEndpointDefinition.matchesType(TokenEndpointDefinition other) = other.isReceiveTokenEndpointDefinition(); eq SendTokenEndpointDefinition.matchesType(TokenEndpointDefinition other) = other.isSendTokenEndpointDefinition(); + // --- assignableTo --- syn boolean MappingDefinitionType.assignableTo(JavaTypeUse target); eq JavaMappingDefinitionType.assignableTo(JavaTypeUse target) = getType().assignableTo(target); eq JavaArrayMappingDefinitionType.assignableTo(JavaTypeUse target) { @@ -65,6 +80,7 @@ aspect Analysis { // --- shouldSendValue --- syn boolean TokenEndpointDefinition.shouldSendValue() = isSendTokenEndpointDefinition() && !getToken().getNTA(); + syn boolean TypeEndpointDefinition.shouldSendValue() = isSendTypeEndpointDefinition() && !getType().getNTA(); // --- needProxyToken --- syn boolean TokenComponent.needProxyToken() = !getDependencySourceDefinitionList().isEmpty() || getTokenEndpointDefinitionList().stream().anyMatch(TokenEndpointDefinition::shouldSendValue); diff --git a/ragconnect.base/src/main/jastadd/Errors.jrag b/ragconnect.base/src/main/jastadd/Errors.jrag index 88f3aece6a64041a95f2784be4882d01008ff8c5..c3ecc643a4edc8319da82f49438dc46f167a3618 100644 --- a/ragconnect.base/src/main/jastadd/Errors.jrag +++ b/ragconnect.base/src/main/jastadd/Errors.jrag @@ -32,6 +32,10 @@ aspect Errors { when isAlreadyDefined() to RagConnect.errors(); + SendTypeEndpointDefinition contributes error("At least one mapping needs to be used") + when effectiveMappings().isEmpty() + to RagConnect.errors(); + DependencyDefinition contributes error("Dependency definition already defined for " + getSource().containingTypeDecl().getName() + " with name " + getID()) when isAlreadyDefined() to RagConnect.errors(); diff --git a/ragconnect.base/src/main/jastadd/NameResolution.jrag b/ragconnect.base/src/main/jastadd/NameResolution.jrag index f282ba55983feeae814e12823ff31f1d6480b6a8..253f1dabf8ed0f15e2483aafde9144d992d87cf2 100644 --- a/ragconnect.base/src/main/jastadd/NameResolution.jrag +++ b/ragconnect.base/src/main/jastadd/NameResolution.jrag @@ -11,4 +11,20 @@ aspect NameResolution { return null; } + refine RefResolverStubs eq ASTNode.globallyResolveTypeComponentByToken(String id) { + // return a TypeComponent. id is of the form 'parent_type_name + "." + child_type_name' + int dotIndex = id.indexOf("."); + String parentTypeName = id.substring(0, dotIndex); + String childTypeName = id.substring(dotIndex + 1); + TypeDecl type = program().resolveTypeDecl(parentTypeName); + // iterate over components and find the matching typeComponent + for (Component comp : type.getComponentList()) { + if (comp.isTypeComponent() && comp.getName().equals(childTypeName)) { + return comp.asTypeComponent(); + } + } + System.err.println("Could not resolve TypeComponent '" + id + "'."); + return null; + } + } diff --git a/ragconnect.base/src/main/jastadd/Navigation.jrag b/ragconnect.base/src/main/jastadd/Navigation.jrag index 1c2c4af4a40db2ff7ffb0bf962716d515553fd97..c6432a14d9258795f1f402366ec5c418993d4aa1 100644 --- a/ragconnect.base/src/main/jastadd/Navigation.jrag +++ b/ragconnect.base/src/main/jastadd/Navigation.jrag @@ -27,13 +27,13 @@ aspect Navigation { syn TokenEndpointDefinition EndpointDefinition.asTokenEndpointDefinition() = null; eq TokenEndpointDefinition.asTokenEndpointDefinition() = this; - // --- isSendTokenEndpointDefinition --- - syn boolean EndpointDefinition.isSendTokenEndpointDefinition() = false; - eq SendTokenEndpointDefinition.isSendTokenEndpointDefinition() = true; + // --- isTypeEndpointDefinition --- + syn boolean EndpointDefinition.isTypeEndpointDefinition() = false; + eq TypeEndpointDefinition.isTypeEndpointDefinition() = true; - // --- asSendTokenEndpointDefinition --- - syn SendTokenEndpointDefinition EndpointDefinition.asSendTokenEndpointDefinition() = null; - eq SendTokenEndpointDefinition.asSendTokenEndpointDefinition() = this; + // --- asTypeEndpointDefinition --- + syn TypeEndpointDefinition EndpointDefinition.asTypeEndpointDefinition() = null; + eq TypeEndpointDefinition.asTypeEndpointDefinition() = this; // --- isReceiveTokenEndpointDefinition --- syn boolean EndpointDefinition.isReceiveTokenEndpointDefinition() = false; @@ -43,6 +43,30 @@ aspect Navigation { syn ReceiveTokenEndpointDefinition EndpointDefinition.asReceiveTokenEndpointDefinition() = null; eq ReceiveTokenEndpointDefinition.asReceiveTokenEndpointDefinition() = this; + // --- isSendTokenEndpointDefinition --- + syn boolean EndpointDefinition.isSendTokenEndpointDefinition() = false; + eq SendTokenEndpointDefinition.isSendTokenEndpointDefinition() = true; + + // --- asSendTokenEndpointDefinition --- + syn SendTokenEndpointDefinition EndpointDefinition.asSendTokenEndpointDefinition() = null; + eq SendTokenEndpointDefinition.asSendTokenEndpointDefinition() = this; + + // --- isReceiveTypeEndpointDefinition --- + syn boolean EndpointDefinition.isReceiveTypeEndpointDefinition() = false; + eq ReceiveTypeEndpointDefinition.isReceiveTypeEndpointDefinition() = true; + + // --- asReceiveTypeEndpointDefinition --- + syn ReceiveTypeEndpointDefinition EndpointDefinition.asReceiveTypeEndpointDefinition() = null; + eq ReceiveTypeEndpointDefinition.asReceiveTypeEndpointDefinition() = this; + + // --- isSendTypeEndpointDefinition --- + syn boolean EndpointDefinition.isSendTypeEndpointDefinition() = false; + eq SendTypeEndpointDefinition.isSendTypeEndpointDefinition() = true; + + // --- asSendTypeEndpointDefinition --- + syn SendTypeEndpointDefinition EndpointDefinition.asSendTypeEndpointDefinition() = null; + eq SendTypeEndpointDefinition.asSendTypeEndpointDefinition() = this; + // --- targetEndpointDefinition --- syn SendTokenEndpointDefinition DependencyDefinition.targetEndpointDefinition() { // resolve definition in here, as we do not need resolveMethod in any other place (yet) diff --git a/ragconnect.base/src/main/jastadd/RagConnect.relast b/ragconnect.base/src/main/jastadd/RagConnect.relast index 9958106ba82c6efe32126c9f7b795ac7c66378e6..bd3e5c0d964881a7d7d49a68da83f1b27b79d0a7 100644 --- a/ragconnect.base/src/main/jastadd/RagConnect.relast +++ b/ragconnect.base/src/main/jastadd/RagConnect.relast @@ -10,6 +10,12 @@ rel TokenEndpointDefinition.Token <-> TokenComponent.TokenEndpointDefinition*; ReceiveTokenEndpointDefinition : TokenEndpointDefinition; SendTokenEndpointDefinition : TokenEndpointDefinition; +abstract TypeEndpointDefinition : EndpointDefinition; +rel TypeEndpointDefinition.Type <-> TypeComponent.TypeEndpointDefinition*; + +ReceiveTypeEndpointDefinition : TypeEndpointDefinition; +SendTypeEndpointDefinition : TypeEndpointDefinition; + DependencyDefinition ::= <ID>; rel DependencyDefinition.Source <-> TokenComponent.DependencySourceDefinition*; rel DependencyDefinition.Target -> TokenComponent; diff --git a/ragconnect.base/src/main/jastadd/intermediate/Generation.jadd b/ragconnect.base/src/main/jastadd/intermediate/Generation.jadd index 9ee95b7ba4d87ecbaf60a75271dadcd82e38d190..00ef291fa015596647a6f15756ce6f4380929501 100644 --- a/ragconnect.base/src/main/jastadd/intermediate/Generation.jadd +++ b/ragconnect.base/src/main/jastadd/intermediate/Generation.jadd @@ -18,29 +18,42 @@ aspect AttributesForMustache { // --- MEndpointDefinition --- syn String MEndpointDefinition.preemptiveExpectedValue(); syn String MEndpointDefinition.preemptiveReturn(); - syn TokenEndpointDefinition MEndpointDefinition.endpointDef(); + syn EndpointDefinition MEndpointDefinition.endpointDef(); syn String MEndpointDefinition.firstInputVarName(); + syn String MEndpointDefinition.parentTypeName(); + syn String MEndpointDefinition.entityName(); eq MEndpointDefinition.getInnerMappingDefinition(int i).isLast() = i == getNumInnerMappingDefinition() - 1; eq MEndpointDefinition.getInnerMappingDefinition(int i).inputVarName() = i == 0 ? firstInputVarName() : getInnerMappingDefinition(i - 1).outputVarName(); syn String MEndpointDefinition.connectParameterName() = "uriString"; - syn String MEndpointDefinition.connectMethod() = "connect" + tokenName(); + syn String MEndpointDefinition.connectMethod() = "connect" + entityName(); 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(); + String extra; + if (endpointDef().isTokenEndpointDefinition()) { + extra = endpointDef().asTokenEndpointDefinition().lookupTokenEndpointDefinitions(token()).size() > 1 ? uniqueSuffix() : ""; + } else if (endpointDef().isTypeEndpointDefinition()) { + extra = endpointDef().asTypeEndpointDefinition().lookupTypeEndpointDefinitions(type()).size() > 1 ? uniqueSuffix() : ""; + } else { + extra = ""; + } + return "disconnect" + extra + entityName(); } - // + syn String MEndpointDefinition.uniqueSuffix(); - eq MSendDefinition.uniqueSuffix() = "Send"; - eq MReceiveDefinition.uniqueSuffix() = "Receive"; + eq MTokenSendDefinition.uniqueSuffix() = "Send"; + eq MTokenReceiveDefinition.uniqueSuffix() = "Receive"; + eq MTypeSendDefinition.uniqueSuffix() = "Send"; + eq MTypeReceiveDefinition.uniqueSuffix() = "Receive"; - syn TokenComponent MEndpointDefinition.token() = endpointDef().getToken(); + // TODO potentially dangerous because asXEndpointDefinition can return null + syn TokenComponent MEndpointDefinition.token() = endpointDef().asTokenEndpointDefinition().getToken(); + syn TypeComponent MEndpointDefinition.type() = endpointDef().asTypeEndpointDefinition().getType(); syn boolean MEndpointDefinition.alwaysApply() = endpointDef().getAlwaysApply(); - syn String MEndpointDefinition.parentTypeName() = token().containingTypeDecl().getName(); syn String MEndpointDefinition.tokenName() = token().getName(); + syn String MEndpointDefinition.typeName() = type().getName(); syn MInnerMappingDefinition MEndpointDefinition.lastDefinition() = getInnerMappingDefinition(getNumInnerMappingDefinition() - 1); syn String MEndpointDefinition.lastDefinitionToType() = lastDefinition().toType(); syn String MEndpointDefinition.lastResult() = lastDefinition().outputVarName(); @@ -51,12 +64,20 @@ aspect AttributesForMustache { if (token().isPrimitiveType() && lastDefinition().mappingDef().getToType().isPrimitiveType()) { return preemptiveExpectedValue() + " == " + lastResult(); } - if (lastDefinition().mappingDef().isDefaultMappingDefinition()) { + if (lastDefinition().mappingDef().getToType().isPrimitiveType() || lastDefinition().mappingDef().isDefaultMappingDefinition()) { return preemptiveExpectedValue() + " != null && " + preemptiveExpectedValue() + ".equals(" + lastResult() + ")"; } return preemptiveExpectedValue() + " != null ? " + preemptiveExpectedValue() + ".equals(" + lastResult() + ") : " + lastResult() + " == null"; } + // --- MTokenEndpointDefinition --- + eq MTokenEndpointDefinition.parentTypeName() = token().containingTypeDecl().getName(); + eq MTokenEndpointDefinition.entityName() = tokenName(); + + // --- MTypeEndpointDefinition --- + eq MTypeEndpointDefinition.parentTypeName() = type().containingTypeDecl().getName(); + eq MTypeEndpointDefinition.entityName() = typeName(); + // --- MInnerMappingDefinition --- inh boolean MInnerMappingDefinition.isLast(); inh String MInnerMappingDefinition.inputVarName(); @@ -65,24 +86,43 @@ aspect AttributesForMustache { syn MappingDefinition MInnerMappingDefinition.mappingDef() = getMMappingDefinition().getMappingDefinition(); syn String MInnerMappingDefinition.outputVarName() = "result" + methodName(); // we do not need "_" in between here, because methodName begins with one - // --- MReceiveDefinition --- - eq MReceiveDefinition.preemptiveExpectedValue() = "get" + tokenName() + "()"; - eq MReceiveDefinition.preemptiveReturn() = "return;"; - eq MReceiveDefinition.endpointDef() = getReceiveTokenEndpointDefinition(); - eq MReceiveDefinition.firstInputVarName() = "message"; - - // --- MSendDefinition --- - eq MSendDefinition.preemptiveExpectedValue() = lastValue(); - eq MSendDefinition.preemptiveReturn() = "return false;"; - eq MSendDefinition.endpointDef() = getSendTokenEndpointDefinition(); - eq MSendDefinition.firstInputVarName() = "get" + tokenName() + "()"; - - syn String MSendDefinition.sender() = "_sender_" + tokenName(); - syn String MSendDefinition.lastValue() = "_lastValue" + tokenName(); - syn String MSendDefinition.updateMethod() = "_update_" + tokenName(); - syn String MSendDefinition.writeMethod() = "_writeLastValue_" + tokenName(); - syn String MSendDefinition.tokenResetMethod() = "get" + tokenName() + "_reset"; - syn boolean MSendDefinition.shouldSendValue() = endpointDef().shouldSendValue(); + // --- MTokenReceiveDefinition --- + eq MTokenReceiveDefinition.preemptiveExpectedValue() = "get" + tokenName() + "()"; + eq MTokenReceiveDefinition.preemptiveReturn() = "return;"; + eq MTokenReceiveDefinition.endpointDef() = getReceiveTokenEndpointDefinition(); + eq MTokenReceiveDefinition.firstInputVarName() = "message"; + + // --- MTokenSendDefinition --- + eq MTokenSendDefinition.preemptiveExpectedValue() = lastValue(); + eq MTokenSendDefinition.preemptiveReturn() = "return false;"; + eq MTokenSendDefinition.endpointDef() = getSendTokenEndpointDefinition(); + eq MTokenSendDefinition.firstInputVarName() = "get" + tokenName() + "()"; + + syn String MTokenSendDefinition.sender() = "_sender_" + tokenName(); + syn String MTokenSendDefinition.lastValue() = "_lastValue" + tokenName(); + syn String MTokenSendDefinition.updateMethod() = "_update_" + tokenName(); + syn String MTokenSendDefinition.writeMethod() = "_writeLastValue_" + tokenName(); + syn String MTokenSendDefinition.tokenResetMethod() = "get" + tokenName() + "_reset"; + syn boolean MTokenSendDefinition.shouldSendValue() = endpointDef().asTokenEndpointDefinition().shouldSendValue(); + + // MTypeReceiveDefinition + eq MTypeReceiveDefinition.preemptiveExpectedValue() = null; + eq MTypeReceiveDefinition.preemptiveReturn() = null; + eq MTypeReceiveDefinition.endpointDef() = getReceiveTypeEndpointDefinition(); + eq MTypeReceiveDefinition.firstInputVarName() = null; + + // MTypeSendDefinition + eq MTypeSendDefinition.preemptiveExpectedValue() = null; + eq MTypeSendDefinition.preemptiveReturn() = null; + eq MTypeSendDefinition.endpointDef() = getSendTypeEndpointDefinition(); + eq MTypeSendDefinition.firstInputVarName() = null; + + syn String MTypeSendDefinition.sender() = "_sender_" + typeName(); + syn String MTypeSendDefinition.lastValue() = "_lastValue" + typeName(); + syn String MTypeSendDefinition.updateMethod() = "_update_" + typeName(); + syn String MTypeSendDefinition.writeMethod() = "_writeLastValue_" + typeName(); + syn String MTypeSendDefinition.tokenResetMethod() = "get" + typeName() + "_reset"; + syn boolean MTypeSendDefinition.shouldSendValue() = endpointDef().asTypeEndpointDefinition().shouldSendValue(); // --- MMappingDefinition --- syn String MMappingDefinition.toType() = getMappingDefinition().getToType().prettyPrint(); @@ -96,7 +136,7 @@ aspect AttributesForMustache { syn String MDependencyDefinition.dependencyMethod() = "add" + capitalize(getDependencyDefinition().getID()); syn String MDependencyDefinition.sourceParentTypeName() = getDependencyDefinition().getSource().containingTypeDecl().getName(); syn String MDependencyDefinition.internalRelationPrefix() = "_internal_" + getDependencyDefinition().getID(); - syn nta MSendDefinition MDependencyDefinition.targetEndpointDefinition() { + syn nta MTokenSendDefinition MDependencyDefinition.targetEndpointDefinition() { return getDependencyDefinition().targetEndpointDefinition().toMustache(); } @@ -110,7 +150,7 @@ aspect AttributesForMustache { syn String MTokenComponent.javaType() = getTokenComponent().effectiveJavaTypeUse().prettyPrint(); syn String MTokenComponent.internalName() = getTokenComponent().needProxyToken() ? "_internal_" + name() : externalName(); syn String MTokenComponent.externalName() = name(); - syn MSendDefinition MTokenComponent.normalTokenSendDef() { + syn MTokenSendDefinition MTokenComponent.normalTokenSendDef() { for (TokenEndpointDefinition endpointDef : getTokenComponent().getTokenEndpointDefinitionList()) { if (endpointDef.shouldSendValue()) { return endpointDef.asSendTokenEndpointDefinition().toMustache(); @@ -124,11 +164,16 @@ aspect AttributesForMustache { MRagConnect result = new MRagConnect(); result.setRagConnect(this); for (EndpointDefinition def : getEndpointDefinitionList()) { - if (def.isSendTokenEndpointDefinition()) { - SendTokenEndpointDefinition sendDef = def.asSendTokenEndpointDefinition(); - result.addSendDefinition(sendDef.toMustache()); + if (def.isReceiveTokenEndpointDefinition()) { + result.addTokenReceiveDefinition(def.asReceiveTokenEndpointDefinition().toMustache()); + } else if (def.isSendTokenEndpointDefinition()) { + result.addTokenSendDefinition(def.asSendTokenEndpointDefinition().toMustache()); + } else if (def.isReceiveTypeEndpointDefinition()) { + result.addTypeReceiveDefinition(def.asReceiveTypeEndpointDefinition().toMustache()); + } else if (def.isSendTypeEndpointDefinition()) { + result.addTypeSendDefinition(def.asSendTypeEndpointDefinition().toMustache()); } else { - result.addReceiveDefinition(def.asReceiveTokenEndpointDefinition().toMustache()); + throw new RuntimeException("Unknown endpoint definition: " + def); } } for (MappingDefinition def : allMappingDefinitions()) { @@ -163,20 +208,34 @@ aspect AttributesForMustache { } } - syn lazy MReceiveDefinition ReceiveTokenEndpointDefinition.toMustache() { - MReceiveDefinition result = new MReceiveDefinition(); + syn lazy MTokenReceiveDefinition ReceiveTokenEndpointDefinition.toMustache() { + MTokenReceiveDefinition result = new MTokenReceiveDefinition(); result.setReceiveTokenEndpointDefinition(this); result.addInnerMappings(); return result; } - syn lazy MSendDefinition SendTokenEndpointDefinition.toMustache() { - MSendDefinition result = new MSendDefinition(); + syn lazy MTokenSendDefinition SendTokenEndpointDefinition.toMustache() { + MTokenSendDefinition result = new MTokenSendDefinition(); result.setSendTokenEndpointDefinition(this); result.addInnerMappings(); return result; } + syn lazy MTypeReceiveDefinition ReceiveTypeEndpointDefinition.toMustache() { + MTypeReceiveDefinition result = new MTypeReceiveDefinition(); + result.setReceiveTypeEndpointDefinition(this); + result.addInnerMappings(); + return result; + } + + syn lazy MTypeSendDefinition SendTypeEndpointDefinition.toMustache() { + MTypeSendDefinition result = new MTypeSendDefinition(); + result.setSendTypeEndpointDefinition(this); + result.addInnerMappings(); + return result; + } + syn lazy MMappingDefinition MappingDefinition.toMustache() { MMappingDefinition result = new MMappingDefinition(); result.setMappingDefinition(this); diff --git a/ragconnect.base/src/main/jastadd/intermediate/Mappings.jrag b/ragconnect.base/src/main/jastadd/intermediate/Mappings.jrag index 7aa82d304079592d605997484d1348a3d3681875..1ef7d167efd07d06d9dbea7ca8d37ba3a30e1186 100644 --- a/ragconnect.base/src/main/jastadd/intermediate/Mappings.jrag +++ b/ragconnect.base/src/main/jastadd/intermediate/Mappings.jrag @@ -79,44 +79,32 @@ aspect DefaultMappings { aspect Mappings { // --- effectiveMappings --- - syn java.util.List<MappingDefinition> EndpointDefinition.effectiveMappings(); - eq ReceiveTokenEndpointDefinition.effectiveMappings() { - // if there is a first mapping, check if it is suitable. - // or if no mappings are specified. - // then prepend the suitable default mapping + syn java.util.List<MappingDefinition> EndpointDefinition.effectiveMappings() { java.util.List<MappingDefinition> result; - if (getMappingList().isEmpty() || !hasSuitableEdgeMapping()) { - result = new java.util.ArrayList(); - result.add(suitableDefaultMapping()); - result.addAll(getMappingList()); + if (isReceiveTokenEndpointDefinition() || isReceiveTypeEndpointDefinition()) { + // if no mappings are specified, or if first mapping is not suitable. + // then prepend the suitable default mapping + if (getMappingList().isEmpty() || !getMappingList().get(0).getFromType().isByteArray()) { + result = new java.util.ArrayList(); + result.add(suitableReceiveDefaultMapping()); + result.addAll(getMappingList()); + } else { + result = getMappingList(); + } + } else if (isSendTokenEndpointDefinition() || isSendTypeEndpointDefinition()) { + // if no mappings are specified, or if last mapping is not suitable + // then append the suitable default mapping + if (getMappingList().isEmpty() || !getMappingList().get(getMappingList().size() - 1).getToType().isByteArray()) { + result = new java.util.ArrayList(getMappingList()); + result.add(suitableSendDefaultMapping()); + } else { + result = getMappingList(); + } } else { - result = getMappingList(); + throw new RuntimeException("Unknown endpoint definition: " + this); } return result; } - eq SendTokenEndpointDefinition.effectiveMappings() { - // if there is a mapping, check if it is suitable. - // or if no mappings are specified. - // then append the suitable default mapping - java.util.List<MappingDefinition> result; - if (getMappingList().isEmpty() || !hasSuitableEdgeMapping()) { - result = new java.util.ArrayList(getMappingList()); - result.add(suitableDefaultMapping()); - } else { - result = getMappingList(); - } - return result; - } - - // --- hasSuitableEdgeMapping --- - syn boolean TokenEndpointDefinition.hasSuitableEdgeMapping(); - eq ReceiveTokenEndpointDefinition.hasSuitableEdgeMapping() = isSuitableEdgeMapping(getMappingList().get(0)); - eq SendTokenEndpointDefinition.hasSuitableEdgeMapping() = isSuitableEdgeMapping(getMappingList().get(getMappingList().size() - 1)); - - // --- isSuitableEdgeMapping(def) --- - syn boolean TokenEndpointDefinition.isSuitableEdgeMapping(MappingDefinition def); - eq ReceiveTokenEndpointDefinition.isSuitableEdgeMapping(MappingDefinition def) = def.getFromType().isByteArray(); - eq SendTokenEndpointDefinition.isSuitableEdgeMapping(MappingDefinition def) = def.getToType().isByteArray(); // --- isPrimitiveType --- syn boolean TokenComponent.isPrimitiveType() = effectiveJavaTypeUse().isPrimitiveType(); @@ -140,13 +128,9 @@ aspect Mappings { syn boolean MappingDefinitionType.isArray() = false; eq JavaArrayMappingDefinitionType.isArray() = true; - // --- suitableDefaultMapping --- - syn DefaultMappingDefinition EndpointDefinition.suitableDefaultMapping(); - eq ReceiveTokenEndpointDefinition.suitableDefaultMapping() { - String typeName = getMappingList().isEmpty() ? - getToken().effectiveJavaTypeUse().getName() : - getMappingList().get(0).getFromType().prettyPrint(); - switch(typeName) { + // --- suitableReceiveDefaultMapping --- + syn DefaultMappingDefinition EndpointDefinition.suitableReceiveDefaultMapping() { + switch (targetTypeName()) { case "int": case "Integer": return ragconnect().defaultBytesToIntMapping(); case "short": @@ -163,11 +147,9 @@ aspect Mappings { default: return null; } } - eq SendTokenEndpointDefinition.suitableDefaultMapping() { - String typeName = getMappingList().isEmpty() ? - getToken().effectiveJavaTypeUse().getName() : - getMappingList().get(getMappingList().size() - 1).getFromType().prettyPrint(); - switch(typeName) { + // --- suitableSendDefaultMapping --- + syn DefaultMappingDefinition EndpointDefinition.suitableSendDefaultMapping() { + switch (targetTypeName()) { case "int": case "Integer": return ragconnect().defaultIntToBytesMapping(); case "short": @@ -184,6 +166,26 @@ aspect Mappings { default: return null; } } + + // --- targetTypeName --- + syn String EndpointDefinition.targetTypeName(); + eq ReceiveTokenEndpointDefinition.targetTypeName() { + return getMappingList().isEmpty() ? + getToken().effectiveJavaTypeUse().getName() : + getMappingList().get(0).getFromType().prettyPrint(); + } + eq ReceiveTypeEndpointDefinition.targetTypeName() { + return getMappingList().get(0).getFromType().prettyPrint(); + } + eq SendTokenEndpointDefinition.targetTypeName() { + return getMappingList().isEmpty() ? + getToken().effectiveJavaTypeUse().getName() : + getMappingList().get(getMappingList().size() - 1).getToType().prettyPrint(); + } + eq SendTypeEndpointDefinition.targetTypeName() { + return getMappingList().get(getMappingList().size() - 1).getToType().prettyPrint(); + } + // eq ReceiveFromRestDefinition.suitableDefaultMapping() { // String typeName = getMappingList().isEmpty() ? // getToken().getJavaTypeUse().getName() : diff --git a/ragconnect.base/src/main/jastadd/intermediate/MustacheNodes.relast b/ragconnect.base/src/main/jastadd/intermediate/MustacheNodes.relast index 06843177098ba889b665257c9ba2f965f5ecda88..8255cfe5ad9e67e00e53e95b4ddc110a480dce28 100644 --- a/ragconnect.base/src/main/jastadd/intermediate/MustacheNodes.relast +++ b/ragconnect.base/src/main/jastadd/intermediate/MustacheNodes.relast @@ -1,7 +1,13 @@ -MRagConnect ::= ReceiveDefinition:MReceiveDefinition* SendDefinition:MSendDefinition* MappingDefinition:MMappingDefinition* DependencyDefinition:MDependencyDefinition* RootTypeComponent:MTypeComponent* TokenComponent:MTokenComponent* Handler:MHandler*; +MRagConnect ::= TokenReceiveDefinition:MTokenReceiveDefinition* TokenSendDefinition:MTokenSendDefinition* TypeReceiveDefinition:MTypeReceiveDefinition* TypeSendDefinition:MTypeSendDefinition* MappingDefinition:MMappingDefinition* DependencyDefinition:MDependencyDefinition* RootTypeComponent:MTypeComponent* TokenComponent:MTokenComponent* Handler:MHandler*; + abstract MEndpointDefinition ::= InnerMappingDefinition:MInnerMappingDefinition*; -MReceiveDefinition : MEndpointDefinition; -MSendDefinition : MEndpointDefinition; +abstract MTokenEndpointDefinition : MEndpointDefinition; +MTokenReceiveDefinition : MTokenEndpointDefinition; +MTokenSendDefinition : MTokenEndpointDefinition; +abstract MTypeEndpointDefinition : MEndpointDefinition; +MTypeReceiveDefinition : MTypeEndpointDefinition; +MTypeSendDefinition : MTypeEndpointDefinition; + MMappingDefinition; MInnerMappingDefinition; MDependencyDefinition; @@ -11,8 +17,10 @@ MHandler ::= <ClassName> <Construction> <AttributeName> <FieldName> <InUse:boole rel MRagConnect.RagConnect -> RagConnect; rel MInnerMappingDefinition.MMappingDefinition -> MMappingDefinition; -rel MReceiveDefinition.ReceiveTokenEndpointDefinition -> ReceiveTokenEndpointDefinition; -rel MSendDefinition.SendTokenEndpointDefinition -> SendTokenEndpointDefinition; +rel MTokenReceiveDefinition.ReceiveTokenEndpointDefinition -> ReceiveTokenEndpointDefinition; +rel MTokenSendDefinition.SendTokenEndpointDefinition -> SendTokenEndpointDefinition; +rel MTypeReceiveDefinition.ReceiveTypeEndpointDefinition -> ReceiveTypeEndpointDefinition; +rel MTypeSendDefinition.SendTypeEndpointDefinition -> SendTypeEndpointDefinition; rel MMappingDefinition.MappingDefinition -> MappingDefinition; rel MDependencyDefinition.DependencyDefinition -> DependencyDefinition; rel MTypeComponent.TypeComponent -> TypeComponent; diff --git a/ragconnect.base/src/main/jastadd/intermediate2mustache/MustacheNodesToYAML.jrag b/ragconnect.base/src/main/jastadd/intermediate2mustache/MustacheNodesToYAML.jrag index 337527db4b44261a30c6768450ded30ad99446db..9de1c1e6ecf3e2f05580b3c324316708e353ad40 100644 --- a/ragconnect.base/src/main/jastadd/intermediate2mustache/MustacheNodesToYAML.jrag +++ b/ragconnect.base/src/main/jastadd/intermediate2mustache/MustacheNodesToYAML.jrag @@ -25,19 +25,33 @@ aspect MustacheNodesToYAML { root.put("restHandlerField", restHandlerField()); root.put("restHandlerAttribute", restHandlerAttribute()); - // ReceiveDefinitions + // TokenReceiveDefinitions ListElement receiveDefinitions = new ListElement(); - for (MReceiveDefinition def : getReceiveDefinitionList()) { + for (MTokenReceiveDefinition def : getTokenReceiveDefinitionList()) { receiveDefinitions.addElement(def.toYAML()); } - root.put("ReceiveDefinitions", receiveDefinitions); + root.put("TokenReceiveDefinitions", receiveDefinitions); - // SendDefinitions + // TokenSendDefinitions ListElement sendDefinitions = new ListElement(); - for (MSendDefinition def : getSendDefinitionList()) { + for (MTokenSendDefinition def : getTokenSendDefinitionList()) { sendDefinitions.addElement(def.toYAML()); } - root.put("SendDefinitions", sendDefinitions); + root.put("TokenSendDefinitions", sendDefinitions); + + // TypeReceiveDefinitions + ListElement typeReceiveDefinitions = new ListElement(); + for (MTypeReceiveDefinition def : getTypeReceiveDefinitionList()) { + typeReceiveDefinitions.addElement(def.toYAML()); + } + root.put("TypeReceiveDefinitions", typeReceiveDefinitions); + + // TypeSendDefinitions + ListElement typeSendDefinitions = new ListElement(); + for (MTypeSendDefinition def : getTypeSendDefinitionList()) { + typeSendDefinitions.addElement(def.toYAML()); + } + root.put("TypeSendDefinitions", typeSendDefinitions); // MappingDefinitions ListElement mappingDefinitions = new ListElement(); @@ -88,13 +102,30 @@ aspect MustacheNodesToYAML { return result; } - syn MappingElement MReceiveDefinition.toYAML() { + syn MappingElement MTokenReceiveDefinition.toYAML() { + MappingElement result = super.toYAML(); + result.put("loggingEnabledForReads", loggingEnabledForReads); + return result; + } + + syn MappingElement MTokenSendDefinition.toYAML() { + MappingElement result = super.toYAML(); + result.put("sender", sender()); + result.put("lastValue", lastValue()); + result.put("loggingEnabledForWrites", loggingEnabledForWrites); + result.put("updateMethod", updateMethod()); + result.put("writeMethod", writeMethod()); + result.put("tokenResetMethod", tokenResetMethod()); + return result; + } + + syn MappingElement MTypeReceiveDefinition.toYAML() { MappingElement result = super.toYAML(); result.put("loggingEnabledForReads", loggingEnabledForReads); return result; } - syn MappingElement MSendDefinition.toYAML() { + syn MappingElement MTypeSendDefinition.toYAML() { MappingElement result = super.toYAML(); result.put("sender", sender()); result.put("lastValue", lastValue()); diff --git a/ragconnect.base/src/main/jastadd/parser/RagConnect.parser b/ragconnect.base/src/main/jastadd/parser/RagConnect.parser index 0432b0df96c44060f6df1d6918a856f62810230d..4094bfa23d62f87540939f2619274ade313f6db4 100644 --- a/ragconnect.base/src/main/jastadd/parser/RagConnect.parser +++ b/ragconnect.base/src/main/jastadd/parser/RagConnect.parser @@ -33,12 +33,18 @@ EndpointDefinition endpoint_definition EndpointDefinition endpoint_definition_type = RECEIVE token_ref {: return new ReceiveTokenEndpointDefinition().setToken(token_ref); :} | SEND token_ref {: return new SendTokenEndpointDefinition().setToken(token_ref); :} + | RECEIVE TREE type_ref {: return new ReceiveTypeEndpointDefinition().setType(type_ref); :} + | SEND TREE type_ref {: return new SendTypeEndpointDefinition().setType(type_ref); :} ; TokenComponent token_ref = ID.type_name DOT ID.token_name {: return TokenComponent.createRef(type_name + "." + token_name); :} ; +TypeComponent type_ref + = ID.parent_type_name DOT ID.child_type_name {: return TypeComponent.createRef(parent_type_name + "." + child_type_name); :} +; + ArrayList string_list = ID | string_list COMMA ID diff --git a/ragconnect.base/src/main/jastadd/scanner/Keywords.flex b/ragconnect.base/src/main/jastadd/scanner/Keywords.flex index 5773118d8fda8ffdc536b504aa7056b8784ddfb3..40d751b37ffab7ffe63355f50e226f794de02c3b 100644 --- a/ragconnect.base/src/main/jastadd/scanner/Keywords.flex +++ b/ragconnect.base/src/main/jastadd/scanner/Keywords.flex @@ -5,3 +5,4 @@ "maps" { return sym(Terminals.MAPS); } "to" { return sym(Terminals.TO); } "as" { return sym(Terminals.AS); } +"tree" { return sym(Terminals.TREE); } diff --git a/ragconnect.base/src/main/resources/ragconnect.mustache b/ragconnect.base/src/main/resources/ragconnect.mustache index 45e5e11c33c8988286c4b209f9d04ee956f5da29..41cde06f025abc9663ce1acae3ee7549f5987956 100644 --- a/ragconnect.base/src/main/resources/ragconnect.mustache +++ b/ragconnect.base/src/main/resources/ragconnect.mustache @@ -1,13 +1,21 @@ {{#usesMqtt}}{{> mqtt}}{{/usesMqtt}} {{> handler}} aspect RagConnect { - {{#ReceiveDefinitions}} + {{#TokenReceiveDefinitions}} {{> receiveDefinition}} - {{/ReceiveDefinitions}} + {{/TokenReceiveDefinitions}} - {{#SendDefinitions}} + {{#TokenSendDefinitions}} {{> sendDefinition}} - {{/SendDefinitions}} + {{/TokenSendDefinitions}} + + {{#TypeReceiveDefinitions}} + {{> receiveDefinition}} + {{/TypeReceiveDefinitions}} + + {{#TypeSendDefinitions}} + {{> sendDefinition}} + {{/TypeSendDefinitions}} {{#MappingDefinitions}} {{> mappingDefinition}} @@ -20,6 +28,18 @@ aspect RagConnect { {{#TokenComponents}} {{> tokenComponent}} {{/TokenComponents}} + public void {{rootNodeName}}.ragconnectCheckIncremental() { + {{#incrementalOptionActive}} + // check if --tracing is active + trace().getReceiver(); + // check if tracing of INC_FLUSH_ATTR is possible, i.e., if --tracing=flush + ASTState.Trace.Event checkTracing = ASTState.Trace.Event.INC_FLUSH_ATTR; + // check if --rewrite is active + mayHaveRewrite(); + // check if --incremental is active + Object checkIncremental = inc_throwAway_visited; + {{/incrementalOptionActive}} + } } {{#incrementalOptionActive}} diff --git a/ragconnect.tests/build.gradle b/ragconnect.tests/build.gradle index d2e772edfb66165bc18e1bf33614d2e5468ecb59..1ff5652f946d8a8c7f8b88d03b3e10fa171e00e7 100644 --- a/ragconnect.tests/build.gradle +++ b/ragconnect.tests/build.gradle @@ -76,7 +76,15 @@ task allTests(type: Test, dependsOn: testClasses) { useJUnitPlatform { includeTags 'mqtt' -// excludeTags '!NewTest' + } +} + +task specificTest(type: Test, dependsOn: testClasses) { + description = 'Run test tagged with "NewTest"' + group = 'verification' + + useJUnitPlatform { + includeTags 'NewTest' } } @@ -362,8 +370,7 @@ task preprocessIncrementalTest(type: JavaExec, group: 'verification') { 'src/test/01-input/incremental/Test.connect', '--rootNode=A', '--tracing=cache,flush', - '--incremental=param', - '--logReads', '--logWrites', '--verbose' + '--incremental=param' } task compileIncrementalTest(type: RelastTest) { @@ -377,11 +384,43 @@ task compileIncrementalTest(type: RelastTest) { 'src/test/02-after-ragconnect/incremental/MqttHandler.jadd', 'src/test/02-after-ragconnect/incremental/RagConnect.jadd' extraJastAddOptions '--tracing=cache,flush', - '--incremental=param', - '--cache=all', - '--rewrite=cnta', - '--flush=full' + '--incremental=param', + '--cache=all', + '--rewrite=cnta', + '--flush=full' } compileTestJava.dependsOn compileIncrementalTest compileIncrementalTest.dependsOn preprocessIncrementalTest + +// --- Test: mapping --- +task preprocessMappingTest(type: JavaExec, group: 'verification') { + doFirst { + delete 'src/test/02-after-ragconnect/mapping/Test.relast', + 'src/test/02-after-ragconnect/mapping/MqttHandler.jadd', + 'src/test/02-after-ragconnect/mapping/RagConnect.jadd' + } + + classpath = sourceSets.main.runtimeClasspath + main = 'org.jastadd.ragconnect.compiler.Compiler' + args '--o=src/test/02-after-ragconnect/mapping', + 'src/test/01-input/mapping/Test.relast', + 'src/test/01-input/mapping/Test.connect', + '--rootNode=A', + '--logReads', '--logWrites', '--verbose' +} + +task compileMappingTest(type: RelastTest) { + useJastAddNames = true + jastAddList = 'JastAddList' + relastFiles 'src/test/02-after-ragconnect/mapping/Test.relast', + 'src/test/02-after-ragconnect/mapping/RagConnect.relast' + grammarName = 'src/test/03-after-relast/mapping/mapping' + packageName = 'mapping.ast' + moreInputFiles 'src/test/01-input/mapping/Test.jadd', + 'src/test/02-after-ragconnect/mapping/MqttHandler.jadd', + 'src/test/02-after-ragconnect/mapping/RagConnect.jadd' +} + +compileTestJava.dependsOn compileMappingTest +compileMappingTest.dependsOn preprocessMappingTest diff --git a/ragconnect.tests/src/test/01-input/defaultOnlyRead/Test.connect b/ragconnect.tests/src/test/01-input/defaultOnlyRead/Test.connect index e274994175513ff743409068375f419b6e3141fc..475d91614073a4a3e8211a5e9e7362c6c832f0e0 100644 --- a/ragconnect.tests/src/test/01-input/defaultOnlyRead/Test.connect +++ b/ragconnect.tests/src/test/01-input/defaultOnlyRead/Test.connect @@ -7,9 +7,46 @@ receive NativeTypes.DoubleValue; receive NativeTypes.CharValue; receive NativeTypes.StringValue; +receive NativeTypes.IntValueTransformed using IntTransformation; +receive NativeTypes.ShortValueTransformed using ShortTransformation; +receive NativeTypes.LongValueTransformed using LongTransformation; +receive NativeTypes.FloatValueTransformed using FloatTransformation; +receive NativeTypes.DoubleValueTransformed using DoubleTransformation; +receive NativeTypes.CharValueTransformed using CharTransformation; +receive NativeTypes.StringValueTransformed using StringTransformation; + receive BoxedTypes.IntValue; receive BoxedTypes.ShortValue; receive BoxedTypes.LongValue; receive BoxedTypes.FloatValue; receive BoxedTypes.DoubleValue; receive BoxedTypes.CharValue; + +receive BoxedTypes.IntValueTransformed using IntTransformation; +receive BoxedTypes.ShortValueTransformed using ShortTransformation; +receive BoxedTypes.LongValueTransformed using LongTransformation; +receive BoxedTypes.FloatValueTransformed using FloatTransformation; +receive BoxedTypes.DoubleValueTransformed using DoubleTransformation; +receive BoxedTypes.CharValueTransformed using CharTransformation; + +IntTransformation maps int i to int {: + return i; +:} +ShortTransformation maps short s to short {: + return s; +:} +LongTransformation maps long l to long {: + return l; +:} +FloatTransformation maps float f to float {: + return f; +:} +DoubleTransformation maps double d to double {: + return d; +:} +CharTransformation maps char c to char {: + return c; +:} +StringTransformation maps String s to String {: + return s; +:} diff --git a/ragconnect.tests/src/test/01-input/defaultOnlyRead/Test.relast b/ragconnect.tests/src/test/01-input/defaultOnlyRead/Test.relast index 30eba76b346dace40c72ca4e172b88ef206ea063..750dc0795e39ae42eb10d9ed733ea9a01fc05c26 100644 --- a/ragconnect.tests/src/test/01-input/defaultOnlyRead/Test.relast +++ b/ragconnect.tests/src/test/01-input/defaultOnlyRead/Test.relast @@ -1,3 +1,3 @@ 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> ; +NativeTypes ::= <IntValue:int> <ShortValue:short> <LongValue:long> <FloatValue:float> <DoubleValue:double> <CharValue:char> <StringValue:String> <IntValueTransformed:int> <ShortValueTransformed:short> <LongValueTransformed:long> <FloatValueTransformed:float> <DoubleValueTransformed:double> <CharValueTransformed:char> <StringValueTransformed:String> ; +BoxedTypes ::= <IntValue:Integer> <ShortValue:Short> <LongValue:Long> <FloatValue:Float> <DoubleValue:Double> <CharValue:Character> <IntValueTransformed:Integer> <ShortValueTransformed:Short> <LongValueTransformed:Long> <FloatValueTransformed:Float> <DoubleValueTransformed:Double> <CharValueTransformed:Character> ; diff --git a/ragconnect.tests/src/test/01-input/defaultOnlyWrite/Test.connect b/ragconnect.tests/src/test/01-input/defaultOnlyWrite/Test.connect index a48f49f60f66c3358ee513e79f2bbeb43df8d5e9..076809cf16de0b52b809856e0d17ac0010c8f21f 100644 --- a/ragconnect.tests/src/test/01-input/defaultOnlyWrite/Test.connect +++ b/ragconnect.tests/src/test/01-input/defaultOnlyWrite/Test.connect @@ -8,6 +8,15 @@ send NativeTypesSyn.DoubleValue; send NativeTypesSyn.CharValue; send NativeTypesSyn.StringValue; +// native types, synthesized, transformed +send NativeTypesSyn.IntValueTransformed using IntTransformation; +send NativeTypesSyn.ShortValueTransformed using ShortTransformation; +send NativeTypesSyn.LongValueTransformed using LongTransformation; +send NativeTypesSyn.FloatValueTransformed using FloatTransformation; +send NativeTypesSyn.DoubleValueTransformed using DoubleTransformation; +send NativeTypesSyn.CharValueTransformed using CharTransformation; +send NativeTypesSyn.StringValueTransformed using StringTransformation; + // boxed types, synthesized send BoxedTypesSyn.IntValue; send BoxedTypesSyn.ShortValue; @@ -16,6 +25,14 @@ send BoxedTypesSyn.FloatValue; send BoxedTypesSyn.DoubleValue; send BoxedTypesSyn.CharValue; +// boxed types, synthesized, transformed +send BoxedTypesSyn.IntValueTransformed using IntTransformation; +send BoxedTypesSyn.ShortValueTransformed using ShortTransformation; +send BoxedTypesSyn.LongValueTransformed using LongTransformation; +send BoxedTypesSyn.FloatValueTransformed using FloatTransformation; +send BoxedTypesSyn.DoubleValueTransformed using DoubleTransformation; +send BoxedTypesSyn.CharValueTransformed using CharTransformation; + // --- dependency definitions --- NativeTypesSyn.IntValue canDependOn NativeTypesSyn.DriverSyn as nativeIntDependency; NativeTypesSyn.ShortValue canDependOn NativeTypesSyn.DriverSyn as nativeShortDependency; @@ -31,6 +48,21 @@ BoxedTypesSyn.FloatValue canDependOn BoxedTypesSyn.DriverSyn as boxedFloatDepend BoxedTypesSyn.DoubleValue canDependOn BoxedTypesSyn.DriverSyn as boxedDoubleDependency; BoxedTypesSyn.CharValue canDependOn BoxedTypesSyn.DriverSyn as boxedCharDependency; +NativeTypesSyn.IntValueTransformed canDependOn NativeTypesSyn.DriverSyn as nativeIntTransformedDependency; +NativeTypesSyn.ShortValueTransformed canDependOn NativeTypesSyn.DriverSyn as nativeShortTransformedDependency; +NativeTypesSyn.LongValueTransformed canDependOn NativeTypesSyn.DriverSyn as nativeLongTransformedDependency; +NativeTypesSyn.FloatValueTransformed canDependOn NativeTypesSyn.DriverSyn as nativeFloatTransformedDependency; +NativeTypesSyn.DoubleValueTransformed canDependOn NativeTypesSyn.DriverSyn as nativeDoubleTransformedDependency; +NativeTypesSyn.CharValueTransformed canDependOn NativeTypesSyn.DriverSyn as nativeCharTransformedDependency; +NativeTypesSyn.StringValueTransformed canDependOn NativeTypesSyn.DriverSyn as nativeStringTransformedDependency; + +BoxedTypesSyn.IntValueTransformed canDependOn BoxedTypesSyn.DriverSyn as boxedIntTransformedDependency; +BoxedTypesSyn.ShortValueTransformed canDependOn BoxedTypesSyn.DriverSyn as boxedShortTransformedDependency; +BoxedTypesSyn.LongValueTransformed canDependOn BoxedTypesSyn.DriverSyn as boxedLongTransformedDependency; +BoxedTypesSyn.FloatValueTransformed canDependOn BoxedTypesSyn.DriverSyn as boxedFloatTransformedDependency; +BoxedTypesSyn.DoubleValueTransformed canDependOn BoxedTypesSyn.DriverSyn as boxedDoubleTransformedDependency; +BoxedTypesSyn.CharValueTransformed canDependOn BoxedTypesSyn.DriverSyn as boxedCharTransformedDependency; + // --- inherited attributes not supported --- //// native types, inherited @@ -49,3 +81,25 @@ BoxedTypesSyn.CharValue canDependOn BoxedTypesSyn.DriverSyn as boxedCharDependen //send BoxedTypesInh.FloatValue; //send BoxedTypesInh.DoubleValue; //send BoxedTypesInh.CharValue; + +IntTransformation maps int i to int {: + return i; +:} +ShortTransformation maps short s to short {: + return s; +:} +LongTransformation maps long l to long {: + return l; +:} +FloatTransformation maps float f to float {: + return f; +:} +DoubleTransformation maps double d to double {: + return d; +:} +CharTransformation maps char c to char {: + return c; +:} +StringTransformation maps String s to String {: + return s; +:} diff --git a/ragconnect.tests/src/test/01-input/defaultOnlyWrite/Test.jadd b/ragconnect.tests/src/test/01-input/defaultOnlyWrite/Test.jadd index 49bbf604d398f7a9d92e879b2b515c9e83dd3182..1692609251ba21e58d41049a58eadd1efdf4753c 100644 --- a/ragconnect.tests/src/test/01-input/defaultOnlyWrite/Test.jadd +++ b/ragconnect.tests/src/test/01-input/defaultOnlyWrite/Test.jadd @@ -7,6 +7,13 @@ aspect Computation { syn double NativeTypesSyn.getDoubleValue() = Double.parseDouble(getDriverSyn()); syn char NativeTypesSyn.getCharValue() = getDriverSyn().charAt(0); syn String NativeTypesSyn.getStringValue() = new String(getDriverSyn()); + syn int NativeTypesSyn.getIntValueTransformed() = Integer.parseInt(getDriverSyn()); + syn short NativeTypesSyn.getShortValueTransformed() = Short.parseShort(getDriverSyn()); + syn long NativeTypesSyn.getLongValueTransformed() = Long.parseLong(getDriverSyn()); + syn float NativeTypesSyn.getFloatValueTransformed() = Float.parseFloat(getDriverSyn()); + syn double NativeTypesSyn.getDoubleValueTransformed() = Double.parseDouble(getDriverSyn()); + syn char NativeTypesSyn.getCharValueTransformed() = getDriverSyn().charAt(0); + syn String NativeTypesSyn.getStringValueTransformed() = new String(getDriverSyn()); // boxed types, synthesized syn Integer BoxedTypesSyn.getIntValue() = Integer.valueOf(getDriverSyn()); @@ -15,6 +22,12 @@ aspect Computation { syn Float BoxedTypesSyn.getFloatValue() = Float.valueOf(getDriverSyn()); syn Double BoxedTypesSyn.getDoubleValue() = Double.valueOf(getDriverSyn()); syn Character BoxedTypesSyn.getCharValue() = getDriverSyn().charAt(0); + syn Integer BoxedTypesSyn.getIntValueTransformed() = Integer.valueOf(getDriverSyn()); + syn Short BoxedTypesSyn.getShortValueTransformed() = Short.valueOf(getDriverSyn()); + syn Long BoxedTypesSyn.getLongValueTransformed() = Long.valueOf(getDriverSyn()); + syn Float BoxedTypesSyn.getFloatValueTransformed() = Float.valueOf(getDriverSyn()); + syn Double BoxedTypesSyn.getDoubleValueTransformed() = Double.valueOf(getDriverSyn()); + syn Character BoxedTypesSyn.getCharValueTransformed() = getDriverSyn().charAt(0); // --- inherited attributes not supported --- // // native types, inherited diff --git a/ragconnect.tests/src/test/01-input/defaultOnlyWrite/Test.relast b/ragconnect.tests/src/test/01-input/defaultOnlyWrite/Test.relast index e0fd7829b88b8fac04b64393e0262c69b4ac6a62..56452539efeeec9cdd67f5e17a61bb0e41061a57 100644 --- a/ragconnect.tests/src/test/01-input/defaultOnlyWrite/Test.relast +++ b/ragconnect.tests/src/test/01-input/defaultOnlyWrite/Test.relast @@ -1,8 +1,8 @@ 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>/ ; +NativeTypesSyn ::= <DriverSyn:String> /<IntValue:int>/ /<ShortValue:short>/ /<LongValue:long>/ /<FloatValue:float>/ /<DoubleValue:double>/ /<CharValue:char>/ /<StringValue:String>/ /<IntValueTransformed:int>/ /<ShortValueTransformed:short>/ /<LongValueTransformed:long>/ /<FloatValueTransformed:float>/ /<DoubleValueTransformed:double>/ /<CharValueTransformed:char>/ /<StringValueTransformed:String>/ ; // boxed types, synthesized -BoxedTypesSyn ::= <DriverSyn:String> /<IntValue:Integer>/ /<ShortValue:Short>/ /<LongValue:Long>/ /<FloatValue:Float>/ /<DoubleValue:Double>/ /<CharValue:Character>/ ; +BoxedTypesSyn ::= <DriverSyn:String> /<IntValue:Integer>/ /<ShortValue:Short>/ /<LongValue:Long>/ /<FloatValue:Float>/ /<DoubleValue:Double>/ /<CharValue:Character>/ /<IntValueTransformed:Integer>/ /<ShortValueTransformed:Short>/ /<LongValueTransformed:Long>/ /<FloatValueTransformed:Float>/ /<DoubleValueTransformed:Double>/ /<CharValueTransformed:Character>/ ; // --- inherited attributes not supported --- //// native types, inherited diff --git a/ragconnect.tests/src/test/01-input/mapping/README.md b/ragconnect.tests/src/test/01-input/mapping/README.md new file mode 100644 index 0000000000000000000000000000000000000000..4414f2eca557de36c2f3f0ff76f367d8fec9e20b --- /dev/null +++ b/ragconnect.tests/src/test/01-input/mapping/README.md @@ -0,0 +1,3 @@ +# Default Mapping + +Idea: Check different numbers of sequential mappings diff --git a/ragconnect.tests/src/test/01-input/mapping/Test.connect b/ragconnect.tests/src/test/01-input/mapping/Test.connect new file mode 100644 index 0000000000000000000000000000000000000000..1b38714a1a61afe69d0b494f0e163e8621d08aab --- /dev/null +++ b/ragconnect.tests/src/test/01-input/mapping/Test.connect @@ -0,0 +1,46 @@ +receive NativeTypes.IntValue using String2Int ; +receive NativeTypes.ShortValue using String2Int, Int2Short ; +receive NativeTypes.LongValue using String2Int, Int2Short, Short2Long ; +receive NativeTypes.FloatValue using String2Int, Int2Short, Short2Long, Long2Float ; +receive NativeTypes.DoubleValue using String2Int, Int2Short, Short2Long, Long2Float, Float2Double ; +receive NativeTypes.CharValue using String2Int, Int2Short, Short2Long, Long2Float, Float2Double, Double2Char ; + +send NativeTypes.WriteIntValue using String2Int ; +send NativeTypes.WriteShortValue using String2Int, Int2Short ; +send NativeTypes.WriteLongValue using String2Int, Int2Short, Short2Long ; +send NativeTypes.WriteFloatValue using String2Int, Int2Short, Short2Long, Long2Float ; +send NativeTypes.WriteDoubleValue using String2Int, Int2Short, Short2Long, Long2Float, Float2Double ; +send NativeTypes.WriteCharValue using String2Int, Int2Short, Short2Long, Long2Float, Float2Double, Double2Char ; + +receive BoxedTypes.IntValue using String2Int ; +receive BoxedTypes.ShortValue using String2Int, Int2Short ; +receive BoxedTypes.LongValue using String2Int, Int2Short, Short2Long ; +receive BoxedTypes.FloatValue using String2Int, Int2Short, Short2Long, Long2Float ; +receive BoxedTypes.DoubleValue using String2Int, Int2Short, Short2Long, Long2Float, Float2Double ; +receive BoxedTypes.CharValue using String2Int, Int2Short, Short2Long, Long2Float, Float2Double, Double2Char ; + +String2Int maps String s to int {: + return Integer.parseInt(s); +:} +Int2Short maps int i to short {: + return (short) i; +:} +Short2Long maps short s to long {: + return (long) s; +:} +Long2Float maps long l to float {: + return (float) (l + 0.01); +:} +Float2Double maps float f to double {: + return (double) f; +:} +Double2Char maps double d to char {: + return (char) ((int) d); +:} + +NativeTypes.WriteIntValue canDependOn NativeTypes.Driver as nativeIntDependency; +NativeTypes.WriteShortValue canDependOn NativeTypes.Driver as nativeShortDependency; +NativeTypes.WriteLongValue canDependOn NativeTypes.Driver as nativeLongDependency; +NativeTypes.WriteFloatValue canDependOn NativeTypes.Driver as nativeFloatDependency; +NativeTypes.WriteDoubleValue canDependOn NativeTypes.Driver as nativeDoubleDependency; +NativeTypes.WriteCharValue canDependOn NativeTypes.Driver as nativeCharDependency; diff --git a/ragconnect.tests/src/test/01-input/mapping/Test.jadd b/ragconnect.tests/src/test/01-input/mapping/Test.jadd new file mode 100644 index 0000000000000000000000000000000000000000..7837d7dc7328b0b2ec1563e163383fb242190f5b --- /dev/null +++ b/ragconnect.tests/src/test/01-input/mapping/Test.jadd @@ -0,0 +1,9 @@ +aspect Computation { + // native types, synthesized + syn String NativeTypes.getWriteIntValue() = getDriver(); + syn String NativeTypes.getWriteShortValue() = getDriver(); + syn String NativeTypes.getWriteLongValue() = getDriver(); + syn String NativeTypes.getWriteFloatValue() = getDriver(); + syn String NativeTypes.getWriteDoubleValue() = getDriver(); + syn String NativeTypes.getWriteCharValue() = getDriver(); +} diff --git a/ragconnect.tests/src/test/01-input/mapping/Test.relast b/ragconnect.tests/src/test/01-input/mapping/Test.relast new file mode 100644 index 0000000000000000000000000000000000000000..c15991d5029b783f96b1d0f77fb6c242f0883bf3 --- /dev/null +++ b/ragconnect.tests/src/test/01-input/mapping/Test.relast @@ -0,0 +1,3 @@ +A ::= NativeTypes BoxedTypes ; +NativeTypes ::= <IntValue:int> <ShortValue:short> <LongValue:long> <FloatValue:float> <DoubleValue:double> <CharValue:char> <Driver:String> /<WriteIntValue:String>/ /<WriteShortValue:String>/ /<WriteLongValue:String>/ /<WriteFloatValue:String>/ /<WriteDoubleValue:String>/ /<WriteCharValue:String>/; +BoxedTypes ::= <IntValue:Integer> <ShortValue:Short> <LongValue:Long> <FloatValue:Float> <DoubleValue:Double> <CharValue:Character> ; diff --git a/ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/DefaultOnlyReadTest.java b/ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/DefaultOnlyReadTest.java index 35fd0b77128c2e9c4735e3435dd417a48c5ae010..14b26799670088f7b3acf16bb7f6d1946ae8f914 100644 --- a/ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/DefaultOnlyReadTest.java +++ b/ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/DefaultOnlyReadTest.java @@ -66,6 +66,15 @@ public class DefaultOnlyReadTest extends AbstractMqttTest { floats.connectDoubleValue(mqttUri(TOPIC_NATIVE_DOUBLE)); chars.connectCharValue(mqttUri(TOPIC_NATIVE_CHAR)); chars.connectStringValue(mqttUri(TOPIC_NATIVE_STRING)); + + integers.connectIntValueTransformed(mqttUri(TOPIC_NATIVE_INT)); + integers.connectShortValueTransformed(mqttUri(TOPIC_NATIVE_SHORT)); + integers.connectLongValueTransformed(mqttUri(TOPIC_NATIVE_LONG)); + floats.connectFloatValueTransformed(mqttUri(TOPIC_NATIVE_FLOAT)); + floats.connectDoubleValueTransformed(mqttUri(TOPIC_NATIVE_DOUBLE)); + chars.connectCharValueTransformed(mqttUri(TOPIC_NATIVE_CHAR)); + chars.connectStringValueTransformed(mqttUri(TOPIC_NATIVE_STRING)); + allBoxed.connectIntValue(mqttUri(TOPIC_BOXED_INTEGER)); allBoxed.connectShortValue(mqttUri(TOPIC_BOXED_SHORT)); allBoxed.connectLongValue(mqttUri(TOPIC_BOXED_LONG)); @@ -73,6 +82,13 @@ public class DefaultOnlyReadTest extends AbstractMqttTest { allBoxed.connectDoubleValue(mqttUri(TOPIC_BOXED_DOUBLE)); allBoxed.connectCharValue(mqttUri(TOPIC_BOXED_CHARACTER)); + allBoxed.connectIntValueTransformed(mqttUri(TOPIC_BOXED_INTEGER)); + allBoxed.connectShortValueTransformed(mqttUri(TOPIC_BOXED_SHORT)); + allBoxed.connectLongValueTransformed(mqttUri(TOPIC_BOXED_LONG)); + allBoxed.connectFloatValueTransformed(mqttUri(TOPIC_BOXED_FLOAT)); + allBoxed.connectDoubleValueTransformed(mqttUri(TOPIC_BOXED_DOUBLE)); + allBoxed.connectCharValueTransformed(mqttUri(TOPIC_BOXED_CHARACTER)); + sender = new MqttHandler().dontSendWelcomeMessage().setHost(TestUtils.getMqttHost()); assertTrue(sender.waitUntilReady(2, TimeUnit.SECONDS)); } @@ -117,12 +133,27 @@ public class DefaultOnlyReadTest extends AbstractMqttTest { assertEquals(expectedCharValue, chars.getCharValue()); assertEquals(expectedStringValue, chars.getStringValue()); + assertEquals(expectedIntValue, integers.getIntValueTransformed()); + assertEquals(expectedShortValue, integers.getShortValueTransformed()); + assertEquals(expectedLongValue, integers.getLongValueTransformed()); + assertEquals(expectedFloatValue, floats.getFloatValueTransformed(), TestUtils.DELTA); + assertEquals(expectedDoubleValue, floats.getDoubleValueTransformed(), TestUtils.DELTA); + assertEquals(expectedCharValue, chars.getCharValueTransformed()); + assertEquals(expectedStringValue, chars.getStringValueTransformed()); + assertEquals(expectedIntValue, allBoxed.getIntValue().intValue()); assertEquals(expectedShortValue, allBoxed.getShortValue().shortValue()); assertEquals(expectedLongValue, allBoxed.getLongValue().longValue()); assertEquals(expectedFloatValue, allBoxed.getFloatValue(), TestUtils.DELTA); assertEquals(expectedDoubleValue, allBoxed.getDoubleValue(), TestUtils.DELTA); assertEquals(expectedCharValue, allBoxed.getCharValue().charValue()); + + assertEquals(expectedIntValue, allBoxed.getIntValueTransformed().intValue()); + assertEquals(expectedShortValue, allBoxed.getShortValueTransformed().shortValue()); + assertEquals(expectedLongValue, allBoxed.getLongValueTransformed().longValue()); + assertEquals(expectedFloatValue, allBoxed.getFloatValueTransformed(), TestUtils.DELTA); + assertEquals(expectedDoubleValue, allBoxed.getDoubleValueTransformed(), TestUtils.DELTA); + assertEquals(expectedCharValue, allBoxed.getCharValueTransformed().charValue()); } @Override diff --git a/ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/DefaultOnlyWriteTest.java b/ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/DefaultOnlyWriteTest.java index 05b217f705d6152adf14f6d1f45f4f394a992a76..3044bb53504018a2586552d60a3c21d0b192f0e2 100644 --- a/ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/DefaultOnlyWriteTest.java +++ b/ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/DefaultOnlyWriteTest.java @@ -26,6 +26,14 @@ public class DefaultOnlyWriteTest extends AbstractMqttTest { private static final String TOPIC_NATIVE_CHAR = "native/char"; private static final String TOPIC_NATIVE_STRING = "native/string"; + private static final String TOPIC_NATIVE_INT_TRANSFORMED = "native/int/t"; + private static final String TOPIC_NATIVE_SHORT_TRANSFORMED = "native/short/t"; + private static final String TOPIC_NATIVE_LONG_TRANSFORMED = "native/long/t"; + private static final String TOPIC_NATIVE_FLOAT_TRANSFORMED = "native/float/t"; + private static final String TOPIC_NATIVE_DOUBLE_TRANSFORMED = "native/double/t"; + private static final String TOPIC_NATIVE_CHAR_TRANSFORMED = "native/char/t"; + private static final String TOPIC_NATIVE_STRING_TRANSFORMED = "native/string/t"; + private static final String TOPIC_BOXED_INTEGER = "boxed/Integer"; private static final String TOPIC_BOXED_SHORT = "boxed/Short"; private static final String TOPIC_BOXED_LONG = "boxed/Long"; @@ -33,6 +41,13 @@ public class DefaultOnlyWriteTest extends AbstractMqttTest { private static final String TOPIC_BOXED_DOUBLE = "boxed/Double"; private static final String TOPIC_BOXED_CHARACTER = "boxed/Character"; + private static final String TOPIC_BOXED_INTEGER_TRANSFORMED = "boxed/Integer/t"; + private static final String TOPIC_BOXED_SHORT_TRANSFORMED = "boxed/Short/t"; + private static final String TOPIC_BOXED_LONG_TRANSFORMED = "boxed/Long/t"; + private static final String TOPIC_BOXED_FLOAT_TRANSFORMED = "boxed/Float/t"; + private static final String TOPIC_BOXED_DOUBLE_TRANSFORMED = "boxed/Double/t"; + private static final String TOPIC_BOXED_CHARACTER_TRANSFORMED = "boxed/Character/t"; + private A model; private NativeTypesSyn nativeIntegers; private NativeTypesSyn nativeFloats; @@ -41,7 +56,8 @@ public class DefaultOnlyWriteTest extends AbstractMqttTest { private BoxedTypesSyn boxedFloats; private BoxedTypesSyn boxedChars; private MqttHandler receiver; - private ReceiverData data; + private ReceiverData dataNormal; + private ReceiverData dataTransformed; @Override protected void createModel() { @@ -79,6 +95,14 @@ public class DefaultOnlyWriteTest extends AbstractMqttTest { nativeChars.addNativeCharDependency(nativeChars); nativeChars.addNativeStringDependency(nativeChars); + nativeIntegers.addNativeIntTransformedDependency(nativeIntegers); + nativeIntegers.addNativeShortTransformedDependency(nativeIntegers); + nativeIntegers.addNativeLongTransformedDependency(nativeIntegers); + nativeFloats.addNativeFloatTransformedDependency(nativeFloats); + nativeFloats.addNativeDoubleTransformedDependency(nativeFloats); + nativeChars.addNativeCharTransformedDependency(nativeChars); + nativeChars.addNativeStringTransformedDependency(nativeChars); + boxedIntegers.addBoxedIntDependency(boxedIntegers); boxedIntegers.addBoxedShortDependency(boxedIntegers); boxedIntegers.addBoxedLongDependency(boxedIntegers); @@ -86,60 +110,15 @@ public class DefaultOnlyWriteTest extends AbstractMqttTest { boxedFloats.addBoxedDoubleDependency(boxedFloats); boxedChars.addBoxedCharDependency(boxedChars); - data = new ReceiverData(); + boxedIntegers.addBoxedIntTransformedDependency(boxedIntegers); + boxedIntegers.addBoxedShortTransformedDependency(boxedIntegers); + boxedIntegers.addBoxedLongTransformedDependency(boxedIntegers); + boxedFloats.addBoxedFloatTransformedDependency(boxedFloats); + boxedFloats.addBoxedDoubleTransformedDependency(boxedFloats); + boxedChars.addBoxedCharTransformedDependency(boxedChars); - receiver.newConnection(TOPIC_NATIVE_INT, bytes -> { - data.numberOfNativeIntValues += 1; - data.lastNativeIntValue = java.nio.ByteBuffer.wrap(bytes).getInt(); - }); - receiver.newConnection(TOPIC_NATIVE_SHORT, bytes -> { - data.numberOfNativeShortValues += 1; - data.lastNativeShortValue = java.nio.ByteBuffer.wrap(bytes).getShort(); - }); - receiver.newConnection(TOPIC_NATIVE_LONG, bytes -> { - data.numberOfNativeLongValues += 1; - data.lastNativeLongValue = java.nio.ByteBuffer.wrap(bytes).getLong(); - }); - receiver.newConnection(TOPIC_NATIVE_FLOAT, bytes -> { - data.numberOfNativeFloatValues += 1; - data.lastNativeFloatValue = java.nio.ByteBuffer.wrap(bytes).getFloat(); - }); - receiver.newConnection(TOPIC_NATIVE_DOUBLE, bytes -> { - data.numberOfNativeDoubleValues += 1; - data.lastNativeDoubleValue = java.nio.ByteBuffer.wrap(bytes).getDouble(); - }); - receiver.newConnection(TOPIC_NATIVE_CHAR, bytes -> { - data.numberOfNativeCharValues += 1; - data.lastNativeCharValue = java.nio.ByteBuffer.wrap(bytes).getChar(); - }); - receiver.newConnection(TOPIC_NATIVE_STRING, bytes -> { - data.numberOfNativeStringValues += 1; - data.lastNativeStringValue = new String(bytes); - }); - receiver.newConnection(TOPIC_BOXED_INTEGER, bytes -> { - data.numberOfBoxedIntValues += 1; - data.lastBoxedIntValue = java.nio.ByteBuffer.wrap(bytes).getInt(); - }); - receiver.newConnection(TOPIC_BOXED_SHORT, bytes -> { - data.numberOfBoxedShortValues += 1; - data.lastBoxedShortValue = java.nio.ByteBuffer.wrap(bytes).getShort(); - }); - receiver.newConnection(TOPIC_BOXED_LONG, bytes -> { - data.numberOfBoxedLongValues += 1; - data.lastBoxedLongValue = java.nio.ByteBuffer.wrap(bytes).getLong(); - }); - receiver.newConnection(TOPIC_BOXED_FLOAT, bytes -> { - data.numberOfBoxedFloatValues += 1; - data.lastBoxedFloatValue = java.nio.ByteBuffer.wrap(bytes).getFloat(); - }); - receiver.newConnection(TOPIC_BOXED_DOUBLE, bytes -> { - data.numberOfBoxedDoubleValues += 1; - data.lastBoxedDoubleValue = java.nio.ByteBuffer.wrap(bytes).getDouble(); - }); - receiver.newConnection(TOPIC_BOXED_CHARACTER, bytes -> { - data.numberOfBoxedCharValues += 1; - data.lastBoxedCharValue = java.nio.ByteBuffer.wrap(bytes).getChar(); - }); + dataNormal = createReceiver(false); + dataTransformed = createReceiver(true); nativeIntegers.connectIntValue(mqttUri(TOPIC_NATIVE_INT), writeCurrentValue); nativeIntegers.connectShortValue(mqttUri(TOPIC_NATIVE_SHORT), writeCurrentValue); @@ -148,53 +127,121 @@ public class DefaultOnlyWriteTest extends AbstractMqttTest { nativeFloats.connectDoubleValue(mqttUri(TOPIC_NATIVE_DOUBLE), writeCurrentValue); nativeChars.connectCharValue(mqttUri(TOPIC_NATIVE_CHAR), writeCurrentValue); nativeChars.connectStringValue(mqttUri(TOPIC_NATIVE_STRING), writeCurrentValue); + + nativeIntegers.connectIntValueTransformed(mqttUri(TOPIC_NATIVE_INT_TRANSFORMED), writeCurrentValue); + nativeIntegers.connectShortValueTransformed(mqttUri(TOPIC_NATIVE_SHORT_TRANSFORMED), writeCurrentValue); + nativeIntegers.connectLongValueTransformed(mqttUri(TOPIC_NATIVE_LONG_TRANSFORMED), writeCurrentValue); + nativeFloats.connectFloatValueTransformed(mqttUri(TOPIC_NATIVE_FLOAT_TRANSFORMED), writeCurrentValue); + nativeFloats.connectDoubleValueTransformed(mqttUri(TOPIC_NATIVE_DOUBLE_TRANSFORMED), writeCurrentValue); + nativeChars.connectCharValueTransformed(mqttUri(TOPIC_NATIVE_CHAR_TRANSFORMED), writeCurrentValue); + nativeChars.connectStringValueTransformed(mqttUri(TOPIC_NATIVE_STRING_TRANSFORMED), writeCurrentValue); + boxedIntegers.connectIntValue(mqttUri(TOPIC_BOXED_INTEGER), writeCurrentValue); boxedIntegers.connectShortValue(mqttUri(TOPIC_BOXED_SHORT), writeCurrentValue); boxedIntegers.connectLongValue(mqttUri(TOPIC_BOXED_LONG), writeCurrentValue); boxedFloats.connectFloatValue(mqttUri(TOPIC_BOXED_FLOAT), writeCurrentValue); boxedFloats.connectDoubleValue(mqttUri(TOPIC_BOXED_DOUBLE), writeCurrentValue); boxedChars.connectCharValue(mqttUri(TOPIC_BOXED_CHARACTER), writeCurrentValue); + + boxedIntegers.connectIntValueTransformed(mqttUri(TOPIC_BOXED_INTEGER_TRANSFORMED), writeCurrentValue); + boxedIntegers.connectShortValueTransformed(mqttUri(TOPIC_BOXED_SHORT_TRANSFORMED), writeCurrentValue); + boxedIntegers.connectLongValueTransformed(mqttUri(TOPIC_BOXED_LONG_TRANSFORMED), writeCurrentValue); + boxedFloats.connectFloatValueTransformed(mqttUri(TOPIC_BOXED_FLOAT_TRANSFORMED), writeCurrentValue); + boxedFloats.connectDoubleValueTransformed(mqttUri(TOPIC_BOXED_DOUBLE_TRANSFORMED), writeCurrentValue); + boxedChars.connectCharValueTransformed(mqttUri(TOPIC_BOXED_CHARACTER_TRANSFORMED), writeCurrentValue); + } + + private ReceiverData createReceiver(boolean transformed) { + ReceiverData result = new ReceiverData(); + + receiver.newConnection(transformed ? TOPIC_NATIVE_INT_TRANSFORMED : TOPIC_NATIVE_INT, bytes -> { + result.numberOfNativeIntValues += 1; + result.lastNativeIntValue = java.nio.ByteBuffer.wrap(bytes).getInt(); + }); + receiver.newConnection(transformed ? TOPIC_NATIVE_SHORT_TRANSFORMED : TOPIC_NATIVE_SHORT, bytes -> { + result.numberOfNativeShortValues += 1; + result.lastNativeShortValue = java.nio.ByteBuffer.wrap(bytes).getShort(); + }); + receiver.newConnection(transformed ? TOPIC_NATIVE_LONG_TRANSFORMED : TOPIC_NATIVE_LONG, bytes -> { + result.numberOfNativeLongValues += 1; + result.lastNativeLongValue = java.nio.ByteBuffer.wrap(bytes).getLong(); + }); + receiver.newConnection(transformed ? TOPIC_NATIVE_FLOAT_TRANSFORMED : TOPIC_NATIVE_FLOAT, bytes -> { + result.numberOfNativeFloatValues += 1; + result.lastNativeFloatValue = java.nio.ByteBuffer.wrap(bytes).getFloat(); + }); + receiver.newConnection(transformed ? TOPIC_NATIVE_DOUBLE_TRANSFORMED : TOPIC_NATIVE_DOUBLE, bytes -> { + result.numberOfNativeDoubleValues += 1; + result.lastNativeDoubleValue = java.nio.ByteBuffer.wrap(bytes).getDouble(); + }); + receiver.newConnection(transformed ? TOPIC_NATIVE_CHAR_TRANSFORMED : TOPIC_NATIVE_CHAR, bytes -> { + result.numberOfNativeCharValues += 1; + result.lastNativeCharValue = java.nio.ByteBuffer.wrap(bytes).getChar(); + }); + receiver.newConnection(transformed ? TOPIC_NATIVE_STRING_TRANSFORMED : TOPIC_NATIVE_STRING, bytes -> { + result.numberOfNativeStringValues += 1; + result.lastNativeStringValue = new String(bytes); + }); + receiver.newConnection(transformed ? TOPIC_BOXED_INTEGER_TRANSFORMED : TOPIC_BOXED_INTEGER, bytes -> { + result.numberOfBoxedIntValues += 1; + result.lastBoxedIntValue = java.nio.ByteBuffer.wrap(bytes).getInt(); + }); + receiver.newConnection(transformed ? TOPIC_BOXED_SHORT_TRANSFORMED : TOPIC_BOXED_SHORT, bytes -> { + result.numberOfBoxedShortValues += 1; + result.lastBoxedShortValue = java.nio.ByteBuffer.wrap(bytes).getShort(); + }); + receiver.newConnection(transformed ? TOPIC_BOXED_LONG_TRANSFORMED : TOPIC_BOXED_LONG, bytes -> { + result.numberOfBoxedLongValues += 1; + result.lastBoxedLongValue = java.nio.ByteBuffer.wrap(bytes).getLong(); + }); + receiver.newConnection(transformed ? TOPIC_BOXED_FLOAT_TRANSFORMED : TOPIC_BOXED_FLOAT, bytes -> { + result.numberOfBoxedFloatValues += 1; + result.lastBoxedFloatValue = java.nio.ByteBuffer.wrap(bytes).getFloat(); + }); + receiver.newConnection(transformed ? TOPIC_BOXED_DOUBLE_TRANSFORMED : TOPIC_BOXED_DOUBLE, bytes -> { + result.numberOfBoxedDoubleValues += 1; + result.lastBoxedDoubleValue = java.nio.ByteBuffer.wrap(bytes).getDouble(); + }); + receiver.newConnection(transformed ? TOPIC_BOXED_CHARACTER_TRANSFORMED : TOPIC_BOXED_CHARACTER, bytes -> { + result.numberOfBoxedCharValues += 1; + result.lastBoxedCharValue = java.nio.ByteBuffer.wrap(bytes).getChar(); + }); + return result; } @Override protected void communicateSendInitialValue() throws InterruptedException { // check initial value - TestUtils.waitForMqtt(); checkData(1, 1, 1.1, 'a', "ab"); // set new value setData("2", "2.2", "cd"); // check new value - TestUtils.waitForMqtt(); checkData(2, 2, 2.2, 'c', "cd"); // set new value setData("3", "3.2", "ee"); // check new value - TestUtils.waitForMqtt(); checkData(3, 3, 3.2, 'e', "ee"); } @Override protected void communicateOnlyUpdatedValue() throws InterruptedException { // check initial value (will be default values) - TestUtils.waitForMqtt(); checkData(0, null, null, null, null); // set new value setData("2", "2.2", "cd"); // check new value - TestUtils.waitForMqtt(); checkData(1, 2, 2.2, 'c', "cd"); // set new value setData("3", "3.2", "ee"); // check new value - TestUtils.waitForMqtt(); checkData(2, 3, 3.2, 'e', "ee"); } @@ -220,58 +267,61 @@ public class DefaultOnlyWriteTest extends AbstractMqttTest { private void checkData(int expectedNumberOfValues, Integer expectedInt, Double expectedDouble, - Character expectedChar, String expectedString) { - assertEquals(expectedNumberOfValues, data.numberOfNativeIntValues); - assertEquals(expectedNumberOfValues, data.numberOfNativeShortValues); - assertEquals(expectedNumberOfValues, data.numberOfNativeLongValues); - assertEquals(expectedNumberOfValues, data.numberOfNativeFloatValues); - assertEquals(expectedNumberOfValues, data.numberOfNativeDoubleValues); - assertEquals(expectedNumberOfValues, data.numberOfNativeCharValues); - assertEquals(expectedNumberOfValues, data.numberOfNativeStringValues); - - assertEquals(expectedNumberOfValues, data.numberOfBoxedIntValues); - assertEquals(expectedNumberOfValues, data.numberOfBoxedShortValues); - assertEquals(expectedNumberOfValues, data.numberOfBoxedLongValues); - assertEquals(expectedNumberOfValues, data.numberOfBoxedFloatValues); - assertEquals(expectedNumberOfValues, data.numberOfBoxedDoubleValues); - assertEquals(expectedNumberOfValues, data.numberOfBoxedCharValues); - - if (expectedInt != null) { - assertEquals(expectedInt.intValue(), data.lastNativeIntValue); - assertEquals(expectedInt.shortValue(), data.lastNativeShortValue); - assertEquals(expectedInt.longValue(), data.lastNativeLongValue); - assertEquals(expectedInt.intValue(), data.lastBoxedIntValue.intValue()); - assertEquals(expectedInt.shortValue(), data.lastBoxedShortValue.shortValue()); - assertEquals(expectedInt.longValue(), data.lastBoxedLongValue.longValue()); - } else { - assertEquals(0, data.lastNativeIntValue); - assertEquals(0, data.lastNativeShortValue); - assertEquals(0, data.lastNativeLongValue); - assertNull(data.lastBoxedIntValue); - assertNull(data.lastBoxedShortValue); - assertNull(data.lastBoxedLongValue); - } - - if (expectedDouble != null) { - assertEquals(expectedDouble.floatValue(), data.lastNativeFloatValue, TestUtils.DELTA); - assertEquals(expectedDouble, data.lastNativeDoubleValue, TestUtils.DELTA); - assertEquals(expectedDouble.floatValue(), data.lastBoxedFloatValue, TestUtils.DELTA); - assertEquals(expectedDouble, data.lastBoxedDoubleValue, TestUtils.DELTA); - } else { - assertEquals(0f, data.lastNativeFloatValue, TestUtils.DELTA); - assertEquals(0d, data.lastNativeDoubleValue, TestUtils.DELTA); - assertNull(data.lastBoxedFloatValue); - assertNull(data.lastBoxedDoubleValue); - } - - if (expectedChar != null) { - assertEquals(expectedChar.charValue(), data.lastNativeCharValue); - assertEquals(expectedChar, data.lastBoxedCharValue); - } else { - assertEquals('\0', data.lastNativeCharValue); - assertNull(data.lastBoxedCharValue); + Character expectedChar, String expectedString) throws InterruptedException { + TestUtils.waitForMqtt(); + for (ReceiverData data : new ReceiverData[]{dataNormal, dataTransformed}) { + assertEquals(expectedNumberOfValues, data.numberOfNativeIntValues); + assertEquals(expectedNumberOfValues, data.numberOfNativeShortValues); + assertEquals(expectedNumberOfValues, data.numberOfNativeLongValues); + assertEquals(expectedNumberOfValues, data.numberOfNativeFloatValues); + assertEquals(expectedNumberOfValues, data.numberOfNativeDoubleValues); + assertEquals(expectedNumberOfValues, data.numberOfNativeCharValues); + assertEquals(expectedNumberOfValues, data.numberOfNativeStringValues); + + assertEquals(expectedNumberOfValues, data.numberOfBoxedIntValues); + assertEquals(expectedNumberOfValues, data.numberOfBoxedShortValues); + assertEquals(expectedNumberOfValues, data.numberOfBoxedLongValues); + assertEquals(expectedNumberOfValues, data.numberOfBoxedFloatValues); + assertEquals(expectedNumberOfValues, data.numberOfBoxedDoubleValues); + assertEquals(expectedNumberOfValues, data.numberOfBoxedCharValues); + + if (expectedInt != null) { + assertEquals(expectedInt.intValue(), data.lastNativeIntValue); + assertEquals(expectedInt.shortValue(), data.lastNativeShortValue); + assertEquals(expectedInt.longValue(), data.lastNativeLongValue); + assertEquals(expectedInt.intValue(), data.lastBoxedIntValue.intValue()); + assertEquals(expectedInt.shortValue(), data.lastBoxedShortValue.shortValue()); + assertEquals(expectedInt.longValue(), data.lastBoxedLongValue.longValue()); + } else { + assertEquals(0, data.lastNativeIntValue); + assertEquals(0, data.lastNativeShortValue); + assertEquals(0, data.lastNativeLongValue); + assertNull(data.lastBoxedIntValue); + assertNull(data.lastBoxedShortValue); + assertNull(data.lastBoxedLongValue); + } + + if (expectedDouble != null) { + assertEquals(expectedDouble.floatValue(), data.lastNativeFloatValue, TestUtils.DELTA); + assertEquals(expectedDouble, data.lastNativeDoubleValue, TestUtils.DELTA); + assertEquals(expectedDouble.floatValue(), data.lastBoxedFloatValue, TestUtils.DELTA); + assertEquals(expectedDouble, data.lastBoxedDoubleValue, TestUtils.DELTA); + } else { + assertEquals(0f, data.lastNativeFloatValue, TestUtils.DELTA); + assertEquals(0d, data.lastNativeDoubleValue, TestUtils.DELTA); + assertNull(data.lastBoxedFloatValue); + assertNull(data.lastBoxedDoubleValue); + } + + if (expectedChar != null) { + assertEquals(expectedChar.charValue(), data.lastNativeCharValue); + assertEquals(expectedChar, data.lastBoxedCharValue); + } else { + assertEquals('\0', data.lastNativeCharValue); + assertNull(data.lastBoxedCharValue); + } + assertEquals(expectedString, data.lastNativeStringValue); } - assertEquals(expectedString, data.lastNativeStringValue); } private static class ReceiverData { diff --git a/ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/IncrementalDependencyTest.java b/ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/IncrementalDependencyTest.java index 4c323595ae5e339a0bfeeb0e357a206b33682542..00123e5dbec5cc1a26e3c7d85620b64160943a12 100644 --- a/ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/IncrementalDependencyTest.java +++ b/ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/IncrementalDependencyTest.java @@ -17,7 +17,6 @@ import static org.junit.jupiter.api.Assertions.assertTrue; * * @author rschoene - Initial contribution */ -@Tag("NewTest") public class IncrementalDependencyTest extends AbstractMqttTest { private static final String TOPIC_IN = "in/a"; @@ -42,6 +41,7 @@ public class IncrementalDependencyTest extends AbstractMqttTest { b2 = new B(); model.addB(b1); model.addB(b2); + model.ragconnectCheckIncremental(); } @Override diff --git a/ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/MappingTest.java b/ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/MappingTest.java new file mode 100644 index 0000000000000000000000000000000000000000..84ad0b9e90305e4acbe3a582f403310330c7c9e3 --- /dev/null +++ b/ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/MappingTest.java @@ -0,0 +1,218 @@ +package org.jastadd.ragconnect.tests; + +import mapping.ast.A; +import mapping.ast.BoxedTypes; +import mapping.ast.MqttHandler; +import mapping.ast.NativeTypes; +import org.junit.jupiter.api.Tag; + +import java.io.IOException; +import java.util.concurrent.TimeUnit; + +import static org.jastadd.ragconnect.tests.TestUtils.mqttUri; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * Test case "mapping". + * + * @author rschoene - Initial contribution + */ +@Tag("NewTest") +public class MappingTest extends AbstractMqttTest { + + private static final String TOPIC_INPUT = "input"; + private static final String TOPIC_WRITE_NATIVE_INT = "native/int"; + private static final String TOPIC_WRITE_NATIVE_SHORT = "native/short"; + private static final String TOPIC_WRITE_NATIVE_LONG = "native/long"; + private static final String TOPIC_WRITE_NATIVE_FLOAT = "native/float"; + private static final String TOPIC_WRITE_NATIVE_DOUBLE = "native/double"; + private static final String TOPIC_WRITE_NATIVE_CHAR = "native/char"; + + private A model; + private NativeTypes natives; + private BoxedTypes boxes; + private MqttHandler handler; + private ReceiverData data; + + @Override + protected void createModel() { + model = new A(); + natives = new NativeTypes(); + natives.setDriver("1"); + boxes = new BoxedTypes(); + model.setNativeTypes(natives); + model.setBoxedTypes(boxes); + } + + @Override + protected void setupReceiverAndConnect(boolean writeCurrentValue) throws IOException { + model.ragconnectSetupMqttWaitUntilReady(2, TimeUnit.SECONDS); + + handler = new MqttHandler().dontSendWelcomeMessage().setHost(TestUtils.getMqttHost()); + assertTrue(handler.waitUntilReady(2, TimeUnit.SECONDS)); + + natives.addNativeIntDependency(natives); + natives.addNativeShortDependency(natives); + natives.addNativeLongDependency(natives); + natives.addNativeFloatDependency(natives); + natives.addNativeDoubleDependency(natives); + natives.addNativeCharDependency(natives); + + data = new ReceiverData(); + handler.newConnection(TOPIC_WRITE_NATIVE_INT, bytes -> { + data.numberOfNativeIntValues += 1; + data.lastNativeIntValue = java.nio.ByteBuffer.wrap(bytes).getInt(); + }); + handler.newConnection(TOPIC_WRITE_NATIVE_SHORT, bytes -> { + data.numberOfNativeShortValues += 1; + data.lastNativeShortValue = java.nio.ByteBuffer.wrap(bytes).getShort(); + }); + handler.newConnection(TOPIC_WRITE_NATIVE_LONG, bytes -> { + data.numberOfNativeLongValues += 1; + data.lastNativeLongValue = java.nio.ByteBuffer.wrap(bytes).getLong(); + }); + handler.newConnection(TOPIC_WRITE_NATIVE_FLOAT, bytes -> { + data.numberOfNativeFloatValues += 1; + data.lastNativeFloatValue = java.nio.ByteBuffer.wrap(bytes).getFloat(); + }); + handler.newConnection(TOPIC_WRITE_NATIVE_DOUBLE, bytes -> { + data.numberOfNativeDoubleValues += 1; + data.lastNativeDoubleValue = java.nio.ByteBuffer.wrap(bytes).getDouble(); + }); + handler.newConnection(TOPIC_WRITE_NATIVE_CHAR, bytes -> { + data.numberOfNativeCharValues += 1; + data.lastNativeCharValue = java.nio.ByteBuffer.wrap(bytes).getChar(); + }); + + 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.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)); + + 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)); + } + + @Override + protected void communicateSendInitialValue() throws InterruptedException { + checkSendData(1, 1, (short) 1, 1, 1.01f, 1.01d, (char) 1); + // no check for initial received data (no input set yet) + + // send first value + sendAndSetData("21", "31"); + checkSendData(2, 21, (short) 21, 21, 21.01f, 21.01d, (char) 21); + checkReceiveData(31, (short) 31, 31, 31.01f, 31.01d, (char) 31); + + // send same value + sendAndSetData("21", "31"); + checkSendData(2, 21, (short) 21, 21, 21.01f, 21.01d, (char) 21); + checkReceiveData(31, (short) 31, 31, 31.01f, 31.01d, (char) 31); + + // send new value + sendAndSetData("22", "32"); + checkSendData(3, 22, (short) 22, 22, 22.01f, 22.01d, (char) 22); + checkReceiveData(32, (short) 32, 32, 32.01f, 32.01d, (char) 32); + } + + @Override + protected void communicateOnlyUpdatedValue() throws InterruptedException { + checkSendData(0, 0, (short) 0, 0, 0f, 0d, (char) 0); + // no check for initial received data (no input set yet) + + // send first value + sendAndSetData("41", "51"); + checkSendData(1, 41, (short) 41, 41, 41.01f, 41.01d, (char) 41); + checkReceiveData(51, (short) 51, 51, 51.01f, 51.01d, (char) 51); + + // send same value + sendAndSetData("41", "51"); + checkSendData(1, 41, (short) 41, 41, 41.01f, 41.01d, (char) 41); + checkReceiveData(51, (short) 51, 51, 51.01f, 51.01d, (char) 51); + + // send new value + sendAndSetData("42", "52"); + checkSendData(2, 42, (short) 42, 42, 42.01f, 42.01d, (char) 42); + checkReceiveData(52, (short) 52, 52, 52.01f, 52.01d, (char) 52); + } + + @Override + protected void closeConnections() { + if (handler != null) { + handler.close(); + } + if (model != null) { + model.ragconnectCloseConnections(); + } + } + + private void sendAndSetData(String driver, String input) { + natives.setDriver(driver); + handler.publish(TOPIC_INPUT, input.getBytes()); + } + + private void checkSendData(int expectedNumberOfValues, int expectedInt, short expectedShort, long expectedLong, float expectedFloat, double expectedDouble, char expectedChar) throws InterruptedException { + TestUtils.waitForMqtt(); + assertEquals(expectedNumberOfValues, data.numberOfNativeIntValues); + assertEquals(expectedNumberOfValues, data.numberOfNativeShortValues); + assertEquals(expectedNumberOfValues, data.numberOfNativeLongValues); + assertEquals(expectedNumberOfValues, data.numberOfNativeFloatValues); + assertEquals(expectedNumberOfValues, data.numberOfNativeDoubleValues); + assertEquals(expectedNumberOfValues, data.numberOfNativeCharValues); + + if (expectedNumberOfValues == 0) { + return; + } + assertEquals(expectedInt, data.lastNativeIntValue); + assertEquals(expectedShort, data.lastNativeShortValue); + assertEquals(expectedLong, data.lastNativeLongValue); + assertEquals(expectedFloat, data.lastNativeFloatValue, TestUtils.DELTA); + assertEquals(expectedDouble, data.lastNativeDoubleValue, TestUtils.DELTA); + assertEquals(expectedChar, data.lastNativeCharValue); + } + + private void checkReceiveData(int expectedInt, short expectedShort, long expectedLong, float expectedFloat, double expectedDouble, char expectedChar) { + assertEquals(expectedInt, natives.getIntValue()); + assertEquals(expectedShort, natives.getShortValue()); + assertEquals(expectedLong, natives.getLongValue()); + assertEquals(expectedFloat, natives.getFloatValue(), TestUtils.DELTA); + assertEquals(expectedDouble, natives.getDoubleValue(), TestUtils.DELTA); + assertEquals(expectedChar, natives.getCharValue()); + + assertEquals(expectedInt, boxes.getIntValue()); + assertEquals(expectedShort, boxes.getShortValue()); + assertEquals(expectedLong, boxes.getLongValue()); + assertEquals(expectedFloat, boxes.getFloatValue(), TestUtils.DELTA); + assertEquals(expectedDouble, boxes.getDoubleValue(), TestUtils.DELTA); + assertEquals(expectedChar, boxes.getCharValue()); + } + + private static class ReceiverData { + int lastNativeIntValue; + int numberOfNativeIntValues = 0; + short lastNativeShortValue; + int numberOfNativeShortValues = 0; + long lastNativeLongValue; + int numberOfNativeLongValues = 0; + float lastNativeFloatValue; + int numberOfNativeFloatValues = 0; + double lastNativeDoubleValue; + int numberOfNativeDoubleValues = 0; + char lastNativeCharValue; + int numberOfNativeCharValues = 0; + } + +} diff --git a/ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/TutorialTest.java b/ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/TutorialTest.java index dbfca5452a1f6058dfe699efce4e3d682b9e19ec..6e66c761ffe4b5e6045d567cc1bdf9a14dea4de0 100644 --- a/ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/TutorialTest.java +++ b/ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/TutorialTest.java @@ -2,7 +2,6 @@ package org.jastadd.ragconnect.tests; import tutorial.ast.A; import tutorial.ast.B; -import tutorial.ast.MqttHandler; import java.io.IOException; @@ -15,7 +14,6 @@ import static org.jastadd.ragconnect.tests.TestUtils.mqttUri; */ public class TutorialTest extends AbstractMqttTest { - private MqttHandler handler; private A a; private B b1; private B b2; @@ -58,9 +56,6 @@ public class TutorialTest extends AbstractMqttTest { @Override protected void closeConnections() { - if (handler != null) { - handler.close(); - } if (a != null) { a.ragconnectCloseConnections(); }