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