horok/libreoffice
1
0
Fork 0
Code Activity
libreoffice/testtools/source/bridgetest/cli/cli_cpp_bridgetest.cxx
Daniel Baumann 8e63e14cf6
Adding upstream version 4:25.2.3. 
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
2025-06-22 16:20:04 +02:00

928 lines
33 KiB
C++
Raw Permalink Blame History

/* -*- 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.03125f, 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.03125f, 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.03125f, 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.03125f, 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: */
View git blame Copy permalink