diff options
Diffstat (limited to 'udkapi/com/sun/star/test/bridge/XBridgeTest.idl')
-rw-r--r-- | udkapi/com/sun/star/test/bridge/XBridgeTest.idl | 306 |
1 files changed, 306 insertions, 0 deletions
diff --git a/udkapi/com/sun/star/test/bridge/XBridgeTest.idl b/udkapi/com/sun/star/test/bridge/XBridgeTest.idl new file mode 100644 index 000000000000..05f444a43318 --- /dev/null +++ b/udkapi/com/sun/star/test/bridge/XBridgeTest.idl @@ -0,0 +1,306 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 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 |