CWS-TOOLING: integrate CWS sb135

5 files changed, 522 insertions, 558 deletions

diff --git a/qadevOOo/prj/build.lst b/qadevOOo/prj/build.lst
index e159c6a7b6cc..50d60a563c64 100644
--- a/qadevOOo/prj/build.lst
+++ b/qadevOOo/prj/build.lst
@@ -4,4 +4,3 @@ qa  qadevOOo			                         nmake   -   all qa_runner_ant_build NULL
 qa  qadevOOo\runner			                 nmake   -   all qa_make_package qa_runner_ant_build NULL
 
 qa qadevOOo\qa\unoapi nmake - all qa_qa_unoapi qa_make_package NULL
-qa qadevOOo\qa\complex\junitskeleton        nmake - all qa_complex_junitskel qa_make_package NULL
diff --git a/testautomation/writer/required/includes/w_007_.inc b/testautomation/writer/required/includes/w_007_.inc
index 20b468c9605c..466328026d9b 100644
--- a/testautomation/writer/required/includes/w_007_.inc
+++ b/testautomation/writer/required/includes/w_007_.inc
@@ -910,6 +910,7 @@ testcase tToolsUpdate
     Call wTypeKeys ("Dieser Text ist zur Aktualisierung")
     printlog " Insert / Indexes"
     InsertIndexes
+    sleep 1
 
     Kontext "Active"
     if ( Active.Exists( 2 ) ) then
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<MyClass>, public OWeakObject
 {
 public:
@@ -411,549 +380,545 @@ static sal_Bool performTest(
     const Reference<XBridgeTest > & 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<XInterface > 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<XInterface > *)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<XInterface > *)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<XBridgeTest2> 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<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], 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<XInterface > *)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<XInterface > *)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<XInterface > *)0 ) ) );
