1100 lines
36 KiB
C#
1100 lines
36 KiB
C#
/*
|
|
* 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 System;
|
|
using System.Diagnostics;
|
|
using System.Reflection;
|
|
using uno;
|
|
using uno.util;
|
|
using unoidl.com.sun.star.uno;
|
|
using unoidl.com.sun.star.lang;
|
|
//using unoidl.com.sun.star.test.bridge;
|
|
using unoidl.test.testtools.bridgetest;
|
|
|
|
namespace foo
|
|
{
|
|
public interface MyInterface
|
|
{
|
|
}
|
|
}
|
|
|
|
namespace cs_testobj
|
|
{
|
|
class ORecursiveCall: WeakBase, XRecursiveCall
|
|
{
|
|
public void callRecursivly(XRecursiveCall xCall, int nToCall)
|
|
{
|
|
lock (this)
|
|
{
|
|
if (nToCall > 0)
|
|
{
|
|
nToCall --;
|
|
xCall.callRecursivly(this, nToCall);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
class Constants
|
|
{
|
|
public const string STRING_TEST_CONSTANT = "\" paco\' chorizo\\\' \"\'";
|
|
}
|
|
|
|
public class BridgeTest : WeakBase, XMain
|
|
{
|
|
static bool compareData(Object val1, Object val2)
|
|
{
|
|
if (val1 == null && val2 == null || val1 == val2)
|
|
return true;
|
|
if ((val1 == null && val2 != null) ||
|
|
(val1 != null && val2 == null) || val1.GetType() != val2.GetType())
|
|
return false;
|
|
|
|
bool ret = false;
|
|
Type t1 = val1.GetType();
|
|
//Sequence
|
|
if (t1.IsArray)
|
|
{
|
|
ret = compareSequence((Array) val1, (Array) val2);
|
|
}
|
|
//String
|
|
else if (t1 == typeof(string))
|
|
{
|
|
ret = (string) val1 == (string) 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 != null && ar2 != null);
|
|
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;
|
|
Type elemType = t1.GetElementType();
|
|
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 != null && val2 != null);
|
|
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(rData1.Any, 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(rData1.Any, rData2.Any));
|
|
}
|
|
|
|
static void assign( TestElement rData,
|
|
bool bBool, char cChar, byte nByte,
|
|
short nShort, ushort nUShort,
|
|
int nLong, uint nULong,
|
|
long nHyper, ulong nUHyper,
|
|
float fFloat, double fDouble,
|
|
TestEnum eEnum, string rStr,
|
|
byte nByte2, short nShort2,
|
|
Object xTest,
|
|
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,
|
|
short nShort, ushort nUShort,
|
|
int nLong, uint nULong,
|
|
long nHyper, ulong nUHyper,
|
|
float fFloat, double fDouble,
|
|
TestEnum eEnum, string rStr,
|
|
byte nByte2, short nShort2,
|
|
Object xTest,
|
|
Any rAny,
|
|
TestElement[] rSequence)
|
|
{
|
|
assign( (TestElement) rData,
|
|
bBool, cChar, nByte, nShort, nUShort, nLong, nULong, nHyper, nUHyper, fFloat, fDouble,
|
|
eEnum, rStr, nByte2, nShort2, xTest, rAny );
|
|
rData.Sequence = rSequence;
|
|
}
|
|
|
|
// template < class type >
|
|
static bool testAny(Type typ, Object value, XBridgeTest xLBT )
|
|
{
|
|
Any any;
|
|
if (typ == null)
|
|
any = new Any(value.GetType(), value);
|
|
else
|
|
any = new Any(typ, value);
|
|
|
|
Any any2 = xLBT.transportAny(any);
|
|
bool ret;
|
|
if( ! (ret= compareData(any, any2)))
|
|
{
|
|
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( null, data.Byte ,xLBT ) && bReturn;
|
|
bReturn = testAny( null, data.Short,xLBT ) && bReturn;
|
|
bReturn = testAny( null, data.UShort,xLBT ) && bReturn;
|
|
bReturn = testAny( null, data.Long,xLBT ) && bReturn;
|
|
bReturn = testAny( null, data.ULong,xLBT ) && bReturn;
|
|
bReturn = testAny( null, data.Hyper,xLBT ) && bReturn;
|
|
bReturn = testAny( null,data.UHyper,xLBT ) && bReturn;
|
|
bReturn = testAny( null, data.Float,xLBT ) && bReturn;
|
|
bReturn = testAny( null, data.Double,xLBT ) && bReturn;
|
|
bReturn = testAny( null, data.Enum,xLBT ) && bReturn;
|
|
bReturn = testAny( null, data.String,xLBT ) && bReturn;
|
|
bReturn = testAny( null, data.Byte2 ,xLBT ) && bReturn;
|
|
bReturn = testAny( null, data.Short2,xLBT ) && bReturn;
|
|
bReturn = testAny(typeof(XWeak), data.Interface,xLBT ) && bReturn;
|
|
bReturn = testAny(null, data, xLBT ) && bReturn;
|
|
|
|
{
|
|
Any a1= new Any(true);
|
|
Any a2 = xLBT.transportAny( a1 );
|
|
bReturn = compareData(a2, a1) && bReturn;
|
|
}
|
|
|
|
{
|
|
Any a1= new Any('A');
|
|
Any a2 = xLBT.transportAny(a1);
|
|
bReturn = compareData(a2, 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
|
|
{
|
|
foo.MyInterface a = (foo.MyInterface) xLBT;
|
|
}
|
|
catch( System.InvalidCastException)
|
|
{
|
|
bRet = true;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
bool performTest(XBridgeTest xLBT)
|
|
{
|
|
check( xLBT != null, "### no test interface!" );
|
|
bool bRet = true;
|
|
if (xLBT == null)
|
|
return false;
|
|
|
|
// 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 = new Any( typeof(Object), xI);
|
|
assign( (TestElement)aData,
|
|
true, '@', 17, 0x1234, 0xfedc, 0x12345678, 0xfedcba98,
|
|
0x123456789abcdef0, 0xfedcba9876543210,
|
|
17.03125f, 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.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= new Any(typeof(Object), xI);
|
|
assign( (TestElement)aSetData,
|
|
aData.Bool, aData.Char, aData.Byte, aData.Short, aData.UShort,
|
|
aData.Long, aData.ULong, aData.Hyper, aData.UHyper, aData.Float, aData.Double,
|
|
aData.Enum, aData.String, 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(
|
|
out aRet.Bool,
|
|
out aRet.Char,
|
|
out aRet.Byte,
|
|
out aRet.Short,
|
|
out aRet.UShort,
|
|
out aRet.Long,
|
|
out aRet.ULong,
|
|
out aRet.Hyper,
|
|
out aRet.UHyper,
|
|
out aRet.Float,
|
|
out aRet.Double,
|
|
out aRet.Enum,
|
|
out aRet.String,
|
|
out aRet.Byte2,
|
|
out aRet.Short2,
|
|
out aRet.Interface,
|
|
out aRet.Any,
|
|
out aRet.Sequence,
|
|
out aRet2 );
|
|
|
|
bRet = check( compareData( aData, aRet ) && compareData( aData, aRet2 ) , "getValues test") && bRet;
|
|
|
|
// set last retrieved values
|
|
TestDataElements aSV2ret = xLBT.setValues2(
|
|
ref aRet.Bool,
|
|
ref aRet.Char,
|
|
ref aRet.Byte,
|
|
ref aRet.Short,
|
|
ref aRet.UShort,
|
|
ref aRet.Long,
|
|
ref aRet.ULong,
|
|
ref aRet.Hyper,
|
|
ref aRet.UHyper,
|
|
ref aRet.Float,
|
|
ref aRet.Double,
|
|
ref aRet.Enum,
|
|
ref aRet.String,
|
|
ref aRet.Byte2,
|
|
ref aRet.Short2,
|
|
ref aRet.Interface,
|
|
ref aRet.Any,
|
|
ref aRet.Sequence,
|
|
ref 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(
|
|
out aRet.Bool,
|
|
out aRet.Char,
|
|
out aRet.Byte,
|
|
out aRet.Short,
|
|
out aRet.UShort,
|
|
out aRet.Long,
|
|
out aRet.ULong,
|
|
out aRet.Hyper,
|
|
out aRet.UHyper,
|
|
out aRet.Float,
|
|
out aRet.Double,
|
|
out aRet.Enum,
|
|
out aRet.String,
|
|
out aRet.Byte2,
|
|
out aRet.Short2,
|
|
out aRet.Interface,
|
|
out aRet.Any,
|
|
out aRet.Sequence,
|
|
out 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 = null;
|
|
aRet.Interface = xLBT.Interface;
|
|
bRet = (aRet.Interface == null) && bRet;
|
|
|
|
}
|
|
// Test extended attributes that raise exceptions:
|
|
try {
|
|
int i = xLBT.RaiseAttr1;
|
|
bRet &= check(false, "getRaiseAttr1 did not throw");
|
|
} catch (RuntimeException )
|
|
{
|
|
}
|
|
catch (System.Exception) {
|
|
bRet &= check(false, "getRaiseAttr1 threw wrong type");
|
|
}
|
|
try {
|
|
xLBT.RaiseAttr1 = 0;
|
|
bRet &= check(false, "setRaiseAttr1 did not throw");
|
|
} catch (IllegalArgumentException) {
|
|
} catch (System.Exception) {
|
|
bRet &= check(false, "setRaiseAttr1 threw wrong type");
|
|
}
|
|
try {
|
|
int i = xLBT.RaiseAttr2;
|
|
bRet &= check(false, "getRaiseAttr2 did not throw");
|
|
} catch (IllegalArgumentException ) {
|
|
} catch (System.Exception) {
|
|
bRet &= check(false, "getRaiseAttr2 threw wrong type");
|
|
}
|
|
|
|
// Test instantiated polymorphic struct types:
|
|
{
|
|
TestPolyStruct poly = new TestPolyStruct(true);
|
|
bRet &= check(
|
|
(bool) xLBT.transportPolyBoolean(poly).member,
|
|
"transportPolyBoolean");
|
|
poly = new TestPolyStruct(12345L);
|
|
xLBT.transportPolyHyper(ref poly);
|
|
bRet &= check((long)poly.member == 12345L, "transportPolyUnsignedHyper");
|
|
|
|
Any[] seq = { new Any(33), new Any("ABC")};
|
|
poly = new TestPolyStruct(seq);
|
|
TestPolyStruct poly2;
|
|
xLBT.transportPolySequence(poly, out poly2);
|
|
try {
|
|
Any[] ar = (Any[]) poly2.member;
|
|
bRet &= check(
|
|
ar.Length == 2, "transportPolySequence, length");
|
|
|
|
int v0;
|
|
v0 = (int) ar[0].Value;
|
|
bRet &= check(v0 == 33, "transportPolySequence, element 0");
|
|
|
|
string v1 = (string) ar[1].Value;
|
|
bRet &= check(
|
|
v1.Equals("ABC"),
|
|
"transportPolySequence, element 1");
|
|
} catch (InvalidCastException )
|
|
{
|
|
bRet &= check(false, "transportPolySequence");
|
|
}
|
|
|
|
try {
|
|
//When the test object is a cli object then them member is null
|
|
//otherwise the bridge has provided a default value.
|
|
TestPolyStruct s = xLBT.getNullPolyLong();
|
|
if (s.member != null)
|
|
bRet &= check(((int) s.member) == 0, "getNullPolyLong");
|
|
|
|
s = xLBT.getNullPolyString();
|
|
if (s.member != null)
|
|
bRet &= check(((string) s.member).Length == 0,
|
|
"getNullPolyString");
|
|
s = xLBT.getNullPolyType();
|
|
if (s.member != null)
|
|
bRet &= check(((Type) s.member) == typeof(void),
|
|
"getNullPolyType");
|
|
s = xLBT.getNullPolyAny();
|
|
if (s.member != null)
|
|
{
|
|
Any nullAny = (Any) s.member;
|
|
//???
|
|
bRet &= check(nullAny.Type == typeof(void),
|
|
"getNullPolyAny");
|
|
}
|
|
s = xLBT.getNullPolySequence();
|
|
if (s.member != null)
|
|
bRet &= check(((bool[]) s.member).Length == 0,
|
|
"getNullPolySequence");
|
|
s = xLBT.getNullPolyEnum();
|
|
if (s.member != null)
|
|
bRet &= check(((TestEnum) s.member) == TestEnum.TEST,
|
|
"getNullPolyEnum");
|
|
s = xLBT.getNullPolyStruct();
|
|
if (s.member != null)
|
|
bRet &= check(((TestStruct) s.member).member == 0,
|
|
"getNullPolyStruct");
|
|
s = xLBT.getNullPolyInterface();
|
|
bRet &= check(s.member == null, "getNullPolyInterface");
|
|
|
|
s = xLBT.getNullPolyBadEnum();
|
|
bRet &= check(((TestBadEnum)s.member) == TestBadEnum.M, "getNullPolyBadEnum");
|
|
|
|
} catch(InvalidCastException)
|
|
{
|
|
bRet &= check(false, "getNullPolyXXX, InvalidCastException");
|
|
}
|
|
|
|
}
|
|
|
|
XBridgeTest2 xBT2 = xLBT as XBridgeTest2;
|
|
if (xBT2 != null) {
|
|
try {
|
|
xBT2.testConstructorsService(m_xContext);
|
|
} catch (BadConstructorArguments) {
|
|
bRet = false;
|
|
}
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
static bool performSequenceTest(XBridgeTest xBT)
|
|
{
|
|
bool bRet = true;
|
|
XBridgeTest2 xBT2 = xBT as XBridgeTest2;
|
|
if ( xBT2 == null)
|
|
return false;
|
|
|
|
// perform sequence tests (XBridgeTest2)
|
|
// create the sequence which are compared with the results
|
|
bool[] arBool = {true, false, true};
|
|
char[] arChar = {'A','B','C'};
|
|
byte[] arByte = { 1, 2, 0xff};
|
|
short[] arShort = {Int16.MinValue, 1, Int16.MaxValue};
|
|
UInt16[] arUShort = {UInt16.MinValue , 1, UInt16.MaxValue};
|
|
int[] arLong = {Int32.MinValue, 1, Int32.MaxValue};
|
|
UInt32[] arULong = {UInt32.MinValue, 1, UInt32.MaxValue};
|
|
long[] arHyper = {Int64.MinValue, 1, Int64.MaxValue};
|
|
UInt64[] arUHyper = {UInt64.MinValue, 1, UInt64.MaxValue};
|
|
float[] arFloat = {1.1f, 2.2f, 3.3f};
|
|
double[] arDouble = {1.11, 2.22, 3.33};
|
|
string[] arString = {"String 1", "String 2", "String 3"};
|
|
|
|
Any[] arAny = {new Any(true), new Any(11111), new Any(3.14)};
|
|
Object[] arObject = {new WeakBase(), new WeakBase(), new WeakBase()};
|
|
TestEnum[] arEnum = {TestEnum.ONE, TestEnum.TWO, TestEnum.CHECK};
|
|
|
|
TestElement[] arStruct = {new TestElement(), new TestElement(),
|
|
new TestElement()};
|
|
assign( arStruct[0], true, '@', 17, 0x1234, 0xfedc, 0x12345678, 0xfedcba98,
|
|
0x123456789abcdef0, 0xfedcba9876543210, 17.03125f, 3.1415926359,
|
|
TestEnum.LOLA, Constants.STRING_TEST_CONSTANT, arObject[0],
|
|
new Any( typeof(Object), arObject[0]) );
|
|
assign( arStruct[1], true, 'A', 17, 0x1234, 0xfedc, 0x12345678, 0xfedcba98,
|
|
0x123456789abcdef0, 0xfedcba9876543210, 17.03125f, 3.1415926359,
|
|
TestEnum.TWO, Constants.STRING_TEST_CONSTANT, arObject[1],
|
|
new Any( typeof(Object), arObject[1]) );
|
|
assign( arStruct[2], true, 'B', 17, 0x1234, 0xfedc, 0x12345678, 0xfedcba98,
|
|
0x123456789abcdef0, 0xfedcba9876543210, 17.03125f, 3.1415926359,
|
|
TestEnum.CHECK, Constants.STRING_TEST_CONSTANT, arObject[2],
|
|
new 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}}};
|
|
|
|
{
|
|
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;
|
|
bool[] 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;
|
|
short[] seqShortRet = xBT2.setSequenceShort(arShort);
|
|
bRet = check( compareData(seqShortRet, arShort), "sequence test") && bRet;
|
|
int[] seqLongRet = xBT2.setSequenceLong(arLong);
|
|
bRet = check( compareData(seqLongRet, arLong), "sequence test") && bRet;
|
|
long[] seqHyperRet = xBT2.setSequenceHyper(arHyper);
|
|
bRet = check( compareData(seqHyperRet,arHyper), "sequence test") && bRet;
|
|
float[] 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;
|
|
TestEnum[] seqEnumRet = xBT2.setSequenceEnum(arEnum);
|
|
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;
|
|
}
|
|
{
|
|
bool[] arBoolTemp = (bool[]) arBool.Clone();
|
|
char[] arCharTemp = (char[]) arChar.Clone();
|
|
byte[] arByteTemp = (byte[]) arByte.Clone();
|
|
short[] arShortTemp = (short[]) arShort.Clone();
|
|
UInt16[] arUShortTemp = (UInt16[]) arUShort.Clone();
|
|
int[] arLongTemp = (int[]) arLong.Clone();
|
|
UInt32[] arULongTemp = (UInt32[]) arULong.Clone();
|
|
long[] arHyperTemp = (long[]) arHyper.Clone();
|
|
UInt64[] arUHyperTemp = (UInt64[]) arUHyper.Clone();
|
|
float[] arFloatTemp = (float[]) arFloat.Clone();
|
|
double[] arDoubleTemp = (double[]) arDouble.Clone();
|
|
TestEnum[] arEnumTemp = (TestEnum[]) arEnum.Clone();
|
|
string[] arStringTemp = (string[]) arString.Clone();
|
|
Object[] arObjectTemp = (Object[]) arObject.Clone();
|
|
Any[] arAnyTemp = (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}}};
|
|
|
|
xBT2.setSequencesInOut(ref arBoolTemp, ref arCharTemp, ref arByteTemp,
|
|
ref arShortTemp, ref arUShortTemp, ref arLongTemp,
|
|
ref arULongTemp,ref arHyperTemp, ref arUHyperTemp,
|
|
ref arFloatTemp,ref arDoubleTemp, ref arEnumTemp,
|
|
ref arStringTemp, ref arObjectTemp,
|
|
ref arAnyTemp, ref arLong2Temp, ref 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;
|
|
|
|
bool[] arBoolOut;
|
|
char[] arCharOut;
|
|
byte[] arByteOut;
|
|
short[] arShortOut;
|
|
UInt16[] arUShortOut;
|
|
int[] arLongOut;
|
|
UInt32[] arULongOut;
|
|
long[] arHyperOut;
|
|
UInt64[] arUHyperOut;
|
|
float[] 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;
|
|
bool[] _arBool = new bool[0];
|
|
bool[] 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;
|
|
short[] _arShort = new short[0];
|
|
short[] seqShortRet = xBT2.setSequenceShort(_arShort);
|
|
bRet = check( compareData(seqShortRet, _arShort), "sequence test") && bRet;
|
|
int[] _arLong = new int[0];
|
|
int[] seqLongRet = xBT2.setSequenceLong(_arLong);
|
|
bRet = check( compareData(seqLongRet, _arLong), "sequence test") && bRet;
|
|
long[] _arHyper = new long[0];
|
|
long[] seqHyperRet = xBT2.setSequenceHyper(_arHyper);
|
|
bRet = check( compareData(seqHyperRet, _arHyper), "sequence test") && bRet;
|
|
float[] _arFloat = new float[0];
|
|
float[] 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];
|
|
TestEnum[] seqEnumRet = xBT2.setSequenceEnum(_arEnum);
|
|
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 testObjectMethodsImplementetion(XBridgeTest xLBT)
|
|
{
|
|
bool ret = false;
|
|
Object obj = new Object();
|
|
Object xInt = (Object) xLBT;
|
|
XBridgeTestBase xBase = xLBT as XBridgeTestBase;
|
|
if (xBase == null)
|
|
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
|
|
{
|
|
TestDataElements aRet = new TestDataElements();
|
|
TestDataElements aRet2 = new TestDataElements();
|
|
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 */
|
|
unchecked
|
|
{
|
|
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;
|
|
}
|
|
|
|
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( testObjectMethodsImplementetion(xLBT), "object methods test") && bRet;
|
|
bRet = performQueryForUnknownType( xLBT ) && bRet;
|
|
if ( ! bRet)
|
|
{
|
|
throw new unoidl.com.sun.star.uno.RuntimeException( "error (cli_cs_bridgetest.cs): test failed!", null);
|
|
}
|
|
}
|
|
|
|
public BridgeTest( XComponentContext xContext )
|
|
{
|
|
m_xContext = xContext;
|
|
}
|
|
|
|
private XComponentContext m_xContext;
|
|
|
|
public int run( String [] args )
|
|
{
|
|
Debug.AutoFlush = true;
|
|
// System.Diagnostics.Debugger.Launch();
|
|
try
|
|
{
|
|
if (args.Length < 1)
|
|
{
|
|
throw new RuntimeException(
|
|
"missing argument for bridgetest!", this );
|
|
}
|
|
Object test_obj =
|
|
m_xContext.getServiceManager().createInstanceWithContext(
|
|
args[ 0 ], m_xContext );
|
|
|
|
Debug.WriteLine(
|
|
"Calling object: {0}", test_obj.ToString() );
|
|
|
|
XBridgeTest xTest = (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)
|
|
{
|
|
throw new unoidl.com.sun.star.uno.RuntimeException(
|
|
"cli_cs_bridgetest.cs: unexpected exception occurred in XMain::run. Original exception: " +
|
|
exc.GetType().Name + "\n Message: " + exc.Message , null);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|