| /************************************************************** |
| * |
| * 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 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_testtools.hxx" |
| |
| #using <mscorlib.dll> |
| #using <System.dll> |
| #using <cli_basetypes.dll> |
| #using <cli_uretypes.dll> |
| #using <cli_ure.dll> |
| #using <cli_types_bridgetest.dll> |
| |
| 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::com::sun::star::test::bridge; |
| 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 if (t1->IsValueType) |
| { |
| //Any, enum, int, bool char, float, double etc. |
| ret = val1->Equals(val2); |
| } |
| else |
| { |
| Debug::Assert(false); |
| } |
| 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->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->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, |
| 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->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, |
| Object* xTest, |
| Any rAny, |
| TestElement* rSequence[]) |
| { |
| assign( static_cast<TestElement*>(rData), |
| bBool, cChar, nByte, nShort, nUShort, nLong, nULong, nHyper, nUHyper, fFloat, fDouble, |
| eEnum, rStr, 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(__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, 3.1415926359, 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->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, |
| 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->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->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->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->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->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->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->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(); |
| |
| //TestEnum arEnum[] = new TestEnum[3]; |
| //arEnum[0] = TestEnum::ONE; arEnum[1] = TestEnum::TWO; |
| //arEnum[2] = TestEnum::CHECK; |
| 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, 3.1415926359, |
| TestEnum::LOLA, Constants::STRING_TEST_CONSTANT, arObject[0], |
| Any( __typeof(Object), arObject[0]) ); |
| assign( arStruct[1], true, 'A', 17, 0x1234, 0xfedc, 0x12345678, 0xfedcba98, |
| 0x123456789abcdef0, 0xfedcba9876543210, 17.0815f, 3.1415926359, |
| TestEnum::TWO, Constants::STRING_TEST_CONSTANT, arObject[1], |
| Any( __typeof(Object), arObject[1]) ); |
| assign( arStruct[2], true, 'B', 17, 0x1234, 0xfedc, 0x12345678, 0xfedcba98, |
| 0x123456789abcdef0, 0xfedcba9876543210, 17.0815f, 3.1415926359, |
| TestEnum::CHECK, Constants::STRING_TEST_CONSTANT, arObject[2], |
| Any( __typeof(Object), arObject[2] ) ); |
| |
| |
| // int[][][] arLong3 = new int[][][]{ |
| // new int[][]{new int[]{1,2,3},new int[]{4,5,6}, new int[]{7,8,9} }, |
| // new int [][]{new int[]{1,2,3},new int[]{4,5,6}, new int[]{7,8,9}}, |
| // new int[][]{new int[]{1,2,3},new int[]{4,5,6}, new int[]{7,8,9}}}; |
| |
| { |
| |
| // Console::WriteLine(new String("cli_cpp_bridgetest: |
| // int[][] seqSeqRet = xBT2->setDim2(arLong3[0]); |
| // bRet = check( compareData(seqSeqRet, arLong3[0]), "sequence test") && bRet; |
| // int[][][] seqSeqRet2 = xBT2->setDim3(arLong3); |
| // bRet = check( compareData(seqSeqRet2, arLong3), "sequence test") && bRet; |
| |
| 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>)")); |
| // bRet = check( compareData(seqEnumRet, arEnum), "sequence test") && bRet; |
| 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; |
| } |
| { |
| // Boolean arBoolTemp[] = static_cast<Boolean[]>( arBool->Clone()); |
| // Char arCharTemp[] = static_cast<Char[]>(arChar->Clone()); |
| // Byte arByteTemp[] = static_cast<Byte[]>(arByte->Clone()); |
| // Int16 arShortTemp[] = static_cast<Int16[]>(arShort->Clone()); |
| // UInt16 arUShortTemp[] = static_cast<UInt16[]>(arUShort->Clone()); |
| // Int32 arLongTemp[] = static_cast<Int32[]>(arLong->Clone()); |
| // UInt32 arULongTemp[] = static_cast<UInt32[]>(arULong->Clone()); |
| // Int64 arHyperTemp[] = static_cast<Int64[]>(arHyper->Clone()); |
| // UInt64 arUHyperTemp[] = static_cast<UInt64[]>(arUHyper->Clone()); |
| // Single arFloatTemp[] = static_cast<Single[]>(arFloat->Clone()); |
| // Double arDoubleTemp[] = static_cast<Double[]>(arDouble->Clone()); |
| // TestEnum arEnumTemp[] = static_cast<TestEnum[]>(arEnum->Clone()); |
| // String* arStringTemp[] = static_cast<String*[]>(arString->Clone()); |
| // Object* arObjectTemp = static_cast<Object*[]>(arObject->Clone()); |
| // Any arAnyTemp[] = static_cast<Any[]>(arAny->Clone()); |
| // // make sure this are has the same contents as arLong3[0] |
| // int[][] arLong2Temp = new int[][]{new int[]{1,2,3},new int[]{4,5,6}, new int[]{7,8,9} }; |
| // // make sure this are has the same contents as arLong3 |
| // int[][][] arLong3Temp = new int[][][]{ |
| // new int[][]{new int[]{1,2,3},new int[]{4,5,6}, new int[]{7,8,9} }, |
| // new int [][]{new int[]{1,2,3},new int[]{4,5,6}, new int[]{7,8,9}}, |
| // new int[][]{new int[]{1,2,3},new int[]{4,5,6}, new int[]{7,8,9}}}; |
| Console::WriteLine(new String("cli_cpp_bridgetest: no test of " |
| "XBridgeTest2::setSequencesInOut and XBridgeTest2.setSequencesOut " |
| "because jagged arrays are not supported by C++ compiler")); |
| // xBT2->setSequencesInOut(& arBoolTemp, & arCharTemp, & arByteTemp, |
| // & arShortTemp, & arUShortTemp, & arLongTemp, |
| // & arULongTemp,& arHyperTemp, & arUHyperTemp, |
| // & arFloatTemp,& arDoubleTemp, & arEnumTemp, |
| // & arStringTemp, & arObjectTemp, |
| // & arAnyTemp, & arLong2Temp, & arLong3Temp); |
| // bRet = check( |
| // compareData(arBoolTemp, arBool) && |
| // compareData(arCharTemp , arChar) && |
| // compareData(arByteTemp , arByte) && |
| // compareData(arShortTemp , arShort) && |
| // compareData(arUShortTemp , arUShort) && |
| // compareData(arLongTemp , arLong) && |
| // compareData(arULongTemp , arULong) && |
| // compareData(arHyperTemp , arHyper) && |
| // compareData(arUHyperTemp , arUHyper) && |
| // compareData(arFloatTemp , arFloat) && |
| // compareData(arDoubleTemp , arDouble) && |
| // compareData(arEnumTemp , arEnum) && |
| // compareData(arStringTemp , arString) && |
| // compareData(arObjectTemp , arObject) && |
| // compareData(arAnyTemp , arAny) && |
| // compareData(arLong2Temp , arLong3[0]) && |
| // compareData(arLong3Temp , arLong3), "sequence test") && bRet; |
| |
| //Boolean arBoolOut[]; |
| //Char arCharOut[]; |
| //Byte arByteOut[]; |
| //Int16 arShortOut[]; |
| //UInt16 arUShortOut[]; |
| //Int32 arLongOut[]; |
| //UInt32 arULongOut[]; |
| //Int64 arHyperOut[]; |
| //UInt64 arUHyperOut[]; |
| //Single arFloatOut[]; |
| //Double arDoubleOut[]; |
| //TestEnum arEnumOut[]; |
| //String* arStringOut[]; |
| //Object* arObjectOut[]; |
| //Any arAnyOut[]; |
| // int[][] arLong2Out; |
| // int[][][] arLong3Out; |
| |
| // xBT2->setSequencesOut(out arBoolOut, out arCharOut, out arByteOut, |
| // out arShortOut, out arUShortOut, out arLongOut, |
| // out arULongOut, out arHyperOut, out arUHyperOut, |
| // out arFloatOut, out arDoubleOut, out arEnumOut, |
| // out arStringOut, out arObjectOut, out arAnyOut, |
| // out arLong2Out, out arLong3Out); |
| // bRet = check( |
| // compareData(arBoolOut, arBool) && |
| // compareData(arCharOut, arChar) && |
| // compareData(arByteOut, arByte) && |
| // compareData(arShortOut, arShort) && |
| // compareData(arUShortOut, arUShort) && |
| // compareData(arLongOut, arLong) && |
| // compareData(arULongOut, arULong) && |
| // compareData(arHyperOut, arHyper) && |
| // compareData(arUHyperOut, arUHyper) && |
| // compareData(arFloatOut, arFloat) && |
| // compareData(arDoubleOut, arDouble) && |
| // compareData(arEnumOut, arEnum) && |
| // compareData(arStringOut, arString) && |
| // compareData(arObjectOut, arObject) && |
| // compareData(arAnyOut, arAny) && |
| // compareData(arLong2Out, arLong3[0]) && |
| // compareData(arLong3Out, arLong3), "sequence test") && bRet; |
| } |
| { |
| //test with empty sequences |
| // int[][] _arLong2 = new int[0][]; |
| // int[][] seqSeqRet = xBT2->setDim2(_arLong2); |
| // bRet = check( compareData(seqSeqRet, _arLong2), "sequence test") && bRet; |
| // int[][][] _arLong3 = new int[0][][]; |
| // int[][][] seqSeqRet2 = xBT2->setDim3(_arLong3); |
| // bRet = check( compareData(seqSeqRet2, _arLong3), "sequence test") && bRet; |
| 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); |
| // compiler bug: _arEnum has type System.Enum and not TestEnum |
| // bRet = check( compareData(seqEnumRet, _arEnum), "sequence test") && bRet; |
| 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 testObjectMethodsImplemention(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( testObjectMethodsImplemention(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: |
| 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 occured 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); |
| } |
| } |
| }; |
| |
| } |
