/**************************************************************
 * 
 * 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.
 * 
 *************************************************************/



#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;
    short                      Short;
    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;
};
/**
 * all floats, ia64 handles them specially
 */
struct AllFloats
{
    float                      a;
    float                      b;
    float                      c;
    float                      d;
};
/**
 * complex types adding string, inteface, 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 immeadiatly.
     *                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)
     */
    [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 );

    /**
     * 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
     */
    AllFloats echoAllFloats( [in] AllFloats aStruct );

    /**
     * register return test 4 (i107182)
     */
    long testPPCAlignment( [in] hyper l1, [in] hyper l2, [in] long i1, [in] hyper l3, [in] long i2 );

    [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;

    [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 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 );

    XMulti getMulti();
    string testMulti([in] XMulti multi);
};


/**
 * Inherting 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 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;
};


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();
};

}; }; };