1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_testtools.hxx" 26 27 #include <stdio.h> 28 #include <string.h> 29 #include <osl/diagnose.h> 30 #include "osl/diagnose.hxx" 31 #include <osl/time.h> 32 #include <sal/types.h> 33 #include "typelib/typedescription.hxx" 34 #include <uno/dispatcher.hxx> 35 #include "uno/mapping.hxx" 36 #include <uno/data.h> 37 #include "uno/environment.hxx" 38 39 #include <cppuhelper/factory.hxx> 40 #include <cppuhelper/implbase2.hxx> 41 #include <cppuhelper/implbase1.hxx> 42 43 #include <com/sun/star/lang/XServiceInfo.hpp> 44 #include <com/sun/star/lang/XComponent.hpp> 45 #include <com/sun/star/lang/XMain.hpp> 46 #include <com/sun/star/bridge/UnoUrlResolver.hpp> 47 #include <com/sun/star/bridge/XUnoUrlResolver.hpp> 48 #include "com/sun/star/uno/RuntimeException.hpp" 49 #include "com/sun/star/uno/Type.hxx" 50 51 #include "test/testtools/bridgetest/BadConstructorArguments.hpp" 52 #include "test/testtools/bridgetest/TestPolyStruct.hpp" 53 #include "test/testtools/bridgetest/XBridgeTest.hpp" 54 #include "test/testtools/bridgetest/XBridgeTest2.hpp" 55 #include "test/testtools/bridgetest/XMulti.hpp" 56 57 #include "currentcontextchecker.hxx" 58 #include "multi.hxx" 59 60 using namespace rtl; 61 using namespace osl; 62 using namespace cppu; 63 using namespace com::sun::star::uno; 64 using namespace com::sun::star::lang; 65 using namespace com::sun::star::registry; 66 using namespace com::sun::star::bridge; 67 using namespace test::testtools::bridgetest; 68 69 #define SERVICENAME "com.sun.star.test.bridge.BridgeTest" 70 #define IMPLNAME "com.sun.star.comp.bridge.BridgeTest" 71 72 #define OUSTR(x) ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(x) ) 73 #define STRING_TEST_CONSTANT "\" paco\' chorizo\\\' \"\'" 74 75 namespace bridge_test 76 { 77 template< class T> 78 Sequence<T> cloneSequence(const Sequence<T>& val); 79 80 //-------------------------------------------------------------------------------------------------- 81 inline static Sequence< OUString > getSupportedServiceNames() 82 { 83 OUString aName( RTL_CONSTASCII_USTRINGPARAM(SERVICENAME) ); 84 return Sequence< OUString >( &aName, 1 ); 85 } 86 87 static bool check( bool b , char const * message ) 88 { 89 if ( ! b ) 90 fprintf( stderr, "%s failed\n" , message ); 91 return b; 92 } 93 94 namespace { 95 96 bool checkEmpty(rtl::OUString const & string, char const * message) { 97 bool ok = string.getLength() == 0; 98 if (!ok) { 99 fprintf( 100 stderr, "%s failed: %s\n", message, 101 rtl::OUStringToOString(string, RTL_TEXTENCODING_UTF8).getStr()); 102 } 103 return ok; 104 } 105 106 } 107 108 //================================================================================================== 109 class TestBridgeImpl : public osl::DebugBase<TestBridgeImpl>, 110 public WeakImplHelper2< XMain, XServiceInfo > 111 { 112 Reference< XComponentContext > m_xContext; 113 114 public: 115 TestBridgeImpl( const Reference< XComponentContext > & xContext ) 116 : m_xContext( xContext ) 117 {} 118 virtual ~TestBridgeImpl() 119 { 120 } 121 122 // XServiceInfo 123 virtual OUString SAL_CALL getImplementationName() throw (RuntimeException); 124 virtual sal_Bool SAL_CALL supportsService( const OUString & rServiceName ) throw (RuntimeException); 125 virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() throw (RuntimeException); 126 127 // XMain 128 virtual sal_Int32 SAL_CALL run( const Sequence< OUString > & rArgs ) throw (RuntimeException); 129 }; 130 131 //================================================================================================== 132 static sal_Bool equals( const TestElement & rData1, const TestElement & rData2 ) 133 { 134 check( rData1.Bool == rData2.Bool, "### bool does not match!" ); 135 check( rData1.Char == rData2.Char, "### char does not match!" ); 136 check( rData1.Byte == rData2.Byte, "### byte does not match!" ); 137 check( rData1.Short == rData2.Short, "### short does not match!" ); 138 check( rData1.UShort == rData2.UShort, "### unsigned short does not match!" ); 139 check( rData1.Long == rData2.Long, "### long does not match!" ); 140 check( rData1.ULong == rData2.ULong, "### unsigned long does not match!" ); 141 check( rData1.Hyper == rData2.Hyper, "### hyper does not match!" ); 142 check( rData1.UHyper == rData2.UHyper, "### unsigned hyper does not match!" ); 143 check( rData1.Float == rData2.Float, "### float does not match!" ); 144 check( rData1.Double == rData2.Double, "### double does not match!" ); 145 check( rData1.Enum == rData2.Enum, "### enum does not match!" ); 146 check( rData1.String == rData2.String, "### string does not match!" ); 147 check( rData1.Interface == rData2.Interface, "### interface does not match!" ); 148 check( rData1.Any == rData2.Any, "### any does not match!" ); 149 150 return (rData1.Bool == rData2.Bool && 151 rData1.Char == rData2.Char && 152 rData1.Byte == rData2.Byte && 153 rData1.Short == rData2.Short && 154 rData1.UShort == rData2.UShort && 155 rData1.Long == rData2.Long && 156 rData1.ULong == rData2.ULong && 157 rData1.Hyper == rData2.Hyper && 158 rData1.UHyper == rData2.UHyper && 159 rData1.Float == rData2.Float && 160 rData1.Double == rData2.Double && 161 rData1.Enum == rData2.Enum && 162 rData1.String == rData2.String && 163 rData1.Interface == rData2.Interface && 164 rData1.Any == rData2.Any); 165 } 166 //================================================================================================== 167 static sal_Bool equals( const TestData & rData1, const TestData & rData2 ) 168 { 169 sal_Int32 nLen; 170 171 if ((rData1.Sequence == rData2.Sequence) && 172 equals( (const TestElement &)rData1, (const TestElement &)rData2 ) && 173 (nLen = rData1.Sequence.getLength()) == rData2.Sequence.getLength()) 174 { 175 // once again by hand sequence == 176 const TestElement * pElements1 = rData1.Sequence.getConstArray(); 177 const TestElement * pElements2 = rData2.Sequence.getConstArray(); 178 for ( ; nLen--; ) 179 { 180 if (! equals( pElements1[nLen], pElements2[nLen] )) 181 { 182 check( sal_False, "### sequence element did not match!" ); 183 return sal_False; 184 } 185 } 186 return sal_True; 187 } 188 return sal_False; 189 } 190 //================================================================================================== 191 static void assign( TestElement & rData, 192 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, const ::rtl::OUString& rStr, 198 const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >& xTest, 199 const ::com::sun::star::uno::Any& rAny ) 200 { 201 rData.Bool = bBool; 202 rData.Char = cChar; 203 rData.Byte = nByte; 204 rData.Short = nShort; 205 rData.UShort = nUShort; 206 rData.Long = nLong; 207 rData.ULong = nULong; 208 rData.Hyper = nHyper; 209 rData.UHyper = nUHyper; 210 rData.Float = fFloat; 211 rData.Double = fDouble; 212 rData.Enum = eEnum; 213 rData.String = rStr; 214 rData.Interface = xTest; 215 rData.Any = rAny; 216 } 217 218 namespace { 219 220 template < typename T > 221 bool testAny( 222 T const & value, Reference< XBridgeTest > const & xLBT, 223 char const * typeName = 0) 224 { 225 Any any; 226 any <<= value; 227 Any any2 = xLBT->transportAny(any); 228 bool success = true; 229 if (any != any2) { 230 fprintf( 231 stderr, "any is different after roundtrip: in %s, out %s\n", 232 OUStringToOString( 233 any.getValueType().getTypeName(), 234 RTL_TEXTENCODING_ASCII_US).getStr(), 235 OUStringToOString( 236 any2.getValueType().getTypeName(), 237 RTL_TEXTENCODING_ASCII_US).getStr()); 238 success = false; 239 } 240 if (typeName != 0 241 && !any2.getValueType().getTypeName().equalsAscii(typeName)) 242 { 243 fprintf( 244 stderr, "any has wrong type after roundtrip: %s instead of %s\n", 245 OUStringToOString( 246 any2.getValueType().getTypeName(), 247 RTL_TEXTENCODING_ASCII_US).getStr(), 248 typeName); 249 success = false; 250 } 251 return success; 252 } 253 254 } 255 256 static sal_Bool performAnyTest( const Reference< XBridgeTest > &xLBT, const TestData &data) 257 { 258 bool bReturn = true; 259 bReturn = testAny( data.Byte ,xLBT ) && bReturn; 260 bReturn = testAny( data.Short,xLBT ) && bReturn; 261 bReturn = testAny( data.UShort,xLBT ) && bReturn; 262 bReturn = testAny( data.Long,xLBT ) && bReturn; 263 bReturn = testAny( data.ULong,xLBT ) && bReturn; 264 bReturn = testAny( data.Hyper,xLBT ) && bReturn; 265 bReturn = testAny( data.UHyper,xLBT ) && bReturn; 266 bReturn = testAny( data.Float,xLBT ) && bReturn; 267 bReturn = testAny( data.Double,xLBT ) && bReturn; 268 bReturn = testAny( data.Enum,xLBT ) && bReturn; 269 bReturn = testAny( data.String,xLBT ) && bReturn; 270 bReturn = testAny( data.Interface,xLBT ) && bReturn; 271 bReturn = testAny( data, xLBT ) && bReturn; 272 bReturn &= testAny( 273 TestPolyStruct< sal_Unicode >(' '), xLBT, 274 "test.testtools.bridgetest.TestPolyStruct<char>"); 275 276 Any a; 277 { 278 a.setValue( &(data.Bool) , getCppuBooleanType() ); 279 Any a2 = xLBT->transportAny( a ); 280 OSL_ASSERT( a2 == a ); 281 } 282 283 { 284 a.setValue( &(data.Char) , getCppuCharType() ); 285 Any a2 = xLBT->transportAny( a ); 286 OSL_ASSERT( a2 == a ); 287 } 288 289 return bReturn; 290 } 291 292 //_______________________________________________________________________________________ 293 static sal_Bool performSequenceOfCallTest( const Reference < XBridgeTest > &xLBT ) 294 { 295 sal_Int32 i,nRounds; 296 sal_Int32 nGlobalIndex = 0; 297 const sal_Int32 nWaitTimeSpanMUSec = 10000; 298 for( nRounds = 0 ; nRounds < 10 ; nRounds ++ ) 299 { 300 for( i = 0 ; i < nRounds ; i ++ ) 301 { 302 // fire oneways 303 xLBT->callOneway( nGlobalIndex , nWaitTimeSpanMUSec ); 304 nGlobalIndex ++; 305 } 306 307 // call synchron 308 xLBT->call( nGlobalIndex , nWaitTimeSpanMUSec ); 309 nGlobalIndex ++; 310 } 311 312 return xLBT->sequenceOfCallTestPassed(); 313 } 314 315 class ORecursiveCall : public WeakImplHelper1< XRecursiveCall > 316 { 317 private: 318 Mutex m_mutex; 319 320 public: 321 void SAL_CALL callRecursivly( 322 const ::com::sun::star::uno::Reference< XRecursiveCall >& xCall, 323 sal_Int32 nToCall ) 324 throw(::com::sun::star::uno::RuntimeException) 325 { 326 MutexGuard guard( m_mutex ); 327 if( nToCall ) 328 { 329 nToCall --; 330 xCall->callRecursivly( this , nToCall ); 331 } 332 333 } 334 }; 335 336 337 //_______________________________________________________________________________________ 338 static sal_Bool performRecursiveCallTest( const Reference < XBridgeTest > & xLBT ) 339 { 340 xLBT->startRecursiveCall( new ORecursiveCall , 50 ); 341 // on failure, the test would lock up or crash 342 return sal_True; 343 } 344 345 class MyClass : public osl::DebugBase<MyClass>, public OWeakObject 346 { 347 public: 348 MyClass(); 349 virtual ~MyClass(); 350 virtual void SAL_CALL acquire() throw (); 351 virtual void SAL_CALL release() throw (); 352 }; 353 354 //______________________________________________________________________________ 355 MyClass::MyClass() 356 { 357 } 358 //______________________________________________________________________________ 359 MyClass::~MyClass() 360 { 361 } 362 //______________________________________________________________________________ 363 void MyClass::acquire() throw () 364 { 365 OWeakObject::acquire(); 366 } 367 //______________________________________________________________________________ 368 void MyClass::release() throw () 369 { 370 OWeakObject::release(); 371 } 372 373 //================================================================================================== 374 static sal_Bool performTest( 375 const Reference<XComponentContext> & xContext, 376 const Reference<XBridgeTest > & xLBT, 377 bool noCurrentContext ) 378 { 379 check(xLBT.is(), "### no test interface!"); 380 bool bRet = true; 381 if (xLBT.is()) { 382 // this data is never ever granted access to by calls other than 383 // equals(), assign()! 384 TestData aData; // test against this data 385 Reference< XInterface > xI(new MyClass); 386 assign( 387 (TestElement &) aData, true, '@', 17, 0x1234, 0xFEDC, 0x12345678, 388 0xFEDCBA98, SAL_CONST_INT64(0x123456789ABCDEF0), 389 SAL_CONST_UINT64(0xFEDCBA9876543210), 17.0815f, 3.1415926359, 390 TestEnum_LOLA, OUSTR(STRING_TEST_CONSTANT), xI, 391 Any(&xI, getCppuType((Reference< XInterface > const *) 0))); 392 bRet &= check(aData.Any == xI, "### unexpected any!"); 393 bRet &= check(!(aData.Any != xI), "### unexpected any!"); 394 aData.Sequence.realloc(2); 395 aData.Sequence[0] = *(TestElement const *) &aData; 396 // aData.Sequence[1] is empty 397 // aSetData is a manually copy of aData for first setting: 398 TestData aSetData; 399 assign( 400 (TestElement &) aSetData, aData.Bool, aData.Char, aData.Byte, 401 aData.Short, aData.UShort, aData.Long, aData.ULong, aData.Hyper, 402 aData.UHyper, aData.Float, aData.Double, aData.Enum, aData.String, 403 xI, Any(&xI, getCppuType((Reference< XInterface > const *) 0))); 404 aSetData.Sequence.realloc(2); 405 aSetData.Sequence[0] = *(TestElement const *) &aSetData; 406 // aSetData.Sequence[1] is empty 407 xLBT->setValues( 408 aSetData.Bool, aSetData.Char, aSetData.Byte, aSetData.Short, 409 aSetData.UShort, aSetData.Long, aSetData.ULong, aSetData.Hyper, 410 aSetData.UHyper, aSetData.Float, aSetData.Double, aSetData.Enum, 411 aSetData.String, aSetData.Interface, aSetData.Any, 412 aSetData.Sequence, aSetData); 413 { 414 TestData aRet; 415 TestData aRet2; 416 xLBT->getValues( 417 aRet.Bool, aRet.Char, aRet.Byte, aRet.Short, aRet.UShort, 418 aRet.Long, aRet.ULong, aRet.Hyper, aRet.UHyper, aRet.Float, 419 aRet.Double, aRet.Enum, aRet.String, aRet.Interface, aRet.Any, 420 aRet.Sequence, aRet2); 421 bRet &= check( 422 equals(aData, aRet) && equals(aData, aRet2), "getValues test"); 423 // Set last retrieved values: 424 TestData aSV2ret( 425 xLBT->setValues2( 426 aRet.Bool, aRet.Char, aRet.Byte, aRet.Short, aRet.UShort, 427 aRet.Long, aRet.ULong, aRet.Hyper, aRet.UHyper, aRet.Float, 428 aRet.Double, aRet.Enum, aRet.String, aRet.Interface, 429 aRet.Any, aRet.Sequence, aRet2)); 430 // Check inout sequence order (=> inout sequence parameter was 431 // switched by test objects): 432 TestElement temp(aRet.Sequence[0]); 433 aRet.Sequence[0] = aRet.Sequence[1]; 434 aRet.Sequence[1] = temp; 435 bRet &= check( 436 equals(aData, aSV2ret) && equals(aData, aRet2), 437 "getValues2 test"); 438 } 439 { 440 TestData aRet; 441 TestData aRet2; 442 TestData aGVret( 443 xLBT->getValues( 444 aRet.Bool, aRet.Char, aRet.Byte, aRet.Short, aRet.UShort, 445 aRet.Long, aRet.ULong, aRet.Hyper, aRet.UHyper, aRet.Float, 446 aRet.Double, aRet.Enum, aRet.String, aRet.Interface, 447 aRet.Any, aRet.Sequence, aRet2)); 448 bRet &= check( 449 (equals(aData, aRet) && equals(aData, aRet2) && 450 equals(aData, aGVret)), 451 "getValues test"); 452 // Set last retrieved values: 453 xLBT->setBool(aRet.Bool); 454 xLBT->setChar(aRet.Char); 455 xLBT->setByte(aRet.Byte); 456 xLBT->setShort(aRet.Short); 457 xLBT->setUShort(aRet.UShort); 458 xLBT->setLong(aRet.Long); 459 xLBT->setULong(aRet.ULong); 460 xLBT->setHyper(aRet.Hyper); 461 xLBT->setUHyper(aRet.UHyper); 462 xLBT->setFloat(aRet.Float); 463 xLBT->setDouble(aRet.Double); 464 xLBT->setEnum(aRet.Enum); 465 xLBT->setString(aRet.String); 466 xLBT->setInterface(aRet.Interface); 467 xLBT->setAny(aRet.Any); 468 xLBT->setSequence(aRet.Sequence); 469 xLBT->setStruct(aRet2); 470 } 471 { 472 TestData aRet; 473 aRet.Hyper = xLBT->getHyper(); 474 aRet.UHyper = xLBT->getUHyper(); 475 aRet.Float = xLBT->getFloat(); 476 aRet.Double = xLBT->getDouble(); 477 aRet.Byte = xLBT->getByte(); 478 aRet.Char = xLBT->getChar(); 479 aRet.Bool = xLBT->getBool(); 480 aRet.Short = xLBT->getShort(); 481 aRet.UShort = xLBT->getUShort(); 482 aRet.Long = xLBT->getLong(); 483 aRet.ULong = xLBT->getULong(); 484 aRet.Enum = xLBT->getEnum(); 485 aRet.String = xLBT->getString(); 486 aRet.Interface = xLBT->getInterface(); 487 aRet.Any = xLBT->getAny(); 488 aRet.Sequence = xLBT->getSequence(); 489 TestData aRet2(xLBT->getStruct()); 490 bRet &= check( 491 equals(aData, aRet) && equals(aData, aRet2), 492 "struct comparison test"); 493 { 494 SmallStruct aIn(1, 2); 495 SmallStruct aOut(xLBT->echoSmallStruct(aIn)); 496 bRet &= check( 497 memcmp(&aIn, &aOut, sizeof(SmallStruct)) == 0, 498 "small struct test"); 499 } 500 { 501 MediumStruct aIn(1, 2, 3, 4); 502 MediumStruct aOut(xLBT->echoMediumStruct(aIn)); 503 bRet &= check( 504 memcmp(&aIn, &aOut, sizeof(MediumStruct)) == 0, 505 "medium struct test"); 506 } 507 { 508 BigStruct aIn(1, 2, 3, 4, 5, 6, 7, 8); 509 BigStruct aOut(xLBT->echoBigStruct(aIn)); 510 bRet &= check( 511 memcmp(&aIn, &aOut, sizeof(BigStruct)) == 0, 512 "big struct test"); 513 } 514 { 515 AllFloats aIn(1.1f, 2.2f, 3.3f, 4.4f); 516 AllFloats aOut(xLBT->echoAllFloats(aIn)); 517 bRet &= check( 518 memcmp(&aIn, &aOut, sizeof(AllFloats)) == 0, 519 "all floats struct test"); 520 } 521 { 522 sal_Int32 i2 = xLBT->testPPCAlignment(0, 0, 0, 0, 0xBEAF); 523 bRet &= check(i2 == 0xBEAF, "ppc-style alignment test"); 524 } 525 // Test extended attributes that raise exceptions: 526 try { 527 xLBT->getRaiseAttr1(); 528 bRet &= check(false, "getRaiseAttr1 did not throw"); 529 } catch (RuntimeException &) { 530 } catch (...) { 531 bRet &= check(false, "getRaiseAttr1 threw wrong type"); 532 } 533 try { 534 xLBT->setRaiseAttr1(0); 535 bRet &= check(false, "setRaiseAttr1 did not throw"); 536 } catch (IllegalArgumentException &) { 537 } catch (...) { 538 bRet &= check(false, "setRaiseAttr1 threw wrong type"); 539 } 540 try { 541 xLBT->getRaiseAttr2(); 542 bRet &= check(false, "getRaiseAttr2 did not throw"); 543 } catch (IllegalArgumentException &) { 544 } catch (...) { 545 bRet &= check(false, "getRaiseAttr2 threw wrong type"); 546 } 547 #if !defined(OS2) && !(defined(FREEBSD) && defined(INTEL)) 548 // see i120310 for OS2 details 549 // FreeBSD i386 coredumps on this test in cpp_vtable_call(): 550 // pTypeDescr appears to point to garbage, pMapFunctionIndexToMemberIndex 551 // points to unreadable memory, as does abase.pTypeName. Refcounts 552 // don't look reasonable, etc. 553 // Test instantiated polymorphic struct types: 554 { 555 bRet &= check( 556 (xLBT->transportPolyBoolean( 557 TestPolyStruct< sal_Bool >(true)). 558 member), 559 "transportPolyBoolean"); 560 TestPolyStruct< sal_Int64 > tps1(12345); 561 xLBT->transportPolyHyper(tps1); 562 bRet &= check(tps1.member == 12345, "transportPolyHyper"); 563 Sequence< Any > seq(2); 564 seq[0] <<= static_cast< sal_uInt32 >(33); 565 seq[1] <<= rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ABC")); 566 TestPolyStruct< Sequence< Any > > tps2(seq); 567 TestPolyStruct< Sequence< Any > > tps3; 568 xLBT->transportPolySequence(tps2, tps3); 569 bRet &= check( 570 tps3.member.getLength() == 2, 571 "transportPolySequence, length"); 572 sal_uInt32 v0 = sal_uInt32(); 573 tps3.member[0] >>= v0; 574 bRet &= check(v0 == 33, "transportPolySequence, element 0"); 575 rtl::OUString v1; 576 tps3.member[1] >>= v1; 577 bRet &= check( 578 v1.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("ABC")), 579 "transportPolySequence, element 1"); 580 bRet &= check( 581 xLBT->getNullPolyLong().member == 0, "getNullPolyLong"); 582 bRet &= check( 583 xLBT->getNullPolyString().member.getLength() == 0, 584 "getNullPolyString"); 585 bRet &= check( 586 xLBT->getNullPolyType().member == Type(), 587 "getNullPolyType"); 588 Any nullAny(xLBT->getNullPolyAny().member); 589 bRet &= check( 590 (((nullAny.getValueTypeName() == 591 rtl::OUString( 592 RTL_CONSTASCII_USTRINGPARAM( 593 "com.sun.star.uno.XInterface"))) && 594 !static_cast< Reference< XInterface > const * >( 595 nullAny.getValue())->is()) 596 || nullAny == Any()), 597 "getNullPolyAny"); 598 bRet &= check( 599 xLBT->getNullPolySequence().member.getLength() == 0, 600 "getNullPolySequence"); 601 bRet &= check( 602 xLBT->getNullPolyEnum().member == TestEnum_TEST, 603 "getNullPolyEnum"); 604 bRet &= check( 605 xLBT->getNullPolyBadEnum().member == TestBadEnum_M, 606 "getNullPolyBadEnum"); 607 bRet &= check( 608 xLBT->getNullPolyStruct().member.member == 0, 609 "getNullPolyStruct"); 610 bRet &= check( 611 !xLBT->getNullPolyInterface().member.is(), 612 "getNullPolyInterface"); 613 } 614 #endif // OS2 615 616 // Any test: 617 bRet &= check(performAnyTest(xLBT , aData), "any test"); 618 // Sequence of call test: 619 bRet &= check( 620 performSequenceOfCallTest(xLBT), "sequence of call test"); 621 // Recursive call test: 622 bRet &= check(performRecursiveCallTest(xLBT), "recursive test"); 623 bRet &= check( 624 equals(aData, aRet) && equals(aData, aRet2), 625 "recursive test results"); 626 // Multiple inheritance test: 627 bRet &= checkEmpty( 628 testtools::bridgetest::testMulti(xLBT->getMulti()), 629 "remote multi"); 630 bRet &= checkEmpty( 631 xLBT->testMulti(new testtools::bridgetest::Multi), 632 "local multi"); 633 } 634 } 635 { 636 Reference< XBridgeTest2 > xBT2(xLBT, UNO_QUERY); 637 if (!xBT2.is()) { 638 return bRet; 639 } 640 // Perform sequence tests (XBridgeTest2); create the sequence which is 641 // compared with the results: 642 sal_Bool _arBool[] = { true, false, true }; 643 sal_Unicode _arChar[] = { 0x0065, 0x0066, 0x0067 }; 644 sal_Int8 _arByte[] = { 1, 2, -1 }; 645 sal_Int16 _arShort[] = { -0x8000, 1, 0x7FFF }; 646 sal_uInt16 _arUShort[] = { 0 , 1, 0xFFFF }; 647 sal_Int32 _arLong[] = { -0x7FFFFFFF, 1, 0x7FFFFFFF }; 648 sal_uInt32 _arULong[] = { 0, 1, 0xFFFFFFFF }; 649 sal_Int64 _arHyper[] = { 650 SAL_CONST_INT64(-0x7FFFFFFFFFFFFFFF), 1, 651 SAL_CONST_INT64(+0x7FFFFFFFFFFFFFFF) }; 652 sal_uInt64 _arUHyper[] = { 0, 1, SAL_CONST_UINT64(0xFFFFFFFFFFFFFFFF) }; 653 float _arFloat[] = { 1.1f, 2.2f, 3.3f }; 654 double _arDouble[] = { 1.11, 2.22, 3.33 }; 655 OUString _arString[] = { 656 OUString(RTL_CONSTASCII_USTRINGPARAM("String 1")), 657 OUString(RTL_CONSTASCII_USTRINGPARAM("String 2")), 658 OUString(RTL_CONSTASCII_USTRINGPARAM("String 3")) }; 659 sal_Bool _aBool = true; 660 sal_Int32 _aInt = 0xBABEBABE; 661 float _aFloat = 3.14f; 662 Any _any1(&_aBool, getCppuBooleanType()); 663 Any _any2(&_aInt, getCppuType((sal_Int32 *) 0)); 664 Any _any3(&_aFloat, getCppuType((float *) 0)); 665 Any _arAny[] = { _any1, _any2, _any3 }; 666 Reference< XInterface > _arObj[3]; 667 _arObj[0] = new OWeakObject(); 668 _arObj[1] = new OWeakObject(); 669 _arObj[2] = new OWeakObject(); 670 TestEnum _arEnum[] = { TestEnum_ONE, TestEnum_TWO, TestEnum_CHECK }; 671 TestElement _arStruct[3]; 672 assign( 673 _arStruct[0], true, '@', 17, 0x1234, 0xFEDC, 0x12345678, 0xFEDCBA98, 674 SAL_CONST_INT64(0x123456789ABCDEF0), 675 SAL_CONST_UINT64(0xFEDCBA9876543210), 17.0815f, 3.1415926359, 676 TestEnum_LOLA, OUSTR(STRING_TEST_CONSTANT), _arObj[0], 677 Any(&_arObj[0], getCppuType((Reference< XInterface > const *) 0))); 678 assign( 679 _arStruct[1], true, 'A', 17, 0x1234, 0xFEDC, 0x12345678, 0xFEDCBA98, 680 SAL_CONST_INT64(0x123456789ABCDEF0), 681 SAL_CONST_UINT64(0xFEDCBA9876543210), 17.0815f, 3.1415926359, 682 TestEnum_TWO, OUSTR(STRING_TEST_CONSTANT), _arObj[1], 683 Any(&_arObj[1], getCppuType((Reference< XInterface > const *) 0))); 684 assign( 685 _arStruct[2], true, 'B', 17, 0x1234, 0xFEDC, 0x12345678, 0xFEDCBA98, 686 SAL_CONST_INT64(0x123456789ABCDEF0), 687 SAL_CONST_UINT64(0xFEDCBA9876543210), 17.0815f, 3.1415926359, 688 TestEnum_CHECK, OUSTR(STRING_TEST_CONSTANT), _arObj[2], 689 Any(&_arObj[2], getCppuType((Reference< XInterface > const *) 0))); 690 { 691 Sequence<sal_Bool> arBool(_arBool, 3); 692 Sequence<sal_Unicode> arChar( _arChar, 3); 693 Sequence<sal_Int8> arByte(_arByte, 3); 694 Sequence<sal_Int16> arShort(_arShort, 3); 695 Sequence<sal_uInt16> arUShort(_arUShort, 3); 696 Sequence<sal_Int32> arLong(_arLong, 3); 697 Sequence<sal_uInt32> arULong(_arULong, 3); 698 Sequence<sal_Int64> arHyper(_arHyper, 3); 699 Sequence<sal_uInt64> arUHyper(_arUHyper, 3); 700 Sequence<float> arFloat(_arFloat, 3); 701 Sequence<double> arDouble(_arDouble, 3); 702 Sequence<OUString> arString(_arString, 3); 703 Sequence<Any> arAny(_arAny, 3); 704 Sequence<Reference<XInterface> > arObject(_arObj, 3); 705 Sequence<TestEnum> arEnum(_arEnum, 3); 706 Sequence<TestElement> arStruct(_arStruct, 3); 707 Sequence<Sequence<sal_Int32> > _arSeqLong2[3]; 708 for (int j = 0; j != 3; ++j) { 709 Sequence< sal_Int32 > _arSeqLong[3]; 710 for (int i = 0; i != 3; ++i) { 711 _arSeqLong[i] = Sequence< sal_Int32 >(_arLong, 3); 712 } 713 _arSeqLong2[j] = Sequence< Sequence< sal_Int32 > >( 714 _arSeqLong, 3); 715 } 716 Sequence< Sequence< Sequence< sal_Int32> > > arLong3( 717 _arSeqLong2, 3); 718 Sequence< Sequence< sal_Int32 > > seqSeqRet( 719 xBT2->setDim2(arLong3[0])); 720 bRet &= check(seqSeqRet == arLong3[0], "sequence test"); 721 Sequence< Sequence< Sequence< sal_Int32 > > > seqSeqRet2( 722 xBT2->setDim3(arLong3)); 723 bRet &= check(seqSeqRet2 == arLong3, "sequence test"); 724 Sequence< Any > seqAnyRet(xBT2->setSequenceAny(arAny)); 725 bRet &= check(seqAnyRet == arAny, "sequence test"); 726 Sequence< sal_Bool > seqBoolRet(xBT2->setSequenceBool(arBool)); 727 bRet &= check(seqBoolRet == arBool, "sequence test"); 728 Sequence< sal_Int8 > seqByteRet(xBT2->setSequenceByte(arByte)); 729 bRet &= check(seqByteRet == arByte, "sequence test"); 730 Sequence< sal_Unicode > seqCharRet(xBT2->setSequenceChar(arChar)); 731 bRet &= check(seqCharRet == arChar, "sequence test"); 732 Sequence< sal_Int16 > seqShortRet(xBT2->setSequenceShort(arShort)); 733 bRet &= check(seqShortRet == arShort, "sequence test"); 734 Sequence< sal_Int32 > seqLongRet(xBT2->setSequenceLong(arLong)); 735 bRet &= check(seqLongRet == arLong, "sequence test"); 736 Sequence< sal_Int64 > seqHyperRet(xBT2->setSequenceHyper(arHyper)); 737 bRet &= check(seqHyperRet == arHyper, "sequence test"); 738 Sequence< float > seqFloatRet(xBT2->setSequenceFloat(arFloat)); 739 bRet &= check(seqFloatRet == arFloat, "sequence test"); 740 Sequence< double > seqDoubleRet(xBT2->setSequenceDouble(arDouble)); 741 bRet &= check(seqDoubleRet == arDouble, "sequence test"); 742 Sequence< TestEnum > seqEnumRet(xBT2->setSequenceEnum(arEnum)); 743 bRet &= check(seqEnumRet == arEnum, "sequence test"); 744 Sequence< sal_uInt16 > seqUShortRet( 745 xBT2->setSequenceUShort(arUShort)); 746 bRet &= check(seqUShortRet == arUShort, "sequence test"); 747 Sequence< sal_uInt32 > seqULongRet(xBT2->setSequenceULong(arULong)); 748 bRet &= check(seqULongRet == arULong, "sequence test"); 749 Sequence< sal_uInt64 > seqUHyperRet( 750 xBT2->setSequenceUHyper(arUHyper)); 751 bRet &= check(seqUHyperRet == arUHyper, "sequence test"); 752 Sequence< Reference< XInterface > > seqObjectRet( 753 xBT2->setSequenceXInterface(arObject)); 754 bRet &= check(seqObjectRet == arObject, "sequence test"); 755 Sequence< OUString > seqStringRet( 756 xBT2->setSequenceString(arString)); 757 bRet &= check(seqStringRet == arString, "sequence test"); 758 Sequence< TestElement > seqStructRet( 759 xBT2->setSequenceStruct(arStruct)); 760 bRet &= check(seqStructRet == arStruct, "sequence test"); 761 Sequence< sal_Bool > arBoolTemp(cloneSequence(arBool)); 762 Sequence< sal_Unicode > arCharTemp(cloneSequence(arChar)); 763 Sequence< sal_Int8 > arByteTemp(cloneSequence(arByte)); 764 Sequence< sal_Int16 > arShortTemp(cloneSequence(arShort)); 765 Sequence< sal_uInt16 > arUShortTemp(cloneSequence(arUShort)); 766 Sequence< sal_Int32 > arLongTemp(cloneSequence(arLong)); 767 Sequence< sal_uInt32 > arULongTemp(cloneSequence(arULong)); 768 Sequence< sal_Int64 > arHyperTemp(cloneSequence(arHyper)); 769 Sequence< sal_uInt64 > arUHyperTemp(cloneSequence(arUHyper)); 770 Sequence< float > arFloatTemp(cloneSequence(arFloat)); 771 Sequence< double > arDoubleTemp(cloneSequence(arDouble)); 772 Sequence< TestEnum > arEnumTemp(cloneSequence(arEnum)); 773 Sequence< OUString > arStringTemp(cloneSequence(arString)); 774 Sequence< Reference< XInterface > > arObjectTemp( 775 cloneSequence(arObject)); 776 Sequence< Any > arAnyTemp(cloneSequence(arAny)); 777 Sequence< Sequence< sal_Int32 > > arLong2Temp(arLong3[0]); 778 Sequence< Sequence< Sequence< sal_Int32 > > > arLong3Temp(arLong3); 779 xBT2->setSequencesInOut( 780 arBoolTemp, arCharTemp, arByteTemp, arShortTemp, arUShortTemp, 781 arLongTemp,arULongTemp, arHyperTemp, arUHyperTemp, arFloatTemp, 782 arDoubleTemp, arEnumTemp, arStringTemp, arObjectTemp, arAnyTemp, 783 arLong2Temp, arLong3Temp); 784 bRet &= check( 785 (arBoolTemp == arBool && arCharTemp == arChar && 786 arByteTemp == arByte && arShortTemp == arShort && 787 arUShortTemp == arUShort && arLongTemp == arLong && 788 arULongTemp == arULong && arHyperTemp == arHyper && 789 arUHyperTemp == arUHyper && arFloatTemp == arFloat && 790 arDoubleTemp == arDouble && arEnumTemp == arEnum && 791 arStringTemp == arString && arObjectTemp == arObject && 792 arAnyTemp == arAny && arLong2Temp == arLong3[0] && 793 arLong3Temp == arLong3), 794 "sequence test"); 795 Sequence< sal_Bool > arBoolOut; 796 Sequence< sal_Unicode > arCharOut; 797 Sequence< sal_Int8 > arByteOut; 798 Sequence< sal_Int16 > arShortOut; 799 Sequence< sal_uInt16 > arUShortOut; 800 Sequence< sal_Int32 > arLongOut; 801 Sequence< sal_uInt32 > arULongOut; 802 Sequence< sal_Int64 > arHyperOut; 803 Sequence< sal_uInt64 > arUHyperOut; 804 Sequence< float > arFloatOut; 805 Sequence< double > arDoubleOut; 806 Sequence< TestEnum > arEnumOut; 807 Sequence< OUString > arStringOut; 808 Sequence< Reference< XInterface > > arObjectOut; 809 Sequence< Any > arAnyOut; 810 Sequence< Sequence< sal_Int32 > > arLong2Out; 811 Sequence< Sequence< Sequence< sal_Int32 > > > arLong3Out; 812 xBT2->setSequencesOut( 813 arBoolOut, arCharOut, arByteOut, arShortOut, arUShortOut, 814 arLongOut,arULongOut, arHyperOut, arUHyperOut, arFloatOut, 815 arDoubleOut, arEnumOut, arStringOut, arObjectOut, arAnyOut, 816 arLong2Out, arLong3Out); 817 bRet &= check( 818 (arBoolOut == arBool && arCharOut == arChar && 819 arByteOut == arByte && arShortOut == arShort && 820 arUShortOut == arUShort && arLongOut == arLong && 821 arULongOut == arULong && arHyperOut == arHyper && 822 arUHyperOut == arUHyper && arFloatOut == arFloat && 823 arDoubleOut == arDouble && arEnumOut == arEnum && 824 arStringOut == arString && arObjectOut == arObject && 825 arAnyOut == arAny && arLong2Out == arLong3[0] && 826 arLong3Out == arLong3), 827 "sequence test"); 828 } 829 { 830 // Test with empty sequences: 831 Sequence< Sequence< sal_Int32 > > arLong2; 832 Sequence< Sequence< sal_Int32 > > seqSeqRet(xBT2->setDim2(arLong2)); 833 bRet &= check(seqSeqRet == arLong2, "sequence test"); 834 Sequence< Sequence< Sequence< sal_Int32 > > > arLong3; 835 Sequence< Sequence< Sequence< sal_Int32 > > > seqSeqRet2( 836 xBT2->setDim3(arLong3)); 837 bRet &= check(seqSeqRet2 == arLong3, "sequence test"); 838 Sequence< Any > arAny; 839 Sequence< Any > seqAnyRet(xBT2->setSequenceAny(arAny)); 840 bRet &= check(seqAnyRet == arAny, "sequence test"); 841 Sequence< sal_Bool > arBool; 842 Sequence< sal_Bool > seqBoolRet(xBT2->setSequenceBool(arBool)); 843 bRet &= check(seqBoolRet == arBool, "sequence test"); 844 Sequence< sal_Int8 > arByte; 845 Sequence< sal_Int8 > seqByteRet(xBT2->setSequenceByte(arByte)); 846 bRet &= check(seqByteRet == arByte, "sequence test"); 847 Sequence< sal_Unicode > arChar; 848 Sequence< sal_Unicode > seqCharRet(xBT2->setSequenceChar(arChar)); 849 bRet &= check(seqCharRet == arChar, "sequence test"); 850 Sequence< sal_Int16 > arShort; 851 Sequence< sal_Int16 > seqShortRet(xBT2->setSequenceShort(arShort)); 852 bRet &= check(seqShortRet == arShort, "sequence test"); 853 Sequence< sal_Int32 > arLong; 854 Sequence< sal_Int32 > seqLongRet(xBT2->setSequenceLong(arLong)); 855 bRet &= check(seqLongRet == arLong, "sequence test"); 856 Sequence< sal_Int64 > arHyper; 857 Sequence< sal_Int64 > seqHyperRet(xBT2->setSequenceHyper(arHyper)); 858 bRet &= check(seqHyperRet == arHyper, "sequence test"); 859 Sequence< float > arFloat; 860 Sequence< float > seqFloatRet(xBT2->setSequenceFloat(arFloat)); 861 bRet &= check(seqFloatRet == arFloat, "sequence test"); 862 Sequence< double > arDouble; 863 Sequence< double > seqDoubleRet(xBT2->setSequenceDouble(arDouble)); 864 bRet &= check(seqDoubleRet == arDouble, "sequence test"); 865 Sequence< TestEnum > arEnum; 866 Sequence< TestEnum > seqEnumRet(xBT2->setSequenceEnum(arEnum)); 867 bRet &= check(seqEnumRet == arEnum, "sequence test"); 868 Sequence< sal_uInt16 > arUShort; 869 Sequence< sal_uInt16 > seqUShortRet( 870 xBT2->setSequenceUShort(arUShort)); 871 bRet &= check(seqUShortRet == arUShort, "sequence test"); 872 Sequence< sal_uInt32 > arULong; 873 Sequence< sal_uInt32 > seqULongRet(xBT2->setSequenceULong(arULong)); 874 bRet &= check(seqULongRet == arULong, "sequence test"); 875 Sequence< sal_uInt64 > arUHyper; 876 Sequence< sal_uInt64 > seqUHyperRet( 877 xBT2->setSequenceUHyper(arUHyper)); 878 bRet &= check(seqUHyperRet == arUHyper, "sequence test"); 879 Sequence< Reference< XInterface > > arObject; 880 Sequence< Reference< XInterface > > seqObjectRet( 881 xBT2->setSequenceXInterface(arObject)); 882 bRet &= check(seqObjectRet == arObject, "sequence test"); 883 Sequence< OUString > arString; 884 Sequence< OUString > seqStringRet( 885 xBT2->setSequenceString(arString)); 886 bRet &= check(seqStringRet == arString, "sequence test"); 887 Sequence< TestElement > arStruct; 888 Sequence< TestElement > seqStructRet( 889 xBT2->setSequenceStruct(arStruct)); 890 bRet &= check(seqStructRet == arStruct, "sequence test"); 891 } 892 // Issue #i60341# shows that the most interesting case is were Java 893 // calls the constructors; however, since this client is currently not 894 // available in Java, while the server is, the logic is reversed here: 895 try { 896 xBT2->testConstructorsService(xContext); 897 } catch (BadConstructorArguments &) { 898 bRet = false; 899 } 900 if (!noCurrentContext) { 901 if (!(new testtools::bridgetest::CurrentContextChecker)->perform( 902 xBT2->getCurrentContextChecker(), 0, 1)) 903 { 904 bRet = false; 905 } 906 if (!(new testtools::bridgetest::CurrentContextChecker)->perform( 907 xBT2->getCurrentContextChecker(), 0, 2)) 908 { 909 bRet = false; 910 } 911 if (!(new testtools::bridgetest::CurrentContextChecker)->perform( 912 xBT2->getCurrentContextChecker(), 1, 2)) 913 { 914 bRet = false; 915 } 916 if (!(new testtools::bridgetest::CurrentContextChecker)->perform( 917 xBT2->getCurrentContextChecker(), 1, 3)) 918 { 919 bRet = false; 920 } 921 } 922 } 923 return bRet; 924 } 925 926 static sal_Bool raiseOnewayException( const Reference < XBridgeTest > & xLBT ) 927 { 928 sal_Bool bReturn = sal_True; 929 OUString sCompare = OUSTR(STRING_TEST_CONSTANT); 930 Reference<XInterface> const x(xLBT->getInterface()); 931 try 932 { 933 // Note : the exception may fly or not (e.g. remote scenario). 934 // When it flies, it must contain the correct elements. 935 xLBT->raiseRuntimeExceptionOneway( sCompare, x ); 936 } 937 catch( RuntimeException & e ) 938 { 939 bReturn = ( 940 #if OSL_DEBUG_LEVEL == 0 941 // java stack traces trash Message 942 e.Message == sCompare && 943 #endif 944 xLBT->getInterface() == e.Context && 945 x == e.Context ); 946 } 947 return bReturn; 948 } 949 950 //================================================================================================== 951 static sal_Bool raiseException( const Reference< XBridgeTest > & xLBT ) 952 { 953 sal_Int32 nCount = 0; 954 try 955 { 956 try 957 { 958 try 959 { 960 TestData aRet, aRet2; 961 xLBT->raiseException( 962 5, OUSTR(STRING_TEST_CONSTANT), 963 xLBT->getInterface() ); 964 } 965 catch (IllegalArgumentException aExc) 966 { 967 if (aExc.ArgumentPosition == 5 && 968 #if OSL_DEBUG_LEVEL == 0 969 // java stack traces trash Message 970 aExc.Message.compareToAscii( STRING_TEST_CONSTANT ) == 0 && 971 #endif 972 aExc.Context == xLBT->getInterface()) 973 { 974 #ifdef COMPCHECK 975 //When we check if a new compiler still works then we must not call 976 //getRuntimeException because it uses cppu::getCaughtException which 977 //does only work if all libs are build with the same runtime. 978 return true; 979 #else 980 ++nCount; 981 #endif 982 } 983 else 984 { 985 check( sal_False, "### unexpected exception content!" ); 986 } 987 988 /** it is certain, that the RuntimeException testing will fail, if no */ 989 xLBT->getRuntimeException(); 990 } 991 } 992 catch (const RuntimeException & rExc) 993 { 994 if (rExc.Context == xLBT->getInterface() 995 #if OSL_DEBUG_LEVEL == 0 996 // java stack traces trash Message 997 && rExc.Message.compareToAscii( STRING_TEST_CONSTANT ) == 0 998 #endif 999 ) 1000 { 1001 ++nCount; 1002 } 1003 else 1004 { 1005 check( sal_False, "### unexpected exception content!" ); 1006 } 1007 1008 /** it is certain, that the RuntimeException testing will fail, if no */ 1009 xLBT->setRuntimeException( 0xcafebabe ); 1010 } 1011 } 1012 catch (Exception & rExc) 1013 { 1014 if (rExc.Context == xLBT->getInterface() 1015 #if OSL_DEBUG_LEVEL == 0 1016 // java stack traces trash Message 1017 && rExc.Message.compareToAscii( STRING_TEST_CONSTANT ) == 0 1018 #endif 1019 ) 1020 { 1021 ++nCount; 1022 } 1023 else 1024 { 1025 check( sal_False, "### unexpected exception content!" ); 1026 } 1027 return (nCount == 3); 1028 } 1029 return sal_False; 1030 } 1031 1032 /* Returns an acquired sequence 1033 */ 1034 uno_Sequence* cloneSequence(const uno_Sequence* val, const Type& type) 1035 { 1036 TypeDescription td(type); 1037 td.makeComplete(); 1038 typelib_TypeDescription* pTdRaw = td.get(); 1039 typelib_IndirectTypeDescription* pIndirectTd = 1040 (typelib_IndirectTypeDescription*) pTdRaw; 1041 1042 typelib_TypeDescription* pTdElem = pIndirectTd->pType->pType; 1043 sal_Int8* buf = new sal_Int8[pTdElem->nSize * val->nElements]; 1044 sal_Int8* pBufCur = buf; 1045 1046 uno_Sequence* retSeq = NULL; 1047 switch (pTdElem->eTypeClass) 1048 { 1049 case TypeClass_SEQUENCE: 1050 { 1051 Type _tElem(pTdElem->pWeakRef); 1052 for (int i = 0; i < val->nElements; i++) 1053 { 1054 uno_Sequence* seq = cloneSequence( 1055 *(uno_Sequence**) (&val->elements + i * pTdElem->nSize), 1056 _tElem); 1057 *((uno_Sequence**) pBufCur) = seq; 1058 pBufCur += pTdElem->nSize; 1059 } 1060 break; 1061 } 1062 default: 1063 uno_type_sequence_construct( 1064 &retSeq, type.getTypeLibType(), (void*) val->elements, 1065 val->nElements, reinterpret_cast< uno_AcquireFunc >(cpp_acquire)); 1066 break; 1067 } 1068 delete[] buf; 1069 return retSeq; 1070 } 1071 1072 template< class T> 1073 Sequence<T> cloneSequence(const Sequence<T>& val) 1074 { 1075 Sequence<T> seq( cloneSequence(val.get(), getCppuType(&val)), SAL_NO_ACQUIRE); 1076 return seq; 1077 } 1078 1079 template< class T > 1080 inline bool makeSurrogate( 1081 Reference< T > & rOut, Reference< T > const & rOriginal ) 1082 { 1083 rOut.clear(); 1084 if (! rOriginal.is()) 1085 return false; 1086 1087 Environment aCppEnv_official; 1088 Environment aUnoEnv_ano; 1089 Environment aCppEnv_ano; 1090 1091 OUString aCppEnvTypeName( 1092 RTL_CONSTASCII_USTRINGPARAM(CPPU_CURRENT_LANGUAGE_BINDING_NAME) ); 1093 OUString aUnoEnvTypeName( 1094 RTL_CONSTASCII_USTRINGPARAM(UNO_LB_UNO) ); 1095 // official: 1096 uno_getEnvironment( 1097 reinterpret_cast< uno_Environment ** >( &aCppEnv_official ), 1098 aCppEnvTypeName.pData, 0 ); 1099 // anonymous: 1100 uno_createEnvironment( 1101 reinterpret_cast< uno_Environment ** >( &aCppEnv_ano ), 1102 aCppEnvTypeName.pData, 0 ); 1103 uno_createEnvironment( 1104 reinterpret_cast< uno_Environment ** >( &aUnoEnv_ano ), 1105 aUnoEnvTypeName.pData, 0 ); 1106 1107 UnoInterfaceReference unoI; 1108 Mapping cpp2uno( aCppEnv_official.get(), aUnoEnv_ano.get() ); 1109 Mapping uno2cpp( aUnoEnv_ano.get(), aCppEnv_ano.get() ); 1110 if (!cpp2uno.is() || !uno2cpp.is()) 1111 { 1112 throw RuntimeException( 1113 OUSTR("cannot get C++-UNO mappings!"), 1114 Reference< XInterface >() ); 1115 } 1116 cpp2uno.mapInterface( 1117 reinterpret_cast< void ** >( &unoI.m_pUnoI ), 1118 rOriginal.get(), ::getCppuType( &rOriginal ) ); 1119 if (! unoI.is()) 1120 { 1121 throw RuntimeException( 1122 OUSTR("mapping C++ to binary UNO failed!"), 1123 Reference< XInterface >() ); 1124 } 1125 uno2cpp.mapInterface( 1126 reinterpret_cast< void ** >( &rOut ), 1127 unoI.get(), ::getCppuType( &rOriginal ) ); 1128 if (! rOut.is()) 1129 { 1130 throw RuntimeException( 1131 OUSTR("mapping binary UNO to C++ failed!"), 1132 Reference< XInterface >() ); 1133 } 1134 1135 return rOut.is(); 1136 } 1137 1138 //================================================================================================== 1139 sal_Int32 TestBridgeImpl::run( const Sequence< OUString > & rArgs ) 1140 throw (RuntimeException) 1141 { 1142 bool bRet = false; 1143 try 1144 { 1145 if (! rArgs.getLength()) 1146 { 1147 throw RuntimeException( OUString( RTL_CONSTASCII_USTRINGPARAM( 1148 "no test object specified!\n" 1149 "usage : ServiceName of test object | -u unourl of test object\n" ) ), 1150 Reference< XInterface >() ); 1151 } 1152 1153 Reference< XInterface > xOriginal; 1154 bool remote; 1155 sal_Int32 i; 1156 if( rArgs.getLength() > 1 && 0 == rArgs[0].compareToAscii( "-u" ) ) 1157 { 1158 remote = true; 1159 i = 2; 1160 } 1161 else 1162 { 1163 remote = false; 1164 i = 1; 1165 } 1166 bool noCurrentContext = false; 1167 if (i < rArgs.getLength() 1168 && rArgs[i].equalsAsciiL( 1169 RTL_CONSTASCII_STRINGPARAM("noCurrentContext"))) 1170 { 1171 noCurrentContext = true; 1172 ++i; 1173 } 1174 bool stress = false; 1175 if (i < rArgs.getLength() 1176 && rArgs[i].equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("stress"))) 1177 { 1178 stress = true; 1179 ++i; 1180 } 1181 1182 for (;;) { 1183 Reference< XInterface > o; 1184 if (remote) { 1185 o = UnoUrlResolver::create(m_xContext)->resolve(rArgs[1]); 1186 } else { 1187 o = m_xContext->getServiceManager()->createInstanceWithContext( 1188 rArgs[0], m_xContext); 1189 } 1190 if (!stress) { 1191 xOriginal = o; 1192 break; 1193 } 1194 } 1195 1196 if (! xOriginal.is()) 1197 { 1198 throw RuntimeException( 1199 OUString( RTL_CONSTASCII_USTRINGPARAM( 1200 "cannot get test object!") ), 1201 Reference< XInterface >() ); 1202 } 1203 Reference< XBridgeTest > xTest( xOriginal, UNO_QUERY ); 1204 if (! xTest.is()) 1205 { 1206 throw RuntimeException( 1207 OUString( RTL_CONSTASCII_USTRINGPARAM("test object does not implement XBridgeTest!") ), 1208 Reference< XInterface >() ); 1209 } 1210 1211 Reference<XBridgeTest > xLBT; 1212 bRet = check( makeSurrogate( xLBT, xTest ), "makeSurrogate" ); 1213 bRet = check( 1214 performTest( m_xContext, xLBT, noCurrentContext ), "standard test" ) 1215 && bRet; 1216 bRet = check( raiseException( xLBT ) , "exception test" )&& bRet; 1217 bRet = check( raiseOnewayException( xLBT ), 1218 "oneway exception test" ) && bRet; 1219 if (! bRet) 1220 { 1221 throw RuntimeException( 1222 OUString( RTL_CONSTASCII_USTRINGPARAM("error: test failed!") ), 1223 Reference< XInterface >() ); 1224 } 1225 } 1226 catch (Exception & exc) 1227 { 1228 OString cstr( OUStringToOString( exc.Message, RTL_TEXTENCODING_ASCII_US ) ); 1229 fprintf( stderr, "exception occured: %s\n", cstr.getStr() ); 1230 throw; 1231 } 1232 1233 if( bRet ) 1234 { 1235 printf( "\n\n ### test succeeded!\n" ); 1236 } 1237 else 1238 { 1239 printf( "\n> ### test failed!\n" ); 1240 } 1241 1242 return 0; 1243 } 1244 1245 // XServiceInfo 1246 //__________________________________________________________________________________________________ 1247 OUString TestBridgeImpl::getImplementationName() 1248 throw (RuntimeException) 1249 { 1250 return OUString( RTL_CONSTASCII_USTRINGPARAM(IMPLNAME) ); 1251 } 1252 //__________________________________________________________________________________________________ 1253 sal_Bool TestBridgeImpl::supportsService( const OUString & rServiceName ) 1254 throw (RuntimeException) 1255 { 1256 const Sequence< OUString > & rSNL = getSupportedServiceNames(); 1257 const OUString * pArray = rSNL.getConstArray(); 1258 for ( sal_Int32 nPos = rSNL.getLength(); nPos--; ) 1259 { 1260 if (pArray[nPos] == rServiceName) 1261 return sal_True; 1262 } 1263 return sal_False; 1264 } 1265 //__________________________________________________________________________________________________ 1266 Sequence< OUString > TestBridgeImpl::getSupportedServiceNames() 1267 throw (RuntimeException) 1268 { 1269 return bridge_test::getSupportedServiceNames(); 1270 } 1271 1272 // ... 1273 1274 //================================================================================================== 1275 static Reference< XInterface > SAL_CALL TestBridgeImpl_create( 1276 const Reference< XComponentContext > & xContext ) 1277 { 1278 return Reference< XInterface >( 1279 static_cast< OWeakObject * >( new TestBridgeImpl( xContext ) ) ); 1280 } 1281 1282 } 1283 1284 extern "C" 1285 { 1286 //================================================================================================== 1287 void SAL_CALL component_getImplementationEnvironment( 1288 const sal_Char ** ppEnvTypeName, uno_Environment ** ) 1289 { 1290 *ppEnvTypeName = CPPU_CURRENT_LANGUAGE_BINDING_NAME; 1291 } 1292 //================================================================================================== 1293 void * SAL_CALL component_getFactory( 1294 const sal_Char * pImplName, void * pServiceManager, void * ) 1295 { 1296 void * pRet = 0; 1297 1298 if (pServiceManager && rtl_str_compare( pImplName, IMPLNAME ) == 0) 1299 { 1300 Reference< XInterface > xFactory( 1301 createSingleComponentFactory( 1302 bridge_test::TestBridgeImpl_create, 1303 OUString( RTL_CONSTASCII_USTRINGPARAM(IMPLNAME) ), 1304 bridge_test::getSupportedServiceNames() ) ); 1305 1306 if (xFactory.is()) 1307 { 1308 xFactory->acquire(); 1309 pRet = xFactory.get(); 1310 } 1311 } 1312 1313 return pRet; 1314 } 1315 } 1316