Examples with StructWithStringArray joynr.interlanguagetest.namedTypeCollection1.StructWithStringArray used on opensource projects

Example 1 with StructWithStringArray

use of joynr.interlanguagetest.namedTypeCollection1.StructWithStringArray in project joynr by bmwcarit.

the class IltStringBroadcastFilter method filter.

@Override
public boolean filter(String stringOut, String[] stringArrayOut, ExtendedTypeCollectionEnumerationInTypeCollection enumerationOut, StructWithStringArray structWithStringArrayOut, StructWithStringArray[] structWithStringArrayArrayOut, TestInterfaceBroadcastInterface.BroadcastWithFilteringBroadcastFilterParameters filterParameters) {
    LOG.info("IltStringBroadcastFilter: invoked");
    // check output parameter contents
    if (!IltUtil.checkStringArray(stringArrayOut)) {
        LOG.info("IltStringBroadcastFilter: invalid stringArrayOut value");
        LOG.info("IltStringBroadcastFilter: FAILED");
        return false;
    }
    if (enumerationOut != ExtendedTypeCollectionEnumerationInTypeCollection.ENUM_2_VALUE_EXTENSION_FOR_TYPECOLLECTION) {
        LOG.info("IltStringBroadcastFilter: invalid enumerationOut value");
        LOG.info("IltStringBroadcastFilter: FAILED");
        return false;
    }
    if (!IltUtil.checkStructWithStringArray(structWithStringArrayOut)) {
        LOG.info("IltStringBroadcastFilter: invalid structWithStringArrayOut value");
        LOG.info("IltStringBroadcastFilter: FAILED");
        return false;
    }
    if (!IltUtil.checkStructWithStringArrayArray(structWithStringArrayArrayOut)) {
        LOG.info("IltStringBroadcastFilter: invalid structWithStringArrayArrayOut value");
        LOG.info("IltStringBroadcastFilter: FAILED");
        return false;
    }
    // check filter parameter contents
    // variables to store deserialized values
    String[] stringArrayOfInterest;
    ExtendedTypeCollectionEnumerationInTypeCollection enumerationOfInterest;
    StructWithStringArray structWithStringArrayOfInterest;
    StructWithStringArray[] structWithStringArrayArrayOfInterest;
    try {
        stringArrayOfInterest = jsonSerializer.readValue(filterParameters.getStringArrayOfInterest(), String[].class);
    } catch (IOException e) {
        LOG.info("IltStringBroadcastFilter: got exception while deserializing stringArrayOfInterest");
        LOG.info("IltStringBroadcastFilter: FAILED");
        return false;
    }
    if (!IltUtil.checkStringArray(stringArrayOfInterest)) {
        LOG.info("IltStringBroadcastFilter: invalid stringArrayOfInterest filter parameter value");
        LOG.info("IltStringBroadcastFilter: FAILED");
        return false;
    }
    try {
        enumerationOfInterest = jsonSerializer.readValue(filterParameters.getEnumerationOfInterest(), ExtendedTypeCollectionEnumerationInTypeCollection.class);
    } catch (IOException e) {
        LOG.info("IltStringBroadcastFilter: got exception while deserializing enumerationOfInterest");
        LOG.info("IltStringBroadcastFilter: FAILED");
        return false;
    }
    if (enumerationOfInterest != ExtendedTypeCollectionEnumerationInTypeCollection.ENUM_2_VALUE_EXTENSION_FOR_TYPECOLLECTION) {
        LOG.info("IltStringBroadcastFilter: invalid enumerationOfInterest filter parameter value");
        LOG.info("IltStringBroadcastFilter: FAILED");
        return false;
    }
    try {
        structWithStringArrayOfInterest = jsonSerializer.readValue(filterParameters.getStructWithStringArrayOfInterest(), StructWithStringArray.class);
    } catch (IOException e) {
        LOG.info("IltStringBroadcastFilter: got exception while deserializing structWithStringArrayOfInterest");
        LOG.info("IltStringBroadcastFilter: FAILED");
        return false;
    }
    if (!IltUtil.checkStructWithStringArray(structWithStringArrayOfInterest)) {
        LOG.info("IltStringBroadcastFilter: invalid structWithStringArrayOfInterest filter parameter value");
        LOG.info("IltStringBroadcastFilter: FAILED");
        return false;
    }
    try {
        structWithStringArrayArrayOfInterest = jsonSerializer.readValue(filterParameters.getStructWithStringArrayArrayOfInterest(), StructWithStringArray[].class);
    } catch (IOException e) {
        LOG.info("IltStringBroadcastFilter: got exception while deserializing structWithStringArrayOfInterest");
        LOG.info("IltStringBroadcastFilter: FAILED");
        return false;
    }
    if (!IltUtil.checkStructWithStringArrayArray(structWithStringArrayArrayOfInterest)) {
        LOG.info("IltStringBroadcastFilter: invalid structWithStringArrayArrayOfInterest filter parameter value");
        LOG.info("IltStringBroadcastFilter: FAILED");
        return false;
    }
    // decision for publication is made based on stringOfInterest
    if (stringOut.equals(filterParameters.getStringOfInterest())) {
        LOG.info("IltStringBroadcastFilter: OK - publication should be sent");
        return true;
    } else {
        LOG.info("IltStringBroadcastFilter: OK - publication should NOT Be sent");
        return false;
    }
}

