joynr.interlanguagetest.DefaultTestInterfaceProvider Maven / Gradle / Ivy

Go to download
/*
 *
 * Copyright (C) 2011 - 2018 BMW Car IT GmbH
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// #####################################################
//#######################################################
//###                                                 ###
//##    WARNING: This file is generated. DO NOT EDIT   ##
//##             All changes will be lost!             ##
//###                                                 ###
//#######################################################
// #####################################################
package joynr.interlanguagetest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import io.joynr.provider.Promise;
import io.joynr.provider.Deferred;
import io.joynr.provider.DeferredVoid;

import joynr.interlanguagetest.Enumeration;
import joynr.interlanguagetest.namedTypeCollection1.StructWithStringArray;
import joynr.interlanguagetest.namedTypeCollection2.BaseStruct;
import joynr.interlanguagetest.namedTypeCollection2.BaseStructWithoutElements;
import joynr.interlanguagetest.namedTypeCollection2.ExtendedBaseStruct;
import joynr.interlanguagetest.namedTypeCollection2.ExtendedEnumerationWithPartlyDefinedValues;
import joynr.interlanguagetest.namedTypeCollection2.ExtendedExtendedBaseStruct;
import joynr.interlanguagetest.namedTypeCollection2.ExtendedExtendedEnumeration;
import joynr.interlanguagetest.namedTypeCollection2.ExtendedInterfaceEnumerationInTypeCollection;
import joynr.interlanguagetest.namedTypeCollection2.ExtendedStructOfPrimitives;
import joynr.interlanguagetest.namedTypeCollection2.ExtendedTypeCollectionEnumerationInTypeCollection;
import joynr.interlanguagetest.namedTypeCollection2.MapStringString;

public class DefaultTestInterfaceProvider extends TestInterfaceAbstractProvider {
	private static final Logger logger = LoggerFactory.getLogger(DefaultTestInterfaceProvider.class);

	protected Byte attributeUInt8;
	protected Double attributeDouble;
	protected Boolean attributeBooleanReadonly;
	protected String attributeStringNoSubscriptions;
	protected Byte attributeInt8readonlyNoSubscriptions;
	protected String[] attributeArrayOfStringImplicit;
	protected Enumeration attributeEnumeration;
	protected ExtendedEnumerationWithPartlyDefinedValues attributeExtendedEnumerationReadonly;
	protected BaseStruct attributeBaseStruct;
	protected ExtendedExtendedBaseStruct attributeExtendedExtendedBaseStruct;
	protected MapStringString attributeMapStringString;
	protected Boolean attributeWithExceptionFromGetter;
	protected Boolean attributeWithExceptionFromSetter;
	protected Integer attributeFireAndForget;

	public DefaultTestInterfaceProvider() {
	}


	@Override
	public Promise> getAttributeUInt8() {
		Deferred deferred = new Deferred<>();
		deferred.resolve(attributeUInt8);
		return new Promise<>(deferred);
	}
	@Override
	public Promise setAttributeUInt8(Byte attributeUInt8) {
		DeferredVoid deferred = new DeferredVoid();
		this.attributeUInt8 = attributeUInt8;
		attributeUInt8Changed(attributeUInt8);
		deferred.resolve();
		return new Promise<>(deferred);
	}

	@Override
	public Promise> getAttributeDouble() {
		Deferred deferred = new Deferred<>();
		deferred.resolve(attributeDouble);
		return new Promise<>(deferred);
	}
	@Override
	public Promise setAttributeDouble(Double attributeDouble) {
		DeferredVoid deferred = new DeferredVoid();
		this.attributeDouble = attributeDouble;
		attributeDoubleChanged(attributeDouble);
		deferred.resolve();
		return new Promise<>(deferred);
	}

	@Override
	public Promise> getAttributeBooleanReadonly() {
		Deferred deferred = new Deferred<>();
		deferred.resolve(attributeBooleanReadonly);
		return new Promise<>(deferred);
	}

	@Override
	public Promise> getAttributeStringNoSubscriptions() {
		Deferred deferred = new Deferred<>();
		deferred.resolve(attributeStringNoSubscriptions);
		return new Promise<>(deferred);
	}
	@Override
	public Promise setAttributeStringNoSubscriptions(String attributeStringNoSubscriptions) {
		DeferredVoid deferred = new DeferredVoid();
		this.attributeStringNoSubscriptions = attributeStringNoSubscriptions;
		deferred.resolve();
		return new Promise<>(deferred);
	}

	@Override
	public Promise> getAttributeInt8readonlyNoSubscriptions() {
		Deferred deferred = new Deferred<>();
		deferred.resolve(attributeInt8readonlyNoSubscriptions);
		return new Promise<>(deferred);
	}

	@Override
	public Promise> getAttributeArrayOfStringImplicit() {
		Deferred deferred = new Deferred<>();
		deferred.resolve(attributeArrayOfStringImplicit);
		return new Promise<>(deferred);
	}
	@Override
	public Promise setAttributeArrayOfStringImplicit(String[] attributeArrayOfStringImplicit) {
		DeferredVoid deferred = new DeferredVoid();
		this.attributeArrayOfStringImplicit = attributeArrayOfStringImplicit;
		attributeArrayOfStringImplicitChanged(attributeArrayOfStringImplicit);
		deferred.resolve();
		return new Promise<>(deferred);
	}

	@Override
	public Promise> getAttributeEnumeration() {
		Deferred deferred = new Deferred<>();
		deferred.resolve(attributeEnumeration);
		return new Promise<>(deferred);
	}
	@Override
	public Promise setAttributeEnumeration(Enumeration attributeEnumeration) {
		DeferredVoid deferred = new DeferredVoid();
		this.attributeEnumeration = attributeEnumeration;
		attributeEnumerationChanged(attributeEnumeration);
		deferred.resolve();
		return new Promise<>(deferred);
	}

	@Override
	public Promise> getAttributeExtendedEnumerationReadonly() {
		Deferred deferred = new Deferred<>();
		deferred.resolve(attributeExtendedEnumerationReadonly);
		return new Promise<>(deferred);
	}

	@Override
	public Promise> getAttributeBaseStruct() {
		Deferred deferred = new Deferred<>();
		deferred.resolve(attributeBaseStruct);
		return new Promise<>(deferred);
	}
	@Override
	public Promise setAttributeBaseStruct(BaseStruct attributeBaseStruct) {
		DeferredVoid deferred = new DeferredVoid();
		this.attributeBaseStruct = attributeBaseStruct;
		attributeBaseStructChanged(attributeBaseStruct);
		deferred.resolve();
		return new Promise<>(deferred);
	}

	@Override
	public Promise> getAttributeExtendedExtendedBaseStruct() {
		Deferred deferred = new Deferred<>();
		deferred.resolve(attributeExtendedExtendedBaseStruct);
		return new Promise<>(deferred);
	}
	@Override
	public Promise setAttributeExtendedExtendedBaseStruct(ExtendedExtendedBaseStruct attributeExtendedExtendedBaseStruct) {
		DeferredVoid deferred = new DeferredVoid();
		this.attributeExtendedExtendedBaseStruct = attributeExtendedExtendedBaseStruct;
		attributeExtendedExtendedBaseStructChanged(attributeExtendedExtendedBaseStruct);
		deferred.resolve();
		return new Promise<>(deferred);
	}

	@Override
	public Promise> getAttributeMapStringString() {
		Deferred deferred = new Deferred<>();
		deferred.resolve(attributeMapStringString);
		return new Promise<>(deferred);
	}
	@Override
	public Promise setAttributeMapStringString(MapStringString attributeMapStringString) {
		DeferredVoid deferred = new DeferredVoid();
		this.attributeMapStringString = attributeMapStringString;
		attributeMapStringStringChanged(attributeMapStringString);
		deferred.resolve();
		return new Promise<>(deferred);
	}

	@Override
	public Promise> getAttributeWithExceptionFromGetter() {
		Deferred deferred = new Deferred<>();
		deferred.resolve(attributeWithExceptionFromGetter);
		return new Promise<>(deferred);
	}

	@Override
	public Promise> getAttributeWithExceptionFromSetter() {
		Deferred deferred = new Deferred<>();
		deferred.resolve(attributeWithExceptionFromSetter);
		return new Promise<>(deferred);
	}
	@Override
	public Promise setAttributeWithExceptionFromSetter(Boolean attributeWithExceptionFromSetter) {
		DeferredVoid deferred = new DeferredVoid();
		this.attributeWithExceptionFromSetter = attributeWithExceptionFromSetter;
		attributeWithExceptionFromSetterChanged(attributeWithExceptionFromSetter);
		deferred.resolve();
		return new Promise<>(deferred);
	}

	@Override
	public Promise> getAttributeFireAndForget() {
		Deferred deferred = new Deferred<>();
		deferred.resolve(attributeFireAndForget);
		return new Promise<>(deferred);
	}
	@Override
	public Promise setAttributeFireAndForget(Integer attributeFireAndForget) {
		DeferredVoid deferred = new DeferredVoid();
		this.attributeFireAndForget = attributeFireAndForget;
		attributeFireAndForgetChanged(attributeFireAndForget);
		deferred.resolve();
		return new Promise<>(deferred);
	}


	/*
	* methodWithoutParameters
	*/
	@Override
	public Promise methodWithoutParameters(
			) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodWithoutParameters called");
		logger.warn("**********************************************");
		DeferredVoid deferred = new DeferredVoid();
		deferred.resolve();
		return new Promise<>(deferred);
	}

	/*
	* methodWithoutInputParameter
	*/
	@Override
	public Promise methodWithoutInputParameter(
			) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodWithoutInputParameter called");
		logger.warn("**********************************************");
		MethodWithoutInputParameterDeferred deferred = new MethodWithoutInputParameterDeferred();
		Boolean booleanOut = false;
		deferred.resolve(booleanOut);
		return new Promise<>(deferred);
	}

	/*
	* methodWithoutOutputParameter
	*/
	@Override
	public Promise methodWithoutOutputParameter(
			Boolean booleanArg) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodWithoutOutputParameter called");
		logger.warn("**********************************************");
		DeferredVoid deferred = new DeferredVoid();
		deferred.resolve();
		return new Promise<>(deferred);
	}

	/*
	* methodWithSinglePrimitiveParameters
	*/
	@Override
	public Promise methodWithSinglePrimitiveParameters(
			Short uInt16Arg) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodWithSinglePrimitiveParameters called");
		logger.warn("**********************************************");
		MethodWithSinglePrimitiveParametersDeferred deferred = new MethodWithSinglePrimitiveParametersDeferred();
		String stringOut = "";
		deferred.resolve(stringOut);
		return new Promise<>(deferred);
	}

	/*
	* methodWithMultiplePrimitiveParameters
	*/
	@Override
	public Promise methodWithMultiplePrimitiveParameters(
			Integer int32Arg,
			Float floatArg,
			Boolean booleanArg) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodWithMultiplePrimitiveParameters called");
		logger.warn("**********************************************");
		MethodWithMultiplePrimitiveParametersDeferred deferred = new MethodWithMultiplePrimitiveParametersDeferred();
		Double doubleOut = 0d;
		String stringOut = "";
		deferred.resolve(doubleOut, stringOut);
		return new Promise<>(deferred);
	}

	/*
	* methodWithSingleArrayParameters
	*/
	@Override
	public Promise methodWithSingleArrayParameters(
			Double[] doubleArrayArg) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodWithSingleArrayParameters called");
		logger.warn("**********************************************");
		MethodWithSingleArrayParametersDeferred deferred = new MethodWithSingleArrayParametersDeferred();
		String[] stringArrayOut = {};
		deferred.resolve(stringArrayOut);
		return new Promise<>(deferred);
	}

	/*
	* methodWithMultipleArrayParameters
	*/
	@Override
	public Promise methodWithMultipleArrayParameters(
			String[] stringArrayArg,
			Byte[] int8ArrayArg,
			ExtendedInterfaceEnumerationInTypeCollection[] enumArrayArg,
			StructWithStringArray[] structWithStringArrayArrayArg) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodWithMultipleArrayParameters called");
		logger.warn("**********************************************");
		MethodWithMultipleArrayParametersDeferred deferred = new MethodWithMultipleArrayParametersDeferred();
		Long[] uInt64ArrayOut = {};
		StructWithStringArray[] structWithStringArrayArrayOut = {};
		deferred.resolve(uInt64ArrayOut, structWithStringArrayArrayOut);
		return new Promise<>(deferred);
	}

	/*
	* methodWithSingleEnumParameters
	*/
	@Override
	public Promise methodWithSingleEnumParameters(
			ExtendedEnumerationWithPartlyDefinedValues enumerationArg) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodWithSingleEnumParameters called");
		logger.warn("**********************************************");
		MethodWithSingleEnumParametersDeferred deferred = new MethodWithSingleEnumParametersDeferred();
		ExtendedTypeCollectionEnumerationInTypeCollection enumerationOut = ExtendedTypeCollectionEnumerationInTypeCollection.ENUM_2_VALUE_EXTENSION_FOR_TYPECOLLECTION;
		deferred.resolve(enumerationOut);
		return new Promise<>(deferred);
	}

	/*
	* methodWithMultipleEnumParameters
	*/
	@Override
	public Promise methodWithMultipleEnumParameters(
			Enumeration enumerationArg,
			ExtendedTypeCollectionEnumerationInTypeCollection extendedEnumerationArg) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodWithMultipleEnumParameters called");
		logger.warn("**********************************************");
		MethodWithMultipleEnumParametersDeferred deferred = new MethodWithMultipleEnumParametersDeferred();
		ExtendedEnumerationWithPartlyDefinedValues extendedEnumerationOut = ExtendedEnumerationWithPartlyDefinedValues.ENUM_2_VALUE_EXTENSION_FOR_ENUM_WITHOUT_DEFINED_VALUES;
		Enumeration enumerationOut = Enumeration.ENUM_0_VALUE_1;
		deferred.resolve(extendedEnumerationOut, enumerationOut);
		return new Promise<>(deferred);
	}

	/*
	* methodWithSingleMapParameters
	*/
	@Override
	public Promise methodWithSingleMapParameters(
			MapStringString mapArg) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodWithSingleMapParameters called");
		logger.warn("**********************************************");
		MethodWithSingleMapParametersDeferred deferred = new MethodWithSingleMapParametersDeferred();
		MapStringString mapOut = new MapStringString();
		deferred.resolve(mapOut);
		return new Promise<>(deferred);
	}

	/*
	* methodWithSingleStructParameters
	*/
	@Override
	public Promise methodWithSingleStructParameters(
			ExtendedBaseStruct extendedBaseStructArg) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodWithSingleStructParameters called");
		logger.warn("**********************************************");
		MethodWithSingleStructParametersDeferred deferred = new MethodWithSingleStructParametersDeferred();
		ExtendedStructOfPrimitives extendedStructOfPrimitivesOut = new ExtendedStructOfPrimitives();
		deferred.resolve(extendedStructOfPrimitivesOut);
		return new Promise<>(deferred);
	}

	/*
	* methodWithMultipleStructParameters
	*/
	@Override
	public Promise methodWithMultipleStructParameters(
			ExtendedStructOfPrimitives extendedStructOfPrimitivesArg,
			BaseStruct baseStructArg) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodWithMultipleStructParameters called");
		logger.warn("**********************************************");
		MethodWithMultipleStructParametersDeferred deferred = new MethodWithMultipleStructParametersDeferred();
		BaseStructWithoutElements baseStructWithoutElementsOut = new BaseStructWithoutElements();
		ExtendedExtendedBaseStruct extendedExtendedBaseStructOut = new ExtendedExtendedBaseStruct();
		deferred.resolve(baseStructWithoutElementsOut, extendedExtendedBaseStructOut);
		return new Promise<>(deferred);
	}

	/*
	* methodWithStringsAndSpecifiedStringOutLength
	*/
	@Override
	public Promise methodWithStringsAndSpecifiedStringOutLength(
			String stringArg,
			Integer int32StringLengthArg) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodWithStringsAndSpecifiedStringOutLength called");
		logger.warn("**********************************************");
		MethodWithStringsAndSpecifiedStringOutLengthDeferred deferred = new MethodWithStringsAndSpecifiedStringOutLengthDeferred();
		String stringOut = "";
		deferred.resolve(stringOut);
		return new Promise<>(deferred);
	}

	/*
	* methodFireAndForgetWithoutParameter
	*/
	@Override
	public void methodFireAndForgetWithoutParameter(
			) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodFireAndForgetWithoutParameter called");
		logger.warn("**********************************************");
	}

	/*
	* methodFireAndForgetWithInputParameter
	*/
	@Override
	public void methodFireAndForgetWithInputParameter(
			Integer int32Arg) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodFireAndForgetWithInputParameter called");
		logger.warn("**********************************************");
	}

	/*
	* overloadedMethod
	*/
	@Override
	public Promise overloadedMethod(
			) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.overloadedMethod called");
		logger.warn("**********************************************");
		OverloadedMethod1Deferred deferred = new OverloadedMethod1Deferred();
		String stringOut = "";
		deferred.resolve(stringOut);
		return new Promise<>(deferred);
	}

	/*
	* overloadedMethod
	*/
	@Override
	public Promise overloadedMethod(
			Boolean booleanArg) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.overloadedMethod called");
		logger.warn("**********************************************");
		OverloadedMethod1Deferred deferred = new OverloadedMethod1Deferred();
		String stringOut = "";
		deferred.resolve(stringOut);
		return new Promise<>(deferred);
	}

	/*
	* overloadedMethod
	*/
	@Override
	public Promise overloadedMethod(
			ExtendedExtendedEnumeration[] enumArrayArg,
			Long int64Arg,
			BaseStruct baseStructArg,
			Boolean booleanArg) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.overloadedMethod called");
		logger.warn("**********************************************");
		OverloadedMethod2Deferred deferred = new OverloadedMethod2Deferred();
		Double doubleOut = 0d;
		String[] stringArrayOut = {};
		ExtendedBaseStruct extendedBaseStructOut = new ExtendedBaseStruct();
		deferred.resolve(doubleOut, stringArrayOut, extendedBaseStructOut);
		return new Promise<>(deferred);
	}

	/*
	* overloadedMethodWithSelector
	*/
	@Override
	public Promise overloadedMethodWithSelector(
			) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.overloadedMethodWithSelector called");
		logger.warn("**********************************************");
		OverloadedMethodWithSelector1Deferred deferred = new OverloadedMethodWithSelector1Deferred();
		String stringOut = "";
		deferred.resolve(stringOut);
		return new Promise<>(deferred);
	}

	/*
	* overloadedMethodWithSelector
	*/
	@Override
	public Promise overloadedMethodWithSelector(
			Boolean booleanArg) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.overloadedMethodWithSelector called");
		logger.warn("**********************************************");
		OverloadedMethodWithSelector1Deferred deferred = new OverloadedMethodWithSelector1Deferred();
		String stringOut = "";
		deferred.resolve(stringOut);
		return new Promise<>(deferred);
	}

	/*
	* overloadedMethodWithSelector
	*/
	@Override
	public Promise overloadedMethodWithSelector(
			ExtendedExtendedEnumeration[] enumArrayArg,
			Long int64Arg,
			BaseStruct baseStructArg,
			Boolean booleanArg) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.overloadedMethodWithSelector called");
		logger.warn("**********************************************");
		OverloadedMethodWithSelector2Deferred deferred = new OverloadedMethodWithSelector2Deferred();
		Double doubleOut = 0d;
		String[] stringArrayOut = {};
		ExtendedBaseStruct extendedBaseStructOut = new ExtendedBaseStruct();
		deferred.resolve(doubleOut, stringArrayOut, extendedBaseStructOut);
		return new Promise<>(deferred);
	}

	/*
	* methodWithoutErrorEnum
	*/
	@Override
	public Promise methodWithoutErrorEnum(
			String wantedExceptionArg) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodWithoutErrorEnum called");
		logger.warn("**********************************************");
		DeferredVoid deferred = new DeferredVoid();
		deferred.resolve();
		return new Promise<>(deferred);
	}

	/*
	* methodWithAnonymousErrorEnum
	*/
	@Override
	public Promise methodWithAnonymousErrorEnum(
			String wantedExceptionArg) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodWithAnonymousErrorEnum called");
		logger.warn("**********************************************");
		MethodWithAnonymousErrorEnumDeferred deferred = new MethodWithAnonymousErrorEnumDeferred();
		deferred.resolve();
		return new Promise<>(deferred);
	}

	/*
	* methodWithExistingErrorEnum
	*/
	@Override
	public Promise methodWithExistingErrorEnum(
			String wantedExceptionArg) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodWithExistingErrorEnum called");
		logger.warn("**********************************************");
		MethodWithExistingErrorEnumDeferred deferred = new MethodWithExistingErrorEnumDeferred();
		deferred.resolve();
		return new Promise<>(deferred);
	}

	/*
	* methodWithExtendedErrorEnum
	*/
	@Override
	public Promise methodWithExtendedErrorEnum(
			String wantedExceptionArg) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodWithExtendedErrorEnum called");
		logger.warn("**********************************************");
		MethodWithExtendedErrorEnumDeferred deferred = new MethodWithExtendedErrorEnumDeferred();
		deferred.resolve();
		return new Promise<>(deferred);
	}

	/*
	* methodToFireBroadcastWithSinglePrimitiveParameter
	*/
	@Override
	public Promise methodToFireBroadcastWithSinglePrimitiveParameter(
			) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodToFireBroadcastWithSinglePrimitiveParameter called");
		logger.warn("**********************************************");
		DeferredVoid deferred = new DeferredVoid();
		deferred.resolve();
		return new Promise<>(deferred);
	}

	/*
	* methodToFireBroadcastWithMultiplePrimitiveParameters
	*/
	@Override
	public Promise methodToFireBroadcastWithMultiplePrimitiveParameters(
			) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodToFireBroadcastWithMultiplePrimitiveParameters called");
		logger.warn("**********************************************");
		DeferredVoid deferred = new DeferredVoid();
		deferred.resolve();
		return new Promise<>(deferred);
	}

	/*
	* methodToFireBroadcastWithSingleArrayParameter
	*/
	@Override
	public Promise methodToFireBroadcastWithSingleArrayParameter(
			) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodToFireBroadcastWithSingleArrayParameter called");
		logger.warn("**********************************************");
		DeferredVoid deferred = new DeferredVoid();
		deferred.resolve();
		return new Promise<>(deferred);
	}

	/*
	* methodToFireBroadcastWithMultipleArrayParameters
	*/
	@Override
	public Promise methodToFireBroadcastWithMultipleArrayParameters(
			) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodToFireBroadcastWithMultipleArrayParameters called");
		logger.warn("**********************************************");
		DeferredVoid deferred = new DeferredVoid();
		deferred.resolve();
		return new Promise<>(deferred);
	}

	/*
	* methodToFireBroadcastWithSingleEnumerationParameter
	*/
	@Override
	public Promise methodToFireBroadcastWithSingleEnumerationParameter(
			) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodToFireBroadcastWithSingleEnumerationParameter called");
		logger.warn("**********************************************");
		DeferredVoid deferred = new DeferredVoid();
		deferred.resolve();
		return new Promise<>(deferred);
	}

	/*
	* methodToFireBroadcastWithMultipleEnumerationParameters
	*/
	@Override
	public Promise methodToFireBroadcastWithMultipleEnumerationParameters(
			) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodToFireBroadcastWithMultipleEnumerationParameters called");
		logger.warn("**********************************************");
		DeferredVoid deferred = new DeferredVoid();
		deferred.resolve();
		return new Promise<>(deferred);
	}

	/*
	* methodToFireBroadcastWithSingleStructParameter
	*/
	@Override
	public Promise methodToFireBroadcastWithSingleStructParameter(
			) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodToFireBroadcastWithSingleStructParameter called");
		logger.warn("**********************************************");
		DeferredVoid deferred = new DeferredVoid();
		deferred.resolve();
		return new Promise<>(deferred);
	}

	/*
	* methodToFireBroadcastWithMultipleStructParameters
	*/
	@Override
	public Promise methodToFireBroadcastWithMultipleStructParameters(
			) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodToFireBroadcastWithMultipleStructParameters called");
		logger.warn("**********************************************");
		DeferredVoid deferred = new DeferredVoid();
		deferred.resolve();
		return new Promise<>(deferred);
	}

	/*
	* methodToFireBroadcastWithFiltering
	*/
	@Override
	public Promise methodToFireBroadcastWithFiltering(
			String stringArg) {
		logger.warn("**********************************************");
		logger.warn("* DefaultTestInterfaceProvider.methodToFireBroadcastWithFiltering called");
		logger.warn("**********************************************");
		DeferredVoid deferred = new DeferredVoid();
		deferred.resolve();
		return new Promise<>(deferred);
	}
}