testtools/source/bridgetest/cli/cli_cs_bridgetest.cs

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