diff options
Diffstat (limited to '')
| -rw-r--r-- | testtools/source/bridgetest/idl/bridgetest.idl | 654 | ||||
| -rw-r--r-- | testtools/source/bridgetest/idl/com/sun/star/test/performance/XPerformanceTest.idl | 130 |
2 files changed, 784 insertions, 0 deletions
diff --git a/testtools/source/bridgetest/idl/bridgetest.idl b/testtools/source/bridgetest/idl/bridgetest.idl new file mode 100644 index 000000000..82d63c37e --- /dev/null +++ b/testtools/source/bridgetest/idl/bridgetest.idl @@ -0,0 +1,654 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include <com/sun/star/lang/IllegalArgumentException.idl> +#include <com/sun/star/lang/XComponent.idl> +#include <com/sun/star/uno/XComponentContext.idl> +#include <com/sun/star/uno/XInterface.idl> + +module test { module testtools { module bridgetest { + +enum TestEnum +{ + TEST, + ONE, + TWO, + CHECK, + LOLA, + PALOO, + ZA +}; + +enum TestBadEnum { M = 1 }; + +struct TestStruct +{ + long member; +}; + +/** + * simple types + */ +struct TestSimple +{ + boolean Bool; + char Char; + byte Byte; + byte Byte2; + short Short; + short Short2; + unsigned short UShort; + long Long; + unsigned long ULong; + hyper Hyper; + unsigned hyper UHyper; + float Float; + double Double; + TestEnum Enum; +}; +/** + * equal to max size returned in registers on x86_64 + */ +struct SmallStruct +{ + hyper a; + hyper b; +}; +/** + * equal to max size returned in registers on ia64 + */ +struct MediumStruct +{ + hyper a; + hyper b; + hyper c; + hyper d; +}; +/** + * bigger than max size returned in registers on ia64 + */ +struct BigStruct +{ + hyper a; + hyper b; + hyper c; + hyper d; + hyper e; + hyper f; + hyper g; + hyper h; +}; +/** + * two floats, BSDs/MacOSX on intel handle returning small + * structs differently than Linux + */ +struct TwoFloats +{ + float a; + float b; +}; +/** + * all floats, ia64 handles them specially + */ +struct FourFloats +{ + float a; + float b; + float c; + float d; +}; +/** + * Small struct with mixed float and integers. + * Should return in registers on BSDs/MACOSx + */ +struct MixedFloatAndInteger +{ + float a; + long b; +}; +struct DoubleHyper { + double a; + hyper b; +}; +struct HyperDouble { + hyper a; + double b; +}; +struct FloatFloatLongByte { + float a; + float b; + long c; + byte d; +}; +/** + * Small struct with three bytes. Should *not* return in registers on + * BSDs/MACOSx + */ +struct ThreeByteStruct +{ + byte a; + byte b; + byte c; +}; +/** + * complex types adding string, interface, any + */ +struct TestElement : TestSimple +{ + string String; + com::sun::star::uno::XInterface Interface; + any Any; +}; +/** + * adding even more complexity, sequence< TestElement > + */ +struct TestDataElements : TestElement +{ + sequence< TestElement > Sequence; +}; + +/** + * typedef used in interface + */ +typedef TestDataElements TestData; + +struct TestPolyStruct<T> { T member; }; +struct TestPolyStruct2<T,C> { + T member1; + C member2; +}; + +interface XRecursiveCall : com::sun::star::uno::XInterface +{ + /*** + * @param nToCall If nToCall is 0, the method returns immediately. + * Otherwise, call the given interface with nToCall -1 + * + ***/ + void callRecursivly( [in] XRecursiveCall xCall , [in] long nToCall ); +}; + +interface XMultiBase1 { + [attribute] double att1; // initially 0.0 + long fn11([in] long arg); // return 11 * arg + string fn12([in] string arg); // return "12" + arg +}; + +interface XMultiBase2: XMultiBase1 { + long fn21([in] long arg); // return 21 * arg + string fn22([in] string arg); // return "22" + arg +}; + +interface XMultiBase3 { + [attribute] double att3; // initially 0.0 + long fn31([in] long arg); // return 31 * arg + string fn32([in] string arg); // return "32" + arg + long fn33(); // return 33 +}; + +interface XMultiBase3a: XMultiBase3 {}; + +interface XMultiBase4 { + long fn41([in] long arg); // return 41 * arg +}; + +interface XMultiBase5 { + interface XMultiBase3; + interface XMultiBase4; + interface XMultiBase1; +}; + +interface XMultiBase6 { + interface XMultiBase2; + interface XMultiBase3a; + interface XMultiBase5; + long fn61([in] long arg); // return 61 * arg + string fn62([in] string arg); // return "62" + arg +}; + +interface XMultiBase7 { + long fn71([in] long arg); // return 71 * arg + string fn72([in] string arg); // return "72" + arg + long fn73(); // return 73 +}; + +interface XMulti { + interface XMultiBase6; + interface XMultiBase7; +}; + +/** + * 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. + */ +interface XBridgeTestBase : com::sun::star::uno::XInterface +{ + /** + * in parameter test, tests by calls reference also (complex types) + */ + 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] byte aByte2, + [in] short aShort2, + [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] byte aByte2, + [inout] short aShort2, + [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] byte aByte2, + [out] short aShort2, + [out] com::sun::star::uno::XInterface xInterface, + [out] any aAny, + [out] sequence< TestElement > aSequence, + [out] TestData aStruct ); + + /** + * register return test 1 + */ + SmallStruct echoSmallStruct( [in] SmallStruct aStruct ); + + /** + * register return test 2 + */ + MediumStruct echoMediumStruct( [in] MediumStruct aStruct ); + + /** + * register return test 3 + */ + BigStruct echoBigStruct( [in] BigStruct aStruct ); + + /** + * register return test 4 + */ + TwoFloats echoTwoFloats( [in] TwoFloats aStruct ); + + /** + * register return test 5 + */ + FourFloats echoFourFloats( [in] FourFloats aStruct ); + + /** + * register return test 6 + */ + MixedFloatAndInteger echoMixedFloatAndInteger( [in] MixedFloatAndInteger aStruct ); + + DoubleHyper echoDoubleHyper([in] DoubleHyper s); + + HyperDouble echoHyperDouble([in] HyperDouble s); + + FloatFloatLongByte echoFloatFloatLongByte([in] FloatFloatLongByte s); + + /** + * register return test 7 + */ + ThreeByteStruct echoThreeByteStruct( [in] ThreeByteStruct aStruct ); + + /** + * PPC Alignment test (#i107182#) + */ + long testPPCAlignment( [in] hyper l1, [in] hyper l2, [in] long i1, [in] hyper l3, [in] long i2 ); + + /** + * PPC64 Alignment test + */ + long testPPC64Alignment( [in] double d1, [in] double d2, [in] double d3, [in] long i1 ); + + + /** + * VFP ABI (armhf) doubles test + */ + double testTenDoubles( [in] double d1, [in] double d2, [in] double d3, [in] double d4, [in] double d5, [in] double d6, [in] double d7, [in] double d8, [in] double d9, [in] double d10 ); + + [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] byte Byte2; + [attribute] short Short2; + [attribute] com::sun::star::uno::XInterface Interface; + [attribute] any Any; + [attribute] sequence< TestElement > Sequence; + [attribute] TestData Struct; + + [attribute] long RaiseAttr1 { + set raises (com::sun::star::lang::IllegalArgumentException); + }; + [attribute, readonly] long RaiseAttr2 { + get raises (com::sun::star::lang::IllegalArgumentException); + }; + + TestPolyStruct<boolean> transportPolyBoolean( + [in] TestPolyStruct<boolean> arg); + void transportPolyHyper([inout] TestPolyStruct<hyper> arg); + void transportPolySequence( + [in] TestPolyStruct<sequence<any> > arg1, + [out] TestPolyStruct<sequence<any> > arg2); + + TestPolyStruct<long> getNullPolyLong(); + TestPolyStruct<string> getNullPolyString(); + TestPolyStruct<type> getNullPolyType(); + TestPolyStruct<any> getNullPolyAny(); + TestPolyStruct<sequence<boolean> > getNullPolySequence(); + TestPolyStruct<TestEnum> getNullPolyEnum(); + TestPolyStruct<TestBadEnum> getNullPolyBadEnum(); + TestPolyStruct<TestStruct> getNullPolyStruct(); + TestPolyStruct<XBridgeTestBase> getNullPolyInterface(); + + /*** + * This method returns the parameter value. + * Method to extensively 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 ); + 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 ); + + XMulti getMulti(); + string testMulti([in] XMulti multi); +}; + + +/** + * Inheriting from monster; adds raiseException(), attribute raising RuntimeException. + */ +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 exception may fly or not. When it flies, it should + * have the proper message and context. + ***/ + 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; +}; + + +exception BadConstructorArguments: com::sun::star::uno::Exception {}; + +service Constructors: com::sun::star::uno::XInterface { + create1( + [in] boolean arg0, + [in] byte arg1, + [in] short arg2, + [in] unsigned short arg3, + [in] long arg4, + [in] unsigned long arg5, + [in] hyper arg6, + [in] unsigned hyper arg7, + [in] float arg8, + [in] double arg9, + [in] char arg10, + [in] string arg11, + [in] type arg12, + [in] any arg13, + [in] sequence< boolean > arg14, + [in] sequence< byte > arg15, + [in] sequence< short > arg16, + [in] sequence< unsigned short > arg17, + [in] sequence< long > arg18, + [in] sequence< unsigned long > arg19, + [in] sequence< hyper > arg20, + [in] sequence< unsigned hyper > arg21, + [in] sequence< float > arg22, + [in] sequence< double > arg23, + [in] sequence< char > arg24, + [in] sequence< string > arg25, + [in] sequence< type > arg26, + [in] sequence< any > arg27, + [in] sequence< sequence< boolean > > arg28, + [in] sequence< sequence< any > > arg29, + [in] sequence< TestEnum > arg30, + [in] sequence< TestStruct > arg31, + [in] sequence< TestPolyStruct< boolean > > arg32, + [in] sequence< TestPolyStruct< any > > arg33, + [in] sequence< com::sun::star::uno::XInterface > arg34, + [in] TestEnum arg35, + [in] TestStruct arg36, + [in] TestPolyStruct< boolean > arg37, + [in] TestPolyStruct< any > arg38, + [in] com::sun::star::uno::XInterface arg39) + raises (BadConstructorArguments); + + create2([in] any... args) raises (BadConstructorArguments); + +}; + +service Constructors2: XMultiBase1 { + + create1( + [in] TestPolyStruct<type> arg1, + [in] TestPolyStruct<any> arg2, + [in] TestPolyStruct<boolean> arg3, + [in] TestPolyStruct<byte> arg4, + [in] TestPolyStruct<short> arg5, + [in] TestPolyStruct<long> arg6, + [in] TestPolyStruct<hyper> arg7, + [in] TestPolyStruct<char> arg8, + [in] TestPolyStruct<string> arg9, + [in] TestPolyStruct<float> arg10, + [in] TestPolyStruct<double> arg11, + [in] TestPolyStruct<com::sun::star::uno::XInterface> arg12, + [in] TestPolyStruct<com::sun::star::lang::XComponent> arg13, + [in] TestPolyStruct<TestEnum> arg14, + [in] TestPolyStruct<TestPolyStruct2<char,any> > arg15, + [in] TestPolyStruct<TestPolyStruct2<TestPolyStruct2<char,any>,string> > arg16, + [in] TestPolyStruct2<string, TestPolyStruct2<char, TestPolyStruct<any> > > arg17, + [in] TestPolyStruct2<TestPolyStruct2<char,any>, TestPolyStruct<char> > arg18, + [in] TestPolyStruct<sequence<type> > arg19, + [in] TestPolyStruct<sequence<any> > arg20, + [in] TestPolyStruct<sequence<boolean> > arg21, + [in] TestPolyStruct<sequence<byte> > arg22, + [in] TestPolyStruct<sequence<short> > arg23, + [in] TestPolyStruct<sequence<long> > arg24, + [in] TestPolyStruct<sequence<hyper> > arg25, + [in] TestPolyStruct<sequence<char> > arg26, + [in] TestPolyStruct<sequence<string> > arg27, + [in] TestPolyStruct<sequence<float> > arg28, + [in] TestPolyStruct<sequence<double> > arg29, + [in] TestPolyStruct<sequence<com::sun::star::uno::XInterface> > arg30, + [in] TestPolyStruct<sequence<com::sun::star::lang::XComponent> > arg31, + [in] TestPolyStruct<sequence<TestEnum> > arg32, + [in] TestPolyStruct<sequence<TestPolyStruct2<char, sequence<any> > > > arg33, + [in] TestPolyStruct<sequence<TestPolyStruct2<TestPolyStruct<char>, sequence<any> > > > arg34, + [in] TestPolyStruct<sequence<sequence<long> > > arg35, + [in] sequence<TestPolyStruct<long > > arg36, + [in] sequence<TestPolyStruct<TestPolyStruct2<char,any> > > arg37, + [in] sequence<TestPolyStruct<TestPolyStruct2<TestPolyStruct2<char,any>,string> > > arg38, + [in] sequence<TestPolyStruct2<string, TestPolyStruct2<char, TestPolyStruct<any> > > > arg39, + [in] sequence<TestPolyStruct2<TestPolyStruct2<char,any>, TestPolyStruct<char> > > arg40, + [in] sequence<sequence<TestPolyStruct< char > > > arg41, + [in] sequence<sequence<TestPolyStruct<TestPolyStruct2<char,any> > > >arg42, + [in] sequence<sequence<TestPolyStruct<TestPolyStruct2<TestPolyStruct2<char,any>,string> > > > arg43, + [in] sequence<sequence<TestPolyStruct2<string, TestPolyStruct2<char, TestPolyStruct<any> > > > > arg44, + [in] sequence<sequence<TestPolyStruct2<TestPolyStruct2<char,any>, TestPolyStruct<char> > > > arg45 + ); +}; + +interface XCurrentContextChecker { + boolean perform( + [in] XCurrentContextChecker other, [in] long setSteps, + [in] long checkSteps); +}; + +/** Extended tests with sequences. + */ +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); + + void testConstructorsService( + [in] com::sun::star::uno::XComponentContext context) + raises (BadConstructorArguments); + + XCurrentContextChecker getCurrentContextChecker(); +}; + +}; }; }; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/testtools/source/bridgetest/idl/com/sun/star/test/performance/XPerformanceTest.idl b/testtools/source/bridgetest/idl/com/sun/star/test/performance/XPerformanceTest.idl new file mode 100644 index 000000000..b92b7b4c3 --- /dev/null +++ b/testtools/source/bridgetest/idl/com/sun/star/test/performance/XPerformanceTest.idl @@ -0,0 +1,130 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ +#ifndef __com_sun_star_test_performance_XPerformanceTest_idl__ +#define __com_sun_star_test_performance_XPerformanceTest_idl__ + +#include <com/sun/star/uno/XInterface.idl> + +module com +{ +module sun +{ +module star +{ +module test +{ +module performance +{ + +/** struct of simple types to be carried +*/ +published struct SimpleTypes +{ + 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; +}; +/** struct ComplexTypes adding Sequence, String, Interface, Any to SimpleTypes +*/ +published struct ComplexTypes : SimpleTypes +{ + sequence< long > Sequence; + string String; + com::sun::star::uno::XInterface Interface; + any Any; +}; + +/** A performance test object has to be implemented in a special way, that: + <ul> + <li>queryInterface() execution times remain (nearly) static</li> + <li>functions kept simple, thus there is (nearly) no execution time of the function itself</li> + <li>no dynamic data is ever returned except of createObject(), so return 0, empty strings etc.</li> + </ul> + The interface is divided into three sections: + <ul> + <li>measuring asynchron/ synchron calls</li> + <li>complex data calls with/out return value; in/out parameters</li> + <li>single data types like long, float, string etc.</li> + <li>method calls versa attribute calls</li> + <li>raising RuntimeException</li> + </ul> +*/ +published interface XPerformanceTest : com::sun::star::uno::XInterface +{ + void async(); + void sync(); + + ComplexTypes complexIn( [in] ComplexTypes aVal ); + ComplexTypes complexInout( [inout] ComplexTypes aVal ); + + void complexOneway( [in] ComplexTypes aVal ); + void complexNoreturn( [in] ComplexTypes aVal ); + + XPerformanceTest createObject(); + + [attribute] long Long_attr; + [attribute] hyper Hyper_attr; + [attribute] float Float_attr; + [attribute] double Double_attr; + [attribute] string String_attr; + [attribute] com::sun::star::uno::XInterface Interface_attr; + [attribute] any Any_attr; + [attribute] sequence< com::sun::star::uno::XInterface > Sequence_attr; + [attribute] ComplexTypes Struct_attr; + + long getLong(); + void setLong( [in] long n ); + hyper getHyper(); + void setHyper( [in] hyper n ); + float getFloat(); + void setFloat( [in] float f ); + double getDouble(); + void setDouble( [in] double f ); + string getString(); + void setString( [in] string s ); + com::sun::star::uno::XInterface getInterface(); + void setInterface( [in] com::sun::star::uno::XInterface x ); + any getAny(); + void setAny( [in] any a ); + sequence< com::sun::star::uno::XInterface > getSequence(); + void setSequence( [in] sequence< com::sun::star::uno::XInterface > seq ); + ComplexTypes getStruct(); + void setStruct( [in] ComplexTypes c ); + + void raiseRuntimeException(); +}; + + +}; +}; +}; +}; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |