diff options
Diffstat (limited to 'testtools/source/bridgetest/cli/cli_cpp_bridgetest.cxx')
| -rw-r--r-- | testtools/source/bridgetest/cli/cli_cpp_bridgetest.cxx | 928 |
1 files changed, 928 insertions, 0 deletions
diff --git a/testtools/source/bridgetest/cli/cli_cpp_bridgetest.cxx b/testtools/source/bridgetest/cli/cli_cpp_bridgetest.cxx new file mode 100644 index 000000000..04d9b3066 --- /dev/null +++ b/testtools/source/bridgetest/cli/cli_cpp_bridgetest.cxx @@ -0,0 +1,928 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + + +#using <mscorlib.dll> +#using <System.dll> +#using <cli_basetypes.dll> +#using <cli_uretypes.dll> +#using <cli_ure.dll> +#using <cli_types_bridgetest.dll> +#include <cmath> + +using namespace System; +using namespace System::Diagnostics; +using namespace System::Reflection; +using namespace System::Threading; +using namespace uno; +using namespace uno::util; +using namespace unoidl::com::sun::star::uno; +using namespace unoidl::com::sun::star::lang; +using namespace unoidl::test::testtools::bridgetest; +namespace foo +{ + public __gc __interface MyInterface + { + }; +} + +namespace cpp_bridgetest +{ + __gc class ORecursiveCall: public WeakBase, public XRecursiveCall + { + public: + void callRecursivly(XRecursiveCall * xCall, int nToCall) + { + Monitor::Enter(this); + try + { + { + if (nToCall > 0) + { + nToCall --; + xCall->callRecursivly(this, nToCall); + } + } + } + __finally + { + Monitor::Exit(this); + } + + } + }; + +public __gc class Constants +{ +public: + static String* STRING_TEST_CONSTANT = new String(S"\" paco\' chorizo\\\' \"\'"); +}; + +public __gc class BridgeTest : public WeakBase, public XMain +{ + static bool compareData(Object* val1, Object* val2) + { + if (val1 == 0 && val2 == 0 || val1 == val2) + return true; + if ((val1 == 0 && val2 != 0) || + (val1 != 0 && val2 == 0) || val1->GetType() != val2->GetType()) + return false; + + bool ret = false; + Type* t1 = val1->GetType(); + //Sequence + if (t1->IsArray) + { + ret = compareSequence(static_cast<Array*>(val1), + static_cast<Array*>(val2)); + } + //String + else if (t1 == __typeof(String)) + { + ret = val1->Equals(val2); + } + // Interface implementation + else if (t1->GetInterfaces()->Length > 0 && ! t1->IsValueType) + { + ret = val1 == val2; + } + // Struct + else if ( ! t1->IsValueType) + { + ret = compareStruct(val1, val2); + } + else if (t1 == __typeof(Any)) + { + Any a1 = (Any) val1; + Any a2 = (Any) val2; + ret = a1.Type == a2.Type && compareData(a1.Value, a2.Value); + } + else + { + //Any, enum, int, bool char, float, double etc. + ret = val1->Equals(val2); + } + return ret; + } + + // Arrays have only one dimension + static bool compareSequence(Array* ar1, Array* ar2) + { + Debug::Assert(ar1 != 0 && ar2 != 0); + Type* t1 = ar1->GetType(); + Type* t2 = ar2->GetType(); + + if (!(ar1->Rank == 1 && ar2->Rank == 1 + && ar1->Length == ar2->Length && t1->GetElementType() == t2->GetElementType())) + return false; + + //arrays have same rank and size and element type. + int len = ar1->Length; + bool ret = true; + for (int i = 0; i < len; i++) + { + if (compareData(ar1->GetValue(i), ar2->GetValue(i)) == false) + { + ret = false; + break; + } + } + return ret; + } + + static bool compareStruct(Object* val1, Object* val2) + { + Debug::Assert(val1 != 0 && val2 != 0); + Type* t1 = val1->GetType(); + Type* t2 = val2->GetType(); + if (t1 != t2) + return false; + FieldInfo* fields[] = t1->GetFields(); + int cFields = fields->Length; + bool ret = true; + for (int i = 0; i < cFields; i++) + { + Object* fieldVal1 = fields[i]->GetValue(val1); + Object* fieldVal2 = fields[i]->GetValue(val2); + if ( ! compareData(fieldVal1, fieldVal2)) + { + ret = false; + break; + } + } + return ret; + } + + static bool check( bool b , String* message ) + { + if ( ! b) + Console::WriteLine("{0} failed\n" , message); + return b; + } + + static bool equals(TestElement* rData1, TestElement* rData2) + { + check( rData1->Bool == rData2->Bool, "### bool does not match!" ); + check( rData1->Char == rData2->Char, "### char does not match!" ); + check( rData1->Byte == rData2->Byte, "### byte does not match!" ); + check( rData1->Short == rData2->Short, "### short does not match!" ); + check( rData1->UShort == rData2->UShort, "### unsigned short does not match!" ); + check( rData1->Long == rData2->Long, "### long does not match!" ); + check( rData1->ULong == rData2->ULong, "### unsigned long does not match!" ); + check( rData1->Hyper == rData2->Hyper, "### hyper does not match!" ); + check( rData1->UHyper == rData2->UHyper, "### unsigned hyper does not match!" ); + check( rData1->Float == rData2->Float, "### float does not match!" ); + check( rData1->Double == rData2->Double, "### double does not match!" ); + check( rData1->Enum == rData2->Enum, "### enum does not match!" ); + check( rData1->String == rData2->String, "### string does not match!" ); + check( rData1->Byte2 == rData2->Byte2, "### byte2 does not match!" ); + check( rData1->Short2 == rData2->Short2, "### short2 does not match!" ); + check( rData1->Interface == rData2->Interface, "### interface does not match!" ); + check( compareData(__box(rData1->Any), __box(rData2->Any)), "### any does not match!" ); + + return (rData1->Bool == rData2->Bool && + rData1->Char == rData2->Char && + rData1->Byte == rData2->Byte && + rData1->Short == rData2->Short && + rData1->UShort == rData2->UShort && + rData1->Long == rData2->Long && + rData1->ULong == rData2->ULong && + rData1->Hyper == rData2->Hyper && + rData1->UHyper == rData2->UHyper && + rData1->Float == rData2->Float && + rData1->Double == rData2->Double && + rData1->Enum == rData2->Enum && + rData1->String == rData2->String && + rData1->Byte2 == rData2->Byte2 && + rData1->Short2 == rData2->Short2 && + rData1->Interface == rData2->Interface && + compareData(__box(rData1->Any), __box(rData2->Any))); + } + +static void assign( TestElement* rData, + bool bBool, Char cChar, Byte nByte, + Int16 nShort, UInt16 nUShort, + Int32 nLong, UInt32 nULong, + Int64 nHyper, UInt64 nUHyper, + float fFloat, double fDouble, + TestEnum eEnum, String* rStr, + Byte nByte2, Int16 nShort2, + Object* xTest, + uno::Any rAny ) +{ + rData->Bool = bBool; + rData->Char = cChar; + rData->Byte = nByte; + rData->Short = nShort; + rData->UShort = nUShort; + rData->Long = nLong; + rData->ULong = nULong; + rData->Hyper = nHyper; + rData->UHyper = nUHyper; + rData->Float = fFloat; + rData->Double = fDouble; + rData->Enum = eEnum; + rData->String = rStr; + rData->Byte2 = nByte2; + rData->Short2 = nShort2; + rData->Interface = xTest; + rData->Any = rAny; +} + +static void assign( TestDataElements* rData, + bool bBool, Char cChar, Byte nByte, + Int16 nShort, UInt16 nUShort, + Int32 nLong, UInt32 nULong, + Int64 nHyper, UInt64 nUHyper, + float fFloat, double fDouble, + TestEnum eEnum, String* rStr, + Byte nByte2, Int16 nShort2, + Object* xTest, + Any rAny, + TestElement* rSequence[]) +{ + assign( static_cast<TestElement*>(rData), + bBool, cChar, nByte, nShort, nUShort, nLong, nULong, nHyper, nUHyper, fFloat, fDouble, + eEnum, rStr, nByte2, nShort2, xTest, rAny ); + rData->Sequence = rSequence; +} + +static bool testAny(Type* typ, Object* value, XBridgeTest* xLBT ) +{ + Any any; + if (typ == 0) + any = Any(value->GetType(), value); + else + any = Any(typ, value); + + Any any2 = xLBT->transportAny(any); + bool ret = compareData(__box(any), __box(any2)); + if (!ret) + { + Console::WriteLine("any is different after roundtrip: in {0}, out {1}\n", + any.Type->FullName, any2.Type->FullName); + } + return ret; +} + + +static bool performAnyTest(XBridgeTest* xLBT, TestDataElements* data) +{ + bool bReturn = true; + bReturn = testAny( 0, __box(data->Byte), xLBT ) && bReturn; + bReturn = testAny( 0, __box(data->Short), xLBT ) && bReturn; + bReturn = testAny( 0, __box(data->UShort), xLBT ) && bReturn; + bReturn = testAny( 0, __box(data->Long), xLBT ) && bReturn; + bReturn = testAny( 0, __box(data->ULong), xLBT ) && bReturn; + bReturn = testAny( 0, __box(data->Hyper), xLBT ) && bReturn; + bReturn = testAny( 0, __box(data->UHyper), xLBT ) && bReturn; + bReturn = testAny( 0, __box(data->Float), xLBT ) && bReturn; + bReturn = testAny( 0, __box(data->Double),xLBT ) && bReturn; + bReturn = testAny( 0, __box(data->Enum), xLBT ) && bReturn; + bReturn = testAny( 0, data->String,xLBT ) && bReturn; + bReturn = testAny( 0, data->Byte2,xLBT ) && bReturn; + bReturn = testAny( 0, data->Short2,xLBT ) && bReturn; + bReturn = testAny(__typeof(XWeak), data->Interface,xLBT ) && bReturn; + bReturn = testAny(0, data, xLBT ) && bReturn; + + { + Any a1(true); + Any a2 = xLBT->transportAny( a1 ); + bReturn = compareData(__box(a2), __box(a1)) && bReturn; + } + + { + Any a1('A'); + Any a2 = xLBT->transportAny(a1); + bReturn = compareData( __box(a2), __box(a1)) && bReturn; + } + return bReturn; +} + +static bool performSequenceOfCallTest(XBridgeTest* xLBT) +{ + int i,nRounds; + int nGlobalIndex = 0; + const int nWaitTimeSpanMUSec = 10000; + for( nRounds = 0 ; nRounds < 10 ; nRounds ++ ) + { + for( i = 0 ; i < nRounds ; i ++ ) + { + // fire oneways + xLBT->callOneway(nGlobalIndex, nWaitTimeSpanMUSec); + nGlobalIndex++; + } + + // call synchron + xLBT->call(nGlobalIndex, nWaitTimeSpanMUSec); + nGlobalIndex++; + } + return xLBT->sequenceOfCallTestPassed(); +} + + +static bool performRecursiveCallTest(XBridgeTest* xLBT) +{ + xLBT->startRecursiveCall(new ORecursiveCall(), 50); + // on failure, the test would lock up or crash + return true; +} + +static bool performQueryForUnknownType(XBridgeTest* xLBT) +{ + bool bRet = false; + // test queryInterface for an unknown type + try + { + __try_cast<foo::MyInterface*>(xLBT); + } + catch( System::InvalidCastException*) + { + bRet = true; + } + + return bRet; +} + + +static bool performTest(XBridgeTest* xLBT) +{ + check( xLBT != 0, "### no test interface!" ); + bool bRet = true; + if (xLBT != 0) + { + // this data is never ever granted access to by calls other than equals(), assign()! + TestDataElements* aData = new TestDataElements(); // test against this data + + Object* xI= new WeakBase(); + + Any aAny( __typeof(Object), xI); + assign( static_cast<TestElement*>(aData), + true, '@', 17, 0x1234, 0xfedc, 0x12345678, 0xfedcba98, + 0x123456789abcdef0, 0xfedcba9876543210, + 17.0815f, M_PI, TestEnum::LOLA, + Constants::STRING_TEST_CONSTANT, xI, + aAny); + + bRet = check( aData->Any.Value == xI, "### unexpected any!" ) && bRet; + bRet = check( !(aData->Any.Value != xI), "### unexpected any!" ) && bRet; + + aData->Sequence = new TestElement*[2]; + aData->Sequence[0] = new TestElement( + 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, + aData->Byte2, aData->Short2, + aData->Interface, aData->Any); //(TestElement) aData; + aData->Sequence[1] = new TestElement(); //is empty + + // aData complete + + // this is a manually copy of aData for first setting... + TestDataElements* aSetData = new TestDataElements; + Any aAnySet(__typeof(Object), xI); + assign( static_cast<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, + aData->Byte2, + aData->Short2, + xI, + aAnySet); + + aSetData->Sequence = new TestElement*[2]; + aSetData->Sequence[0] = new TestElement( + 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->Byte2, aSetData->Short2, + aSetData->Interface, aSetData->Any); //TestElement) aSetData; + aSetData->Sequence[1] = new TestElement(); // empty struct + + 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->Byte2, + aSetData->Short2, + aSetData->Interface, + aSetData->Any, + aSetData->Sequence, + aSetData ); + + { + TestDataElements* aRet = new TestDataElements(); + TestDataElements* aRet2 = new TestDataElements(); + 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->Byte2, + & aRet->Short2, + & aRet->Interface, + & aRet->Any, + & aRet->Sequence, + & aRet2 ); + + bRet = check( compareData( aData, aRet ) && compareData( aData, aRet2 ) , "getValues test") && bRet; + + // set last retrieved values + TestDataElements* 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->Byte2, + & aRet->Short2, + & 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( + compareData( aData, aSV2ret ) && compareData( aData, aRet2 ), + "getValues2 test") && bRet; + } + { + TestDataElements* aRet = new TestDataElements(); + TestDataElements* aRet2 = new TestDataElements(); + TestDataElements* 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->Byte2, + & aRet->Short2, + & aRet->Interface, + & aRet->Any, + & aRet->Sequence, + & aRet2 ); + + bRet = check( compareData( aData, aRet ) && compareData( aData, aRet2 ) && compareData( aData, aGVret ), "getValues test" ) && bRet; + + // set last retrieved values + xLBT->Bool = aRet->Bool; + xLBT->Char = aRet->Char; + xLBT->Byte = aRet->Byte; + xLBT->Short = aRet->Short; + xLBT->UShort = aRet->UShort; + xLBT->Long = aRet->Long; + xLBT->ULong = aRet->ULong; + xLBT->Hyper = aRet->Hyper; + xLBT->UHyper = aRet->UHyper; + xLBT->Float = aRet->Float; + xLBT->Double = aRet->Double; + xLBT->Enum = aRet->Enum; + xLBT->String = aRet->String; + xLBT->Byte2 = aRet->Byte2; + xLBT->Short2 = aRet->Short2; + xLBT->Interface = aRet->Interface; + xLBT->Any = aRet->Any; + xLBT->Sequence = aRet->Sequence; + xLBT->Struct = aRet2; + } + { + TestDataElements* aRet = new TestDataElements(); + TestDataElements* aRet2 = new TestDataElements(); + aRet->Hyper = xLBT->Hyper; + aRet->UHyper = xLBT->UHyper; + aRet->Float = xLBT->Float; + aRet->Double = xLBT->Double; + aRet->Byte = xLBT->Byte; + aRet->Char = xLBT->Char; + aRet->Bool = xLBT->Bool; + aRet->Short = xLBT->Short; + aRet->UShort = xLBT->UShort; + aRet->Long = xLBT->Long; + aRet->ULong = xLBT->ULong; + aRet->Enum = xLBT->Enum; + aRet->String = xLBT->String; + aRet->Byte2 = xLBT->Byte2; + aRet->Short2 = xLBT->Short2; + aRet->Interface = xLBT->Interface; + aRet->Any = xLBT->Any; + aRet->Sequence = xLBT->Sequence; + aRet2 = xLBT->Struct; + + bRet = check( compareData( aData, aRet ) && compareData( aData, aRet2 ) , "struct comparison test") && bRet; + + bRet = check(performSequenceTest(xLBT), "sequence test") && bRet; + + // 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 = (compareData( aData, aRet ) && compareData( aData, aRet2 )) && bRet ; + + // check setting of null reference + xLBT->Interface = 0; + aRet->Interface = xLBT->Interface; + bRet = (aRet->Interface == 0) && bRet; + + } + + + } + return bRet; + } +static bool performSequenceTest(XBridgeTest* xBT) +{ + bool bRet = true; + XBridgeTest2* xBT2 = dynamic_cast<XBridgeTest2*>(xBT); + if ( xBT2 == 0) + return false; + + // perform sequence tests (XBridgeTest2) + // create the sequence which are compared with the results + bool arBool __gc[] = new bool __gc [3]; + arBool[0] = true; arBool[1] = false; arBool[2] = true; + Char arChar[] = new Char[3]; + arChar[0] = 'A'; arChar[1] = 'B'; arChar[2] = 'C'; + Byte arByte[] = new Byte[3]; + arByte[0] = 1; arByte[1] = 2; arByte[2] = 0xff; + Int16 arShort[] = new Int16[3]; + arShort[0] = Int16::MinValue; arShort[1] = 1; arShort[2] = Int16::MaxValue; + UInt16 arUShort[] = new UInt16[3]; + arUShort[0] = UInt16::MinValue; arUShort[1] = 1; arUShort[2] = UInt16::MaxValue; + Int32 arLong[] = new Int32[3]; + arLong[0] = Int32::MinValue; arLong[1] = 1; arLong[2] = Int32::MaxValue; + UInt32 arULong[] = new UInt32[3]; + arULong[0] = UInt32::MinValue; arULong[1] = 1; arULong[2] = UInt32::MaxValue; + Int64 arHyper[] = new Int64[3]; + arHyper[0] = Int64::MinValue; arHyper[1] = 1; arHyper[2] = Int64::MaxValue; + UInt64 arUHyper[] = new UInt64[3]; + arUHyper[0] = UInt64::MinValue; arUHyper[1] = 1; + arUHyper[2] = UInt64::MaxValue; + Single arFloat[] = new Single[3]; + arFloat[0] = 1.1f; arFloat[1] = 2.2f; arFloat[2] = 3.3f; + Double arDouble[] = new Double[3]; + arDouble[0] = 1.11; arDouble[1] = 2.22; arDouble[2] = 3.33; + String* arString[] = new String*[3]; + arString[0] = new String("String 1"); + arString[1] = new String("String 2"); + arString[2] = new String("String 3"); + + Any arAny[] = new Any[3]; + arAny[0] = Any(true); arAny[1] = Any(11111); arAny[2] = Any(3.14); + Object* arObject[] = new Object*[3]; + arObject[0] = new WeakBase(); arObject[1] = new WeakBase(); + arObject[1] = new WeakBase(); + + Console::WriteLine(new String("cli_cpp_bridgetest: Workaround for C++ compiler bug:" + " using Array of Int32 instead of Array of enums w")); + Int32 arEnum[] = new Int32[3]; + arEnum[0] = static_cast<Int32>(TestEnum::ONE); + arEnum[1] = static_cast<Int32>(TestEnum::TWO); + arEnum[2] = static_cast<Int32>(TestEnum::CHECK); + + TestElement* arStruct[] = new TestElement*[3]; + arStruct[0] = new TestElement(); arStruct[1] = new TestElement(); + arStruct[2] = new TestElement(); + assign( arStruct[0], true, '@', 17, 0x1234, 0xfedc, 0x12345678, 0xfedcba98, + 0x123456789abcdef0, 0xfedcba9876543210, 17.0815f, M_PI, + TestEnum::LOLA, Constants::STRING_TEST_CONSTANT, 18, 0x5678, arObject[0], + Any( __typeof(Object), arObject[0]) ); + assign( arStruct[1], true, 'A', 17, 0x1234, 0xfedc, 0x12345678, 0xfedcba98, + 0x123456789abcdef0, 0xfedcba9876543210, 17.0815f, M_PI, + TestEnum::TWO, Constants::STRING_TEST_CONSTANT, 18, 0x5678, arObject[1], + Any( __typeof(Object), arObject[1]) ); + assign( arStruct[2], true, 'B', 17, 0x1234, 0xfedc, 0x12345678, 0xfedcba98, + 0x123456789abcdef0, 0xfedcba9876543210, 17.0815f, M_PI, + TestEnum::CHECK, Constants::STRING_TEST_CONSTANT, 18, 0x5678, arObject[2], + Any( __typeof(Object), arObject[2] ) ); + { + Any seqAnyRet[] = xBT2->setSequenceAny(arAny); + bRet = check( compareData(seqAnyRet, arAny), "sequence test") && bRet; + Boolean seqBoolRet[] = xBT2->setSequenceBool(arBool); + bRet = check( compareData(seqBoolRet, arBool), "sequence test") && bRet; + Byte seqByteRet[] = xBT2->setSequenceByte(arByte); + bRet = check( compareData(seqByteRet, arByte), "sequence test") && bRet; + Char seqCharRet[] = xBT2->setSequenceChar(arChar); + bRet = check( compareData(seqCharRet, arChar), "sequence test") && bRet; + Int16 seqShortRet[] = xBT2->setSequenceShort(arShort); + bRet = check( compareData(seqShortRet, arShort), "sequence test") && bRet; + Int32 seqLongRet[] = xBT2->setSequenceLong(arLong); + bRet = check( compareData(seqLongRet, arLong), "sequence test") && bRet; + Int64 seqHyperRet[] = xBT2->setSequenceHyper(arHyper); + bRet = check( compareData(seqHyperRet,arHyper), "sequence test") && bRet; + Single seqFloatRet[] = xBT2->setSequenceFloat(arFloat); + bRet = check( compareData(seqFloatRet, arFloat), "sequence test") && bRet; + Double seqDoubleRet[] = xBT2->setSequenceDouble(arDouble); + bRet = check( compareData(seqDoubleRet, arDouble), "sequence test") && bRet; + xBT2->setSequenceEnum(arEnum); + //comparing seqEnumRet with arEnum will fail since they are of different + //types because of workaround. arEnum is Int32[]. + Console::WriteLine(new String("cli_cpp_bridgetest: Test omitted because " + "of C++ compiler bug. XBridgeTest2::setSequenceEnum(sequence<TestEnum>)")); + UInt16 seqUShortRet[] = xBT2->setSequenceUShort(arUShort); + bRet = check( compareData(seqUShortRet, arUShort), "sequence test") && bRet; + UInt32 seqULongRet[] = xBT2->setSequenceULong(arULong); + bRet = check( compareData(seqULongRet, arULong), "sequence test") && bRet; + UInt64 seqUHyperRet[] = xBT2->setSequenceUHyper(arUHyper); + bRet = check( compareData(seqUHyperRet, arUHyper), "sequence test") && bRet; + Object* seqObjectRet[] = xBT2->setSequenceXInterface(arObject); + bRet = check( compareData(seqObjectRet, arObject), "sequence test") && bRet; + String* seqStringRet[] = xBT2->setSequenceString(arString); + bRet = check( compareData(seqStringRet, arString), "sequence test") && bRet; + TestElement* seqStructRet[] = xBT2->setSequenceStruct(arStruct); + bRet = check( compareData(seqStructRet, arStruct), "sequence test") && bRet; + } + { + Console::WriteLine(new String("cli_cpp_bridgetest: no test of " + "XBridgeTest2::setSequencesInOut and XBridgeTest2.setSequencesOut " + "because jagged arrays are not supported by C++ compiler")); + } + { + Any _arAny[] = new Any[0]; + Any seqAnyRet[] = xBT2->setSequenceAny(_arAny); + bRet = check( compareData(seqAnyRet, _arAny), "sequence test") && bRet; + Boolean _arBool[] = new Boolean[0]; + Boolean seqBoolRet[] = xBT2->setSequenceBool(_arBool); + bRet = check( compareData(seqBoolRet, _arBool), "sequence test") && bRet; + Byte _arByte[] = new Byte[0]; + Byte seqByteRet[] = xBT2->setSequenceByte(_arByte); + bRet = check( compareData(seqByteRet, _arByte), "sequence test") && bRet; + Char _arChar[] = new Char[0]; + Char seqCharRet[] = xBT2->setSequenceChar(_arChar); + bRet = check( compareData(seqCharRet, _arChar), "sequence test") && bRet; + Int16 _arShort[] = new Int16[0]; + Int16 seqShortRet[] = xBT2->setSequenceShort(_arShort); + bRet = check( compareData(seqShortRet, _arShort), "sequence test") && bRet; + Int32 _arLong[] = new Int32[0]; + Int32 seqLongRet[] = xBT2->setSequenceLong(_arLong); + bRet = check( compareData(seqLongRet, _arLong), "sequence test") && bRet; + Int64 _arHyper[] = new Int64[0]; + Int64 seqHyperRet[] = xBT2->setSequenceHyper(_arHyper); + bRet = check( compareData(seqHyperRet, _arHyper), "sequence test") && bRet; + Single _arFloat[] = new Single[0]; + Single seqFloatRet[] = xBT2->setSequenceFloat(_arFloat); + bRet = check( compareData(seqFloatRet, _arFloat), "sequence test") && bRet; + Double _arDouble[] = new Double[0]; + Double seqDoubleRet[] = xBT2->setSequenceDouble(_arDouble); + bRet = check( compareData(seqDoubleRet, _arDouble), "sequence test") && bRet; + TestEnum _arEnum[] = new TestEnum[0]; + xBT2->setSequenceEnum(_arEnum); + UInt16 _arUShort[] = new UInt16[0]; + UInt16 seqUShortRet[] = xBT2->setSequenceUShort(_arUShort); + bRet = check( compareData(seqUShortRet, _arUShort), "sequence test") && bRet; + UInt32 _arULong[] = new UInt32[0]; + UInt32 seqULongRet[] = xBT2->setSequenceULong(_arULong); + bRet = check( compareData(seqULongRet, _arULong), "sequence test") && bRet; + UInt64 _arUHyper[] = new UInt64[0]; + UInt64 seqUHyperRet[] = xBT2->setSequenceUHyper(_arUHyper); + bRet = check( compareData(seqUHyperRet, _arUHyper), "sequence test") && bRet; + Object* _arObject[] = new Object*[0]; + Object* seqObjectRet[] = xBT2->setSequenceXInterface(_arObject); + bRet = check( compareData(seqObjectRet, _arObject), "sequence test") && bRet; + String* _arString[] = new String*[0]; + String* seqStringRet[] = xBT2->setSequenceString(_arString); + bRet = check( compareData(seqStringRet, _arString), "sequence test") && bRet; + TestElement* _arStruct[] = new TestElement*[0]; + TestElement* seqStructRet[] = xBT2->setSequenceStruct(_arStruct); + bRet = check( compareData(seqStructRet, _arStruct), "sequence test") && bRet; + + } + return bRet; +} +/** Test the System::Object method on the proxy object + */ +static bool testObjectMethodsImplementation(XBridgeTest* xLBT) +{ + bool ret = false; + Object* obj = new Object(); + XBridgeTestBase* xBase = dynamic_cast<XBridgeTestBase*>(xLBT); + if (xBase == 0) + return false; + // Object.Equals + ret = xLBT->Equals(obj) == false; + ret = xLBT->Equals(xLBT) && ret; + ret = Object::Equals(obj, obj) && ret; + ret = Object::Equals(xLBT, xBase) && ret; + //Object.GetHashCode + // Don't know how to verify this. Currently it is not possible to get the object id from a proxy + int nHash = xLBT->GetHashCode(); + ret = nHash == xBase->GetHashCode() && ret; + + //Object.ToString + // Don't know how to verify this automatically. + String* s = xLBT->ToString(); + ret = (s->Length > 0) && ret; + return ret; +} + + +static bool raiseOnewayException(XBridgeTest* xLBT) +{ + bool bReturn = true; + String* sCompare = Constants::STRING_TEST_CONSTANT; + try + { + // Note : the exception may fly or not (e.g. remote scenario). + // When it flies, it must contain the correct elements. + xLBT->raiseRuntimeExceptionOneway(sCompare, xLBT->Interface ); + } + catch (RuntimeException* e ) + { + bReturn = ( xLBT->Interface == e->Context ); + } + return bReturn; +} + + +static bool raiseException(XBridgeTest* xLBT ) +{ + int nCount = 0; + try + { + try + { + try + { + xLBT->raiseException( + 5, Constants::STRING_TEST_CONSTANT, xLBT->Interface ); + } + catch (unoidl::com::sun::star::lang::IllegalArgumentException* aExc) + { + if (aExc->ArgumentPosition == 5 && + aExc->Context == xLBT->Interface) + { + ++nCount; + } + else + { + check( false, "### unexpected exception content!" ); + } + + /** it is certain, that the RuntimeException testing will fail, + if no */ + xLBT->RuntimeException = 0; + } + } + catch (unoidl::com::sun::star::uno::RuntimeException* rExc) + { + if (rExc->Context == xLBT->Interface ) + { + ++nCount; + } + else + { + check( false, "### unexpected exception content!" ); + } + + /** it is certain, that the RuntimeException testing will fail, if no */ + xLBT->RuntimeException = (int) 0xcafebabe; + } + } + catch (unoidl::com::sun::star::uno::Exception* rExc) + { + if (rExc->Context == xLBT->Interface) + { + ++nCount; + } + else + + { + check( false, "### unexpected exception content!" ); + } + return (nCount == 3); + } + return false; +} + + static private void perform_test( XBridgeTest* xLBT ) + { + bool bRet= true; + bRet = check( performTest( xLBT ), "standard test" ) && bRet; + bRet = check( raiseException( xLBT ) , "exception test" )&& bRet; + bRet = check( raiseOnewayException( xLBT ), "oneway exception test" ) && bRet; + bRet = check( testObjectMethodsImplementation(xLBT), "object methods test") && bRet; + bRet = performQueryForUnknownType( xLBT ) && bRet; + if (! bRet) + { + throw new unoidl::com::sun::star::uno::RuntimeException( + new String("error: test failed!"), 0); + } + } + XComponentContext* m_xContext; + + public: + explicit BridgeTest( XComponentContext* xContext ) + { + m_xContext = xContext; + } + + + int run( String* args[] ) + { + try + { + if (args->Length < 1) + { + throw new RuntimeException( + "missing argument for bridgetest!", this ); + } + Object* test_obj = + m_xContext->getServiceManager()->createInstanceWithContext( + args[ 0 ], m_xContext ); + if (test_obj == 0) + test_obj = m_xContext->getValueByName( args[ 0 ] ).Value; + + Console::WriteLine( + "cli target bridgetest obj: {0}", test_obj->ToString() ); + XBridgeTest* xTest = __try_cast<XBridgeTest*>(test_obj) ; + perform_test( xTest ); + Console::WriteLine( "\n### cli_uno C++ bridgetest succeeded." ); + return 0; + } + catch (unoidl::com::sun::star::uno::RuntimeException* ) + { + throw; + } + catch (System::Exception* exc) + { + System::Text::StringBuilder* s = new System::Text::StringBuilder(); + s->Append(S"cli_cpp_bridgetest: unexpected exception occurred in XMain::run. Original exception: "); + s->Append(exc->GetType()->Name); + s->Append(S"\n Message: "); + s->Append(exc->Message); + throw new unoidl::com::sun::star::uno::RuntimeException( + s->ToString(), 0); + } + } +}; + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |