From 2edaed16dd7aa3a46a5fb0afe5560fb1b70f110a Mon Sep 17 00:00:00 2001 From: sb Date: Fri, 10 Dec 2010 13:55:39 +0100 Subject: sb135: #i116045# removed performQueryForUnknownType; cleaned up --- testtools/source/bridgetest/bridgetest.cxx | 1064 ++++++++++---------- testtools/source/bridgetest/cppobj.cxx | 2 +- .../source/bridgetest/currentcontextchecker.cxx | 12 +- 3 files changed, 521 insertions(+), 557 deletions(-) (limited to 'testtools') diff --git a/testtools/source/bridgetest/bridgetest.cxx b/testtools/source/bridgetest/bridgetest.cxx index 70cec6b74abf..8b25bc3b4e9a 100644 --- a/testtools/source/bridgetest/bridgetest.cxx +++ b/testtools/source/bridgetest/bridgetest.cxx @@ -346,37 +346,6 @@ static sal_Bool performRecursiveCallTest( const Reference < XBridgeTest > & xLBT return sal_True; } -static sal_Bool performQueryForUnknownType( const Reference< XBridgeTest > & xLBT ) -{ - sal_Bool bRet = sal_True; - // use this when you want to test querying for unknown types - // currently (not supported by the java remote bridge ) - { - // test queryInterface for an unknown type - typelib_TypeDescriptionReference *pTypeRef = 0; - OUString aName( RTL_CONSTASCII_USTRINGPARAM( "foo.MyInterface" ) ); - typelib_typedescriptionreference_new( - &pTypeRef, typelib_TypeClass_INTERFACE, aName.pData); - try - { - Any a = xLBT->queryInterface( Type( pTypeRef ) ); - bRet = check( a == Any( ), "got an foo.MyInterface, but didn't expect to get one" ); - } - catch( com::sun::star::uno::RuntimeException & ) - { - fprintf( - stderr, - "tried to query for an interface reference of an unknown type " - "but got a runtime exception. This should work for native bridges " - "but isn't implemented for Java remote bridge\n" - "Note: All subsequent tests may fail now as the remote bridge is broken\n" - "QueryForUnknownType" ); - } - typelib_typedescriptionreference_release( pTypeRef ); - } - return bRet; -} - class MyClass : public osl::DebugBase, public OWeakObject { public: @@ -411,549 +380,545 @@ static sal_Bool performTest( const Reference & xLBT, bool noCurrentContext ) { - check( xLBT.is(), "### no test interface!" ); + check(xLBT.is(), "### no test interface!"); bool bRet = true; - if (xLBT.is()) - { - // this data is never ever granted access to by calls other than equals(), assign()! + if (xLBT.is()) { + // this data is never ever granted access to by calls other than + // equals(), assign()! TestData aData; // test against this data - - Reference xI( new MyClass ); - - assign( (TestElement &)aData, - sal_True, '@', 17, 0x1234, 0xfedc, 0x12345678, 0xfedcba98, - SAL_CONST_INT64(0x123456789abcdef0), - SAL_CONST_UINT64(0xfedcba9876543210), - (float)17.0815, 3.1415926359, TestEnum_LOLA, - OUSTR(STRING_TEST_CONSTANT), xI, - Any( &xI, ::getCppuType( (const Reference *)0 ) ) ); - - bRet = check( aData.Any == xI, "### unexpected any!" ) && bRet; - bRet = check( !(aData.Any != xI), "### unexpected any!" ) && bRet; - - aData.Sequence.realloc( 2 ); - aData.Sequence[ 0 ] = *(const TestElement *)&aData; - // aData.Sequence[ 1 ] is empty - - // aData complete - //================================================================================ - - // this is a manually copy of aData for first setting... + Reference< XInterface > xI(new MyClass); + assign( + (TestElement &) aData, true, '@', 17, 0x1234, 0xFEDC, 0x12345678, + 0xFEDCBA98, SAL_CONST_INT64(0x123456789ABCDEF0), + SAL_CONST_UINT64(0xFEDCBA9876543210), 17.0815f, 3.1415926359, + TestEnum_LOLA, OUSTR(STRING_TEST_CONSTANT), xI, + Any(&xI, getCppuType((Reference< XInterface > const *) 0))); + bRet &= check(aData.Any == xI, "### unexpected any!"); + bRet &= check(!(aData.Any != xI), "### unexpected any!"); + aData.Sequence.realloc(2); + aData.Sequence[0] = *(TestElement const *) &aData; + // aData.Sequence[1] is empty + // aSetData is a manually copy of aData for first setting: TestData aSetData; - - assign( (TestElement &)aSetData, - aData.Bool, aData.Char, aData.Byte, aData.Short, aData.UShort, - aData.Long, aData.ULong, aData.Hyper, aData.UHyper, aData.Float, aData.Double, - aData.Enum, aData.String, xI, - Any( &xI, ::getCppuType( (const Reference *)0 ) ) ); - - aSetData.Sequence.realloc( 2 ); - aSetData.Sequence[ 0 ] = *(const TestElement *)&aSetData; - // aSetData.Sequence[ 1 ] is empty - + assign( + (TestElement &) aSetData, aData.Bool, aData.Char, aData.Byte, + aData.Short, aData.UShort, aData.Long, aData.ULong, aData.Hyper, + aData.UHyper, aData.Float, aData.Double, aData.Enum, aData.String, + xI, Any(&xI, getCppuType((Reference< XInterface > const *) 0))); + aSetData.Sequence.realloc(2); + aSetData.Sequence[0] = *(TestElement const *) &aSetData; + // aSetData.Sequence[1] is empty xLBT->setValues( - aSetData.Bool, aSetData.Char, aSetData.Byte, aSetData.Short, aSetData.UShort, - aSetData.Long, aSetData.ULong, aSetData.Hyper, aSetData.UHyper, aSetData.Float, aSetData.Double, - aSetData.Enum, aSetData.String, aSetData.Interface, aSetData.Any, aSetData.Sequence, aSetData ); - + aSetData.Bool, aSetData.Char, aSetData.Byte, aSetData.Short, + aSetData.UShort, aSetData.Long, aSetData.ULong, aSetData.Hyper, + aSetData.UHyper, aSetData.Float, aSetData.Double, aSetData.Enum, + aSetData.String, aSetData.Interface, aSetData.Any, + aSetData.Sequence, aSetData); { - TestData aRet, aRet2; - xLBT->getValues( - aRet.Bool, aRet.Char, aRet.Byte, aRet.Short, aRet.UShort, - aRet.Long, aRet.ULong, aRet.Hyper, aRet.UHyper, aRet.Float, aRet.Double, - aRet.Enum, aRet.String, aRet.Interface, aRet.Any, aRet.Sequence, aRet2 ); - - bRet = check( equals( aData, aRet ) && equals( aData, aRet2 ) , "getValues test") && bRet; - - // set last retrieved values - TestData aSV2ret = xLBT->setValues2( - aRet.Bool, aRet.Char, aRet.Byte, aRet.Short, aRet.UShort, - aRet.Long, aRet.ULong, aRet.Hyper, aRet.UHyper, aRet.Float, aRet.Double, - aRet.Enum, aRet.String, aRet.Interface, aRet.Any, aRet.Sequence, aRet2 ); - // check inout sequence order - // => inout sequence parameter was switched by test objects - TestElement temp = aRet.Sequence[ 0 ]; - aRet.Sequence[ 0 ] = aRet.Sequence[ 1 ]; - aRet.Sequence[ 1 ] = temp; - - bRet = check( - equals( aData, aSV2ret ) && equals( aData, aRet2 ), - "getValues2 test") && bRet; + TestData aRet; + TestData aRet2; + xLBT->getValues( + aRet.Bool, aRet.Char, aRet.Byte, aRet.Short, aRet.UShort, + aRet.Long, aRet.ULong, aRet.Hyper, aRet.UHyper, aRet.Float, + aRet.Double, aRet.Enum, aRet.String, aRet.Interface, aRet.Any, + aRet.Sequence, aRet2); + bRet &= check( + equals(aData, aRet) && equals(aData, aRet2), "getValues test"); + // Set last retrieved values: + TestData aSV2ret( + xLBT->setValues2( + aRet.Bool, aRet.Char, aRet.Byte, aRet.Short, aRet.UShort, + aRet.Long, aRet.ULong, aRet.Hyper, aRet.UHyper, aRet.Float, + aRet.Double, aRet.Enum, aRet.String, aRet.Interface, + aRet.Any, aRet.Sequence, aRet2)); + // Check inout sequence order (=> inout sequence parameter was + // switched by test objects): + TestElement temp(aRet.Sequence[0]); + aRet.Sequence[0] = aRet.Sequence[1]; + aRet.Sequence[1] = temp; + bRet &= check( + equals(aData, aSV2ret) && equals(aData, aRet2), + "getValues2 test"); } { - TestData aRet, aRet2; - TestData aGVret = xLBT->getValues( - aRet.Bool, aRet.Char, aRet.Byte, aRet.Short, aRet.UShort, - aRet.Long, aRet.ULong, aRet.Hyper, aRet.UHyper, aRet.Float, aRet.Double, - aRet.Enum, aRet.String, aRet.Interface, aRet.Any, aRet.Sequence, aRet2 ); - - bRet = check( equals( aData, aRet ) && equals( aData, aRet2 ) && equals( aData, aGVret ), "getValues test" ) && bRet; - - // set last retrieved values - xLBT->setBool( aRet.Bool ); - xLBT->setChar( aRet.Char ); - xLBT->setByte( aRet.Byte ); - xLBT->setShort( aRet.Short ); - xLBT->setUShort( aRet.UShort ); - xLBT->setLong( aRet.Long ); - xLBT->setULong( aRet.ULong ); - xLBT->setHyper( aRet.Hyper ); - xLBT->setUHyper( aRet.UHyper ); - xLBT->setFloat( aRet.Float ); - xLBT->setDouble( aRet.Double ); - xLBT->setEnum( aRet.Enum ); - xLBT->setString( aRet.String ); - xLBT->setInterface( aRet.Interface ); - xLBT->setAny( aRet.Any ); - xLBT->setSequence( aRet.Sequence ); - xLBT->setStruct( aRet2 ); + TestData aRet; + TestData aRet2; + TestData aGVret( + xLBT->getValues( + aRet.Bool, aRet.Char, aRet.Byte, aRet.Short, aRet.UShort, + aRet.Long, aRet.ULong, aRet.Hyper, aRet.UHyper, aRet.Float, + aRet.Double, aRet.Enum, aRet.String, aRet.Interface, + aRet.Any, aRet.Sequence, aRet2)); + bRet &= check( + (equals(aData, aRet) && equals(aData, aRet2) && + equals(aData, aGVret)), + "getValues test"); + // Set last retrieved values: + xLBT->setBool(aRet.Bool); + xLBT->setChar(aRet.Char); + xLBT->setByte(aRet.Byte); + xLBT->setShort(aRet.Short); + xLBT->setUShort(aRet.UShort); + xLBT->setLong(aRet.Long); + xLBT->setULong(aRet.ULong); + xLBT->setHyper(aRet.Hyper); + xLBT->setUHyper(aRet.UHyper); + xLBT->setFloat(aRet.Float); + xLBT->setDouble(aRet.Double); + xLBT->setEnum(aRet.Enum); + xLBT->setString(aRet.String); + xLBT->setInterface(aRet.Interface); + xLBT->setAny(aRet.Any); + xLBT->setSequence(aRet.Sequence); + xLBT->setStruct(aRet2); } { - TestData aRet, aRet2; - aRet.Hyper = xLBT->getHyper(); - aRet.UHyper = xLBT->getUHyper(); - aRet.Float = xLBT->getFloat(); - aRet.Double = xLBT->getDouble(); - aRet.Byte = xLBT->getByte(); - aRet.Char = xLBT->getChar(); - aRet.Bool = xLBT->getBool(); - aRet.Short = xLBT->getShort(); - aRet.UShort = xLBT->getUShort(); - aRet.Long = xLBT->getLong(); - aRet.ULong = xLBT->getULong(); - aRet.Enum = xLBT->getEnum(); - aRet.String = xLBT->getString(); - aRet.Interface = xLBT->getInterface(); - aRet.Any = xLBT->getAny(); - aRet.Sequence = xLBT->getSequence(); - aRet2 = xLBT->getStruct(); - - bRet = check( equals( aData, aRet ) && equals( aData, aRet2 ) , "struct comparison test") && bRet; - - { - SmallStruct aIn(1, 2); - SmallStruct aOut = xLBT->echoSmallStruct(aIn); - bRet = check( memcmp(&aIn, &aOut, sizeof(SmallStruct)) == 0, "small struct test" ) && bRet; - } - { - MediumStruct aIn(1, 2, 3, 4); - MediumStruct aOut = xLBT->echoMediumStruct(aIn); - bRet = check( memcmp(&aIn, &aOut, sizeof(MediumStruct)) == 0, "medium struct test" ) && bRet; - } - { - BigStruct aIn(1, 2, 3, 4, 5, 6, 7, 8); - BigStruct aOut = xLBT->echoBigStruct(aIn); - bRet = check( memcmp(&aIn, &aOut, sizeof(BigStruct)) == 0, "big struct test" ) && bRet; - } - { - AllFloats aIn(1.1f, 2.2f, 3.3f, 4.4f); - AllFloats aOut = xLBT->echoAllFloats(aIn); - bRet = check( memcmp(&aIn, &aOut, sizeof(AllFloats)) == 0, "all floats struct test" ) && bRet; - } - { - sal_Int32 i2 = xLBT->testPPCAlignment( 0, 0, 0, 0, 0xbeaf ); - bRet = check( i2 == 0xbeaf, "ppc-style alignment test" ) && bRet; - } - - // Test extended attributes that raise exceptions: - try { - xLBT->getRaiseAttr1(); - bRet &= check(false, "getRaiseAttr1 did not throw"); - } catch (RuntimeException &) { - } catch (...) { - bRet &= check(false, "getRaiseAttr1 threw wrong type"); - } - try { - xLBT->setRaiseAttr1(0); - bRet &= check(false, "setRaiseAttr1 did not throw"); - } catch (IllegalArgumentException &) { - } catch (...) { - bRet &= check(false, "setRaiseAttr1 threw wrong type"); - } - try { - xLBT->getRaiseAttr2(); - bRet &= check(false, "getRaiseAttr2 did not throw"); - } catch (IllegalArgumentException &) { - } catch (...) { - bRet &= check(false, "getRaiseAttr2 threw wrong type"); - } - - // Test instantiated polymorphic struct types: - { - bRet &= check( - xLBT->transportPolyBoolean(TestPolyStruct< sal_Bool >(true)).member, - "transportPolyBoolean"); - TestPolyStruct< sal_Int64 > tps1(12345); - xLBT->transportPolyHyper(tps1); - bRet &= check(tps1.member == 12345, "transportPolyHyper"); - Sequence< Any > seq(2); - seq[0] <<= static_cast< sal_uInt32 >(33); - seq[1] <<= rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ABC")); - TestPolyStruct< Sequence< Any > > tps2(seq); - TestPolyStruct< Sequence< Any > > tps3; - xLBT->transportPolySequence(tps2, tps3); - bRet &= check( - tps3.member.getLength() == 2, "transportPolySequence, length"); - sal_uInt32 v0 = sal_uInt32(); - tps3.member[0] >>= v0; - bRet &= check(v0 == 33, "transportPolySequence, element 0"); - rtl::OUString v1; - tps3.member[1] >>= v1; - bRet &= check( - v1.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("ABC")), - "transportPolySequence, element 1"); - bRet &= check(xLBT->getNullPolyLong().member == 0, "getNullPolyLong"); - bRet &= check( - xLBT->getNullPolyString().member.getLength() == 0, - "getNullPolyString"); - bRet &= check( - xLBT->getNullPolyType().member == Type(), "getNullPolyType"); - Any nullAny(xLBT->getNullPolyAny().member); - bRet &= check( - (((nullAny.getValueTypeName() - == rtl::OUString( - RTL_CONSTASCII_USTRINGPARAM("com.sun.star.uno.XInterface"))) - && !static_cast< Reference< XInterface > const * >( - nullAny.getValue())->is()) - || nullAny == Any()), - "getNullPolyAny"); - bRet &= check( - xLBT->getNullPolySequence().member.getLength() == 0, - "getNullPolySequence"); - bRet &= check( - xLBT->getNullPolyEnum().member == TestEnum_TEST, "getNullPolyEnum"); - bRet &= check( - xLBT->getNullPolyBadEnum().member == TestBadEnum_M, - "getNullPolyBadEnum"); - bRet &= check( - xLBT->getNullPolyStruct().member.member == 0, "getNullPolyStruct"); - bRet &= check( - !xLBT->getNullPolyInterface().member.is(), "getNullPolyInterface"); - } - - // any test - bRet = check( performAnyTest( xLBT , aData ) , "any test" ) && bRet; - - // sequence of call test - bRet = check( performSequenceOfCallTest( xLBT ) , "sequence of call test" ) && bRet; - - // recursive call test - bRet = check( performRecursiveCallTest( xLBT ) , "recursive test" ) && bRet; - - bRet = (equals( aData, aRet ) && equals( aData, aRet2 )) && bRet ; - - // multiple inheritance test - bRet &= checkEmpty( - testtools::bridgetest::testMulti(xLBT->getMulti()), "remote multi"); - bRet &= checkEmpty( - xLBT->testMulti(new testtools::bridgetest::Multi), "local multi"); + TestData aRet; + aRet.Hyper = xLBT->getHyper(); + aRet.UHyper = xLBT->getUHyper(); + aRet.Float = xLBT->getFloat(); + aRet.Double = xLBT->getDouble(); + aRet.Byte = xLBT->getByte(); + aRet.Char = xLBT->getChar(); + aRet.Bool = xLBT->getBool(); + aRet.Short = xLBT->getShort(); + aRet.UShort = xLBT->getUShort(); + aRet.Long = xLBT->getLong(); + aRet.ULong = xLBT->getULong(); + aRet.Enum = xLBT->getEnum(); + aRet.String = xLBT->getString(); + aRet.Interface = xLBT->getInterface(); + aRet.Any = xLBT->getAny(); + aRet.Sequence = xLBT->getSequence(); + TestData aRet2(xLBT->getStruct()); + bRet &= check( + equals(aData, aRet) && equals(aData, aRet2), + "struct comparison test"); + { + SmallStruct aIn(1, 2); + SmallStruct aOut(xLBT->echoSmallStruct(aIn)); + bRet &= check( + memcmp(&aIn, &aOut, sizeof(SmallStruct)) == 0, + "small struct test"); + } + { + MediumStruct aIn(1, 2, 3, 4); + MediumStruct aOut(xLBT->echoMediumStruct(aIn)); + bRet &= check( + memcmp(&aIn, &aOut, sizeof(MediumStruct)) == 0, + "medium struct test"); + } + { + BigStruct aIn(1, 2, 3, 4, 5, 6, 7, 8); + BigStruct aOut(xLBT->echoBigStruct(aIn)); + bRet &= check( + memcmp(&aIn, &aOut, sizeof(BigStruct)) == 0, + "big struct test"); + } + { + AllFloats aIn(1.1f, 2.2f, 3.3f, 4.4f); + AllFloats aOut(xLBT->echoAllFloats(aIn)); + bRet &= check( + memcmp(&aIn, &aOut, sizeof(AllFloats)) == 0, + "all floats struct test"); + } + { + sal_Int32 i2 = xLBT->testPPCAlignment(0, 0, 0, 0, 0xBEAF); + bRet &= check(i2 == 0xBEAF, "ppc-style alignment test"); + } + // Test extended attributes that raise exceptions: + try { + xLBT->getRaiseAttr1(); + bRet &= check(false, "getRaiseAttr1 did not throw"); + } catch (RuntimeException &) { + } catch (...) { + bRet &= check(false, "getRaiseAttr1 threw wrong type"); + } + try { + xLBT->setRaiseAttr1(0); + bRet &= check(false, "setRaiseAttr1 did not throw"); + } catch (IllegalArgumentException &) { + } catch (...) { + bRet &= check(false, "setRaiseAttr1 threw wrong type"); + } + try { + xLBT->getRaiseAttr2(); + bRet &= check(false, "getRaiseAttr2 did not throw"); + } catch (IllegalArgumentException &) { + } catch (...) { + bRet &= check(false, "getRaiseAttr2 threw wrong type"); + } + // Test instantiated polymorphic struct types: + { + bRet &= check( + (xLBT->transportPolyBoolean( + TestPolyStruct< sal_Bool >(true)). + member), + "transportPolyBoolean"); + TestPolyStruct< sal_Int64 > tps1(12345); + xLBT->transportPolyHyper(tps1); + bRet &= check(tps1.member == 12345, "transportPolyHyper"); + Sequence< Any > seq(2); + seq[0] <<= static_cast< sal_uInt32 >(33); + seq[1] <<= rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ABC")); + TestPolyStruct< Sequence< Any > > tps2(seq); + TestPolyStruct< Sequence< Any > > tps3; + xLBT->transportPolySequence(tps2, tps3); + bRet &= check( + tps3.member.getLength() == 2, + "transportPolySequence, length"); + sal_uInt32 v0 = sal_uInt32(); + tps3.member[0] >>= v0; + bRet &= check(v0 == 33, "transportPolySequence, element 0"); + rtl::OUString v1; + tps3.member[1] >>= v1; + bRet &= check( + v1.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("ABC")), + "transportPolySequence, element 1"); + bRet &= check( + xLBT->getNullPolyLong().member == 0, "getNullPolyLong"); + bRet &= check( + xLBT->getNullPolyString().member.getLength() == 0, + "getNullPolyString"); + bRet &= check( + xLBT->getNullPolyType().member == Type(), + "getNullPolyType"); + Any nullAny(xLBT->getNullPolyAny().member); + bRet &= check( + (((nullAny.getValueTypeName() == + rtl::OUString( + RTL_CONSTASCII_USTRINGPARAM( + "com.sun.star.uno.XInterface"))) && + !static_cast< Reference< XInterface > const * >( + nullAny.getValue())->is()) + || nullAny == Any()), + "getNullPolyAny"); + bRet &= check( + xLBT->getNullPolySequence().member.getLength() == 0, + "getNullPolySequence"); + bRet &= check( + xLBT->getNullPolyEnum().member == TestEnum_TEST, + "getNullPolyEnum"); + bRet &= check( + xLBT->getNullPolyBadEnum().member == TestBadEnum_M, + "getNullPolyBadEnum"); + bRet &= check( + xLBT->getNullPolyStruct().member.member == 0, + "getNullPolyStruct"); + bRet &= check( + !xLBT->getNullPolyInterface().member.is(), + "getNullPolyInterface"); + } + // Any test: + bRet &= check(performAnyTest(xLBT , aData), "any test"); + // Sequence of call test: + bRet &= check( + performSequenceOfCallTest(xLBT), "sequence of call test"); + // Recursive call test: + bRet &= check(performRecursiveCallTest(xLBT), "recursive test"); + bRet &= check( + equals(aData, aRet) && equals(aData, aRet2), + "recursive test results"); + // Multiple inheritance test: + bRet &= checkEmpty( + testtools::bridgetest::testMulti(xLBT->getMulti()), + "remote multi"); + bRet &= checkEmpty( + xLBT->testMulti(new testtools::bridgetest::Multi), + "local multi"); } - } { - Reference xBT2(xLBT, UNO_QUERY); - if ( ! xBT2.is()) - return bRet; - - // perform sequence tests (XBridgeTest2) - // create the sequence which are compared with the results - sal_Bool _arBool[] = {sal_True, sal_False, sal_True}; - sal_Unicode _arChar[] = {0x0065, 0x0066, 0x0067}; - sal_Int8 _arByte[] = { 1, 2, -1 }; - sal_Int16 _arShort[] = { -0x8000, 1, 0x7fff }; - sal_uInt16 _arUShort[] = {0 , 1, 0xffff}; - sal_Int32 _arLong[] = {0x80000000, 1, 0x7fffffff}; - sal_uInt32 _arULong[] = {0, 1, 0xffffffff}; - sal_Int64 _arHyper[] = { - SAL_CONST_INT64(0x8000000000000000), 1, - SAL_CONST_INT64(0x7fffffffffffffff)}; - sal_uInt64 _arUHyper[] = {0, 1, SAL_CONST_UINT64(0xffffffffffffffff)}; - float _arFloat[] = {1.1f, 2.2f, 3.3f}; - double _arDouble[] = {1.11, 2.22, 3.33}; - OUString _arString[] = { - OUString(RTL_CONSTASCII_USTRINGPARAM("String 1")), - OUString(RTL_CONSTASCII_USTRINGPARAM("String 2")), - OUString(RTL_CONSTASCII_USTRINGPARAM("String 3")) - }; - - sal_Bool _aBool = sal_True; - sal_Int32 _aInt = 0xbabebabe; - float _aFloat = 3.14f; - Any _any1(&_aBool, getCppuBooleanType()); - Any _any2(&_aInt, getCppuType((sal_Int32*) 0)); - Any _any3(&_aFloat, getCppuType((float*) 0)); - Any _arAny[] = { _any1, _any2, _any3}; - - Reference _arObj[3]; - _arObj[0] = new OWeakObject(); - _arObj[1] = new OWeakObject(); - _arObj[2] = new OWeakObject(); - - TestEnum _arEnum[] = {TestEnum_ONE, TestEnum_TWO, TestEnum_CHECK}; - - TestElement _arStruct[3]; - assign( _arStruct[0], sal_True, '@', 17, 0x1234, 0xfedc, 0x12345678, 0xfedcba98, - SAL_CONST_INT64(0x123456789abcdef0), - SAL_CONST_UINT64(0xfedcba9876543210), - 17.0815f, 3.1415926359, + Reference< XBridgeTest2 > xBT2(xLBT, UNO_QUERY); + if (!xBT2.is()) { + return bRet; + } + // Perform sequence tests (XBridgeTest2); create the sequence which is + // compared with the results: + sal_Bool _arBool[] = { true, false, true }; + sal_Unicode _arChar[] = { 0x0065, 0x0066, 0x0067 }; + sal_Int8 _arByte[] = { 1, 2, -1 }; + sal_Int16 _arShort[] = { -0x8000, 1, 0x7FFF }; + sal_uInt16 _arUShort[] = { 0 , 1, 0xFFFF }; + sal_Int32 _arLong[] = { 0x80000000, 1, 0x7FFFFFFF }; + sal_uInt32 _arULong[] = { 0, 1, 0xFFFFFFFF }; + sal_Int64 _arHyper[] = { + SAL_CONST_INT64(0x8000000000000000), 1, + SAL_CONST_INT64(0x7FFFFFFFFFFFFFFF) }; + sal_uInt64 _arUHyper[] = { 0, 1, SAL_CONST_UINT64(0xFFFFFFFFFFFFFFFF) }; + float _arFloat[] = { 1.1f, 2.2f, 3.3f }; + double _arDouble[] = { 1.11, 2.22, 3.33 }; + OUString _arString[] = { + OUString(RTL_CONSTASCII_USTRINGPARAM("String 1")), + OUString(RTL_CONSTASCII_USTRINGPARAM("String 2")), + OUString(RTL_CONSTASCII_USTRINGPARAM("String 3")) }; + sal_Bool _aBool = true; + sal_Int32 _aInt = 0xBABEBABE; + float _aFloat = 3.14f; + Any _any1(&_aBool, getCppuBooleanType()); + Any _any2(&_aInt, getCppuType((sal_Int32 *) 0)); + Any _any3(&_aFloat, getCppuType((float *) 0)); + Any _arAny[] = { _any1, _any2, _any3 }; + Reference< XInterface > _arObj[3]; + _arObj[0] = new OWeakObject(); + _arObj[1] = new OWeakObject(); + _arObj[2] = new OWeakObject(); + TestEnum _arEnum[] = { TestEnum_ONE, TestEnum_TWO, TestEnum_CHECK }; + TestElement _arStruct[3]; + assign( + _arStruct[0], true, '@', 17, 0x1234, 0xFEDC, 0x12345678, 0xFEDCBA98, + SAL_CONST_INT64(0x123456789ABCDEF0), + SAL_CONST_UINT64(0xFEDCBA9876543210), 17.0815f, 3.1415926359, TestEnum_LOLA, OUSTR(STRING_TEST_CONSTANT), _arObj[0], - Any( &_arObj[0], ::getCppuType( (const Reference *)0 ) ) ); - assign( _arStruct[1], sal_True, 'A', 17, 0x1234, 0xfedc, 0x12345678, 0xfedcba98, - SAL_CONST_INT64(0x123456789abcdef0), - SAL_CONST_UINT64(0xfedcba9876543210), - 17.0815f, 3.1415926359, + Any(&_arObj[0], getCppuType((Reference< XInterface > const *) 0))); + assign( + _arStruct[1], true, 'A', 17, 0x1234, 0xFEDC, 0x12345678, 0xFEDCBA98, + SAL_CONST_INT64(0x123456789ABCDEF0), + SAL_CONST_UINT64(0xFEDCBA9876543210), 17.0815f, 3.1415926359, TestEnum_TWO, OUSTR(STRING_TEST_CONSTANT), _arObj[1], - Any( &_arObj[1], ::getCppuType( (const Reference *)0 ) ) ); - assign( _arStruct[2], sal_True, 'B', 17, 0x1234, 0xfedc, 0x12345678, 0xfedcba98, - SAL_CONST_INT64(0x123456789abcdef0), - SAL_CONST_UINT64(0xfedcba9876543210), - 17.0815f, 3.1415926359, + Any(&_arObj[1], getCppuType((Reference< XInterface > const *) 0))); + assign( + _arStruct[2], true, 'B', 17, 0x1234, 0xFEDC, 0x12345678, 0xFEDCBA98, + SAL_CONST_INT64(0x123456789ABCDEF0), + SAL_CONST_UINT64(0xFEDCBA9876543210), 17.0815f, 3.1415926359, TestEnum_CHECK, OUSTR(STRING_TEST_CONSTANT), _arObj[2], - Any( &_arObj[2], ::getCppuType( (const Reference *)0 ) ) ); - - { - Sequence arBool(_arBool, 3); - Sequence arChar( _arChar, 3); - Sequence arByte(_arByte, 3); - Sequence arShort(_arShort, 3); - Sequence arUShort(_arUShort, 3); - Sequence arLong(_arLong, 3); - Sequence arULong(_arULong, 3); - Sequence arHyper(_arHyper, 3); - Sequence arUHyper(_arUHyper, 3); - Sequence arFloat(_arFloat, 3); - Sequence arDouble(_arDouble, 3); - Sequence arString(_arString, 3); - Sequence arAny(_arAny, 3); - Sequence > arObject(_arObj, 3); - Sequence arEnum(_arEnum, 3); - Sequence arStruct(_arStruct, 3); - Sequence > _arSeqLong2[3]; - for (int j = 0; j < 3; j++) - { - Sequence _arSeqLong[3]; - for (int i = 0; i < 3; i++) - { - _arSeqLong[i] = Sequence(_arLong, 3); - } - - _arSeqLong2[j] = Sequence< Sequence > (_arSeqLong, 3); - } - - Sequence > > arLong3( _arSeqLong2, 3); - Sequence > seqSeqRet = xBT2->setDim2(arLong3[0]); - bRet = check( seqSeqRet == arLong3[0], "sequence test") && bRet; - Sequence > > seqSeqRet2 = xBT2->setDim3(arLong3); - bRet = check( seqSeqRet2 == arLong3, "sequence test") && bRet; - Sequence seqAnyRet = xBT2->setSequenceAny(arAny); - bRet = check( seqAnyRet == arAny, "sequence test") && bRet; - Sequence seqBoolRet = xBT2->setSequenceBool(arBool); - bRet = check( seqBoolRet == arBool, "sequence test") && bRet; - Sequence seqByteRet = xBT2->setSequenceByte(arByte); - bRet = check( seqByteRet == arByte, "sequence test") && bRet; - Sequence seqCharRet = xBT2->setSequenceChar(arChar); - bRet = check( seqCharRet == arChar, "sequence test") && bRet; - Sequence seqShortRet = xBT2->setSequenceShort(arShort); - bRet = check( seqShortRet == arShort, "sequence test") && bRet; - Sequence seqLongRet = xBT2->setSequenceLong(arLong); - bRet = check( seqLongRet == arLong, "sequence test") && bRet; - Sequence seqHyperRet = xBT2->setSequenceHyper(arHyper); - bRet = check( seqHyperRet == arHyper, "sequence test") && bRet; - Sequence seqFloatRet = xBT2->setSequenceFloat(arFloat); - bRet = check( seqFloatRet == arFloat, "sequence test") && bRet; - Sequence seqDoubleRet = xBT2->setSequenceDouble(arDouble); - bRet = check( seqDoubleRet == arDouble, "sequence test") && bRet; - Sequence seqEnumRet = xBT2->setSequenceEnum(arEnum); - bRet = check( seqEnumRet == arEnum, "sequence test") && bRet; - Sequence seqUShortRet = xBT2->setSequenceUShort(arUShort); - bRet = check( seqUShortRet == arUShort, "sequence test") && bRet; - Sequence seqULongRet = xBT2->setSequenceULong(arULong); - bRet = check( seqULongRet == arULong, "sequence test") && bRet; - Sequence seqUHyperRet = xBT2->setSequenceUHyper(arUHyper); - bRet = check( seqUHyperRet == arUHyper, "sequence test") && bRet; - Sequence > seqObjectRet = xBT2->setSequenceXInterface(arObject); - bRet = check( seqObjectRet == arObject, "sequence test") && bRet; - Sequence seqStringRet = xBT2->setSequenceString(arString); - bRet = check( seqStringRet == arString, "sequence test") && bRet; - Sequence seqStructRet = xBT2->setSequenceStruct(arStruct); - bRet = check( seqStructRet == arStruct, "sequence test") && bRet; - - Sequence arBoolTemp = cloneSequence(arBool); - Sequence arCharTemp = cloneSequence(arChar); - Sequence arByteTemp = cloneSequence(arByte); - Sequence arShortTemp = cloneSequence(arShort); - Sequence arUShortTemp = cloneSequence(arUShort); - Sequence arLongTemp = cloneSequence(arLong); - Sequence arULongTemp = cloneSequence(arULong); - Sequence arHyperTemp = cloneSequence(arHyper); - Sequence arUHyperTemp = cloneSequence(arUHyper); - Sequence arFloatTemp = cloneSequence(arFloat); - Sequence arDoubleTemp = cloneSequence(arDouble); - Sequence arEnumTemp = cloneSequence(arEnum); - Sequence arStringTemp = cloneSequence(arString); - Reference _xint; - Sequence > arObjectTemp = cloneSequence(arObject); - Sequence arAnyTemp = cloneSequence(arAny); - Sequence > arLong2Temp(arLong3[0]); - Sequence > > arLong3Temp(arLong3); - - xBT2->setSequencesInOut(arBoolTemp, arCharTemp, arByteTemp, arShortTemp, - arUShortTemp, arLongTemp,arULongTemp, arHyperTemp, - arUHyperTemp, arFloatTemp, arDoubleTemp, - arEnumTemp, arStringTemp, arObjectTemp, arAnyTemp, - arLong2Temp, arLong3Temp); - bRet = check( - arBoolTemp == arBool && - arCharTemp == arChar && - arByteTemp == arByte && - arShortTemp == arShort && - arUShortTemp == arUShort && - arLongTemp == arLong && - arULongTemp == arULong && - arHyperTemp == arHyper && - arUHyperTemp == arUHyper && - arFloatTemp == arFloat && - arDoubleTemp == arDouble && - arEnumTemp == arEnum && - arStringTemp == arString && - arObjectTemp == arObject && - arAnyTemp == arAny && - arLong2Temp == arLong3[0] && - arLong3Temp == arLong3, "sequence test") && bRet; - - Sequence arBoolOut; - Sequence arCharOut; - Sequence arByteOut; - Sequence arShortOut; - Sequence arUShortOut; - Sequence arLongOut; - Sequence arULongOut; - Sequence arHyperOut; - Sequence arUHyperOut; - Sequence arFloatOut; - Sequence arDoubleOut; - Sequence arEnumOut; - Sequence arStringOut; - Sequence > arObjectOut; - Sequence arAnyOut; - Sequence > arLong2Out; - Sequence > > arLong3Out; - xBT2->setSequencesOut(arBoolOut, arCharOut, arByteOut, arShortOut, - arUShortOut, arLongOut,arULongOut, arHyperOut, - arUHyperOut, arFloatOut, arDoubleOut, - arEnumOut, arStringOut, arObjectOut, arAnyOut, - arLong2Out, arLong3Out); - bRet = check( - arBoolOut == arBool && - arCharOut == arChar && - arByteOut == arByte && - arShortOut == arShort && - arUShortOut == arUShort && - arLongOut == arLong && - arULongOut == arULong && - arHyperOut == arHyper && - arUHyperOut == arUHyper && - arFloatOut == arFloat && - arDoubleOut == arDouble && - arEnumOut == arEnum && - arStringOut == arString && - arObjectOut == arObject && - arAnyOut == arAny && - arLong2Out == arLong3[0] && - arLong3Out == arLong3, "sequence test") && bRet; - } - { - //test with empty sequences - Sequence > arLong2; - Sequence > seqSeqRet = xBT2->setDim2(arLong2); - bRet = check( seqSeqRet == arLong2, "sequence test") && bRet; - Sequence > > arLong3; - Sequence > > seqSeqRet2 = xBT2->setDim3( - arLong3); - bRet = check( seqSeqRet2 == arLong3, "sequence test") && bRet; - Sequence arAny; - Sequence seqAnyRet = xBT2->setSequenceAny(arAny); - bRet = check( seqAnyRet == arAny, "sequence test") && bRet; - Sequence arBool; - Sequence seqBoolRet = xBT2->setSequenceBool(arBool); - bRet = check( seqBoolRet == arBool, "sequence test") && bRet; - Sequence arByte; - Sequence seqByteRet = xBT2->setSequenceByte(arByte); - bRet = check( seqByteRet == arByte, "sequence test") && bRet; - Sequence arChar; - Sequence seqCharRet = xBT2->setSequenceChar(arChar); - bRet = check( seqCharRet == arChar, "sequence test") && bRet; - Sequence arShort; - Sequence seqShortRet = xBT2->setSequenceShort(arShort); - bRet = check( seqShortRet == arShort, "sequence test") && bRet; - Sequence arLong; - Sequence seqLongRet = xBT2->setSequenceLong(arLong); - bRet = check( seqLongRet == arLong, "sequence test") && bRet; - Sequence arHyper; - Sequence seqHyperRet = xBT2->setSequenceHyper(arHyper); - bRet = check( seqHyperRet == arHyper, "sequence test") && bRet; - Sequence arFloat; - Sequence seqFloatRet = xBT2->setSequenceFloat(arFloat); - bRet = check( seqFloatRet == arFloat, "sequence test") && bRet; - Sequence arDouble; - Sequence seqDoubleRet = xBT2->setSequenceDouble(arDouble); - bRet = check( seqDoubleRet == arDouble, "sequence test") && bRet; - Sequence arEnum; - Sequence seqEnumRet = xBT2->setSequenceEnum(arEnum); - bRet = check( seqEnumRet == arEnum, "sequence test") && bRet; - Sequence arUShort; - Sequence seqUShortRet = xBT2->setSequenceUShort(arUShort); - bRet = check( seqUShortRet == arUShort, "sequence test") && bRet; - Sequence arULong; - Sequence seqULongRet = xBT2->setSequenceULong(arULong); - bRet = check( seqULongRet == arULong, "sequence test") && bRet; - Sequence arUHyper; - Sequence seqUHyperRet = xBT2->setSequenceUHyper(arUHyper); - bRet = check( seqUHyperRet == arUHyper, "sequence test") && bRet; - Sequence > arObject; - Sequence > seqObjectRet = - xBT2->setSequenceXInterface(arObject); - bRet = check( seqObjectRet == arObject, "sequence test") && bRet; - Sequence arString; - Sequence seqStringRet = xBT2->setSequenceString(arString); - bRet = check( seqStringRet == arString, "sequence test") && bRet; - Sequence arStruct; - Sequence seqStructRet = xBT2->setSequenceStruct(arStruct); - bRet = check( seqStructRet == arStruct, "sequence test") && bRet; - } - // Issue #i60341# shows that the most interesting case is were Java calls - // the constructors; however, since this client is currently not available - // in Java, while the server is, the logic is reversed here: - try { - xBT2->testConstructorsService(xContext); - } catch (BadConstructorArguments &) { - bRet = false; - } - if (!noCurrentContext) { - if (!(new testtools::bridgetest::CurrentContextChecker)->perform( - xBT2->getCurrentContextChecker(), 0, 1)) + Any(&_arObj[2], getCppuType((Reference< XInterface > const *) 0))); { - bRet = false; + Sequence arBool(_arBool, 3); + Sequence arChar( _arChar, 3); + Sequence arByte(_arByte, 3); + Sequence arShort(_arShort, 3); + Sequence arUShort(_arUShort, 3); + Sequence arLong(_arLong, 3); + Sequence arULong(_arULong, 3); + Sequence arHyper(_arHyper, 3); + Sequence arUHyper(_arUHyper, 3); + Sequence arFloat(_arFloat, 3); + Sequence arDouble(_arDouble, 3); + Sequence arString(_arString, 3); + Sequence arAny(_arAny, 3); + Sequence > arObject(_arObj, 3); + Sequence arEnum(_arEnum, 3); + Sequence arStruct(_arStruct, 3); + Sequence > _arSeqLong2[3]; + for (int j = 0; j != 3; ++j) { + Sequence< sal_Int32 > _arSeqLong[3]; + for (int i = 0; i != 3; ++i) { + _arSeqLong[i] = Sequence< sal_Int32 >(_arLong, 3); + } + _arSeqLong2[j] = Sequence< Sequence< sal_Int32 > >( + _arSeqLong, 3); + } + Sequence< Sequence< Sequence< sal_Int32> > > arLong3( + _arSeqLong2, 3); + Sequence< Sequence< sal_Int32 > > seqSeqRet( + xBT2->setDim2(arLong3[0])); + bRet &= check(seqSeqRet == arLong3[0], "sequence test"); + Sequence< Sequence< Sequence< sal_Int32 > > > seqSeqRet2( + xBT2->setDim3(arLong3)); + bRet &= check(seqSeqRet2 == arLong3, "sequence test"); + Sequence< Any > seqAnyRet(xBT2->setSequenceAny(arAny)); + bRet &= check(seqAnyRet == arAny, "sequence test"); + Sequence< sal_Bool > seqBoolRet(xBT2->setSequenceBool(arBool)); + bRet &= check(seqBoolRet == arBool, "sequence test"); + Sequence< sal_Int8 > seqByteRet(xBT2->setSequenceByte(arByte)); + bRet &= check(seqByteRet == arByte, "sequence test"); + Sequence< sal_Unicode > seqCharRet(xBT2->setSequenceChar(arChar)); + bRet &= check(seqCharRet == arChar, "sequence test"); + Sequence< sal_Int16 > seqShortRet(xBT2->setSequenceShort(arShort)); + bRet &= check(seqShortRet == arShort, "sequence test"); + Sequence< sal_Int32 > seqLongRet(xBT2->setSequenceLong(arLong)); + bRet &= check(seqLongRet == arLong, "sequence test"); + Sequence< sal_Int64 > seqHyperRet(xBT2->setSequenceHyper(arHyper)); + bRet &= check(seqHyperRet == arHyper, "sequence test"); + Sequence< float > seqFloatRet(xBT2->setSequenceFloat(arFloat)); + bRet &= check(seqFloatRet == arFloat, "sequence test"); + Sequence< double > seqDoubleRet(xBT2->setSequenceDouble(arDouble)); + bRet &= check(seqDoubleRet == arDouble, "sequence test"); + Sequence< TestEnum > seqEnumRet(xBT2->setSequenceEnum(arEnum)); + bRet &= check(seqEnumRet == arEnum, "sequence test"); + Sequence< sal_uInt16 > seqUShortRet( + xBT2->setSequenceUShort(arUShort)); + bRet &= check(seqUShortRet == arUShort, "sequence test"); + Sequence< sal_uInt32 > seqULongRet(xBT2->setSequenceULong(arULong)); + bRet &= check(seqULongRet == arULong, "sequence test"); + Sequence< sal_uInt64 > seqUHyperRet( + xBT2->setSequenceUHyper(arUHyper)); + bRet &= check(seqUHyperRet == arUHyper, "sequence test"); + Sequence< Reference< XInterface > > seqObjectRet( + xBT2->setSequenceXInterface(arObject)); + bRet &= check(seqObjectRet == arObject, "sequence test"); + Sequence< OUString > seqStringRet( + xBT2->setSequenceString(arString)); + bRet &= check(seqStringRet == arString, "sequence test"); + Sequence< TestElement > seqStructRet( + xBT2->setSequenceStruct(arStruct)); + bRet &= check(seqStructRet == arStruct, "sequence test"); + Sequence< sal_Bool > arBoolTemp(cloneSequence(arBool)); + Sequence< sal_Unicode > arCharTemp(cloneSequence(arChar)); + Sequence< sal_Int8 > arByteTemp(cloneSequence(arByte)); + Sequence< sal_Int16 > arShortTemp(cloneSequence(arShort)); + Sequence< sal_uInt16 > arUShortTemp(cloneSequence(arUShort)); + Sequence< sal_Int32 > arLongTemp(cloneSequence(arLong)); + Sequence< sal_uInt32 > arULongTemp(cloneSequence(arULong)); + Sequence< sal_Int64 > arHyperTemp(cloneSequence(arHyper)); + Sequence< sal_uInt64 > arUHyperTemp(cloneSequence(arUHyper)); + Sequence< float > arFloatTemp(cloneSequence(arFloat)); + Sequence< double > arDoubleTemp(cloneSequence(arDouble)); + Sequence< TestEnum > arEnumTemp(cloneSequence(arEnum)); + Sequence< OUString > arStringTemp(cloneSequence(arString)); + Sequence< Reference< XInterface > > arObjectTemp( + cloneSequence(arObject)); + Sequence< Any > arAnyTemp(cloneSequence(arAny)); + Sequence< Sequence< sal_Int32 > > arLong2Temp(arLong3[0]); + Sequence< Sequence< Sequence< sal_Int32 > > > arLong3Temp(arLong3); + xBT2->setSequencesInOut( + arBoolTemp, arCharTemp, arByteTemp, arShortTemp, arUShortTemp, + arLongTemp,arULongTemp, arHyperTemp, arUHyperTemp, arFloatTemp, + arDoubleTemp, arEnumTemp, arStringTemp, arObjectTemp, arAnyTemp, + arLong2Temp, arLong3Temp); + bRet &= check( + (arBoolTemp == arBool && arCharTemp == arChar && + arByteTemp == arByte && arShortTemp == arShort && + arUShortTemp == arUShort && arLongTemp == arLong && + arULongTemp == arULong && arHyperTemp == arHyper && + arUHyperTemp == arUHyper && arFloatTemp == arFloat && + arDoubleTemp == arDouble && arEnumTemp == arEnum && + arStringTemp == arString && arObjectTemp == arObject && + arAnyTemp == arAny && arLong2Temp == arLong3[0] && + arLong3Temp == arLong3), + "sequence test"); + Sequence< sal_Bool > arBoolOut; + Sequence< sal_Unicode > arCharOut; + Sequence< sal_Int8 > arByteOut; + Sequence< sal_Int16 > arShortOut; + Sequence< sal_uInt16 > arUShortOut; + Sequence< sal_Int32 > arLongOut; + Sequence< sal_uInt32 > arULongOut; + Sequence< sal_Int64 > arHyperOut; + Sequence< sal_uInt64 > arUHyperOut; + Sequence< float > arFloatOut; + Sequence< double > arDoubleOut; + Sequence< TestEnum > arEnumOut; + Sequence< OUString > arStringOut; + Sequence< Reference< XInterface > > arObjectOut; + Sequence< Any > arAnyOut; + Sequence< Sequence< sal_Int32 > > arLong2Out; + Sequence< Sequence< Sequence< sal_Int32 > > > arLong3Out; + xBT2->setSequencesOut( + arBoolOut, arCharOut, arByteOut, arShortOut, arUShortOut, + arLongOut,arULongOut, arHyperOut, arUHyperOut, arFloatOut, + arDoubleOut, arEnumOut, arStringOut, arObjectOut, arAnyOut, + arLong2Out, arLong3Out); + bRet &= check( + (arBoolOut == arBool && arCharOut == arChar && + arByteOut == arByte && arShortOut == arShort && + arUShortOut == arUShort && arLongOut == arLong && + arULongOut == arULong && arHyperOut == arHyper && + arUHyperOut == arUHyper && arFloatOut == arFloat && + arDoubleOut == arDouble && arEnumOut == arEnum && + arStringOut == arString && arObjectOut == arObject && + arAnyOut == arAny && arLong2Out == arLong3[0] && + arLong3Out == arLong3), + "sequence test"); } - if (!(new testtools::bridgetest::CurrentContextChecker)->perform( - xBT2->getCurrentContextChecker(), 0, 2)) { - bRet = false; + // Test with empty sequences: + Sequence< Sequence< sal_Int32 > > arLong2; + Sequence< Sequence< sal_Int32 > > seqSeqRet(xBT2->setDim2(arLong2)); + bRet &= check(seqSeqRet == arLong2, "sequence test"); + Sequence< Sequence< Sequence< sal_Int32 > > > arLong3; + Sequence< Sequence< Sequence< sal_Int32 > > > seqSeqRet2( + xBT2->setDim3(arLong3)); + bRet &= check(seqSeqRet2 == arLong3, "sequence test"); + Sequence< Any > arAny; + Sequence< Any > seqAnyRet(xBT2->setSequenceAny(arAny)); + bRet &= check(seqAnyRet == arAny, "sequence test"); + Sequence< sal_Bool > arBool; + Sequence< sal_Bool > seqBoolRet(xBT2->setSequenceBool(arBool)); + bRet &= check(seqBoolRet == arBool, "sequence test"); + Sequence< sal_Int8 > arByte; + Sequence< sal_Int8 > seqByteRet(xBT2->setSequenceByte(arByte)); + bRet &= check(seqByteRet == arByte, "sequence test"); + Sequence< sal_Unicode > arChar; + Sequence< sal_Unicode > seqCharRet(xBT2->setSequenceChar(arChar)); + bRet &= check(seqCharRet == arChar, "sequence test"); + Sequence< sal_Int16 > arShort; + Sequence< sal_Int16 > seqShortRet(xBT2->setSequenceShort(arShort)); + bRet &= check(seqShortRet == arShort, "sequence test"); + Sequence< sal_Int32 > arLong; + Sequence< sal_Int32 > seqLongRet(xBT2->setSequenceLong(arLong)); + bRet &= check(seqLongRet == arLong, "sequence test"); + Sequence< sal_Int64 > arHyper; + Sequence< sal_Int64 > seqHyperRet(xBT2->setSequenceHyper(arHyper)); + bRet &= check(seqHyperRet == arHyper, "sequence test"); + Sequence< float > arFloat; + Sequence< float > seqFloatRet(xBT2->setSequenceFloat(arFloat)); + bRet &= check(seqFloatRet == arFloat, "sequence test"); + Sequence< double > arDouble; + Sequence< double > seqDoubleRet(xBT2->setSequenceDouble(arDouble)); + bRet &= check(seqDoubleRet == arDouble, "sequence test"); + Sequence< TestEnum > arEnum; + Sequence< TestEnum > seqEnumRet(xBT2->setSequenceEnum(arEnum)); + bRet &= check(seqEnumRet == arEnum, "sequence test"); + Sequence< sal_uInt16 > arUShort; + Sequence< sal_uInt16 > seqUShortRet( + xBT2->setSequenceUShort(arUShort)); + bRet &= check(seqUShortRet == arUShort, "sequence test"); + Sequence< sal_uInt32 > arULong; + Sequence< sal_uInt32 > seqULongRet(xBT2->setSequenceULong(arULong)); + bRet &= check(seqULongRet == arULong, "sequence test"); + Sequence< sal_uInt64 > arUHyper; + Sequence< sal_uInt64 > seqUHyperRet( + xBT2->setSequenceUHyper(arUHyper)); + bRet &= check(seqUHyperRet == arUHyper, "sequence test"); + Sequence< Reference< XInterface > > arObject; + Sequence< Reference< XInterface > > seqObjectRet( + xBT2->setSequenceXInterface(arObject)); + bRet &= check(seqObjectRet == arObject, "sequence test"); + Sequence< OUString > arString; + Sequence< OUString > seqStringRet( + xBT2->setSequenceString(arString)); + bRet &= check(seqStringRet == arString, "sequence test"); + Sequence< TestElement > arStruct; + Sequence< TestElement > seqStructRet( + xBT2->setSequenceStruct(arStruct)); + bRet &= check(seqStructRet == arStruct, "sequence test"); } - if (!(new testtools::bridgetest::CurrentContextChecker)->perform( - xBT2->getCurrentContextChecker(), 1, 2)) - { + // Issue #i60341# shows that the most interesting case is were Java + // calls the constructors; however, since this client is currently not + // available in Java, while the server is, the logic is reversed here: + try { + xBT2->testConstructorsService(xContext); + } catch (BadConstructorArguments &) { bRet = false; } - if (!(new testtools::bridgetest::CurrentContextChecker)->perform( - xBT2->getCurrentContextChecker(), 1, 3)) - { - bRet = false; + if (!noCurrentContext) { + if (!(new testtools::bridgetest::CurrentContextChecker)->perform( + xBT2->getCurrentContextChecker(), 0, 1)) + { + bRet = false; + } + if (!(new testtools::bridgetest::CurrentContextChecker)->perform( + xBT2->getCurrentContextChecker(), 0, 2)) + { + bRet = false; + } + if (!(new testtools::bridgetest::CurrentContextChecker)->perform( + xBT2->getCurrentContextChecker(), 1, 2)) + { + bRet = false; + } + if (!(new testtools::bridgetest::CurrentContextChecker)->perform( + xBT2->getCurrentContextChecker(), 1, 3)) + { + bRet = false; + } } } - } return bRet; } + static sal_Bool raiseOnewayException( const Reference < XBridgeTest > & xLBT ) { sal_Bool bReturn = sal_True; @@ -1247,7 +1212,6 @@ sal_Int32 TestBridgeImpl::run( const Sequence< OUString > & rArgs ) bRet = check( raiseException( xLBT ) , "exception test" )&& bRet; bRet = check( raiseOnewayException( xLBT ), "oneway exception test" ) && bRet; - bRet = performQueryForUnknownType( xLBT ) && bRet; if (! bRet) { throw RuntimeException( diff --git a/testtools/source/bridgetest/cppobj.cxx b/testtools/source/bridgetest/cppobj.cxx index 4c8d690aab06..d4d06cb39a3f 100644 --- a/testtools/source/bridgetest/cppobj.cxx +++ b/testtools/source/bridgetest/cppobj.cxx @@ -159,7 +159,7 @@ public: {} virtual ~Test_Impl() { - OSL_TRACE( "> scalar Test_Impl dtor <\n" ); + OSL_TRACE( "> scalar Test_Impl dtor <" ); } void SAL_CALL acquire() throw () diff --git a/testtools/source/bridgetest/currentcontextchecker.cxx b/testtools/source/bridgetest/currentcontextchecker.cxx index 3da2d74e9d2b..e7e4ec858b7b 100644 --- a/testtools/source/bridgetest/currentcontextchecker.cxx +++ b/testtools/source/bridgetest/currentcontextchecker.cxx @@ -50,8 +50,8 @@ namespace { namespace css = ::com::sun::star; -static char const key[] = "testtools.bridgetest.Key"; -static char const value[] = "good"; +static char const KEY[] = "testtools.bridgetest.Key"; +static char const VALUE[] = "good"; class CurrentContext: public ::osl::DebugBase< CurrentContext >, @@ -77,8 +77,8 @@ CurrentContext::~CurrentContext() {} css::uno::Any CurrentContext::getValueByName(::rtl::OUString const & Name) throw (css::uno::RuntimeException) { - return Name.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM(key)) - ? css::uno::makeAny(::rtl::OUString::createFromAscii(value)) + return Name.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM(KEY)) + ? css::uno::makeAny(::rtl::OUString::createFromAscii(VALUE)) : css::uno::Any(); } @@ -115,13 +115,13 @@ bool testtools::bridgetest::CurrentContextChecker::performCheck( return false; } css::uno::Any a( - context->getValueByName(::rtl::OUString::createFromAscii(key))); + context->getValueByName(::rtl::OUString::createFromAscii(KEY))); if (a.getValueType() != ::cppu::UnoType< ::rtl::OUString >::get()) { return false; } ::rtl::OUString s; OSL_VERIFY(a >>= s); - return s.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM(value)); + return s.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM(VALUE)); } else { return other->perform( this, setSteps >= 0 ? setSteps - 1 : -1, checkSteps - 1); -- cgit