xref: /aoo41x/main/udkapi/com/sun/star/test/bridge/XBridgeTest.idl (revision 408a4873)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.
 *
 *************************************************************/


#ifndef __com_sun_star_test_bridge_XBridge_idl__
#define __com_sun_star_test_bridge_XBridge_idl__

#ifndef __com_sun_star_uno_XInterface_idl__
#include <com/sun/star/uno/XInterface.idl>
#endif

#ifndef __com_sun_star_lang_IllegalArgumentException_idl__
#include <com/sun/star/lang/IllegalArgumentException.idl>
#endif

module com
{
module sun
{
module star
{
module test
{
module bridge
{

published enum TestEnum
{
	TEST,
	ONE,
	TWO,
	CHECK,
	LOLA,
	PALOO,
	ZA
};

/**
 * simple types
 */
published struct TestSimple
{
	boolean					   Bool;
	char					   Char;
	byte					   Byte;
	short					   Short;
	unsigned short			   UShort;
	long					   Long;
	unsigned long			   ULong;
	hyper					   Hyper;
	unsigned hyper			   UHyper;
	float					   Float;
	double					   Double;
	TestEnum				   Enum;
};
/**
 * complex types adding string, inteface, any
 */
published struct TestElement : TestSimple
{
	string					   String;
	com::sun::star::uno::XInterface   Interface;
	any						   Any;
};
/**
 * adding even more complexity, sequence< TestElement >
 */
published struct TestDataElements : TestElement
{
	sequence< TestElement > Sequence;
};

/**
 * typedef used in interface
 */
published typedef TestDataElements TestData;

published interface XRecursiveCall : com::sun::star::uno::XInterface
{
	/***
	 * @param nToCall If nToCall is 0, the method returns immeadiatly.
	 *                Otherwise, call the given interface with nToCall -1
	 *
	 ***/
	void callRecursivly( [in] XRecursiveCall xCall , [in] long nToCall );
};

/**
 * Monster test interface to test bridge calls.
 * An implementation of this object has to store given values and return whenever there
 * is an out param or return value.
 */
published interface XBridgeTestBase : com::sun::star::uno::XInterface
{
	/**
	 * in parameter test, tests by calls reference also (complex types)
	 */
	[oneway] void setValues( [in] boolean bBool, [in] char cChar, [in] byte nByte,
							 [in] short nShort, [in] unsigned short nUShort,
							 [in] long nLong, [in] unsigned long nULong,
							 [in] hyper nHyper, [in] unsigned hyper nUHyper,
							 [in] float fFloat, [in] double fDouble,
							 [in] TestEnum eEnum, [in] string aString,
							 [in] com::sun::star::uno::XInterface xInterface, [in] any aAny,
							 [in] sequence< TestElement > aSequence,
							 [in] TestData aStruct );
	/**
	 * inout parameter test
	 *
	 * @return aStruct. The out parameter contain the values, that were previously set
	 *         by setValues or (if not called before) default constructed values.
	 *
	 */
	TestData setValues2( [inout] boolean bBool, [inout] char cChar, [inout] byte nByte,
						 [inout] short nShort, [inout] unsigned short nUShort,
						 [inout] long nLong, [inout] unsigned long nULong,
						 [inout] hyper nHyper, [inout] unsigned hyper nUHyper,
						 [inout] float fFloat, [inout] double fDouble,
						 [inout] TestEnum eEnum, [inout] string aString,
						 [inout] com::sun::star::uno::XInterface xInterface, [inout] any aAny,
						 [inout] sequence< TestElement > aSequence,
						 [inout] TestData aStruct );

	/**
	 * out parameter test
	 */
	TestData getValues( [out] boolean bBool, [out] char cChar, [out] byte nByte,
						[out] short nShort, [out] unsigned short nUShort,
						[out] long nLong, [out] unsigned long nULong,
						[out] hyper nHyper, [out] unsigned hyper nUHyper,
						[out] float fFloat, [out] double fDouble,
						[out] TestEnum eEnum, [out] string aString,
						[out] com::sun::star::uno::XInterface xInterface, [out] any aAny,
						[out] sequence< TestElement > aSequence,
						[out] TestData aStruct );

	[attribute] boolean					 Bool;
	[attribute] byte					 Byte;
	[attribute] char					 Char;
	[attribute] short					 Short;
	[attribute] unsigned short			 UShort;
	[attribute] long					 Long;
	[attribute] unsigned long			 ULong;
	[attribute] hyper					 Hyper;
	[attribute] unsigned hyper			 UHyper;
	[attribute] float					 Float;
	[attribute] double					 Double;
	[attribute] TestEnum				 Enum;
	[attribute] string					 String;
	[attribute] com::sun::star::uno::XInterface Interface;
	[attribute] any						 Any;
	[attribute] sequence< TestElement >	 Sequence;
	[attribute] TestData				 Struct;


	/***
	 * This method returns the parameter value.
	 * Method to extensivly test anys.
	 ****/
	any transportAny( [in] any value );

	/***
	 * methods to check sequence of calls. Call call() and callOneway
	 * in an arbitrary sequence. Increase the callId for every call.
	 * The testobject sets an error flag.

		@see testSequencePassed
	 ***/
	void call( [in] long nCallId, [in] long nWaitMUSEC );
	[oneway] void callOneway( [in] long nCallId, [in] long nWaitMUSEC );
	boolean sequenceOfCallTestPassed();

	/****
	 * methods to check, if threads thread identity is holded.
	 *
	 ***/
	void startRecursiveCall( [in] XRecursiveCall xCall , [in] long nToCall );
};


/**
 * Inherting from monster; adds raiseException(), attribute raising RuntimeException.
 */
published interface XBridgeTest : XBridgeTestBase
{
	/**
	 * the exception struct returned has to be filled with given arguments.
	 * return value is for dummy.
	 */
	TestData raiseException( [in] short ArgumentPosition,
							 [in] string Message,
							 [in] com::sun::star::uno::XInterface Context )
		raises( com::sun::star::lang::IllegalArgumentException );


	/**
	 * Throws runtime exception.
	 * check remote bridges handle exceptions during oneway calls properly.
	 * Note that on client side the execption may fly or not. When it flies, it should
	 * have the proper message and context.
	 ***/
	[oneway] void raiseRuntimeExceptionOneway(	[in] string Message,
												[in] com::sun::star::uno::XInterface Context );

    /**
	 * raises runtime exception;
	 * the exception struct returned has to be filled with formerly set test data.
	 */
	[attribute] long					 RuntimeException;
};

/** Extended tests with sequences.
 */
published interface XBridgeTest2 : XBridgeTest
{
    sequence< boolean > setSequenceBool( [in] sequence< boolean > aSeq);
    sequence< char > setSequenceChar( [in] sequence< char > aSeq);
    sequence< byte> setSequenceByte( [in] sequence< byte > aSeq);
    sequence< short> setSequenceShort( [in] sequence< short > aSeq);
    sequence< unsigned short > setSequenceUShort( [in] sequence< unsigned short > aSeq);
    sequence< long > setSequenceLong( [in] sequence< long > aSeq);
    sequence< unsigned long > setSequenceULong( [in] sequence< unsigned long > aSeq);
    sequence< hyper > setSequenceHyper( [in] sequence< hyper > aSeq);
    sequence< unsigned hyper > setSequenceUHyper( [in] sequence< unsigned hyper > aSeq);
    sequence< float > setSequenceFloat( [in] sequence< float > aSeq);
    sequence< double > setSequenceDouble( [in] sequence< double > aSeq);
    sequence< TestEnum > setSequenceEnum( [in] sequence< TestEnum > aSeq);
    sequence< string > setSequenceString( [in] sequence< string > aString);
    sequence< com::sun::star::uno::XInterface > setSequenceXInterface(
        [in] sequence< com::sun::star::uno::XInterface > aSeq);
    sequence< any > setSequenceAny( [in] sequence< any > aSeq);
    sequence< TestElement > setSequenceStruct( [in] sequence< TestElement > aSeq);

    sequence< sequence< long > > setDim2( [in] sequence< sequence< long > > aSeq);
    sequence< sequence < sequence < long > > > setDim3(
        [in] sequence< sequence < sequence < long > > > aSeq);

    void setSequencesInOut( [inout] sequence< boolean > aSeqBoolean,
                       [inout] sequence< char > aSeqChar,
                       [inout] sequence< byte > aSeqByte,
                       [inout] sequence< short > aSeqShort,
                       [inout] sequence< unsigned short> aSeqUShort,
                       [inout] sequence< long > aSeqLong,
                       [inout] sequence< unsigned long > aSeqULong,
                       [inout] sequence< hyper > aSeqHyper,
                       [inout] sequence< unsigned hyper > aSeqUHyper,
                       [inout] sequence< float > aSeqFloat,
                       [inout] sequence< double > aSeqDouble,
                       [inout] sequence< TestEnum > aSeqEnum,
                       [inout] sequence< string > aSeqString,
                       [inout] sequence< com::sun::star::uno::XInterface > aSeqXInterface,
                       [inout] sequence< any > aSeqAny,
                       [inout] sequence< sequence< long > > aSeqDim2,
                       [inout] sequence< sequence < sequence < long > > > aSeqDim3);

    void setSequencesOut( [out] sequence< boolean > aSeqBoolean,
                       [out] sequence< char > aSeqChar,
                       [out] sequence< byte > aSeqByte,
                       [out] sequence< short > aSeqShort,
                       [out] sequence< unsigned short> aSeqUShort,
                       [out] sequence< long > aSeqLong,
                       [out] sequence< unsigned long > aSeqULong,
                       [out] sequence< hyper > aSeqHyper,
                       [out] sequence< unsigned hyper > aSeqUHyper,
                       [out] sequence< float > aSeqFloat,
                       [out] sequence< double > aSeqDouble,
                       [out] sequence< TestEnum > aSeqEnum,
                       [out] sequence< string > aSeqString,
                       [out] sequence< com::sun::star::uno::XInterface > aSeqXInterface,
                       [out] sequence< any > aSeqAny,
                       [out] sequence< sequence< long > > aSeqDim2,
                       [out] sequence< sequence < sequence < long > > > aSeqDim3);


};
//=============================================================================

};
};
};
};
};

#endif