testtools/source/bridgetest/cli/cli_cs_bridgetest.cs

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