Example 2 with StructWithStringArray

use of joynr.interlanguagetest.namedTypeCollection1.StructWithStringArray in project joynr by bmwcarit.

the class IltUtil method createStructWithStringArray.

public static StructWithStringArray createStructWithStringArray() {
    StructWithStringArray structWithStringArray = new StructWithStringArray();
    fillStructWithStringArray(structWithStringArray);
    return structWithStringArray;
}

Example 3 with StructWithStringArray

use of joynr.interlanguagetest.namedTypeCollection1.StructWithStringArray in project joynr by bmwcarit.

the class IltProvider method methodWithMultipleArrayParameters.

/*
     * methodWithMultipleArrayParameters
     *
     * return the byte array as int64array
     * return the string list as list of string arrays with 1 element each, where this element
     * refers to the one from input
     */
@Override
public Promise<MethodWithMultipleArrayParametersDeferred> methodWithMultipleArrayParameters(String[] stringArrayArg, Byte[] int8ArrayArg, ExtendedInterfaceEnumerationInTypeCollection[] enumArrayArg, StructWithStringArray[] structWithStringArrayArrayArg) {
    logger.warn("******************************************************");
    logger.warn("* IltProvider.methodWithMultipleArrayParameters called");
    logger.warn("******************************************************");
    MethodWithMultipleArrayParametersDeferred deferred = new MethodWithMultipleArrayParametersDeferred();
    if (!IltUtil.checkStringArray(stringArrayArg)) {
        deferred.reject(new ProviderRuntimeException("methodWithMultipleArrayParameters: invalid stringArrayArg"));
        return new Promise<MethodWithMultipleArrayParametersDeferred>(deferred);
    }
    if (!IltUtil.checkByteArray(int8ArrayArg)) {
        deferred.reject(new ProviderRuntimeException("methodWithMultipleArrayParameters: invalid int8ArrayArg"));
        return new Promise<MethodWithMultipleArrayParametersDeferred>(deferred);
    }
    if (!IltUtil.checkExtendedInterfaceEnumerationInTypeCollectionArray(enumArrayArg)) {
        deferred.reject(new ProviderRuntimeException("methodWithMultipleArrayParameters: invalid enumArrayArg"));
        return new Promise<MethodWithMultipleArrayParametersDeferred>(deferred);
    }
    if (!IltUtil.checkStructWithStringArrayArray(structWithStringArrayArrayArg)) {
        deferred.reject(new ProviderRuntimeException("methodWithMultipleArrayParameters: invalid structWithStringArrayArrayArg"));
        return new Promise<MethodWithMultipleArrayParametersDeferred>(deferred);
    }
    Long[] uInt64ArrayOut = IltUtil.createUInt64Array();
    StructWithStringArray[] structWithStringArrayArrayOut = new StructWithStringArray[2];
    structWithStringArrayArrayOut[0] = IltUtil.createStructWithStringArray();
    structWithStringArrayArrayOut[1] = IltUtil.createStructWithStringArray();
    deferred.resolve(uInt64ArrayOut, structWithStringArrayArrayOut);
    return new Promise<MethodWithMultipleArrayParametersDeferred>(deferred);
}

