summaryrefslogtreecommitdiffstats
path: root/testtools/source/bridgetest/idl
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--testtools/source/bridgetest/idl/bridgetest.idl654
-rw-r--r--testtools/source/bridgetest/idl/com/sun/star/test/performance/XPerformanceTest.idl130
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: */