LCOV - code coverage report
Current view: top level - libreoffice/testtools/source/bridgetest - bridgetest.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 605 673 89.9 %
Date: 2012-12-27 Functions: 57 60 95.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10