Example 4 with StructWithStringArray

use of joynr.interlanguagetest.namedTypeCollection1.StructWithStringArray in project joynr by bmwcarit.

the class IltConsumerFilteredBroadcastSubscriptionTest method callSubscribeBroadcastWithFiltering.

@SuppressWarnings("checkstyle:methodlength")
@Test
public void callSubscribeBroadcastWithFiltering() {
    Future<String> subscriptionIdFuture;
    String subscriptionId;
    int minIntervalMs = 0;
    int maxIntervalMs = 10000;
    long validityMs = 60000;
    int alertAfterIntervalMs = 20000;
    int publicationTtlMs = 5000;
    OnChangeWithKeepAliveSubscriptionQos subscriptionQos = new OnChangeWithKeepAliveSubscriptionQos().setMinIntervalMs(minIntervalMs).setMaxIntervalMs(maxIntervalMs).setValidityMs(validityMs).setAlertAfterIntervalMs(alertAfterIntervalMs).setPublicationTtlMs(publicationTtlMs);
    boolean result;
    LOG.info(name.getMethodName() + "");
    try {
        BroadcastWithFilteringBroadcastFilterParameters filterParameters = new BroadcastWithFilteringBroadcastFilterParameters();
        String stringOfInterst = "fireBroadcast";
        filterParameters.setStringOfInterest(stringOfInterst);
        String[] stringArrayOfInterest = IltUtil.createStringArray();
        String json;
        try {
            LOG.info(name.getMethodName() + " - objectMapper is " + objectMapper);
            LOG.info(name.getMethodName() + " - objectMapper stringArrayOfInterest " + stringArrayOfInterest);
            json = objectMapper.writeValueAsString(stringArrayOfInterest);
        } catch (JsonProcessingException je) {
            fail(name.getMethodName() + " - FAILED - got exception when serializing stringArrayOfInterest" + je.getMessage());
            return;
        }
        filterParameters.setStringArrayOfInterest(json);
        ExtendedTypeCollectionEnumerationInTypeCollection enumerationOfInterest = ExtendedTypeCollectionEnumerationInTypeCollection.ENUM_2_VALUE_EXTENSION_FOR_TYPECOLLECTION;
        try {
            json = objectMapper.writeValueAsString(enumerationOfInterest);
        } catch (JsonProcessingException je) {
            fail(name.getMethodName() + " - FAILED - got exception when serializing enumerationOfInterest" + je.getMessage());
            return;
        }
        filterParameters.setEnumerationOfInterest(json);
        StructWithStringArray structWithStringArrayOfInterest = IltUtil.createStructWithStringArray();
        try {
            json = objectMapper.writeValueAsString(structWithStringArrayOfInterest);
        } catch (JsonProcessingException je) {
            fail(name.getMethodName() + " - FAILED - got exception when serializing structWithStringArrayOfInterest" + je.getMessage());
            return;
        }
        filterParameters.setStructWithStringArrayOfInterest(json);
        StructWithStringArray[] structWithStringArrayArrayOfInterest = IltUtil.createStructWithStringArrayArray();
        try {
            json = objectMapper.writeValueAsString(structWithStringArrayArrayOfInterest);
        } catch (JsonProcessingException je) {
            fail(name.getMethodName() + " - FAILED - got exception when serializing structWithStringArrayArrayOfInterest" + je.getMessage());
            return;
        }
        filterParameters.setStructWithStringArrayArrayOfInterest(json);
        subscriptionIdFuture = testInterfaceProxy.subscribeToBroadcastWithFilteringBroadcast(new BroadcastWithFilteringBroadcastAdapter() {

            @Override
            public void onReceive(String stringOut, String[] stringArrayOut, ExtendedTypeCollectionEnumerationInTypeCollection enumerationOut, StructWithStringArray structWithStringArrayOut, StructWithStringArray[] structWithStringArrayArrayOut) {
                LOG.info(name.getMethodName() + " - callback - got broadcast");
                if (!IltUtil.checkStringArray(stringArrayOut)) {
                    subscribeBroadcastWithFilteringCallbackResult = false;
                } else if (enumerationOut != ExtendedTypeCollectionEnumerationInTypeCollection.ENUM_2_VALUE_EXTENSION_FOR_TYPECOLLECTION) {
                    LOG.info(name.getMethodName() + " - callback - invalid content");
                    subscribeBroadcastWithFilteringCallbackResult = false;
                } else if (!IltUtil.checkStructWithStringArray(structWithStringArrayOut)) {
                    LOG.info(name.getMethodName() + " - callback - invalid content");
                    subscribeBroadcastWithFilteringCallbackResult = false;
                } else if (!IltUtil.checkStructWithStringArrayArray(structWithStringArrayArrayOut)) {
                    LOG.info(name.getMethodName() + " - callback - invalid content");
                    subscribeBroadcastWithFilteringCallbackResult = false;
                } else {
                    LOG.info(name.getMethodName() + " - callback - content OK");
                    subscribeBroadcastWithFilteringCallbackResult = true;
                }
                subscribeBroadcastWithFilteringCallbackDone = true;
            }

            @Override
            public void onError(SubscriptionException error) {
                LOG.info(name.getMethodName() + " - callback - error");
                subscribeBroadcastWithFilteringCallbackResult = false;
                subscribeBroadcastWithFilteringCallbackDone = true;
            }
        }, subscriptionQos, filterParameters);
        subscriptionId = subscriptionIdFuture.get(10000);
        LOG.info(name.getMethodName() + " - subscription successful, subscriptionId = " + subscriptionId);
        LOG.info(name.getMethodName() + " - Waiting one second");
        Thread.sleep(1000);
        LOG.info(name.getMethodName() + " - Wait done, invoking fire method");
        String stringArg = "fireBroadcast";
        testInterfaceProxy.methodToFireBroadcastWithFiltering(stringArg);
        LOG.info(name.getMethodName() + " - fire method invoked");
        // should have been called ahead anyway
        if (subscribeBroadcastWithFilteringCallbackDone == false) {
            LOG.info(name.getMethodName() + " - about to wait for a second for callback");
            Thread.sleep(1000);
            LOG.info(name.getMethodName() + " - wait for callback is over");
        } else {
            LOG.info(name.getMethodName() + " - callback already done");
        }
        if (!subscribeBroadcastWithFilteringCallbackDone) {
            fail(name.getMethodName() + " - FAILED - callback did not get called in time");
            result = false;
        } else if (subscribeBroadcastWithFilteringCallbackResult) {
            LOG.info(name.getMethodName() + " - callback got called and received expected publication");
            result = true;
        } else {
            fail(name.getMethodName() + " - FAILED - callback got called but received unexpected error or publication content");
            result = false;
        }
        // get out, if first test run failed
        if (result == false) {
            return;
        }
        // reset counter for 2nd test
        subscribeBroadcastWithFilteringCallbackResult = false;
        subscribeBroadcastWithFilteringCallbackDone = false;
        LOG.info(name.getMethodName() + " - invoking fire method with wrong stringArg");
        stringArg = "doNotfireBroadcast";
        testInterfaceProxy.methodToFireBroadcastWithFiltering(stringArg);
        LOG.info(name.getMethodName() + " - fire method invoked");
        // should have been called ahead anyway
        if (subscribeBroadcastWithFilteringCallbackDone == false) {
            LOG.info(name.getMethodName() + " - about to wait for a second for callback");
            Thread.sleep(1000);
            LOG.info(name.getMethodName() + " - wait for callback is over");
        } else {
            LOG.info(name.getMethodName() + " - callback already done");
        }
        if (!subscribeBroadcastWithFilteringCallbackDone) {
            LOG.info(name.getMethodName() + " - callback did not get called in time (expected)");
            result = true;
        } else {
            fail(name.getMethodName() + " - FAILED - callback got called unexpectedly");
            result = false;
        }
        // try to unsubscribe
        try {
            testInterfaceProxy.unsubscribeFromBroadcastWithFilteringBroadcast(subscriptionId);
            LOG.info(name.getMethodName() + " - unsubscribe successful");
        } catch (Exception e) {
            fail(name.getMethodName() + " - FAILED - caught unexpected exception on unsubscribe: " + e.getMessage());
            result = false;
        }
        if (!result) {
            LOG.info(name.getMethodName() + " - FAILED");
        } else {
            LOG.info(name.getMethodName() + " - OK");
        }
        return;
    } catch (Exception e) {
        // also catches InterruptedException from Thread.sleep() call
        StringWriter stringWriter = new StringWriter();
        PrintWriter printWriter = new PrintWriter(stringWriter);
        e.printStackTrace(printWriter);
        printWriter.flush();
        fail(name.getMethodName() + " - FAILED - caught unexpected exception: " + stringWriter.toString());
        return;
    }
}