-
-    {
-    Sequence<sal_Bool> arBool(_arBool, 3);
-    Sequence<sal_Unicode> arChar( _arChar, 3);
-    Sequence<sal_Int8> arByte(_arByte, 3);
-    Sequence<sal_Int16> arShort(_arShort, 3);
-    Sequence<sal_uInt16> arUShort(_arUShort, 3);
-    Sequence<sal_Int32> arLong(_arLong, 3);
-    Sequence<sal_uInt32> arULong(_arULong, 3);
-    Sequence<sal_Int64> arHyper(_arHyper, 3);
-    Sequence<sal_uInt64> arUHyper(_arUHyper, 3);
-    Sequence<float> arFloat(_arFloat, 3);
-    Sequence<double> arDouble(_arDouble, 3);
-    Sequence<OUString> arString(_arString, 3);
-    Sequence<Any> arAny(_arAny, 3);
-    Sequence<Reference<XInterface> > arObject(_arObj, 3);
-    Sequence<TestEnum> arEnum(_arEnum, 3);
-    Sequence<TestElement> arStruct(_arStruct, 3);
-    Sequence<Sequence<sal_Int32> > _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") && bRet;
-    Sequence<Sequence<Sequence<sal_Int32> > > seqSeqRet2 = xBT2->setDim3(arLong3);
-    bRet = check( seqSeqRet2 == arLong3, "sequence test") && bRet;
-    Sequence<Any> seqAnyRet = xBT2->setSequenceAny(arAny);
-    bRet = check( seqAnyRet == arAny, "sequence test") && bRet;
-    Sequence<sal_Bool> seqBoolRet = xBT2->setSequenceBool(arBool);
-    bRet = check( seqBoolRet == arBool, "sequence test") && bRet;
-    Sequence<sal_Int8> seqByteRet = xBT2->setSequenceByte(arByte);
-    bRet = check( seqByteRet == arByte, "sequence test") && bRet;
-    Sequence<sal_Unicode> seqCharRet = xBT2->setSequenceChar(arChar);
-    bRet = check( seqCharRet == arChar, "sequence test") && bRet;
-    Sequence<sal_Int16> seqShortRet = xBT2->setSequenceShort(arShort);
-    bRet = check( seqShortRet == arShort, "sequence test") && bRet;
-    Sequence<sal_Int32> seqLongRet = xBT2->setSequenceLong(arLong);
-    bRet = check( seqLongRet == arLong, "sequence test") && bRet;
-    Sequence<sal_Int64> seqHyperRet = xBT2->setSequenceHyper(arHyper);
-    bRet = check( seqHyperRet == arHyper, "sequence test") && bRet;
-    Sequence<float> seqFloatRet = xBT2->setSequenceFloat(arFloat);
-    bRet = check( seqFloatRet == arFloat, "sequence test") && bRet;
-    Sequence<double> seqDoubleRet = xBT2->setSequenceDouble(arDouble);
-    bRet = check( seqDoubleRet == arDouble, "sequence test") && bRet;
-    Sequence<TestEnum> seqEnumRet = xBT2->setSequenceEnum(arEnum);
-    bRet = check( seqEnumRet == arEnum, "sequence test") && bRet;
-    Sequence<sal_uInt16> seqUShortRet = xBT2->setSequenceUShort(arUShort);
-    bRet = check( seqUShortRet == arUShort, "sequence test") && bRet;
-    Sequence<sal_uInt32> seqULongRet = xBT2->setSequenceULong(arULong);
-    bRet = check( seqULongRet == arULong, "sequence test") && bRet;
-    Sequence<sal_uInt64> seqUHyperRet = xBT2->setSequenceUHyper(arUHyper);
-    bRet = check( seqUHyperRet == arUHyper, "sequence test") && bRet;
-    Sequence<Reference<XInterface> > seqObjectRet = xBT2->setSequenceXInterface(arObject);
-    bRet = check( seqObjectRet == arObject, "sequence test") && bRet;
-    Sequence<OUString> seqStringRet = xBT2->setSequenceString(arString);
-    bRet = check( seqStringRet == arString, "sequence test") && bRet;
-    Sequence<TestElement> seqStructRet = xBT2->setSequenceStruct(arStruct);
-    bRet = check( seqStructRet == arStruct, "sequence test") && bRet;
-
-    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);
-    Reference<XInterface> _xint;
-    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") && bRet;
-
-    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") && bRet;
-    }
-    {
-    //test with empty sequences
-        Sequence<Sequence<sal_Int32> > arLong2;
-        Sequence<Sequence<sal_Int32> > seqSeqRet = xBT2->setDim2(arLong2);
-        bRet = check( seqSeqRet == arLong2, "sequence test") && bRet;
-        Sequence<Sequence<Sequence<sal_Int32> > > arLong3;
-        Sequence<Sequence<Sequence<sal_Int32> > > seqSeqRet2 = xBT2->setDim3(
-            arLong3);
-        bRet = check( seqSeqRet2 == arLong3, "sequence test") && bRet;
-        Sequence<Any> arAny;
-        Sequence<Any> seqAnyRet = xBT2->setSequenceAny(arAny);
-        bRet = check( seqAnyRet == arAny, "sequence test") && bRet;
-        Sequence<sal_Bool> arBool;
-        Sequence<sal_Bool> seqBoolRet = xBT2->setSequenceBool(arBool);
-        bRet = check( seqBoolRet == arBool, "sequence test") && bRet;
-        Sequence<sal_Int8> arByte;
-        Sequence<sal_Int8> seqByteRet = xBT2->setSequenceByte(arByte);
-        bRet = check( seqByteRet == arByte, "sequence test") && bRet;
-        Sequence<sal_Unicode> arChar;
-        Sequence<sal_Unicode> seqCharRet = xBT2->setSequenceChar(arChar);
-        bRet = check( seqCharRet == arChar, "sequence test") && bRet;
-        Sequence<sal_Int16> arShort;
-        Sequence<sal_Int16> seqShortRet = xBT2->setSequenceShort(arShort);
-        bRet = check( seqShortRet == arShort, "sequence test") && bRet;
-        Sequence<sal_Int32> arLong;
-        Sequence<sal_Int32> seqLongRet = xBT2->setSequenceLong(arLong);
-        bRet = check( seqLongRet == arLong, "sequence test") && bRet;
-        Sequence<sal_Int64> arHyper;
-        Sequence<sal_Int64> seqHyperRet = xBT2->setSequenceHyper(arHyper);
-        bRet = check( seqHyperRet == arHyper, "sequence test") && bRet;
-        Sequence<float> arFloat;
-        Sequence<float> seqFloatRet = xBT2->setSequenceFloat(arFloat);
-        bRet = check( seqFloatRet == arFloat, "sequence test") && bRet;
-        Sequence<double> arDouble;
-        Sequence<double> seqDoubleRet = xBT2->setSequenceDouble(arDouble);
-        bRet = check( seqDoubleRet == arDouble, "sequence test") && bRet;
-        Sequence<TestEnum> arEnum;
-        Sequence<TestEnum> seqEnumRet = xBT2->setSequenceEnum(arEnum);
-        bRet = check( seqEnumRet == arEnum, "sequence test") && bRet;
-        Sequence<sal_uInt16> arUShort;
-        Sequence<sal_uInt16> seqUShortRet = xBT2->setSequenceUShort(arUShort);
-        bRet = check( seqUShortRet == arUShort, "sequence test") && bRet;
-        Sequence<sal_uInt32> arULong;
-        Sequence<sal_uInt32> seqULongRet = xBT2->setSequenceULong(arULong);
-        bRet = check( seqULongRet == arULong, "sequence test") && bRet;
-        Sequence<sal_uInt64> arUHyper;
-        Sequence<sal_uInt64> seqUHyperRet = xBT2->setSequenceUHyper(arUHyper);
-        bRet = check( seqUHyperRet == arUHyper, "sequence test") && bRet;
-        Sequence<Reference<XInterface> > arObject;
-        Sequence<Reference<XInterface> > seqObjectRet =
-            xBT2->setSequenceXInterface(arObject);
-        bRet = check( seqObjectRet == arObject, "sequence test") && bRet;
-        Sequence<OUString> arString;
-        Sequence<OUString> seqStringRet = xBT2->setSequenceString(arString);
-        bRet = check( seqStringRet == arString, "sequence test") && bRet;
-        Sequence<TestElement> arStruct;
-        Sequence<TestElement> 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<sal_Bool> arBool(_arBool, 3);
+            Sequence<sal_Unicode> arChar( _arChar, 3);
+            Sequence<sal_Int8> arByte(_arByte, 3);
+            Sequence<sal_Int16> arShort(_arShort, 3);
+            Sequence<sal_uInt16> arUShort(_arUShort, 3);
+            Sequence<sal_Int32> arLong(_arLong, 3);
+            Sequence<sal_uInt32> arULong(_arULong, 3);
+            Sequence<sal_Int64> arHyper(_arHyper, 3);
+            Sequence<sal_uInt64> arUHyper(_arUHyper, 3);
+            Sequence<float> arFloat(_arFloat, 3);
+            Sequence<double> arDouble(_arDouble, 3);
+            Sequence<OUString> arString(_arString, 3);
+            Sequence<Any> arAny(_arAny, 3);
+            Sequence<Reference<XInterface> > arObject(_arObj, 3);
+            Sequence<TestEnum> arEnum(_arEnum, 3);
+            Sequence<TestElement> arStruct(_arStruct, 3);
+            Sequence<Sequence<sal_Int32> > _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);