testtools/source/bridgetest/cli/cli_cpp_bridgetest.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: cli_cpp_bridgetest.cxx,v $
  10  * $Revision: 1.11 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28 =======
  29  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  30  *
  31  * Copyright 2008 by Sun Microsystems, Inc.
  32  *
  33  * OpenOffice.org - a multi-platform office productivity suite
  34  *
  35  * $RCSfile: cli_cpp_bridgetest.cxx,v $
  36  * $Revision: 1.11 $
  37  *
  38  * This file is part of OpenOffice.org.
  39  *
  40  * OpenOffice.org is free software: you can redistribute it and/or modify
  41  * it under the terms of the GNU Lesser General Public License version 3
  42  * only, as published by the Free Software Foundation.
  43  *
  44  * OpenOffice.org is distributed in the hope that it will be useful,
  45  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  46  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  47  * GNU Lesser General Public License version 3 for more details
  48  * (a copy is included in the LICENSE file that accompanied this code).
  49  *
  50  * You should have received a copy of the GNU Lesser General Public License
  51  * version 3 along with OpenOffice.org.  If not, see
  52  * <http://www.openoffice.org/license.html>
  53  * for a copy of the LGPLv3 License.
  54 >>>>>>> 1.8.58.2
  55  *
  56  ************************************************************************/
  57
  58 // MARKER(update_precomp.py): autogen include statement, do not remove
  59 #include "precompiled_testtools.hxx"
  60
  61 #using <mscorlib.dll>
  62 #using <System.dll>
  63 #using <cli_basetypes.dll>
  64 #using <cli_uretypes.dll>
  65 #using <cli_ure.dll>
  66 #using <cli_types_bridgetest.dll>
  67
  68 using namespace System;
  69 using namespace System::Diagnostics;
  70 using namespace System::Reflection;
  71 using namespace System::Threading;
  72 using namespace uno;
  73 using namespace uno::util;
  74 using namespace unoidl::com::sun::star::uno;
  75 using namespace unoidl::com::sun::star::lang;
  76 //using namespace unoidl::com::sun::star::test::bridge;
  77 using namespace unoidl::test::testtools::bridgetest;
  78 namespace foo
  79 {
  80     public __gc  __interface MyInterface
  81     {
  82     };
  83 }
  84
  85 namespace cpp_bridgetest
  86 {
  87     __gc class ORecursiveCall: public WeakBase, public XRecursiveCall
  88     {
  89         public:
  90         void  callRecursivly(XRecursiveCall * xCall, int nToCall)
  91         {
  92             Monitor::Enter(this);
  93             try
  94             {
  95                 {
  96                     if (nToCall > 0)
  97                     {
  98                         nToCall --;
  99                         xCall->callRecursivly(this, nToCall);
 100                     }
 101                 }
 102             }
 103             __finally
 104             {
 105                 Monitor::Exit(this);
 106             }
 107
 108         }
 109     };
 110
 111 public __gc class Constants
 112 {
 113 public:
 114     static String* STRING_TEST_CONSTANT  = new String(S"\" paco\' chorizo\\\' \"\'");
 115 };
 116
 117 public __gc class BridgeTest : public WeakBase, public XMain
 118 {
 119     static bool compareData(Object* val1, Object* val2)
 120     {
 121         if (val1 == 0 && val2 == 0 || val1 == val2)
 122             return true;
 123         if ((val1 == 0 && val2 != 0) ||
 124             (val1 != 0 && val2 == 0) || val1->GetType() != val2->GetType())
 125             return false;
 126
 127         bool ret = false;
 128         Type* t1  = val1->GetType();
 129             //Sequence
 130         if (t1->IsArray)
 131         {
 132             ret = compareSequence(static_cast<Array*>(val1),
 133                                   static_cast<Array*>(val2));
 134         }
 135             //String
 136         else if (t1 == __typeof(String))
 137         {
 138             ret = val1->Equals(val2);
 139         }
 140             // Interface implementation
 141         else if (t1->GetInterfaces()->Length > 0 && ! t1->IsValueType)
 142         {
 143             ret = val1 == val2;
 144         }
 145             // Struct
 146         else if ( ! t1->IsValueType)
 147         {
 148             ret = compareStruct(val1, val2);
 149         }
 150         else if (t1 == __typeof(Any))
 151         {
 152             Any a1 = (Any) val1;
 153             Any a2 = (Any) val2;
 154             ret = a1.Type == a2.Type && compareData(a1.Value, a2.Value);
 155         }
 156         else if (t1->IsValueType)
 157         {
 158             //Any, enum, int, bool char, float, double etc.
 159             ret = val1->Equals(val2);
 160         }
 161         else
 162         {
 163             Debug::Assert(false);
 164         }
 165         return ret;
 166     }
 167
 168     // Arrays have only one dimension
 169     static bool compareSequence(Array* ar1, Array* ar2)
 170     {
 171         Debug::Assert(ar1 != 0 && ar2 != 0);
 172         Type* t1 = ar1->GetType();
 173         Type* t2 = ar2->GetType();
 174
 175         if (!(ar1->Rank == 1 && ar2->Rank == 1
 176             && ar1->Length == ar2->Length && t1->GetElementType() == t2->GetElementType()))
 177             return false;
 178
 179         //arrays have same rank and size and element type.
 180         int len  = ar1->Length;
 181         bool ret = true;
 182         for (int i = 0; i < len; i++)
 183         {
 184             if (compareData(ar1->GetValue(i), ar2->GetValue(i)) == false)
 185             {
 186                 ret = false;
 187                 break;
 188             }
 189         }
 190         return ret;
 191     }
 192
 193     static bool compareStruct(Object* val1, Object* val2)
 194     {
 195         Debug::Assert(val1 != 0 && val2 != 0);
 196         Type* t1 = val1->GetType();
 197         Type* t2 = val2->GetType();
 198         if (t1 != t2)
 199             return false;
 200         FieldInfo* fields[] = t1->GetFields();
 201         int cFields = fields->Length;
 202         bool ret = true;
 203         for (int i = 0; i < cFields; i++)
 204         {
 205             Object* fieldVal1 = fields[i]->GetValue(val1);
 206             Object* fieldVal2 = fields[i]->GetValue(val2);
 207             if ( ! compareData(fieldVal1, fieldVal2))
 208             {
 209                 ret = false;
 210                 break;
 211             }
 212         }
 213         return ret;
 214     }
 215
 216     static bool check( bool b , String* message )
 217     {
 218         if ( ! b)
 219         Console::WriteLine("{0} failed\n" , message);
 220         return b;
 221     }
 222
 223     static bool equals(TestElement* rData1, TestElement*  rData2)
 224     {
 225         check( rData1->Bool == rData2->Bool, "### bool does not match!" );
 226         check( rData1->Char == rData2->Char, "### char does not match!" );
 227         check( rData1->Byte == rData2->Byte, "### byte does not match!" );
 228         check( rData1->Short == rData2->Short, "### short does not match!" );
 229         check( rData1->UShort == rData2->UShort, "### unsigned short does not match!" );
 230         check( rData1->Long == rData2->Long, "### long does not match!" );
 231         check( rData1->ULong == rData2->ULong, "### unsigned long does not match!" );
 232         check( rData1->Hyper == rData2->Hyper, "### hyper does not match!" );
 233         check( rData1->UHyper == rData2->UHyper, "### unsigned hyper does not match!" );
 234         check( rData1->Float == rData2->Float, "### float does not match!" );
 235         check( rData1->Double == rData2->Double, "### double does not match!" );
 236         check( rData1->Enum == rData2->Enum, "### enum does not match!" );
 237         check( rData1->String == rData2->String, "### string does not match!" );
 238         check( rData1->Interface == rData2->Interface, "### interface does not match!" );
 239         check( compareData(__box(rData1->Any), __box(rData2->Any)), "### any does not match!" );
 240
 241         return (rData1->Bool == rData2->Bool &&
 242                 rData1->Char == rData2->Char &&
 243                 rData1->Byte == rData2->Byte &&
 244                 rData1->Short == rData2->Short &&
 245                 rData1->UShort == rData2->UShort &&
 246                 rData1->Long == rData2->Long &&
 247                 rData1->ULong == rData2->ULong &&
 248                 rData1->Hyper == rData2->Hyper &&
 249                 rData1->UHyper == rData2->UHyper &&
 250                 rData1->Float == rData2->Float &&
 251                 rData1->Double == rData2->Double &&
 252                 rData1->Enum == rData2->Enum &&
 253                 rData1->String == rData2->String &&
 254                 rData1->Interface == rData2->Interface &&
 255                 compareData(__box(rData1->Any), __box(rData2->Any)));
 256     }
 257
 258 static void assign( TestElement* rData,
 259                     bool bBool, Char cChar, Byte nByte,
 260                     Int16 nShort, UInt16 nUShort,
 261                     Int32 nLong, UInt32 nULong,
 262                     Int64 nHyper, UInt64 nUHyper,
 263                     float fFloat, double fDouble,
 264                     TestEnum eEnum, String* rStr,
 265                     Object* xTest,
 266                     uno::Any rAny )
 267 {
 268     rData->Bool = bBool;
 269     rData->Char = cChar;
 270     rData->Byte = nByte;
 271     rData->Short = nShort;
 272     rData->UShort = nUShort;
 273     rData->Long = nLong;
 274     rData->ULong = nULong;
 275     rData->Hyper = nHyper;
 276     rData->UHyper = nUHyper;
 277     rData->Float = fFloat;
 278     rData->Double = fDouble;
 279     rData->Enum = eEnum;
 280     rData->String = rStr;
 281     rData->Interface = xTest;
 282     rData->Any = rAny;
 283 }
 284
 285 static void assign( TestDataElements* rData,
 286                     bool bBool, Char cChar, Byte nByte,
 287                     Int16 nShort, UInt16 nUShort,
 288                     Int32 nLong, UInt32 nULong,
 289                     Int64 nHyper, UInt64 nUHyper,
 290                     float fFloat, double fDouble,
 291                     TestEnum eEnum, String* rStr,
 292                     Object* xTest,
 293                     Any rAny,
 294                     TestElement* rSequence[])
 295 {
 296     assign( static_cast<TestElement*>(rData),
 297             bBool, cChar, nByte, nShort, nUShort, nLong, nULong, nHyper, nUHyper, fFloat, fDouble,
 298             eEnum, rStr, xTest, rAny );
 299     rData->Sequence = rSequence;
 300 }
 301
 302 static bool testAny(Type* typ, Object*  value, XBridgeTest* xLBT )
 303 {
 304     Any any;
 305     if (typ == 0)
 306         any = Any(value->GetType(), value);
 307     else
 308         any = Any(typ, value);
 309
 310     Any any2 = xLBT->transportAny(any);
 311     bool ret = compareData(__box(any), __box(any2));
 312     if (!ret)
 313     {
 314         Console::WriteLine("any is different after roundtrip: in {0}, out {1}\n",
 315                           any.Type->FullName, any2.Type->FullName);
 316     }
 317     return ret;
 318 }
 319
 320
 321
 322 static bool performAnyTest(XBridgeTest* xLBT,  TestDataElements* data)
 323 {
 324     bool bReturn = true;
 325     bReturn = testAny( 0, __box(data->Byte), xLBT ) && bReturn;
 326     bReturn = testAny( 0, __box(data->Short), xLBT ) && bReturn;
 327     bReturn = testAny(  0, __box(data->UShort), xLBT ) && bReturn;
 328     bReturn = testAny(  0, __box(data->Long), xLBT ) && bReturn;
 329     bReturn = testAny(  0, __box(data->ULong), xLBT ) && bReturn;
 330     bReturn = testAny(  0, __box(data->Hyper), xLBT ) && bReturn;
 331     bReturn = testAny(  0, __box(data->UHyper), xLBT ) && bReturn;
 332     bReturn = testAny( 0, __box(data->Float), xLBT ) && bReturn;
 333     bReturn = testAny( 0, __box(data->Double),xLBT ) && bReturn;
 334     bReturn = testAny( 0, __box(data->Enum), xLBT ) && bReturn;
 335     bReturn = testAny( 0, data->String,xLBT ) && bReturn;
 336     bReturn = testAny(__typeof(XWeak), data->Interface,xLBT ) && bReturn;
 337     bReturn = testAny(0, data, xLBT ) && bReturn;
 338
 339     {
 340         Any a1(true);
 341         Any a2 = xLBT->transportAny( a1 );
 342         bReturn = compareData(__box(a2), __box(a1)) && bReturn;
 343     }
 344
 345     {
 346         Any a1('A');
 347         Any a2 = xLBT->transportAny(a1);
 348         bReturn = compareData( __box(a2), __box(a1)) && bReturn;
 349     }
 350     return bReturn;
 351 }
 352
 353 static bool performSequenceOfCallTest(XBridgeTest* xLBT)
 354 {
 355     int i,nRounds;
 356     int nGlobalIndex = 0;
 357     const int nWaitTimeSpanMUSec = 10000;
 358     for( nRounds = 0 ; nRounds < 10 ; nRounds ++ )
 359     {
 360         for( i = 0 ; i < nRounds ; i ++ )
 361         {
 362             // fire oneways
 363             xLBT->callOneway(nGlobalIndex, nWaitTimeSpanMUSec);
 364             nGlobalIndex++;
 365         }
 366
 367         // call synchron
 368         xLBT->call(nGlobalIndex, nWaitTimeSpanMUSec);
 369         nGlobalIndex++;
 370     }
 371      return xLBT->sequenceOfCallTestPassed();
 372 }
 373
 374
 375
 376
 377 static bool performRecursiveCallTest(XBridgeTest*  xLBT)
 378 {
 379     xLBT->startRecursiveCall(new ORecursiveCall(), 50);
 380     // on failure, the test would lock up or crash
 381     return true;
 382 }
 383
 384 static bool performQueryForUnknownType(XBridgeTest* xLBT)
 385 {
 386     bool bRet = false;
 387     // test queryInterface for an unknown type
 388     try
 389     {
 390         __try_cast<foo::MyInterface*>(xLBT);
 391     }
 392     catch( System::InvalidCastException*)
 393     {
 394         bRet = true;
 395     }
 396
 397     return bRet;
 398 }
 399
 400 // //==================================================================================================
 401 static bool performTest(XBridgeTest* xLBT)
 402 {
 403     check( xLBT != 0, "### no test interface!" );
 404     bool bRet = true;
 405     if (xLBT != 0)
 406     {
 407         // this data is never ever granted access to by calls other than equals(), assign()!
 408         TestDataElements* aData = new TestDataElements(); // test against this data
 409
 410         Object* xI= new WeakBase();
 411
 412         Any aAny( __typeof(Object), xI);
 413         assign( static_cast<TestElement*>(aData),
 414                 true, '@', 17, 0x1234, 0xfedc, 0x12345678, 0xfedcba98,
 415                 0x123456789abcdef0, 0xfedcba9876543210,
 416                 17.0815f, 3.1415926359, TestEnum::LOLA,
 417                 Constants::STRING_TEST_CONSTANT, xI,
 418                 aAny);
 419
 420         bRet = check( aData->Any.Value == xI, "### unexpected any!" ) && bRet;
 421         bRet = check( !(aData->Any.Value != xI), "### unexpected any!" ) && bRet;
 422
 423         aData->Sequence = new TestElement*[2];
 424         aData->Sequence[0] = new TestElement(
 425             aData->Bool, aData->Char, aData->Byte, aData->Short,
 426             aData->UShort, aData->Long, aData->ULong,
 427             aData->Hyper, aData->UHyper, aData->Float,
 428             aData->Double, aData->Enum, aData->String,
 429             aData->Interface, aData->Any); //(TestElement) aData;
 430         aData->Sequence[1] = new TestElement(); //is empty
 431
 432         // aData complete
 433         //
 434         // this is a manually copy of aData for first setting...
 435         TestDataElements* aSetData = new TestDataElements;
 436         Any aAnySet(__typeof(Object), xI);
 437         assign( static_cast<TestElement*>(aSetData),
 438                 aData->Bool,
 439                 aData->Char,
 440                 aData->Byte,
 441                 aData->Short,
 442                 aData->UShort,
 443                 aData->Long, aData->ULong, aData->Hyper, aData->UHyper, aData->Float, aData->Double,
 444                 aData->Enum,
 445                 aData->String,
 446                 xI,
 447                 aAnySet);
 448
 449         aSetData->Sequence = new TestElement*[2];
 450         aSetData->Sequence[0] = new TestElement(
 451             aSetData->Bool, aSetData->Char, aSetData->Byte, aSetData->Short,
 452             aSetData->UShort, aSetData->Long, aSetData->ULong,
 453             aSetData->Hyper, aSetData->UHyper, aSetData->Float,
 454             aSetData->Double, aSetData->Enum, aSetData->String,
 455             aSetData->Interface, aSetData->Any); //TestElement) aSetData;
 456         aSetData->Sequence[1] = new TestElement(); // empty struct
 457
 458         xLBT->setValues(
 459                 aSetData->Bool, aSetData->Char, aSetData->Byte, aSetData->Short, aSetData->UShort,
 460                 aSetData->Long, aSetData->ULong, aSetData->Hyper, aSetData->UHyper, aSetData->Float, aSetData->Double,
 461                 aSetData->Enum, aSetData->String, aSetData->Interface, aSetData->Any, aSetData->Sequence, aSetData );
 462
 463         {
 464         TestDataElements* aRet = new TestDataElements();
 465         TestDataElements* aRet2 = new TestDataElements();
 466         xLBT->getValues(
 467             & aRet->Bool, & aRet->Char, & aRet->Byte, & aRet->Short, & aRet->UShort,
 468             & aRet->Long, & aRet->ULong, & aRet->Hyper, & aRet->UHyper,
 469             & aRet->Float, & aRet->Double, & aRet->Enum, & aRet->String,
 470             & aRet->Interface, & aRet->Any, & aRet->Sequence, & aRet2 );
 471
 472         bRet = check( compareData( aData, aRet ) && compareData( aData, aRet2 ) , "getValues test") && bRet;
 473
 474         // set last retrieved values
 475         TestDataElements* aSV2ret = xLBT->setValues2(
 476             & aRet->Bool, & aRet->Char, & aRet->Byte, & aRet->Short, & aRet->UShort,
 477             & aRet->Long, & aRet->ULong, & aRet->Hyper, & aRet->UHyper, & aRet->Float,
 478             & aRet->Double, & aRet->Enum, & aRet->String, & aRet->Interface, & aRet->Any,
 479             & aRet->Sequence, & aRet2 );
 480
 481         // check inout sequence order
 482         // => inout sequence parameter was switched by test objects
 483         TestElement* temp = aRet->Sequence[ 0 ];
 484         aRet->Sequence[ 0 ] = aRet->Sequence[ 1 ];
 485         aRet->Sequence[ 1 ] = temp;
 486
 487         bRet = check(
 488             compareData( aData, aSV2ret ) && compareData( aData, aRet2 ),
 489             "getValues2 test") && bRet;
 490         }
 491         {
 492         TestDataElements* aRet = new TestDataElements();
 493         TestDataElements* aRet2 = new TestDataElements();
 494         TestDataElements* aGVret = xLBT->getValues(
 495             & aRet->Bool, & aRet->Char, & aRet->Byte, & aRet->Short,
 496             & aRet->UShort, & aRet->Long, & aRet->ULong, & aRet->Hyper,
 497             & aRet->UHyper, & aRet->Float, & aRet->Double, & aRet->Enum,
 498             & aRet->String, & aRet->Interface, & aRet->Any, & aRet->Sequence,
 499             & aRet2 );
 500
 501         bRet = check( compareData( aData, aRet ) && compareData( aData, aRet2 ) && compareData( aData, aGVret ), "getValues test" ) && bRet;
 502
 503         // set last retrieved values
 504         xLBT->Bool = aRet->Bool;
 505         xLBT->Char = aRet->Char;
 506         xLBT->Byte = aRet->Byte;
 507         xLBT->Short = aRet->Short;
 508         xLBT->UShort = aRet->UShort;
 509         xLBT->Long = aRet->Long;
 510         xLBT->ULong = aRet->ULong;
 511         xLBT->Hyper = aRet->Hyper;
 512         xLBT->UHyper = aRet->UHyper;
 513         xLBT->Float = aRet->Float;
 514         xLBT->Double = aRet->Double;
 515         xLBT->Enum = aRet->Enum;
 516         xLBT->String = aRet->String;
 517         xLBT->Interface = aRet->Interface;
 518         xLBT->Any = aRet->Any;
 519         xLBT->Sequence = aRet->Sequence;
 520         xLBT->Struct = aRet2;
 521         }
 522         {
 523         TestDataElements* aRet = new TestDataElements();
 524         TestDataElements* aRet2 = new TestDataElements();
 525         aRet->Hyper = xLBT->Hyper;
 526         aRet->UHyper = xLBT->UHyper;
 527         aRet->Float = xLBT->Float;
 528         aRet->Double = xLBT->Double;
 529         aRet->Byte = xLBT->Byte;
 530         aRet->Char = xLBT->Char;
 531         aRet->Bool = xLBT->Bool;
 532         aRet->Short = xLBT->Short;
 533         aRet->UShort = xLBT->UShort;
 534         aRet->Long = xLBT->Long;
 535         aRet->ULong = xLBT->ULong;
 536         aRet->Enum = xLBT->Enum;
 537         aRet->String = xLBT->String;
 538         aRet->Interface = xLBT->Interface;
 539         aRet->Any = xLBT->Any;
 540         aRet->Sequence = xLBT->Sequence;
 541         aRet2 = xLBT->Struct;
 542
 543         bRet = check( compareData( aData, aRet ) && compareData( aData, aRet2 ) , "struct comparison test") && bRet;
 544
 545         bRet = check(performSequenceTest(xLBT), "sequence test") && bRet;
 546
 547         // any test
 548         bRet = check( performAnyTest( xLBT , aData ) , "any test" ) && bRet;
 549
 550         // sequence of call test
 551         bRet = check( performSequenceOfCallTest( xLBT ) , "sequence of call test" ) && bRet;
 552
 553         // recursive call test
 554         bRet = check( performRecursiveCallTest( xLBT ) , "recursive test" ) && bRet;
 555
 556         bRet = (compareData( aData, aRet ) && compareData( aData, aRet2 )) && bRet ;
 557
 558         // check setting of null reference
 559         xLBT->Interface = 0;
 560         aRet->Interface = xLBT->Interface;
 561         bRet = (aRet->Interface == 0) && bRet;
 562
 563         }
 564
 565
 566     }
 567         return bRet;
 568  }
 569 static bool performSequenceTest(XBridgeTest* xBT)
 570 {
 571     bool bRet = true;
 572     XBridgeTest2*  xBT2 = dynamic_cast<XBridgeTest2*>(xBT);
 573     if ( xBT2 == 0)
 574         return false;
 575
 576     // perform sequence tests (XBridgeTest2)
 577     // create the sequence which are compared with the results
 578     bool arBool __gc[] = new bool __gc [3];
 579     arBool[0] = true; arBool[1] = false; arBool[2] = true;
 580     Char  arChar[] = new  Char[3];
 581     arChar[0] = 'A'; arChar[1] = 'B'; arChar[2] = 'C';
 582     Byte arByte[] = new Byte[3];
 583     arByte[0] =  1; arByte[1] = 2; arByte[2] = 0xff;
 584     Int16 arShort[] = new Int16[3];
 585     arShort[0] = Int16::MinValue; arShort[1] = 1; arShort[2] = Int16::MaxValue;
 586     UInt16 arUShort[] = new UInt16[3];
 587     arUShort[0] = UInt16::MinValue; arUShort[1] = 1; arUShort[2] = UInt16::MaxValue;
 588     Int32 arLong[] = new Int32[3];
 589     arLong[0] = Int32::MinValue; arLong[1] = 1; arLong[2] = Int32::MaxValue;
 590     UInt32 arULong[] = new UInt32[3];
 591     arULong[0] = UInt32::MinValue; arULong[1] = 1; arULong[2] = UInt32::MaxValue;
 592     Int64 arHyper[] = new Int64[3];
 593     arHyper[0] = Int64::MinValue; arHyper[1] = 1; arHyper[2] = Int64::MaxValue;
 594     UInt64 arUHyper[] = new UInt64[3];
 595     arUHyper[0] = UInt64::MinValue; arUHyper[1] = 1;
 596     arUHyper[2] = UInt64::MaxValue;
 597     Single arFloat[] = new Single[3];
 598     arFloat[0] = 1.1f; arFloat[1] = 2.2f; arFloat[2] = 3.3f;
 599     Double arDouble[] = new Double[3];
 600     arDouble[0] = 1.11; arDouble[1] = 2.22; arDouble[2] = 3.33;
 601     String* arString[] = new String*[3];
 602     arString[0] = new String("String 1");
 603     arString[1] = new String("String 2");
 604     arString[2] = new String("String 3");
 605
 606     Any arAny[] = new Any[3];
 607     arAny[0] = Any(true); arAny[1] = Any(11111); arAny[2] = Any(3.14);
 608     Object* arObject[] = new Object*[3];
 609     arObject[0] = new WeakBase(); arObject[1] =  new WeakBase();
 610     arObject[1] = new WeakBase();
 611
 612     //TestEnum arEnum[] = new TestEnum[3];
 613     //arEnum[0] = TestEnum::ONE; arEnum[1] = TestEnum::TWO;
 614     //arEnum[2] = TestEnum::CHECK;
 615     Console::WriteLine(new String("cli_cpp_bridgetest: Workaround for C++ compiler bug:"
 616         " using Array of Int32 instead of Array of enums w"));
 617     Int32 arEnum[] = new Int32[3];
 618     arEnum[0] = static_cast<Int32>(TestEnum::ONE);
 619     arEnum[1] = static_cast<Int32>(TestEnum::TWO);
 620     arEnum[2] = static_cast<Int32>(TestEnum::CHECK);
 621
 622     TestElement* arStruct[] = new TestElement*[3];
 623     arStruct[0] = new TestElement(); arStruct[1] = new TestElement();
 624     arStruct[2] = new TestElement();
 625     assign( arStruct[0], true, '@', 17, 0x1234, 0xfedc, 0x12345678, 0xfedcba98,
 626              0x123456789abcdef0, 0xfedcba9876543210, 17.0815f, 3.1415926359,
 627             TestEnum::LOLA, Constants::STRING_TEST_CONSTANT, arObject[0],
 628             Any( __typeof(Object),  arObject[0]) );
 629     assign( arStruct[1], true, 'A', 17, 0x1234, 0xfedc, 0x12345678, 0xfedcba98,
 630             0x123456789abcdef0, 0xfedcba9876543210, 17.0815f, 3.1415926359,
 631             TestEnum::TWO, Constants::STRING_TEST_CONSTANT, arObject[1],
 632             Any( __typeof(Object), arObject[1]) );
 633     assign( arStruct[2], true, 'B', 17, 0x1234, 0xfedc, 0x12345678, 0xfedcba98,
 634             0x123456789abcdef0, 0xfedcba9876543210, 17.0815f, 3.1415926359,
 635             TestEnum::CHECK, Constants::STRING_TEST_CONSTANT, arObject[2],
 636             Any( __typeof(Object), arObject[2] ) );
 637
 638
 639 //     int[][][] arLong3 = new int[][][]{
 640 //         new int[][]{new int[]{1,2,3},new int[]{4,5,6}, new int[]{7,8,9} },
 641 //         new int [][]{new int[]{1,2,3},new int[]{4,5,6}, new int[]{7,8,9}},
 642 //         new int[][]{new int[]{1,2,3},new int[]{4,5,6}, new int[]{7,8,9}}};
 643
 644     {
 645
 646 //              Console::WriteLine(new String("cli_cpp_bridgetest:
 647 //     int[][] seqSeqRet = xBT2->setDim2(arLong3[0]);
 648 //     bRet = check( compareData(seqSeqRet, arLong3[0]), "sequence test") && bRet;
 649 //     int[][][] seqSeqRet2 = xBT2->setDim3(arLong3);
 650 //     bRet = check( compareData(seqSeqRet2, arLong3), "sequence test") && bRet;
 651
 652     Any seqAnyRet[] = xBT2->setSequenceAny(arAny);
 653     bRet = check( compareData(seqAnyRet, arAny), "sequence test") && bRet;
 654     Boolean seqBoolRet[] = xBT2->setSequenceBool(arBool);
 655     bRet = check( compareData(seqBoolRet, arBool), "sequence test") && bRet;
 656     Byte seqByteRet[] = xBT2->setSequenceByte(arByte);
 657     bRet = check( compareData(seqByteRet, arByte), "sequence test") && bRet;
 658     Char seqCharRet[] = xBT2->setSequenceChar(arChar);
 659     bRet = check( compareData(seqCharRet, arChar), "sequence test") && bRet;
 660     Int16 seqShortRet[] = xBT2->setSequenceShort(arShort);
 661     bRet = check( compareData(seqShortRet, arShort), "sequence test") && bRet;
 662     Int32 seqLongRet[] = xBT2->setSequenceLong(arLong);
 663     bRet = check( compareData(seqLongRet, arLong), "sequence test") && bRet;
 664     Int64 seqHyperRet[] = xBT2->setSequenceHyper(arHyper);
 665     bRet = check( compareData(seqHyperRet,arHyper), "sequence test") && bRet;
 666     Single seqFloatRet[] = xBT2->setSequenceFloat(arFloat);
 667     bRet = check( compareData(seqFloatRet, arFloat), "sequence test") && bRet;
 668     Double seqDoubleRet[] = xBT2->setSequenceDouble(arDouble);
 669     bRet = check( compareData(seqDoubleRet, arDouble), "sequence test") && bRet;
 670     xBT2->setSequenceEnum(arEnum);
 671     //comparing seqEnumRet with arEnum will fail since they are of different
 672     //types because of workaround. arEnum is Int32[].
 673     Console::WriteLine(new String("cli_cpp_bridgetest: Test omitted because "
 674         "of C++ compiler bug. XBridgeTest2::setSequenceEnum(sequence<TestEnum>)"));
 675 //    bRet = check( compareData(seqEnumRet, arEnum), "sequence test") && bRet;
 676     UInt16 seqUShortRet[] = xBT2->setSequenceUShort(arUShort);
 677     bRet = check( compareData(seqUShortRet, arUShort), "sequence test") && bRet;
 678     UInt32 seqULongRet[] = xBT2->setSequenceULong(arULong);
 679     bRet = check( compareData(seqULongRet, arULong), "sequence test") && bRet;
 680     UInt64 seqUHyperRet[] = xBT2->setSequenceUHyper(arUHyper);
 681     bRet = check( compareData(seqUHyperRet, arUHyper), "sequence test") && bRet;
 682     Object* seqObjectRet[] = xBT2->setSequenceXInterface(arObject);
 683     bRet = check( compareData(seqObjectRet, arObject), "sequence test") && bRet;
 684     String* seqStringRet[] = xBT2->setSequenceString(arString);
 685     bRet = check( compareData(seqStringRet, arString), "sequence test") && bRet;
 686     TestElement* seqStructRet[] = xBT2->setSequenceStruct(arStruct);
 687     bRet = check( compareData(seqStructRet, arStruct), "sequence test") && bRet;
 688     }
 689     {
 690 //     Boolean arBoolTemp[] = static_cast<Boolean[]>( arBool->Clone());
 691 //     Char arCharTemp[] = static_cast<Char[]>(arChar->Clone());
 692 //     Byte arByteTemp[] = static_cast<Byte[]>(arByte->Clone());
 693 //     Int16 arShortTemp[] = static_cast<Int16[]>(arShort->Clone());
 694 //     UInt16 arUShortTemp[] = static_cast<UInt16[]>(arUShort->Clone());
 695 //     Int32 arLongTemp[] = static_cast<Int32[]>(arLong->Clone());
 696 //     UInt32 arULongTemp[] = static_cast<UInt32[]>(arULong->Clone());
 697 //     Int64 arHyperTemp[] = static_cast<Int64[]>(arHyper->Clone());
 698 //     UInt64 arUHyperTemp[] = static_cast<UInt64[]>(arUHyper->Clone());
 699 //     Single arFloatTemp[] = static_cast<Single[]>(arFloat->Clone());
 700 //     Double arDoubleTemp[] = static_cast<Double[]>(arDouble->Clone());
 701 //     TestEnum arEnumTemp[] = static_cast<TestEnum[]>(arEnum->Clone());
 702 //     String* arStringTemp[] = static_cast<String*[]>(arString->Clone());
 703 //     Object* arObjectTemp = static_cast<Object*[]>(arObject->Clone());
 704 //     Any arAnyTemp[] = static_cast<Any[]>(arAny->Clone());
 705 //     // make sure this are has the same contents as arLong3[0]
 706 //     int[][] arLong2Temp = new int[][]{new int[]{1,2,3},new int[]{4,5,6}, new int[]{7,8,9} };
 707 //     // make sure this are has the same contents as arLong3
 708 //     int[][][] arLong3Temp = new int[][][]{
 709 //         new int[][]{new int[]{1,2,3},new int[]{4,5,6}, new int[]{7,8,9} },
 710 //         new int [][]{new int[]{1,2,3},new int[]{4,5,6}, new int[]{7,8,9}},
 711 //         new int[][]{new int[]{1,2,3},new int[]{4,5,6}, new int[]{7,8,9}}};
 712     Console::WriteLine(new String("cli_cpp_bridgetest: no test of "
 713         "XBridgeTest2::setSequencesInOut and XBridgeTest2.setSequencesOut "
 714         "because jagged arrays are not supported by C++ compiler"));
 715 //     xBT2->setSequencesInOut(& arBoolTemp, & arCharTemp, & arByteTemp,
 716 //                            & arShortTemp, & arUShortTemp, & arLongTemp,
 717 //                            & arULongTemp,& arHyperTemp, & arUHyperTemp,
 718 //                            & arFloatTemp,& arDoubleTemp, & arEnumTemp,
 719 //                            & arStringTemp, &  arObjectTemp,
 720 //                            & arAnyTemp, & arLong2Temp, & arLong3Temp);
 721 //     bRet = check(
 722 //         compareData(arBoolTemp, arBool) &&
 723 //         compareData(arCharTemp , arChar) &&
 724 //         compareData(arByteTemp , arByte) &&
 725 //         compareData(arShortTemp , arShort) &&
 726 //         compareData(arUShortTemp , arUShort) &&
 727 //         compareData(arLongTemp , arLong) &&
 728 //         compareData(arULongTemp , arULong) &&
 729 //         compareData(arHyperTemp , arHyper) &&
 730 //         compareData(arUHyperTemp , arUHyper) &&
 731 //         compareData(arFloatTemp , arFloat) &&
 732 //         compareData(arDoubleTemp , arDouble) &&
 733 //         compareData(arEnumTemp , arEnum) &&
 734 //         compareData(arStringTemp , arString) &&
 735 //         compareData(arObjectTemp , arObject) &&
 736 //         compareData(arAnyTemp , arAny) &&
 737 //         compareData(arLong2Temp , arLong3[0]) &&
 738 //         compareData(arLong3Temp , arLong3), "sequence test") && bRet;
 739
 740     //Boolean arBoolOut[];
 741     //Char arCharOut[];
 742     //Byte arByteOut[];
 743     //Int16 arShortOut[];
 744     //UInt16 arUShortOut[];
 745     //Int32 arLongOut[];
 746     //UInt32 arULongOut[];
 747     //Int64 arHyperOut[];
 748     //UInt64 arUHyperOut[];
 749     //Single arFloatOut[];
 750     //Double arDoubleOut[];
 751     //TestEnum arEnumOut[];
 752     //String* arStringOut[];
 753     //Object* arObjectOut[];
 754     //Any arAnyOut[];
 755 //     int[][] arLong2Out;
 756 //     int[][][] arLong3Out;
 757
 758 //     xBT2->setSequencesOut(out arBoolOut, out arCharOut, out arByteOut,
 759 //                          out arShortOut, out arUShortOut, out arLongOut,
 760 //                          out arULongOut, out arHyperOut, out arUHyperOut,
 761 //                          out arFloatOut, out arDoubleOut, out arEnumOut,
 762 //                          out arStringOut, out arObjectOut, out arAnyOut,
 763 //                          out arLong2Out, out arLong3Out);
 764 //     bRet = check(
 765 //         compareData(arBoolOut, arBool) &&
 766 //         compareData(arCharOut, arChar) &&
 767 //         compareData(arByteOut, arByte) &&
 768 //         compareData(arShortOut, arShort) &&
 769 //         compareData(arUShortOut, arUShort) &&
 770 //         compareData(arLongOut, arLong) &&
 771 //         compareData(arULongOut, arULong) &&
 772 //         compareData(arHyperOut, arHyper) &&
 773 //         compareData(arUHyperOut, arUHyper) &&
 774 //         compareData(arFloatOut, arFloat) &&
 775 //         compareData(arDoubleOut, arDouble) &&
 776 //         compareData(arEnumOut, arEnum) &&
 777 //         compareData(arStringOut, arString) &&
 778 //         compareData(arObjectOut, arObject) &&
 779 //         compareData(arAnyOut, arAny) &&
 780 //         compareData(arLong2Out, arLong3[0]) &&
 781 //         compareData(arLong3Out, arLong3), "sequence test") && bRet;
 782     }
 783     {
 784     //test with empty sequences
 785    //  int[][] _arLong2 = new int[0][];
 786 //     int[][] seqSeqRet = xBT2->setDim2(_arLong2);
 787 //     bRet = check( compareData(seqSeqRet, _arLong2), "sequence test") && bRet;
 788 //     int[][][] _arLong3 = new int[0][][];
 789 //     int[][][] seqSeqRet2 = xBT2->setDim3(_arLong3);
 790 //    bRet = check( compareData(seqSeqRet2, _arLong3), "sequence test") && bRet;
 791     Any _arAny[] = new Any[0];
 792     Any seqAnyRet[] = xBT2->setSequenceAny(_arAny);
 793     bRet = check( compareData(seqAnyRet, _arAny), "sequence test") && bRet;
 794     Boolean _arBool[] = new Boolean[0];
 795     Boolean seqBoolRet[] = xBT2->setSequenceBool(_arBool);
 796     bRet = check( compareData(seqBoolRet, _arBool), "sequence test") && bRet;
 797     Byte _arByte[] = new Byte[0];
 798     Byte seqByteRet[] = xBT2->setSequenceByte(_arByte);
 799     bRet = check( compareData(seqByteRet, _arByte), "sequence test") && bRet;
 800     Char _arChar[] = new Char[0];
 801     Char seqCharRet[] = xBT2->setSequenceChar(_arChar);
 802     bRet = check( compareData(seqCharRet, _arChar), "sequence test") && bRet;
 803     Int16 _arShort[] = new Int16[0];
 804     Int16 seqShortRet[] = xBT2->setSequenceShort(_arShort);
 805     bRet = check( compareData(seqShortRet, _arShort), "sequence test") && bRet;
 806     Int32 _arLong[] = new Int32[0];
 807     Int32 seqLongRet[] = xBT2->setSequenceLong(_arLong);
 808     bRet = check( compareData(seqLongRet, _arLong), "sequence test") && bRet;
 809     Int64 _arHyper[] = new Int64[0];
 810     Int64 seqHyperRet[] = xBT2->setSequenceHyper(_arHyper);
 811     bRet = check( compareData(seqHyperRet, _arHyper), "sequence test") && bRet;
 812     Single _arFloat[] = new Single[0];
 813     Single  seqFloatRet[] = xBT2->setSequenceFloat(_arFloat);
 814     bRet = check( compareData(seqFloatRet, _arFloat), "sequence test") && bRet;
 815     Double _arDouble[] = new Double[0];
 816     Double seqDoubleRet[] = xBT2->setSequenceDouble(_arDouble);
 817     bRet = check( compareData(seqDoubleRet, _arDouble), "sequence test") && bRet;
 818     TestEnum _arEnum[] = new TestEnum[0];
 819     xBT2->setSequenceEnum(_arEnum);
 820 //      compiler bug: _arEnum has type System.Enum and not TestEnum
 821 //    bRet = check( compareData(seqEnumRet, _arEnum), "sequence test") && bRet;
 822     UInt16 _arUShort[] = new UInt16[0];
 823     UInt16 seqUShortRet[] = xBT2->setSequenceUShort(_arUShort);
 824     bRet = check( compareData(seqUShortRet, _arUShort), "sequence test") && bRet;
 825     UInt32 _arULong[] = new UInt32[0];
 826     UInt32 seqULongRet[] = xBT2->setSequenceULong(_arULong);
 827     bRet = check( compareData(seqULongRet, _arULong), "sequence test") && bRet;
 828     UInt64 _arUHyper[] = new UInt64[0];
 829     UInt64 seqUHyperRet[] = xBT2->setSequenceUHyper(_arUHyper);
 830     bRet = check( compareData(seqUHyperRet, _arUHyper), "sequence test") && bRet;
 831     Object* _arObject[] = new Object*[0];
 832     Object* seqObjectRet[] = xBT2->setSequenceXInterface(_arObject);
 833     bRet = check( compareData(seqObjectRet, _arObject), "sequence test") && bRet;
 834     String* _arString[] = new String*[0];
 835     String* seqStringRet[] = xBT2->setSequenceString(_arString);
 836     bRet = check( compareData(seqStringRet, _arString), "sequence test") && bRet;
 837     TestElement* _arStruct[] = new TestElement*[0];
 838     TestElement* seqStructRet[] = xBT2->setSequenceStruct(_arStruct);
 839     bRet = check( compareData(seqStructRet, _arStruct), "sequence test") && bRet;
 840
 841     }
 842     return bRet;
 843 }
 844 /** Test the System::Object method on the proxy object
 845  */
 846 static bool testObjectMethodsImplemention(XBridgeTest* xLBT)
 847 {
 848     bool ret = false;
 849     Object* obj = new Object();
 850     XBridgeTestBase* xBase = dynamic_cast<XBridgeTestBase*>(xLBT);
 851     if (xBase == 0)
 852         return false;
 853     // Object.Equals
 854     ret = xLBT->Equals(obj) == false;
 855     ret = xLBT->Equals(xLBT) && ret;
 856     ret = Object::Equals(obj, obj) && ret;
 857     ret = Object::Equals(xLBT, xBase) && ret;
 858     //Object.GetHashCode
 859     // Don't know how to verify this. Currently it is not possible to get the object id from a proxy
 860     int nHash = xLBT->GetHashCode();
 861     ret = nHash == xBase->GetHashCode() && ret;
 862
 863     //Object.ToString
 864     // Don't know how to verify this automatically.
 865     String* s = xLBT->ToString();
 866     ret = (s->Length > 0) && ret;
 867     return ret;
 868 }
 869
 870
 871 static bool raiseOnewayException(XBridgeTest* xLBT)
 872 {
 873     bool bReturn = true;
 874     String* sCompare = Constants::STRING_TEST_CONSTANT;
 875     try
 876     {
 877         // Note : the exception may fly or not (e.g. remote scenario).
 878         //        When it flies, it must contain the correct elements.
 879         xLBT->raiseRuntimeExceptionOneway(sCompare, xLBT->Interface );
 880     }
 881     catch (RuntimeException*  e )
 882     {
 883         bReturn = ( xLBT->Interface == e->Context );
 884     }
 885     return bReturn;
 886 }
 887
 888 // //==================================================================================================
 889 static bool raiseException(XBridgeTest* xLBT )
 890 {
 891     int nCount = 0;
 892     try
 893     {
 894         try
 895         {
 896             try
 897             {
 898                 xLBT->raiseException(
 899                     5, Constants::STRING_TEST_CONSTANT, xLBT->Interface );
 900             }
 901             catch (unoidl::com::sun::star::lang::IllegalArgumentException* aExc)
 902             {
 903                 if (aExc->ArgumentPosition == 5 &&
 904                     aExc->Context == xLBT->Interface)
 905                 {
 906                     ++nCount;
 907                 }
 908                 else
 909                 {
 910                     check( false, "### unexpected exception content!" );
 911                 }
 912
 913                 /** it is certain, that the RuntimeException testing will fail,
 914                     if no */
 915                 xLBT->RuntimeException = 0;
 916             }
 917         }
 918         catch (unoidl::com::sun::star::uno::RuntimeException* rExc)
 919         {
 920             if (rExc->Context == xLBT->Interface )
 921             {
 922                 ++nCount;
 923             }
 924             else
 925             {
 926                 check( false, "### unexpected exception content!" );
 927             }
 928
 929             /** it is certain, that the RuntimeException testing will fail, if no */
 930             xLBT->RuntimeException = (int) 0xcafebabe;
 931         }
 932     }
 933     catch (unoidl::com::sun::star::uno::Exception*  rExc)
 934     {
 935         if (rExc->Context == xLBT->Interface)
 936         {
 937             ++nCount;
 938         }
 939         else
 940
 941         {
 942             check( false, "### unexpected exception content!" );
 943         }
 944         return (nCount == 3);
 945     }
 946     return false;
 947 }
 948
 949     static private void perform_test( XBridgeTest* xLBT )
 950     {
 951         bool bRet= true;;
 952        bRet = check( performTest( xLBT ), "standard test" ) && bRet;
 953        bRet = check( raiseException( xLBT ) , "exception test" )&& bRet;
 954        bRet = check( raiseOnewayException( xLBT ), "oneway exception test" ) && bRet;
 955        bRet = check( testObjectMethodsImplemention(xLBT), "object methods test") && bRet;
 956        bRet = performQueryForUnknownType( xLBT ) && bRet;
 957         if (! bRet)
 958         {
 959             throw new unoidl::com::sun::star::uno::RuntimeException(
 960                 new String("error: test failed!"), 0);
 961         }
 962     }
 963     XComponentContext* m_xContext;
 964
 965     public:
 966     BridgeTest( XComponentContext* xContext )
 967     {
 968         m_xContext = xContext;
 969     }
 970
 971
 972
 973     int run( String* args[] )
 974     {
 975         try
 976         {
 977             if (args->Length < 1)
 978             {
 979                 throw new RuntimeException(
 980                     "missing argument for bridgetest!", this );
 981             }
 982             Object* test_obj =
 983                 m_xContext->getServiceManager()->createInstanceWithContext(
 984                     args[ 0 ], m_xContext );
 985             if (test_obj == 0)
 986                 test_obj = m_xContext->getValueByName( args[ 0 ] ).Value;
 987
 988             Console::WriteLine(
 989                 "cli target bridgetest obj: {0}", test_obj->ToString() );
 990             XBridgeTest* xTest = __try_cast<XBridgeTest*>(test_obj) ;
 991             perform_test( xTest );
 992             Console::WriteLine( "\n### cli_uno C++  bridgetest succeeded." );
 993             return 0;
 994         }
 995         catch (unoidl::com::sun::star::uno::RuntimeException* )
 996         {
 997             throw;
 998         }
 999         catch (System::Exception* exc)
1000         {
1001             System::Text::StringBuilder* s = new System::Text::StringBuilder();
1002             s->Append(S"cli_cpp_bridgetest: unexpected exception occured in XMain::run. Original exception: ");
1003             s->Append(exc->GetType()->Name);
1004             s->Append(S"\n Message: ");
1005             s->Append(exc->Message);
1006             throw new unoidl::com::sun::star::uno::RuntimeException(
1007                 s->ToString(), 0);
1008         }
1009     }
1010 };
1011
1012 }