Example 5 with StructWithStringArray

use of joynr.interlanguagetest.namedTypeCollection1.StructWithStringArray in project joynr by bmwcarit.

the class IltConsumerSyncMethodTest method callMethodWithMultipleArrayParameters.

@Test
public void callMethodWithMultipleArrayParameters() {
    LOG.info(name.getMethodName() + "");
    try {
        String[] arg1 = IltUtil.createStringArray();
        Byte[] arg2 = IltUtil.createByteArray();
        ExtendedInterfaceEnumerationInTypeCollection[] arg3 = IltUtil.createExtendedInterfaceEnumerationInTypeCollectionArray();
        StructWithStringArray[] arg4 = IltUtil.createStructWithStringArrayArray();
        MethodWithMultipleArrayParametersReturned result;
        result = testInterfaceProxy.methodWithMultipleArrayParameters(arg1, arg2, arg3, arg4);
        if (result == null) {
            fail(name.getMethodName() + " - FAILED - got no result");
            return;
        }
        if (!IltUtil.checkUInt64Array(result.uInt64ArrayOut)) {
            fail(name.getMethodName() + " - FAILED - got invalid result - stringArrayArg");
            return;
        }
        if (result.structWithStringArrayArrayOut.length != 2) {
            fail(name.getMethodName() + " - FAILED - got invalid result - structWithStringArrayArrayOut");
            return;
        }
        if (!IltUtil.checkStructWithStringArray(result.structWithStringArrayArrayOut[0])) {
            fail(name.getMethodName() + " - FAILED - got invalid result - structWithStringArrayArrayOut[0]");
            return;
        }
        if (!IltUtil.checkStructWithStringArray(result.structWithStringArrayArrayOut[1])) {
            fail(name.getMethodName() + " - FAILED - got invalid result - structWithStringArrayArrayOut[1]");
            return;
        }
    } catch (Exception e) {
        fail(name.getMethodName() + " - FAILED - caught unexpected exception: " + e.getMessage());
        return;
    }
    LOG.info(name.getMethodName() + " - OK");
}