testtools/source/bridgetest/cppobj.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <stdio.h>
  21
  22 #include <cppu/unotype.hxx>
  23 #include <osl/diagnose.h>
  24 #include <osl/diagnose.hxx>
  25 #include <osl/thread.hxx>
  26 #include <osl/mutex.hxx>
  27 #include <osl/time.h>
  28
  29 #include <cppuhelper/implbase.hxx>
  30 #include <cppuhelper/factory.hxx>
  31 #include <cppuhelper/exc_hlp.hxx>
  32 #include <cppuhelper/compbase_ex.hxx>
  33 #include <cppuhelper/supportsservice.hxx>
  34 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  35 #include <com/sun/star/lang/XServiceInfo.hpp>
  36 #include <com/sun/star/lang/XComponent.hpp>
  37 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  38 #include <com/sun/star/uno/Any.hxx>
  39 #include <com/sun/star/uno/RuntimeException.hpp>
  40 #include <com/sun/star/uno/Sequence.hxx>
  41
  42 #include <test/testtools/bridgetest/Constructors.hpp>
  43 #include <test/testtools/bridgetest/Constructors2.hpp>
  44 #include <test/testtools/bridgetest/TestPolyStruct.hpp>
  45 #include <test/testtools/bridgetest/TestPolyStruct2.hpp>
  46 #include <test/testtools/bridgetest/XBridgeTest2.hpp>
  47 #include <test/testtools/bridgetest/XMulti.hpp>
  48
  49 #include "currentcontextchecker.hxx"
  50 #include "multi.hxx"
  51
  52 using namespace osl;
  53 using namespace cppu;
  54 using namespace com::sun::star::uno;
  55 using namespace com::sun::star::lang;
  56 using namespace com::sun::star::registry;
  57 using namespace test::testtools::bridgetest;
  58
  59 #ifdef _MSC_VER
  60 #pragma warning (disable : 4503) // irrelevant for test code
  61 #endif
  62
  63 #define SERVICENAME     "com.sun.star.test.bridge.CppTestObject"
  64 #define IMPLNAME        "com.sun.star.comp.bridge.CppTestObject"
  65
  66 namespace bridge_object
  67 {
  68
  69
  70 static Sequence< OUString > getSupportedServiceNames()
  71 {
  72     return { SERVICENAME };
  73 }
  74
  75
  76 static void assign( TestElement & rData,
  77                     bool bBool, sal_Unicode cChar, sal_Int8 nByte,
  78                     sal_Int16 nShort, sal_uInt16 nUShort,
  79                     sal_Int32 nLong, sal_uInt32 nULong,
  80                     sal_Int64 nHyper, sal_uInt64 nUHyper,
  81                     float fFloat, double fDouble,
  82                     TestEnum eEnum, const OUString& rStr,
  83                     sal_Int8 nByte2, sal_Int16 nShort2,
  84                     const css::uno::Reference< css::uno::XInterface >& xTest,
  85                     const css::uno::Any& rAny )
  86 {
  87     rData.Bool = bBool;
  88     rData.Char = cChar;
  89     rData.Byte = nByte;
  90     rData.Short = nShort;
  91     rData.UShort = nUShort;
  92     rData.Long = nLong;
  93     rData.ULong = nULong;
  94     rData.Hyper = nHyper;
  95     rData.UHyper = nUHyper;
  96     rData.Float = fFloat;
  97     rData.Double = fDouble;
  98     rData.Enum = eEnum;
  99     rData.String = rStr;
 100     rData.Byte2 = nByte2;
 101     rData.Short2 = nShort2;
 102     rData.Interface = xTest;
 103     rData.Any = rAny;
 104 }
 105
 106 static void assign( TestData & rData,
 107                     bool bBool, sal_Unicode cChar, sal_Int8 nByte,
 108                     sal_Int16 nShort, sal_uInt16 nUShort,
 109                     sal_Int32 nLong, sal_uInt32 nULong,
 110                     sal_Int64 nHyper, sal_uInt64 nUHyper,
 111                     float fFloat, double fDouble,
 112                     TestEnum eEnum, const OUString& rStr,
 113                     sal_Int8 nByte2, sal_Int16 nShort2,
 114                     const css::uno::Reference< css::uno::XInterface >& xTest,
 115                     const css::uno::Any& rAny,
 116                     const css::uno::Sequence< TestElement >& rSequence )
 117 {
 118     assign( static_cast<TestElement &>(rData),
 119             bBool, cChar, nByte, nShort, nUShort, nLong, nULong, nHyper, nUHyper, fFloat, fDouble,
 120             eEnum, rStr, nByte2, nShort2, xTest, rAny );
 121     rData.Sequence = rSequence;
 122 }
 123
 124 namespace {
 125
 126 class Test_Impl :
 127     public osl::DebugBase<Test_Impl>,
 128     public WeakImplHelper< XBridgeTest2, XServiceInfo , XRecursiveCall >
 129 {
 130     TestData _aData, _aStructData;
 131     sal_Int32 m_nLastCallId;
 132     bool m_bFirstCall;
 133     bool m_bSequenceOfCallTestPassed;
 134     Mutex m_mutex;
 135
 136     Sequence<sal_Bool> _arBool;
 137     Sequence<sal_Unicode> _arChar;
 138     Sequence<sal_Int8> _arByte;
 139     Sequence<sal_Int16> _arShort;
 140     Sequence<sal_uInt16> _arUShort;
 141     Sequence<sal_Int32> _arLong;
 142     Sequence<sal_uInt32> _arULong;
 143     Sequence<sal_Int64> _arHyper;
 144     Sequence<sal_uInt64> _arUHyper;
 145     Sequence<OUString> _arString;
 146     Sequence<float> _arFloat;
 147     Sequence<double> _arDouble;
 148     Sequence<TestEnum> _arEnum;
 149     Sequence<Reference<XInterface> > _arObject;
 150     Sequence<Sequence<sal_Int32> > _arLong2;
 151     Sequence<Sequence<Sequence<sal_Int32> > > _arLong3;
 152     Sequence<Any> _arAny;
 153     Sequence<TestElement> _arStruct;
 154
 155 public:
 156     Test_Impl() : m_nLastCallId( 0 ),
 157                   m_bFirstCall( true ),
 158                   m_bSequenceOfCallTestPassed( true )
 159         {}
 160
 161     void SAL_CALL acquire() noexcept override
 162     {
 163         OWeakObject::acquire();
 164     }
 165     void SAL_CALL release() noexcept override
 166     {
 167         OWeakObject::release();
 168      }
 169
 170     // XServiceInfo
 171     virtual OUString SAL_CALL getImplementationName() override;
 172     virtual sal_Bool SAL_CALL supportsService( const OUString & rServiceName ) override;
 173     virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
 174
 175     // XLBTestBase
 176     virtual void SAL_CALL setValues( sal_Bool bBool,
 177                                      sal_Unicode cChar,
 178                                      sal_Int8 nByte,
 179                                      sal_Int16 nShort,
 180                                      sal_uInt16 nUShort,
 181                                      sal_Int32 nLong,
 182                                      sal_uInt32 nULong,
 183                                      sal_Int64 nHyper,
 184                                      sal_uInt64 nUHyper,
 185                                      float fFloat,
 186                                      double fDouble,
 187                                      TestEnum eEnum,
 188                                      const OUString& rStr,
 189                                      sal_Int8 nByte2,
 190                                      sal_Int16 nShort2,
 191                                      const css::uno::Reference< css::uno::XInterface >& xTest,
 192                                      const css::uno::Any& rAny,
 193                                      const css::uno::Sequence<TestElement >& rSequence,
 194                                      const ::test::testtools::bridgetest::TestDataElements& rStruct ) override;
 195
 196     virtual ::test::testtools::bridgetest::TestDataElements SAL_CALL setValues2( sal_Bool& bBool,
 197                                                                                  sal_Unicode& cChar,
 198                                                                                  sal_Int8& nByte,
 199                                                                                  sal_Int16& nShort,
 200                                                                                  sal_uInt16& nUShort,
 201                                                                                  sal_Int32& nLong,
 202                                                                                  sal_uInt32& nULong,
 203                                                                                  sal_Int64& nHyper,
 204                                                                                  sal_uInt64& nUHyper,
 205                                                                                  float& fFloat,
 206                                                                                  double& fDouble,
 207                                                                                  TestEnum& eEnum,
 208                                                                                  OUString& rStr,
 209                                                                                  sal_Int8& nByte2,
 210                                                                                  sal_Int16& nShort2,
 211                                                                                  css::uno::Reference< css::uno::XInterface >& xTest,
 212                                                                                  css::uno::Any& rAny,
 213                                                                                  css::uno::Sequence<TestElement >& rSequence,
 214                                                                                  ::test::testtools::bridgetest::TestDataElements& rStruct ) override;
 215
 216     virtual ::test::testtools::bridgetest::TestDataElements SAL_CALL getValues( sal_Bool& bBool,
 217                                                                                 sal_Unicode& cChar,
 218                                                                                 sal_Int8& nByte,
 219                                                                                 sal_Int16& nShort,
 220                                                                                 sal_uInt16& nUShort,
 221                                                                                 sal_Int32& nLong,
 222                                                                                 sal_uInt32& nULong,
 223                                                                                 sal_Int64& nHyper,
 224                                                                                 sal_uInt64& nUHyper,
 225                                                                                 float& fFloat,
 226                                                                                 double& fDouble,
 227                                                                                 TestEnum& eEnum,
 228                                                                                 OUString& rStr,
 229                                                                                 sal_Int8& nByte2,
 230                                                                                 sal_Int16& nShort2,
 231                                                                                 css::uno::Reference< css::uno::XInterface >& xTest,
 232                                                                                 css::uno::Any& rAny,
 233                                                                                 css::uno::Sequence< TestElement >& rSequence,
 234                                                                                 ::test::testtools::bridgetest::TestDataElements& rStruct ) override;
 235
 236     virtual SmallStruct SAL_CALL echoSmallStruct(const SmallStruct& rStruct) override
 237         { return rStruct; }
 238     virtual MediumStruct SAL_CALL echoMediumStruct(const MediumStruct& rStruct) override
 239         { return rStruct; }
 240     virtual BigStruct SAL_CALL echoBigStruct(const BigStruct& rStruct) override
 241         { return rStruct; }
 242     virtual TwoFloats SAL_CALL echoTwoFloats(const TwoFloats& rStruct) override
 243         { return rStruct; }
 244     virtual FourFloats SAL_CALL echoFourFloats(const FourFloats& rStruct) override
 245         { return rStruct; }
 246     virtual MixedFloatAndInteger SAL_CALL echoMixedFloatAndInteger(const MixedFloatAndInteger& rStruct) override
 247         { return rStruct; }
 248     virtual DoubleHyper SAL_CALL echoDoubleHyper(DoubleHyper const & s) override { return s; }
 249     virtual FloatFloatLongByte SAL_CALL echoFloatFloatLongByte(FloatFloatLongByte const & s)
 250         override
 251     { return s; }
 252     virtual ThreeByteStruct SAL_CALL echoThreeByteStruct(const ThreeByteStruct& rStruct) override
 253         { return rStruct; }
 254     virtual sal_Int32 SAL_CALL testPPCAlignment( sal_Int64, sal_Int64, sal_Int32, sal_Int64, sal_Int32 i2 ) override
 255         { return i2; }
 256     virtual sal_Int32 SAL_CALL testPPC64Alignment( double , double , double , sal_Int32 i1 ) override
 257         { return i1; }
 258     virtual double SAL_CALL testTenDoubles( double d1, double d2, double d3, double d4, double d5, double d6, double d7, double d8, double d9, double d10 ) override
 259         { return d1 + d2 + d3 + d4 + d5 + d6 + d7 + d8 + d9 + d10; }
 260     virtual sal_Bool SAL_CALL getBool() override
 261         { return _aData.Bool; }
 262     virtual sal_Int8 SAL_CALL getByte() override
 263         { return _aData.Byte; }
 264     virtual sal_Unicode SAL_CALL getChar() override
 265         { return _aData.Char; }
 266     virtual sal_Int16 SAL_CALL getShort() override
 267         { return _aData.Short; }
 268     virtual sal_uInt16 SAL_CALL getUShort() override
 269         { return _aData.UShort; }
 270     virtual sal_Int32 SAL_CALL getLong() override
 271         { return _aData.Long; }
 272     virtual sal_uInt32 SAL_CALL getULong() override
 273         { return _aData.ULong; }
 274     virtual sal_Int64 SAL_CALL getHyper() override
 275         { return _aData.Hyper; }
 276     virtual sal_uInt64 SAL_CALL getUHyper() override
 277         { return _aData.UHyper; }
 278     virtual float SAL_CALL getFloat() override
 279         { return _aData.Float; }
 280     virtual double SAL_CALL getDouble() override
 281         { return _aData.Double; }
 282     virtual TestEnum SAL_CALL getEnum() override
 283         { return _aData.Enum; }
 284     virtual OUString SAL_CALL getString() override
 285         { return _aData.String; }
 286     virtual sal_Int8 SAL_CALL getByte2() override
 287         { return _aData.Byte2; }
 288     virtual sal_Int16 SAL_CALL getShort2() override
 289         { return _aData.Short2; }
 290     virtual css::uno::Reference< css::uno::XInterface > SAL_CALL getInterface(  ) override
 291         { return _aData.Interface; }
 292     virtual css::uno::Any SAL_CALL getAny() override
 293         { return _aData.Any; }
 294     virtual css::uno::Sequence< TestElement > SAL_CALL getSequence() override
 295         { return _aData.Sequence; }
 296     virtual ::test::testtools::bridgetest::TestDataElements SAL_CALL getStruct() override
 297         { return _aStructData; }
 298
 299     virtual void SAL_CALL setBool( sal_Bool _bool ) override
 300         { _aData.Bool = _bool; }
 301     virtual void SAL_CALL setByte( sal_Int8 _byte ) override
 302         { _aData.Byte = _byte; }
 303     virtual void SAL_CALL setChar( sal_Unicode _char ) override
 304         { _aData.Char = _char; }
 305     virtual void SAL_CALL setShort( sal_Int16 _short ) override
 306         { _aData.Short = _short; }
 307     virtual void SAL_CALL setUShort( sal_uInt16 _ushort ) override
 308         { _aData.UShort = _ushort; }
 309     virtual void SAL_CALL setLong( sal_Int32 _long ) override
 310         { _aData.Long = _long; }
 311     virtual void SAL_CALL setULong( sal_uInt32 _ulong ) override
 312         { _aData.ULong = _ulong; }
 313     virtual void SAL_CALL setHyper( sal_Int64 _hyper ) override
 314         { _aData.Hyper = _hyper; }
 315     virtual void SAL_CALL setUHyper( sal_uInt64 _uhyper ) override
 316         { _aData.UHyper = _uhyper; }
 317     virtual void SAL_CALL setFloat( float _float ) override
 318         { _aData.Float = _float; }
 319     virtual void SAL_CALL setDouble( double _double ) override
 320         { _aData.Double = _double; }
 321     virtual void SAL_CALL setEnum( TestEnum _enum ) override
 322         { _aData.Enum = _enum; }
 323     virtual void SAL_CALL setString( const OUString& _string ) override
 324         { _aData.String = _string; }
 325     virtual void SAL_CALL setByte2( sal_Int8 _byte ) override
 326         { _aData.Byte2 = _byte; }
 327     virtual void SAL_CALL setShort2( sal_Int16 _short ) override
 328         { _aData.Short2 = _short; }
 329     virtual void SAL_CALL setInterface( const css::uno::Reference< css::uno::XInterface >& _interface ) override
 330         { _aData.Interface = _interface; }
 331     virtual void SAL_CALL setAny( const css::uno::Any& _any ) override
 332         { _aData.Any = _any; }
 333     virtual void SAL_CALL setSequence( const css::uno::Sequence<TestElement >& _sequence ) override
 334         { _aData.Sequence = _sequence; }
 335     virtual void SAL_CALL setStruct( const ::test::testtools::bridgetest::TestDataElements& _struct ) override
 336         { _aStructData = _struct; }
 337
 338     virtual sal_Int32 SAL_CALL getRaiseAttr1() override
 339     { throw RuntimeException(); }
 340
 341     virtual void SAL_CALL setRaiseAttr1(sal_Int32) override
 342     { throw IllegalArgumentException(); }
 343
 344     virtual sal_Int32 SAL_CALL getRaiseAttr2() override
 345     { throw IllegalArgumentException(); }
 346
 347     virtual TestPolyStruct< sal_Bool > SAL_CALL transportPolyBoolean(
 348         TestPolyStruct< sal_Bool > const & arg) override
 349     { return arg; }
 350
 351     virtual void SAL_CALL transportPolyHyper(TestPolyStruct< sal_Int64 > &) override {}
 352
 353     virtual void SAL_CALL transportPolySequence(
 354         TestPolyStruct< Sequence< Any > > const & arg1,
 355         TestPolyStruct< Sequence< Any > > & arg2) override
 356     { arg2 = arg1; }
 357
 358     virtual TestPolyStruct< sal_Int32 > SAL_CALL getNullPolyLong() override
 359     { return TestPolyStruct< sal_Int32 >(0); /* work around MS compiler bug */ }
 360
 361     virtual TestPolyStruct< OUString > SAL_CALL getNullPolyString() override
 362     { return TestPolyStruct< OUString >(); }
 363
 364     virtual TestPolyStruct< Type > SAL_CALL getNullPolyType() override
 365     { return TestPolyStruct< Type >(); }
 366
 367     virtual TestPolyStruct< Any > SAL_CALL getNullPolyAny() override
 368     { return TestPolyStruct< Any >(); }
 369
 370     virtual TestPolyStruct< Sequence< sal_Bool > > SAL_CALL
 371     getNullPolySequence() override
 372     { return TestPolyStruct< Sequence< sal_Bool > >(); }
 373
 374     virtual TestPolyStruct< TestEnum > SAL_CALL getNullPolyEnum() override
 375     { return TestPolyStruct< TestEnum >(
 376         test::testtools::bridgetest::TestEnum_TEST);
 377           /* work around MS compiler bug */ }
 378
 379     virtual TestPolyStruct< TestBadEnum > SAL_CALL getNullPolyBadEnum() override
 380     { return TestPolyStruct< TestBadEnum >(
 381         test::testtools::bridgetest::TestBadEnum_M);
 382           /* explicitly instantiate with default enumerator */ }
 383
 384     virtual TestPolyStruct< TestStruct > SAL_CALL getNullPolyStruct() override
 385     { return TestPolyStruct< TestStruct >(); }
 386
 387     virtual TestPolyStruct< Reference< XBridgeTestBase > > SAL_CALL
 388     getNullPolyInterface() override
 389     { return TestPolyStruct< Reference< XBridgeTestBase > >(); }
 390
 391     virtual css::uno::Any SAL_CALL transportAny(
 392         const css::uno::Any& value ) override;
 393
 394     virtual void SAL_CALL call( sal_Int32 nCallId, sal_Int32 nWaitMUSEC ) override;
 395     virtual void SAL_CALL callOneway( sal_Int32 nCallId, sal_Int32 nWaitMUSEC ) override;
 396     virtual sal_Bool SAL_CALL sequenceOfCallTestPassed(  ) override;
 397     virtual void SAL_CALL startRecursiveCall(
 398         const css::uno::Reference< XRecursiveCall >& xCall, sal_Int32 nToCall ) override;
 399
 400     virtual Reference< XMulti > SAL_CALL getMulti() override;
 401
 402     virtual OUString SAL_CALL testMulti(Reference< XMulti > const & multi) override;
 403
 404 public: // XBridgeTest
 405     virtual ::test::testtools::bridgetest::TestDataElements SAL_CALL raiseException( sal_Int16 nArgumentPos, const OUString & rMsg, const Reference< XInterface > & xCOntext ) override;
 406
 407     virtual void SAL_CALL raiseRuntimeExceptionOneway(
 408         const OUString& Message, const css::uno::Reference< css::uno::XInterface >& Context ) override;
 409
 410     virtual sal_Int32 SAL_CALL getRuntimeException() override;
 411     virtual void SAL_CALL setRuntimeException( sal_Int32 _runtimeexception ) override;
 412
 413     // XBridgeTest2
 414     virtual Sequence< sal_Bool > SAL_CALL setSequenceBool(
 415         const Sequence< sal_Bool >& aSeq ) override;
 416     virtual Sequence< sal_Unicode > SAL_CALL setSequenceChar(
 417         const Sequence< sal_Unicode >& aSeq ) override;
 418     virtual Sequence< sal_Int8 > SAL_CALL setSequenceByte(
 419         const Sequence< sal_Int8 >& aSeq ) override;
 420     virtual Sequence< sal_Int16 > SAL_CALL setSequenceShort(
 421         const Sequence< sal_Int16 >& aSeq ) override;
 422     virtual Sequence< sal_uInt16 > SAL_CALL setSequenceUShort(
 423         const Sequence< sal_uInt16 >& aSeq ) override;
 424     virtual Sequence< sal_Int32 > SAL_CALL setSequenceLong(
 425         const Sequence< sal_Int32 >& aSeq ) override;
 426     virtual Sequence< sal_uInt32 > SAL_CALL setSequenceULong(
 427         const Sequence< sal_uInt32 >& aSeq ) override;
 428     virtual Sequence< sal_Int64 > SAL_CALL setSequenceHyper(
 429         const Sequence< sal_Int64 >& aSeq ) override;
 430     virtual Sequence< sal_uInt64 > SAL_CALL setSequenceUHyper(
 431         const Sequence< sal_uInt64 >& aSeq ) override;
 432     virtual Sequence< float > SAL_CALL setSequenceFloat(
 433         const Sequence< float >& aSeq ) override;
 434     virtual Sequence< double > SAL_CALL setSequenceDouble(
 435         const Sequence< double >& aSeq ) override;
 436     virtual Sequence< TestEnum > SAL_CALL setSequenceEnum(
 437         const Sequence< TestEnum >& aSeq ) override ;
 438     virtual Sequence< OUString > SAL_CALL setSequenceString(
 439         const Sequence< OUString >& aString ) override;
 440     virtual Sequence< Reference< XInterface > > SAL_CALL setSequenceXInterface(
 441         const Sequence< Reference< XInterface > >& aSeq ) override;
 442     virtual Sequence<Any > SAL_CALL setSequenceAny(
 443         const Sequence<Any >& aSeq ) override;
 444     virtual Sequence<TestElement > SAL_CALL setSequenceStruct(
 445         const Sequence< TestElement >& aSeq ) override;
 446     virtual Sequence< Sequence< sal_Int32 > > SAL_CALL setDim2(
 447         const Sequence<Sequence< sal_Int32 > >& aSeq ) override;
 448     virtual Sequence< Sequence< Sequence< sal_Int32 > > > SAL_CALL setDim3(
 449         const Sequence< Sequence< Sequence< sal_Int32 > > >& aSeq ) override;
 450     virtual void SAL_CALL setSequencesInOut(Sequence< sal_Bool >& aSeqBoolean,
 451                                 Sequence< sal_Unicode >& aSeqChar,
 452                                 Sequence< sal_Int8 >& aSeqByte,
 453                                 Sequence< sal_Int16 >& aSeqShort,
 454                                 Sequence< sal_uInt16 >& aSeqUShort,
 455                                 Sequence< sal_Int32 >& aSeqLong,
 456                                 Sequence< sal_uInt32 >& aSeqULong,
 457                                 Sequence< sal_Int64 >& aSeqHyper,
 458                                 Sequence< sal_uInt64 >& aSeqUHyper,
 459                                 Sequence< float >& aSeqFloat,
 460                                 Sequence< double >& aSeqDouble,
 461                                 Sequence< TestEnum >& aSeqTestEnum,
 462                                 Sequence< OUString >& aSeqString,
 463                                 Sequence<Reference<XInterface > >& aSeqXInterface,
 464                                 Sequence< Any >& aSeqAny,
 465                                 Sequence< Sequence< sal_Int32 > >& aSeqDim2,
 466                                 Sequence< Sequence< Sequence< sal_Int32 > > >& aSeqDim3 ) override;
 467     virtual void SAL_CALL setSequencesOut( Sequence< sal_Bool >& aSeqBoolean,
 468                              Sequence< sal_Unicode >& aSeqChar,
 469                              Sequence< sal_Int8 >& aSeqByte,
 470                              Sequence< sal_Int16 >& aSeqShort,
 471                              Sequence< sal_uInt16 >& aSeqUShort,
 472                              Sequence< sal_Int32 >& aSeqLong,
 473                              Sequence< sal_uInt32 >& aSeqULong,
 474                              Sequence< sal_Int64 >& aSeqHyper,
 475                              Sequence< sal_uInt64 >& aSeqUHyper,
 476                              Sequence< float >& aSeqFloat,
 477                              Sequence< double >& aSeqDouble,
 478                              Sequence< TestEnum >& aSeqEnum,
 479                              Sequence< OUString >& aSeqString,
 480                              Sequence< Reference< XInterface > >& aSeqXInterface,
 481                              Sequence< Any >& aSeqAny,
 482                              Sequence< Sequence< sal_Int32 > >& aSeqDim2,
 483                              Sequence< Sequence< Sequence< sal_Int32 > > >& aSeqDim3 ) override;
 484     virtual void SAL_CALL testConstructorsService(
 485         Reference< XComponentContext > const & context) override;
 486     virtual Reference< XCurrentContextChecker > SAL_CALL
 487     getCurrentContextChecker() override;
 488
 489 public:
 490     virtual void SAL_CALL callRecursivly( const css::uno::Reference< XRecursiveCall >& xCall, sal_Int32 nToCall ) override;
 491 };
 492
 493 //Dummy class for XComponent implementation
 494 class Dummy : public osl::DebugBase<Dummy>,
 495               public WeakComponentImplHelperBase
 496 {
 497 public:
 498      Dummy(): WeakComponentImplHelperBase(*Mutex::getGlobalMutex()){}
 499
 500 };
 501
 502 }
 503
 504 Any Test_Impl::transportAny( const Any & value )
 505 {
 506     return value;
 507 }
 508
 509
 510 namespace {
 511
 512 void wait(sal_Int32 microSeconds) {
 513     OSL_ASSERT(microSeconds >= 0 && microSeconds <= SAL_MAX_INT32 / 1000);
 514     osl::Thread::wait(std::chrono::microseconds(microSeconds));
 515 }
 516
 517 }
 518
 519 void Test_Impl::call( sal_Int32 nCallId , sal_Int32 nWaitMUSEC )
 520 {
 521     wait(nWaitMUSEC);
 522     if( m_bFirstCall )
 523     {
 524         m_bFirstCall = false;
 525     }
 526     else
 527     {
 528         m_bSequenceOfCallTestPassed = m_bSequenceOfCallTestPassed && (nCallId > m_nLastCallId);
 529     }
 530     m_nLastCallId = nCallId;
 531 }
 532
 533
 534 void Test_Impl::callOneway( sal_Int32 nCallId , sal_Int32 nWaitMUSEC )
 535 {
 536     wait(nWaitMUSEC);
 537     m_bSequenceOfCallTestPassed = m_bSequenceOfCallTestPassed && (nCallId > m_nLastCallId);
 538     m_nLastCallId = nCallId;
 539 }
 540
 541
 542 sal_Bool Test_Impl::sequenceOfCallTestPassed()
 543 {
 544     return m_bSequenceOfCallTestPassed;
 545 }
 546
 547
 548 void SAL_CALL Test_Impl::startRecursiveCall(
 549     const css::uno::Reference< XRecursiveCall >& xCall, sal_Int32 nToCall )
 550 {
 551     MutexGuard guard( m_mutex );
 552     if( nToCall )
 553     {
 554         nToCall --;
 555         xCall->callRecursivly( this , nToCall );
 556     }
 557 }
 558
 559
 560 void SAL_CALL Test_Impl::callRecursivly(
 561     const css::uno::Reference< XRecursiveCall >& xCall,
 562     sal_Int32 nToCall )
 563 {
 564     MutexGuard guard( m_mutex );
 565     if( nToCall )
 566     {
 567         nToCall --;
 568         xCall->callRecursivly( this , nToCall );
 569     }
 570 }
 571
 572 Reference< XMulti > Test_Impl::getMulti() {
 573     return new testtools::bridgetest::Multi;
 574 }
 575
 576 OUString Test_Impl::testMulti(Reference< XMulti > const & multi)
 577 {
 578     return testtools::bridgetest::testMulti(multi);
 579 }
 580
 581
 582 void Test_Impl::setValues( sal_Bool bBool,
 583                            sal_Unicode cChar,
 584                            sal_Int8 nByte,
 585                            sal_Int16 nShort,
 586                            sal_uInt16 nUShort,
 587                            sal_Int32 nLong,
 588                            sal_uInt32 nULong,
 589                            sal_Int64 nHyper,
 590                            sal_uInt64 nUHyper,
 591                            float fFloat,
 592                            double fDouble,
 593                            TestEnum eEnum,
 594                            const OUString& rStr,
 595                            sal_Int8 nByte2,
 596                            sal_Int16 nShort2,
 597                            const css::uno::Reference< css::uno::XInterface >& xTest,
 598                            const css::uno::Any& rAny,
 599                            const css::uno::Sequence<TestElement >& rSequence,
 600                            const ::test::testtools::bridgetest::TestDataElements& rStruct )
 601 {
 602     assign( _aData,
 603             bBool, cChar, nByte, nShort, nUShort, nLong, nULong, nHyper, nUHyper, fFloat, fDouble,
 604             eEnum, rStr, nByte2, nShort2, xTest, rAny, rSequence );
 605     _aStructData = rStruct;
 606 }
 607
 608 ::test::testtools::bridgetest::TestDataElements Test_Impl::setValues2( sal_Bool& bBool,
 609                                                                        sal_Unicode& cChar,
 610                                                                        sal_Int8& nByte,
 611                                                                        sal_Int16& nShort,
 612                                                                        sal_uInt16& nUShort,
 613                                                                        sal_Int32& nLong,
 614                                                                        sal_uInt32& nULong,
 615                                                                        sal_Int64& nHyper,
 616                                                                        sal_uInt64& nUHyper,
 617                                                                        float& fFloat,
 618                                                                        double& fDouble,
 619                                                                        TestEnum& eEnum,
 620                                                                        OUString& rStr,
 621                                                                        sal_Int8& nByte2,
 622                                                                        sal_Int16& nShort2,
 623                                                                        css::uno::Reference< css::uno::XInterface >& xTest,
 624                                                                        css::uno::Any& rAny,
 625                                                                        css::uno::Sequence<TestElement >& rSequence,
 626                                                                        ::test::testtools::bridgetest::TestDataElements& rStruct )
 627 {
 628     assign( _aData,
 629             bBool, cChar, nByte, nShort, nUShort, nLong, nULong, nHyper, nUHyper, fFloat, fDouble,
 630             eEnum, rStr, nByte2, nShort2, xTest, rAny, rSequence );
 631     _aStructData = rStruct;
 632
 633     TestElement elem = rSequence[ 0 ];
 634     rSequence[ 0 ] = rSequence[ 1 ];
 635     rSequence[ 1 ] = elem;
 636
 637     return _aStructData;
 638 }
 639
 640 ::test::testtools::bridgetest::TestDataElements Test_Impl::getValues( sal_Bool& bBool,
 641                                                                       sal_Unicode& cChar,
 642                                                                       sal_Int8& nByte,
 643                                                                       sal_Int16& nShort,
 644                                                                       sal_uInt16& nUShort,
 645                                                                       sal_Int32& nLong,
 646                                                                       sal_uInt32& nULong,
 647                                                                       sal_Int64& nHyper,
 648                                                                       sal_uInt64& nUHyper,
 649                                                                       float& fFloat,
 650                                                                       double& fDouble,
 651                                                                       TestEnum& eEnum,
 652                                                                       OUString& rStr,
 653                                                                       sal_Int8& nByte2,
 654                                                                       sal_Int16& nShort2,
 655                                                                       css::uno::Reference< css::uno::XInterface >& xTest,
 656                                                                       css::uno::Any& rAny,
 657                                                                       css::uno::Sequence<TestElement >& rSequence,
 658                                                                       ::test::testtools::bridgetest::TestDataElements& rStruct )
 659 {
 660     bBool = _aData.Bool;
 661     cChar = _aData.Char;
 662     nByte = _aData.Byte;
 663     nShort = _aData.Short;
 664     nUShort = _aData.UShort;
 665     nLong = _aData.Long;
 666     nULong = _aData.ULong;
 667     nHyper = _aData.Hyper;
 668     nUHyper = _aData.UHyper;
 669     fFloat = _aData.Float;
 670     fDouble = _aData.Double;
 671     eEnum = _aData.Enum;
 672     rStr = _aData.String;
 673     nByte2 = _aData.Byte2;
 674     nShort2 = _aData.Short2;
 675     xTest = _aData.Interface;
 676     rAny = _aData.Any;
 677     rSequence = _aData.Sequence;
 678     rStruct = _aStructData;
 679     return _aStructData;
 680 }
 681
 682 ::test::testtools::bridgetest::TestDataElements Test_Impl::raiseException( sal_Int16 nArgumentPos, const OUString & rMsg, const Reference< XInterface > & xContext )
 683 {
 684     IllegalArgumentException aExc;
 685     aExc.ArgumentPosition = nArgumentPos;
 686     aExc.Message          = _aData.String = rMsg;
 687     aExc.Context          = _aData.Interface = xContext;
 688     throw aExc;
 689 }
 690
 691 void Test_Impl::raiseRuntimeExceptionOneway( const OUString & rMsg, const Reference< XInterface > & xContext )
 692 {
 693     RuntimeException aExc;
 694     aExc.Message          = _aData.String = rMsg;
 695     aExc.Context          = _aData.Interface = xContext;
 696     throw aExc;
 697 }
 698
 699 static void dothrow2(const RuntimeException& e)
 700 {
 701     throw e;
 702 }
 703 static void dothrow(const RuntimeException& e)
 704 {
 705 #if defined _MSC_VER
 706     // currently only for MSVC:
 707     // just to test whether all bridges fall back to a RuntimeException
 708     // in case of a thrown non-UNO exception:
 709     try
 710     {
 711         throw ::std::bad_alloc();
 712     }
 713     catch (...)
 714     {
 715         try
 716         {
 717             Any a( getCaughtException() );
 718             RuntimeException exc;
 719             OSL_VERIFY( a >>= exc );
 720         }
 721         catch (...) // never throws anything
 722         {
 723             fprintf( stderr, "\ngetCaughtException() failed!\n" );
 724             exit( 1 );
 725         }
 726     }
 727 #endif
 728     dothrow2( e );
 729 }
 730
 731 sal_Int32 Test_Impl::getRuntimeException()
 732 {
 733     try
 734     {
 735         dothrow( RuntimeException( _aData.String, _aData.Interface ) );
 736     }
 737     catch (Exception &)
 738     {
 739         Any a( getCaughtException() );
 740         throwException( a );
 741     }
 742     return 0; // for dummy
 743 }
 744
 745 void Test_Impl::setRuntimeException( sal_Int32 )
 746 {
 747     RuntimeException aExc;
 748     aExc.Message          = _aData.String;
 749     aExc.Context          = _aData.Interface;
 750     throwException( makeAny( aExc ) );
 751 }
 752
 753 // XBridgeTest2 -------------------------------------------------------------
 754 Sequence< sal_Bool > SAL_CALL Test_Impl::setSequenceBool(
 755         const Sequence< sal_Bool >& aSeq )
 756 {
 757     _arBool = aSeq;
 758     return aSeq;
 759 }
 760
 761 Sequence< sal_Unicode > SAL_CALL Test_Impl::setSequenceChar(
 762         const Sequence< sal_Unicode >& aSeq )
 763 {
 764     _arChar = aSeq;
 765     return aSeq;
 766 }
 767
 768 Sequence< sal_Int8 > SAL_CALL Test_Impl::setSequenceByte(
 769         const Sequence< sal_Int8 >& aSeq )
 770 {
 771     _arByte = aSeq;
 772     return aSeq;
 773 }
 774
 775 Sequence< sal_Int16 > SAL_CALL Test_Impl::setSequenceShort(
 776         const Sequence< sal_Int16 >& aSeq )
 777 {
 778     _arShort = aSeq;
 779     return aSeq;
 780 }
 781
 782 Sequence< sal_uInt16 > SAL_CALL Test_Impl::setSequenceUShort(
 783         const Sequence< sal_uInt16 >& aSeq )
 784 {
 785     _arUShort = aSeq;
 786     return aSeq;
 787 }
 788
 789 Sequence< sal_Int32 > SAL_CALL Test_Impl::setSequenceLong(
 790         const Sequence< sal_Int32 >& aSeq )
 791 {
 792     _arLong = aSeq;
 793     return aSeq;
 794 }
 795
 796 Sequence< sal_uInt32 > SAL_CALL Test_Impl::setSequenceULong(
 797         const Sequence< sal_uInt32 >& aSeq )
 798 {
 799     _arULong = aSeq;
 800     return aSeq;
 801 }
 802
 803 Sequence< sal_Int64 > SAL_CALL Test_Impl::setSequenceHyper(
 804         const Sequence< sal_Int64 >& aSeq )
 805 {
 806     _arHyper = aSeq;
 807     return aSeq;
 808 }
 809
 810 Sequence< sal_uInt64 > SAL_CALL Test_Impl::setSequenceUHyper(
 811         const Sequence< sal_uInt64 >& aSeq )
 812 {
 813     _arUHyper = aSeq;
 814     return aSeq;
 815 }
 816
 817 Sequence< float > SAL_CALL Test_Impl::setSequenceFloat(
 818         const Sequence< float >& aSeq )
 819 {
 820     _arFloat = aSeq;
 821     return aSeq;
 822 }
 823
 824 Sequence< double > SAL_CALL Test_Impl::setSequenceDouble(
 825     const Sequence< double >& aSeq )
 826 {
 827     _arDouble = aSeq;
 828     return aSeq;
 829 }
 830
 831 Sequence< TestEnum > SAL_CALL Test_Impl::setSequenceEnum(
 832     const Sequence< TestEnum >& aSeq )
 833 {
 834     _arEnum = aSeq;
 835     return aSeq;
 836 }
 837
 838 Sequence< OUString > SAL_CALL Test_Impl::setSequenceString(
 839     const Sequence< OUString >& aSeq )
 840 {
 841     _arString = aSeq;
 842     return aSeq;
 843 }
 844
 845 Sequence< Reference< XInterface > > SAL_CALL Test_Impl::setSequenceXInterface(
 846         const Sequence< Reference< XInterface > >& aSeq )
 847 {
 848     _arObject = aSeq;
 849     return aSeq;
 850 }
 851
 852 Sequence<Any > SAL_CALL Test_Impl::setSequenceAny(
 853     const Sequence<Any >& aSeq )
 854 {
 855     _arAny = aSeq;
 856     return aSeq;
 857 }
 858
 859 Sequence<TestElement > SAL_CALL Test_Impl::setSequenceStruct(
 860     const Sequence< TestElement >& aSeq )
 861 {
 862     _arStruct = aSeq;
 863     return aSeq;
 864 }
 865
 866 Sequence< Sequence< sal_Int32 > > SAL_CALL Test_Impl::setDim2(
 867         const Sequence<Sequence< sal_Int32 > >& aSeq )
 868 {
 869     _arLong2 = aSeq;
 870     return aSeq;
 871 }
 872
 873 Sequence< Sequence< Sequence< sal_Int32 > > > SAL_CALL Test_Impl::setDim3(
 874         const Sequence< Sequence< Sequence< sal_Int32 > > >& aSeq )
 875 {
 876     _arLong3 = aSeq;
 877     return aSeq;
 878 }
 879
 880 void SAL_CALL Test_Impl::setSequencesInOut(Sequence< sal_Bool >& aSeqBoolean,
 881                                 Sequence< sal_Unicode >& aSeqChar,
 882                                 Sequence< sal_Int8 >& aSeqByte,
 883                                 Sequence< sal_Int16 >& aSeqShort,
 884                                 Sequence< sal_uInt16 >& aSeqUShort,
 885                                 Sequence< sal_Int32 >& aSeqLong,
 886                                 Sequence< sal_uInt32 >& aSeqULong,
 887                                 Sequence< sal_Int64 >& aSeqHyper,
 888                                 Sequence< sal_uInt64 >& aSeqUHyper,
 889                                 Sequence< float >& aSeqFloat,
 890                                 Sequence< double >& aSeqDouble,
 891                                 Sequence< TestEnum >& aSeqTestEnum,
 892                                 Sequence< OUString >& aSeqString,
 893                                 Sequence<Reference<XInterface > >& aSeqXInterface,
 894                                 Sequence< Any >& aSeqAny,
 895                                 Sequence< Sequence< sal_Int32 > >& aSeqDim2,
 896                                 Sequence< Sequence< Sequence< sal_Int32 > > >& aSeqDim3 )
 897 {
 898     _arBool = aSeqBoolean;
 899     _arChar = aSeqChar;
 900     _arByte = aSeqByte;
 901     _arShort = aSeqShort;
 902     _arUShort = aSeqUShort;
 903     _arLong = aSeqLong;
 904     _arULong = aSeqULong;
 905     _arHyper  = aSeqHyper;
 906     _arUHyper = aSeqUHyper;
 907     _arFloat = aSeqFloat;
 908     _arDouble = aSeqDouble;
 909     _arEnum = aSeqTestEnum;
 910     _arString = aSeqString;
 911     _arObject = aSeqXInterface;
 912     _arAny = aSeqAny;
 913     _arLong2 = aSeqDim2;
 914     _arLong3 = aSeqDim3;
 915 }
 916
 917 void SAL_CALL Test_Impl::setSequencesOut( Sequence< sal_Bool >& aSeqBoolean,
 918                              Sequence< sal_Unicode >& aSeqChar,
 919                              Sequence< sal_Int8 >& aSeqByte,
 920                              Sequence< sal_Int16 >& aSeqShort,
 921                              Sequence< sal_uInt16 >& aSeqUShort,
 922                              Sequence< sal_Int32 >& aSeqLong,
 923                              Sequence< sal_uInt32 >& aSeqULong,
 924                              Sequence< sal_Int64 >& aSeqHyper,
 925                              Sequence< sal_uInt64 >& aSeqUHyper,
 926                              Sequence< float >& aSeqFloat,
 927                              Sequence< double >& aSeqDouble,
 928                              Sequence< TestEnum >& aSeqEnum,
 929                              Sequence< OUString >& aSeqString,
 930                              Sequence< Reference< XInterface > >& aSeqXInterface,
 931                              Sequence< Any >& aSeqAny,
 932                              Sequence< Sequence< sal_Int32 > >& aSeqDim2,
 933                              Sequence< Sequence< Sequence< sal_Int32 > > >& aSeqDim3 )
 934 {
 935     aSeqBoolean = _arBool;
 936     aSeqChar = _arChar;
 937     aSeqByte = _arByte;
 938     aSeqShort = _arShort;
 939     aSeqUShort = _arUShort;
 940     aSeqLong = _arLong;
 941     aSeqULong = _arULong;
 942     aSeqHyper = _arHyper;
 943     aSeqUHyper = _arUHyper;
 944     aSeqFloat = _arFloat;
 945     aSeqDouble = _arDouble;
 946     aSeqEnum = _arEnum;
 947     aSeqString = _arString;
 948     aSeqXInterface = _arObject;
 949     aSeqAny = _arAny;
 950     aSeqDim2 = _arLong2;
 951     aSeqDim3 = _arLong3;
 952 }
 953
 954 void Test_Impl::testConstructorsService(
 955     Reference< XComponentContext > const & context)
 956 {
 957     Sequence< sal_Bool > arg14(1); arg14[0] = true;
 958     Sequence< sal_Int8 > arg15(1); arg15[0] = SAL_MIN_INT8;
 959     Sequence< sal_Int16 > arg16(1); arg16[0] = SAL_MIN_INT16;
 960     Sequence< sal_uInt16 > arg17(1); arg17[0] = SAL_MAX_UINT16;
 961     Sequence< sal_Int32 > arg18(1); arg18[0] = SAL_MIN_INT32;
 962     Sequence< sal_uInt32 > arg19(1); arg19[0] = SAL_MAX_UINT32;
 963     Sequence< sal_Int64 > arg20(1); arg20[0] = SAL_MIN_INT64;
 964     Sequence< sal_uInt64 > arg21(1); arg21[0] = SAL_MAX_UINT64;
 965     Sequence< float > arg22(1); arg22[0] = 0.123f;
 966     Sequence< double > arg23(1); arg23[0] = 0.456;
 967     Sequence< sal_Unicode > arg24(1); arg24[0] = 'X';
 968     Sequence< OUString > arg25 { "test" };
 969     Sequence< Type > arg26(1); arg26[0] = UnoType< Any >::get();
 970     Sequence< Any > arg27(1); arg27[0] <<= true;
 971     Sequence< Sequence< sal_Bool > > arg28(1);
 972     arg28[0] = Sequence< sal_Bool >(1); arg28[0][0] = true;
 973     Sequence< Sequence< Any > > arg29(1); arg29[0] = Sequence< Any >(1);
 974     arg29[0][0] <<= true;
 975     Sequence< TestEnum > arg30(1); arg30[0] = TestEnum_TWO;
 976     Sequence< TestStruct > arg31(1); arg31[0].member = 10;
 977     Sequence< TestPolyStruct< sal_Bool > > arg32(1); arg32[0].member = true;
 978     Sequence< TestPolyStruct< Any > > arg33(1); arg33[0].member <<= true;
 979     Sequence< Reference< XInterface > > arg34(1);
 980     Constructors::create1(context,
 981         true,
 982         SAL_MIN_INT8,
 983         SAL_MIN_INT16,
 984         SAL_MAX_UINT16,
 985         SAL_MIN_INT32,
 986         SAL_MAX_UINT32,
 987         SAL_MIN_INT64,
 988         SAL_MAX_UINT64,
 989         0.123f,
 990         0.456,
 991         'X',
 992         "test",
 993         UnoType< Any >::get(),
 994         makeAny(true),
 995         arg14,
 996         arg15,
 997         arg16,
 998         arg17,
 999         arg18,
1000         arg19,
1001         arg20,
1002         arg21,
1003         arg22,
1004         arg23,
1005         arg24,
1006         arg25,
1007         arg26,
1008         arg27,
1009         arg28,
1010         arg29,
1011         arg30,
1012         arg31,
1013         arg32,
1014         arg33,
1015         arg34,
1016         TestEnum_TWO,
1017         TestStruct(10),
1018         TestPolyStruct< sal_Bool >(true),
1019         TestPolyStruct< Any >(makeAny(true)),
1020         Reference< XInterface >(nullptr));
1021     Sequence< Any > args(40);
1022     args[0] <<= true;
1023     args[1] <<= SAL_MIN_INT8;
1024     args[2] <<= SAL_MIN_INT16;
1025     args[3] <<= SAL_MAX_UINT16;
1026     args[4] <<= SAL_MIN_INT32;
1027     args[5] <<= SAL_MAX_UINT32;
1028     args[6] <<= SAL_MIN_INT64;
1029     args[7] <<= SAL_MAX_UINT64;
1030     args[8] <<= 0.123f;
1031     args[9] <<= 0.456;
1032     args[10] <<= u'X';
1033     args[11] <<= OUString("test");
1034     args[12] <<= UnoType< Any >::get();
1035     args[13] <<= true;
1036     args[14] <<= arg14;
1037     args[15] <<= arg15;
1038     args[16] <<= arg16;
1039     args[17] <<= arg17;
1040     args[18] <<= arg18;
1041     args[19] <<= arg19;
1042     args[20] <<= arg20;
1043     args[21] <<= arg21;
1044     args[22] <<= arg22;
1045     args[23] <<= arg23;
1046     args[24] <<= arg24;
1047     args[25] <<= arg25;
1048     args[26] <<= arg26;
1049     args[27] <<= arg27;
1050     args[28] <<= arg28;
1051     args[29] <<= arg29;
1052     args[30] <<= arg30;
1053     args[31] <<= arg31;
1054     args[32] <<= arg32;
1055     args[33] <<= arg33;
1056     args[34] <<= arg34;
1057     args[35] <<= TestEnum_TWO;
1058     args[36] <<= TestStruct(10);
1059     args[37] <<= TestPolyStruct< sal_Bool >(true);
1060     args[38] <<= TestPolyStruct< Any >(makeAny(true));
1061     args[39] <<= Reference< XInterface >(nullptr);
1062     Constructors::create2(context, args);
1063
1064     Sequence<Type> argSeq1(1); argSeq1[0] = cppu::UnoType<sal_Int32>::get();
1065     Sequence<Reference<XInterface> > argSeq2 { static_cast<XComponent*>(new Dummy()) };
1066     Sequence<Reference<XComponent> > argSeq2a { static_cast<XComponent*>(new Dummy()) };
1067
1068     Sequence<TestPolyStruct2<sal_Unicode, Sequence<Any> > > argSeq3(1);
1069     argSeq3[0] = TestPolyStruct2<sal_Unicode, Sequence<Any> >('X', arg27);
1070     Sequence<TestPolyStruct2<TestPolyStruct<sal_Unicode>, Sequence<Any> > > argSeq4(1);
1071     argSeq4[0] = TestPolyStruct2<TestPolyStruct<sal_Unicode>, Sequence<Any> >(
1072         TestPolyStruct<sal_Unicode>('X'), arg27);
1073     Sequence<Sequence<sal_Int32> > argSeq5(1);
1074     argSeq5[0] = Sequence<sal_Int32>(1); argSeq5[0][0] = SAL_MIN_INT32;
1075     Sequence<TestPolyStruct<sal_Int32> > argSeq6(1);
1076     argSeq6[0] = TestPolyStruct<sal_Int32>(SAL_MIN_INT32);
1077     Sequence<TestPolyStruct<TestPolyStruct2<sal_Unicode, Any> > > argSeq7(1);
1078     argSeq7[0] = TestPolyStruct<TestPolyStruct2<sal_Unicode, Any> >(
1079         TestPolyStruct2<sal_Unicode, Any>('X', Any(true)));
1080     Sequence<TestPolyStruct<TestPolyStruct2<TestPolyStruct2<sal_Unicode, Any>,OUString> > > argSeq8(1);
1081     argSeq8[0] = TestPolyStruct<TestPolyStruct2<TestPolyStruct2<sal_Unicode, Any>,OUString> > (
1082         TestPolyStruct2<TestPolyStruct2<sal_Unicode, Any>,OUString>(
1083             TestPolyStruct2<sal_Unicode, Any>('X', Any(true)), OUString("test")));
1084     Sequence<TestPolyStruct2<OUString, TestPolyStruct2<sal_Unicode, TestPolyStruct<Any> > > > argSeq9(1);
1085     argSeq9[0] = TestPolyStruct2<OUString, TestPolyStruct2<sal_Unicode, TestPolyStruct<Any> > >(
1086         OUString("test"), TestPolyStruct2<sal_Unicode, TestPolyStruct<Any> >(
1087                      'X', TestPolyStruct<Any>(Any(true))));
1088     Sequence<TestPolyStruct2<TestPolyStruct2<sal_Unicode, Any>, TestPolyStruct<sal_Unicode> > > argSeq10(1);
1089     argSeq10[0] = TestPolyStruct2<TestPolyStruct2<sal_Unicode, Any>, TestPolyStruct<sal_Unicode> >(
1090         TestPolyStruct2<sal_Unicode, Any>('X', Any(true)), TestPolyStruct<sal_Unicode>('X'));
1091     Sequence<Sequence<TestPolyStruct<sal_Unicode > > > argSeq11(1);
1092     argSeq11[0] = Sequence<TestPolyStruct<sal_Unicode > >(1);
1093     argSeq11[0][0] = TestPolyStruct<sal_Unicode>('X');
1094     Sequence<Sequence<TestPolyStruct<TestPolyStruct2<sal_Unicode,Any> > > > argSeq12(1);
1095     argSeq12[0] = Sequence<TestPolyStruct<TestPolyStruct2<sal_Unicode,Any> > >(1);
1096     argSeq12[0][0] = TestPolyStruct<TestPolyStruct2<sal_Unicode,Any> >(
1097         TestPolyStruct2<sal_Unicode,Any>('X', Any(true)));
1098     Sequence<Sequence<TestPolyStruct<TestPolyStruct2<TestPolyStruct2<sal_Unicode,Any>,OUString> > > > argSeq13(1);
1099     argSeq13[0] = Sequence<TestPolyStruct<TestPolyStruct2<TestPolyStruct2<sal_Unicode,Any>,OUString> > >(1);
1100     argSeq13[0][0] = TestPolyStruct<TestPolyStruct2<TestPolyStruct2<sal_Unicode,Any>,OUString> >(
1101         TestPolyStruct2<TestPolyStruct2<sal_Unicode,Any>,OUString>(
1102             TestPolyStruct2<sal_Unicode,Any>('X', Any(true)), OUString("test")));
1103     Sequence<Sequence<TestPolyStruct2<OUString, TestPolyStruct2<sal_Unicode, TestPolyStruct<Any> > > > > argSeq14(1);
1104     argSeq14[0] = Sequence<TestPolyStruct2<OUString, TestPolyStruct2<sal_Unicode, TestPolyStruct<Any> > > >(1);
1105     argSeq14[0][0] = TestPolyStruct2<OUString, TestPolyStruct2<sal_Unicode, TestPolyStruct<Any> > >(
1106         OUString("test"), TestPolyStruct2<sal_Unicode, TestPolyStruct<Any> >(
1107             'X', TestPolyStruct<Any>(Any(true))));
1108     Sequence<Sequence<TestPolyStruct2<TestPolyStruct2<sal_Unicode,Any>, TestPolyStruct<sal_Unicode> > > > argSeq15(1);
1109     argSeq15[0] = Sequence<TestPolyStruct2<TestPolyStruct2<sal_Unicode,Any>, TestPolyStruct<sal_Unicode> > >(1);
1110     argSeq15[0][0] = TestPolyStruct2<TestPolyStruct2<sal_Unicode,Any>, TestPolyStruct<sal_Unicode> >(
1111         TestPolyStruct2<sal_Unicode,Any>('X',Any(true)), TestPolyStruct<sal_Unicode>('X'));
1112
1113     Constructors2::create1(
1114         context,
1115         TestPolyStruct<Type>(cppu::UnoType<sal_Int32>::get()),
1116         TestPolyStruct<Any>(Any(true)),
1117         TestPolyStruct<sal_Bool>(true),
1118         TestPolyStruct<sal_Int8>(SAL_MIN_INT8),
1119         TestPolyStruct<sal_Int16>(SAL_MIN_INT16),
1120         TestPolyStruct<sal_Int32>(SAL_MIN_INT32),
1121         TestPolyStruct<sal_Int64>(SAL_MIN_INT64),
1122         TestPolyStruct<sal_Unicode>('X'),
1123         TestPolyStruct<OUString>(OUString("test")),
1124         TestPolyStruct<float>(0.123f),
1125         TestPolyStruct<double>(0.456),
1126         TestPolyStruct<Reference<XInterface> >(static_cast<XBridgeTest2*>(this)),
1127         TestPolyStruct<Reference<XComponent> >(static_cast<XComponent*>(new Dummy())),
1128         TestPolyStruct<TestEnum>(TestEnum_TWO),
1129         TestPolyStruct<TestPolyStruct2<sal_Unicode, Any> >(
1130             TestPolyStruct2<sal_Unicode, Any>('X', Any(true))),
1131         TestPolyStruct<TestPolyStruct2<TestPolyStruct2<sal_Unicode, Any>,OUString> > (
1132             TestPolyStruct2<TestPolyStruct2<sal_Unicode, Any>,OUString>(
1133                 TestPolyStruct2<sal_Unicode, Any>('X', Any(true)), OUString("test"))),
1134         TestPolyStruct2<OUString, TestPolyStruct2<sal_Unicode,TestPolyStruct<Any> > >(
1135             OUString("test"),
1136             TestPolyStruct2<sal_Unicode, TestPolyStruct<Any> >('X', TestPolyStruct<Any>(Any(true)))),
1137         TestPolyStruct2<TestPolyStruct2<sal_Unicode, Any>, TestPolyStruct<sal_Unicode> >(
1138             TestPolyStruct2<sal_Unicode, Any>('X', Any(true)),
1139             TestPolyStruct<sal_Unicode>('X')),
1140         TestPolyStruct<Sequence<Type> >(argSeq1),
1141         TestPolyStruct<Sequence<Any> >(arg27),
1142         TestPolyStruct<Sequence<sal_Bool> >(arg14),
1143         TestPolyStruct<Sequence<sal_Int8> >(arg15),
1144         TestPolyStruct<Sequence<sal_Int16> >(arg16),
1145         TestPolyStruct<Sequence<sal_Int32> >(arg18),
1146         TestPolyStruct<Sequence<sal_Int64> >(arg20),
1147         TestPolyStruct<Sequence<sal_Unicode> >(arg24),
1148         TestPolyStruct<Sequence<OUString> >(arg25),
1149         TestPolyStruct<Sequence<float> >(arg22),
1150         TestPolyStruct<Sequence<double> >(arg23),
1151         TestPolyStruct<Sequence<Reference<XInterface> > >(argSeq2),
1152         TestPolyStruct<Sequence<Reference<XComponent> > >(argSeq2a),
1153         TestPolyStruct<Sequence<TestEnum> >(arg30),
1154         TestPolyStruct<Sequence<TestPolyStruct2<sal_Unicode, Sequence<Any> > > >(argSeq3),
1155         TestPolyStruct<Sequence<TestPolyStruct2<TestPolyStruct<sal_Unicode>, Sequence<Any> > > > (argSeq4),
1156         TestPolyStruct<Sequence<Sequence<sal_Int32> > >(argSeq5),
1157         argSeq6,
1158         argSeq7,
1159         argSeq8,
1160         argSeq9,
1161         argSeq10,
1162         argSeq11,
1163         argSeq12,
1164         argSeq13,
1165         argSeq14,
1166         argSeq15);
1167 }
1168
1169 Reference< XCurrentContextChecker > Test_Impl::getCurrentContextChecker()
1170 {
1171     return new testtools::bridgetest::CurrentContextChecker;
1172 }
1173
1174 // XServiceInfo
1175
1176 OUString Test_Impl::getImplementationName()
1177 {
1178     return IMPLNAME;
1179 }
1180
1181 sal_Bool Test_Impl::supportsService( const OUString & rServiceName )
1182 {
1183     return cppu::supportsService(this, rServiceName);
1184 }
1185
1186 Sequence< OUString > Test_Impl::getSupportedServiceNames()
1187 {
1188     return bridge_object::getSupportedServiceNames();
1189 }
1190
1191
1192 static Reference< XInterface > Test_Impl_create(
1193     SAL_UNUSED_PARAMETER const Reference< XMultiServiceFactory > & )
1194 {
1195     return Reference< XInterface >( static_cast<XBridgeTest *>(new Test_Impl()) );
1196 }
1197
1198 }
1199
1200 extern "C"
1201 {
1202 SAL_DLLPUBLIC_EXPORT void * component_getFactory(
1203     const char * pImplName, SAL_UNUSED_PARAMETER void * pServiceManager,
1204     SAL_UNUSED_PARAMETER void * )
1205 {
1206     void * pRet = nullptr;
1207
1208     if (pServiceManager && rtl_str_compare( pImplName, IMPLNAME ) == 0)
1209     {
1210         Reference< XSingleServiceFactory > xFactory( createSingleFactory(
1211             static_cast< XMultiServiceFactory * >( pServiceManager ),
1212             IMPLNAME,
1213             bridge_object::Test_Impl_create,
1214             bridge_object::getSupportedServiceNames() ) );
1215
1216         if (xFactory.is())
1217         {
1218             xFactory->acquire();
1219             pRet = xFactory.get();
1220         }
1221     }
1222
1223     return pRet;
1224 }
1225 }
1226
1227 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */