/**************************************************************
 * 
 * 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);
        }
    }
};

}