testtools/source/bridgetest/bridgetest.cxx

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