class/System.Runtime.Remoting/Test/BaseCalls.cs

   1 //
   2 // MonoTests.Remoting.BaseCalls.cs
   3 //
   4 // Author: Lluis Sanchez Gual (lluis@ximian.com)
   5 //
   6 // 2003 (C) Copyright, Ximian, Inc.
   7 //
   8
   9 using System;
  10 using System.IO;
  11 using System.Net;
  12 using System.Text;
  13 using System.Threading;
  14 using System.Collections;
  15 using System.Globalization;
  16 using System.Runtime.Remoting;
  17 using System.Runtime.Remoting.Channels;
  18 using System.Runtime.Remoting.Messaging;
  19 using System.Runtime.Remoting.Lifetime;
  20 using System.Runtime.Remoting.Channels.Tcp;
  21 using System.Runtime.Remoting.Activation;
  22 using System.Runtime.Remoting.Contexts;
  23 using System.Runtime.InteropServices;
  24 using NUnit.Framework;
  25
  26 namespace MonoTests.Remoting
  27 {
  28         public abstract class BaseCallTest
  29         {
  30                 IChannelSender chs;
  31                 string[] remoteUris;
  32                 CallsDomainServer server;
  33                 int remoteDomId;
  34
  35                 [TestFixtureSetUp]
  36                 public void Run()
  37                 {
  38                         remoteDomId = CreateServer ();
  39                 }
  40
  41                 [TestFixtureTearDown]
  42                 public void End ()
  43                 {
  44                         ShutdownServer ();
  45                 }
  46
  47                 public static AppDomain CreateDomain (string friendlyName)
  48                 {
  49                         // return AppDomain.CreateDomain (friendlyName);
  50                         return AppDomain.CreateDomain (friendlyName, null, Directory.GetCurrentDirectory (), ".", false);
  51                 }
  52
  53                 protected virtual int CreateServer ()
  54                 {
  55                         ChannelManager cm = CreateChannelManager ();
  56                         chs = cm.CreateClientChannel ();
  57                         ChannelServices.RegisterChannel (chs);
  58
  59                         AppDomain domain = BaseCallTest.CreateDomain ("testdomain");
  60                         server = (CallsDomainServer) domain.CreateInstanceAndUnwrap(GetType().Assembly.FullName,"MonoTests.Remoting.CallsDomainServer");
  61                         remoteUris = server.Start (cm);
  62                         return server.GetDomId ();
  63                 }
  64
  65                 protected virtual void ShutdownServer ()
  66                 {
  67                         if (server != null) {
  68                                 server.Stop ();
  69                                 if (chs != null)
  70                                         ChannelServices.UnregisterChannel (chs);
  71                         }
  72                 }
  73
  74                 protected virtual RemoteObject CreateRemoteInstance ()
  75                 {
  76                         return (RemoteObject) Activator.GetObject (typeof(RemoteObject), remoteUris[0]);
  77                 }
  78
  79                 protected virtual AbstractRemoteObject CreateRemoteAbstract ()
  80                 {
  81                         return (AbstractRemoteObject) Activator.GetObject (typeof(AbstractRemoteObject), remoteUris[1]);
  82                 }
  83
  84                 protected virtual IRemoteObject CreateRemoteInterface ()
  85                 {
  86                         return (IRemoteObject) Activator.GetObject (typeof(IRemoteObject), remoteUris[2]);
  87                 }
  88
  89                 public InstanceSurrogate InternalGetInstanceSurrogate ()
  90                 {
  91                         InstanceSurrogate s = GetInstanceSurrogate ();
  92                         s.RemoteObject = CreateRemoteInstance ();
  93                         return s;
  94                 }
  95
  96                 public AbstractSurrogate InternalGetAbstractSurrogate ()
  97                 {
  98                         AbstractSurrogate s = GetAbstractSurrogate ();
  99                         s.RemoteObject = CreateRemoteAbstract ();
 100                         return s;
 101                 }
 102
 103                 public InterfaceSurrogate InternalGetInterfaceSurrogate ()
 104                 {
 105                         InterfaceSurrogate s = GetInterfaceSurrogate ();
 106                         s.RemoteObject = CreateRemoteInterface ();
 107                         return s;
 108                 }
 109
 110                 public abstract InstanceSurrogate GetInstanceSurrogate ();
 111                 public abstract AbstractSurrogate GetAbstractSurrogate ();
 112                 public abstract InterfaceSurrogate GetInterfaceSurrogate ();
 113
 114                 public virtual ChannelManager CreateChannelManager ()
 115                 {
 116                         return null;
 117                 }
 118
 119                 //
 120                 // The tests
 121                 //
 122
 123                 [Test]
 124                 public void TestInstanceSimple ()
 125                 {
 126                         RunTestSimple (InternalGetInstanceSurrogate());
 127                 }
 128
 129                 [Test]
 130                 public void TestAbstractSimple ()
 131                 {
 132                         RunTestSimple (InternalGetAbstractSurrogate());
 133                 }
 134
 135                 [Test]
 136                 public void TestInterfaceSimple ()
 137                 {
 138                         RunTestSimple (InternalGetInterfaceSurrogate());
 139                 }
 140
 141                 [Test]
 142                 public void TestInstancePrimitiveParams ()
 143                 {
 144                         RunTestPrimitiveParams (InternalGetInstanceSurrogate());
 145                 }
 146
 147                 [Test]
 148                 public void TestAbstractPrimitiveParams ()
 149                 {
 150                         RunTestPrimitiveParams (InternalGetAbstractSurrogate());
 151                 }
 152
 153                 [Test]
 154                 public void TestInterfacePrimitiveParams ()
 155                 {
 156                         RunTestPrimitiveParams (InternalGetInterfaceSurrogate());
 157                 }
 158
 159                 [Test]
 160                 public void TestInstancePrimitiveParamsInOut ()
 161                 {
 162                         RunTestPrimitiveParamsInOut (InternalGetInstanceSurrogate());
 163                 }
 164
 165                 [Test]
 166                 public void TestAbstractPrimitiveParamsInOut ()
 167                 {
 168                         RunTestPrimitiveParamsInOut (InternalGetAbstractSurrogate());
 169                 }
 170
 171                 [Test]
 172                 public void TestInterfacePrimitiveParamsInOut ()
 173                 {
 174                         RunTestPrimitiveParamsInOut (InternalGetInterfaceSurrogate());
 175                 }
 176
 177                 [Test]
 178                 public void TestInstanceComplexParams ()
 179                 {
 180                         RunTestComplexParams (InternalGetInstanceSurrogate());
 181                 }
 182
 183                 [Test]
 184                 public void TestAbstractComplexParams ()
 185                 {
 186                         RunTestComplexParams (InternalGetAbstractSurrogate());
 187                 }
 188
 189                 [Test]
 190                 public void TestInterfaceComplexParams ()
 191                 {
 192                         RunTestComplexParams (InternalGetInterfaceSurrogate());
 193                 }
 194
 195                 [Test]
 196                 [Category ("NotDotNet")]
 197                 public void TestInstanceComplexParamsInOut ()
 198                 {
 199                         RunTestComplexParamsInOut (InternalGetInstanceSurrogate());
 200                 }
 201
 202                 [Test]
 203                 [Category ("NotDotNet")]
 204                 public void TestAbstractComplexParamsInOut ()
 205                 {
 206                         RunTestComplexParamsInOut (InternalGetAbstractSurrogate());
 207                 }
 208
 209                 [Test]
 210                 [Category ("NotDotNet")]
 211                 public void TestInterfaceComplexParamsInOut ()
 212                 {
 213                         RunTestComplexParamsInOut (InternalGetInterfaceSurrogate());
 214                 }
 215
 216                 [Test]
 217                 public void TestInstanceProcessContextData ()
 218                 {
 219                         RunTestProcessContextData (InternalGetInstanceSurrogate());
 220                 }
 221
 222                 [Test]
 223                 public void TestAbstractProcessContextData ()
 224                 {
 225                         RunTestProcessContextData (InternalGetAbstractSurrogate());
 226                 }
 227
 228                 [Test]
 229                 public void TestInterfaceProcessContextData ()
 230                 {
 231                         RunTestProcessContextData (InternalGetInterfaceSurrogate());
 232                 }
 233
 234                 //
 235                 // The tests runners
 236                 //
 237
 238                 public void RunTestSimple (IRemoteObject testerSurrogate)
 239                 {
 240                         Assert.AreEqual (130772 + remoteDomId, testerSurrogate.Simple (), "ReturnValue");
 241                 }
 242
 243                 public void RunTestPrimitiveParams (IRemoteObject testerSurrogate)
 244                 {
 245                         Assert.AreEqual ("11-22-L-SG@"+remoteDomId, testerSurrogate.PrimitiveParams (11, 22, 'L', "SG"), "ReturnValue");
 246                 }
 247
 248                 public void RunTestPrimitiveParamsInOut (IRemoteObject testerSurrogate)
 249                 {
 250                         int a2, a1 = 9876543;
 251                         float b2, b1 = 82437.83f;
 252                         char c2, c1 = 's';
 253                         string d2, d1 = "asdASDzxcZXC";
 254
 255                         string res = testerSurrogate.PrimitiveParamsInOut (ref a1, out a2, ref b1, out b2, 9821, ref c1, out c2, ref d1, out d2);
 256
 257                         Assert.AreEqual ("9876543-82437.83-s-asdASDzxcZXC@" + remoteDomId, res, "ReturnValue");
 258
 259                         Assert.AreEqual (12345678, a2, "a2");
 260                         Assert.AreEqual (53455.345f, b2, "b2");
 261                         Assert.AreEqual ('g', c2, "c2");
 262                         Assert.AreEqual ("sfARREG$5345DGDfgY7656gDFG>><<dasdasd", d2, "d2");
 263
 264                         Assert.AreEqual (65748392, a1, "a1");
 265                         Assert.AreEqual (98395.654f, b1, "b1");
 266                         Assert.AreEqual ('l', c1, "c1");
 267                         Assert.AreEqual ("aasbasbdyhasbduybo234243", d1, "d1");
 268                 }
 269
 270                 public void RunTestComplexParams (IRemoteObject testerSurrogate)
 271                 {
 272                         ArrayList list = new ArrayList ();
 273                         list.Add (new Complex (11,"first"));
 274                         Complex c = new Complex (22,"second");
 275
 276                         Complex r = testerSurrogate.ComplexParams (list, c, "third");
 277
 278                         Assert.IsNotNull (r, "ReturnValue is null");
 279                         Assert.IsNotNull (r.Child, "ReturnValue.Child is null");
 280                         Assert.IsNotNull (r.Child.Child, "ReturnValue.Child.Child is null");
 281
 282                         Assert.AreEqual (33, r.Id, "ReturnValue.Id");
 283                         Assert.AreEqual ("third@"+remoteDomId, r.Name, "ReturnValue.Name");
 284                         Assert.AreEqual (22, r.Child.Id, "ReturnValue.Child.Id");
 285                         Assert.AreEqual ("second", r.Child.Name, "ReturnValue.Child.Name");
 286                         Assert.AreEqual (11, r.Child.Child.Id, "ReturnValue.Child.Child.Id");
 287                         Assert.AreEqual ("first", r.Child.Child.Name, "ReturnValue.Child.Child.Name");
 288                 }
 289
 290                 public void RunTestComplexParamsInOut (IRemoteObject testerSurrogate)
 291                 {
 292                         ArrayList list = new ArrayList ();
 293                         list.Add (new Complex (11,"first"));
 294                         list.Add (new Complex (22,"second"));
 295
 296                         byte[] bytes = new byte [100];
 297                         for (byte n=0; n<100; n++) bytes[n] = n;
 298                         StringBuilder sb = new StringBuilder ("hello from client");
 299
 300                         Complex c;
 301                         Complex r = testerSurrogate.ComplexParamsInOut (ref list, out c, bytes, sb, "third");
 302
 303                         Assert.IsNotNull (r, "ReturnValue is null");
 304                         Assert.IsNotNull (c, "c is null");
 305                         Assert.IsNotNull (list, "list is null");
 306                         Assert.IsTrue (list.Count == 3, "Invalid list count");
 307                         Assert.IsNotNull (list[0], "list[0] is null");
 308                         Assert.IsNotNull (list[1], "list[1] is null");
 309                         Assert.IsNotNull (list[2], "list[2] is null");
 310                         Assert.IsNotNull (bytes, "bytes is null");
 311                         Assert.IsNotNull (sb, "sb is null");
 312
 313                         Assert.AreEqual (33, r.Id, "ReturnValue.Id");
 314                         Assert.AreEqual ("third@"+remoteDomId, r.Name, "ReturnValue.Name");
 315                         Assert.AreEqual (33, c.Id, "c.Id");
 316                         Assert.AreEqual ("third@"+remoteDomId, c.Name, "c.Name");
 317
 318                         Assert.AreEqual (33, ((Complex)list[2]).Id, "list[2].Id");
 319                         Assert.AreEqual ("third@"+remoteDomId, ((Complex)list[2]).Name, "list[2].Name");
 320                         Assert.AreEqual (22, ((Complex)list[1]).Id, "list[1].Id");
 321                         Assert.AreEqual ("second", ((Complex)list[1]).Name, "list[1].Name");
 322                         Assert.AreEqual (11, ((Complex)list[0]).Id, "list[0].Id");
 323                         Assert.AreEqual ("first", ((Complex)list[0]).Name, "list[0].Name");
 324
 325                         Assert.AreEqual ("hello from client", sb.ToString (), "sb");
 326                         for (int n=0; n<100; n++)
 327                                 Assert.AreEqual (n+1, bytes[n], "bytes["+n+"]");
 328                 }
 329
 330                 public void RunTestProcessContextData (IRemoteObject testerSurrogate)
 331                 {
 332                         CallContext.FreeNamedDataSlot ("clientData");
 333                         CallContext.FreeNamedDataSlot ("serverData");
 334                         CallContext.FreeNamedDataSlot ("mustNotPass");
 335
 336                         // First step
 337
 338                         ContextData cdata = new ContextData ();
 339                         cdata.data = "hi from client";
 340                         cdata.id = 1123;
 341                         cdata.testStep = 1;
 342                         CallContext.SetData ("clientData", cdata);
 343                         CallContext.SetData ("mustNotPass", "more data");
 344
 345                         testerSurrogate.ProcessContextData ();
 346
 347                         cdata = CallContext.GetData ("clientData") as ContextData;
 348                         Assert.IsNotNull (cdata, "clientData is null");
 349                         Assert.AreEqual ("hi from client", cdata.data, "clientData.data");
 350                         Assert.AreEqual (1123, cdata.id, "clientData.id");
 351
 352                         cdata = CallContext.GetData ("serverData") as ContextData;
 353                         Assert.IsNotNull (cdata, "serverData is null");
 354                         Assert.AreEqual ("hi from server", cdata.data, "serverData.data");
 355                         Assert.AreEqual (3211, cdata.id, "serverData.id");
 356
 357                         string mdata = CallContext.GetData ("mustNotPass") as string;
 358                         Assert.IsNotNull (mdata, "mustNotPass is null");
 359                         Assert.AreEqual ("more data", mdata, "mustNotPass");
 360
 361                         // Second step. Test that exceptions return the call context.
 362
 363                         CallContext.FreeNamedDataSlot ("clientData");
 364                         CallContext.FreeNamedDataSlot ("serverData");
 365
 366                         cdata = new ContextData ();
 367                         cdata.data = "hi from client";
 368                         cdata.id = 1123;
 369                         cdata.testStep = 2;
 370                         CallContext.SetData ("clientData", cdata);
 371
 372                         try {
 373                                 testerSurrogate.ProcessContextData ();
 374                                 Assert.IsTrue (false, "Exception not thrown");
 375                         } catch (Exception ex) {
 376                                 if (ex.InnerException != null)
 377                                         ex = ex.InnerException;
 378                                 if (ex.Message != "exception from server")
 379                                         throw;
 380                         }
 381
 382                         cdata = CallContext.GetData ("clientData") as ContextData;
 383                         Assert.IsNotNull (cdata, "clientData is null (2)");
 384                         Assert.AreEqual ("hi from client", cdata.data, "clientData.data (2)");
 385                         Assert.AreEqual (1123, cdata.id, "clientData.id (2)");
 386
 387                         mdata = CallContext.GetData ("mustNotPass") as string;
 388                         Assert.IsNotNull (mdata, "mustNotPass is null");
 389                         Assert.AreEqual ("more data", mdata, "mustNotPass");
 390                 }
 391         }
 392
 393         //
 394         // The server running in the remote domain
 395         //
 396
 397         class CallsDomainServer: MarshalByRefObject
 398         {
 399                 IChannelReceiver ch;
 400
 401                 public string[] Start(ChannelManager cm)
 402                 {
 403                         try
 404                         {
 405                                 ch = cm.CreateServerChannel ();
 406                                 ChannelServices.RegisterChannel ((IChannel)ch);
 407                                 RemotingConfiguration.RegisterWellKnownServiceType (typeof (RemoteObject), "test1", WellKnownObjectMode.SingleCall);
 408                                 RemotingConfiguration.RegisterWellKnownServiceType (typeof (RemoteObject), "test2", WellKnownObjectMode.SingleCall);
 409                                 RemotingConfiguration.RegisterWellKnownServiceType (typeof (RemoteObject), "test3", WellKnownObjectMode.SingleCall);
 410                                 string[] uris = new string[3];
 411                                 uris[0] = ch.GetUrlsForUri ("test1")[0];
 412                                 uris[1] = ch.GetUrlsForUri ("test2")[0];
 413                                 uris[2] = ch.GetUrlsForUri ("test3")[0];
 414                                 return uris;
 415                         }
 416                         catch (Exception ex)
 417                         {
 418                                 Console.WriteLine (ex.ToString());
 419                                 throw;
 420                         }
 421                 }
 422
 423                 public void Stop ()
 424                 {
 425                         if (ch != null)
 426                                 ChannelServices.UnregisterChannel (ch);
 427                 }
 428
 429                 public int GetDomId ()
 430                 {
 431                         return Thread.GetDomainID();
 432                 }
 433         }
 434
 435         [Serializable]
 436         public class ContextData : ILogicalThreadAffinative
 437         {
 438                 public string data;
 439                 public int id;
 440                 public int testStep;
 441         }
 442
 443         [Serializable]
 444         public abstract class ChannelManager
 445         {
 446                 public abstract IChannelSender CreateClientChannel ();
 447                 public abstract IChannelReceiver CreateServerChannel ();
 448         }
 449
 450
 451         //
 452         // Test interface
 453         //
 454         public interface IRemoteObject
 455         {
 456                 int Simple ();
 457                 string PrimitiveParams (int a, uint b, char c, string d);
 458                 string PrimitiveParamsInOut (ref int a1, out int a2, ref float b1, out float b2, int filler, ref char c1, out char c2, ref string d1, out string d2);
 459                 Complex ComplexParams (ArrayList a, Complex b, string c);
 460                 Complex ComplexParamsInOut (ref ArrayList a, out Complex b, [In,Out] byte[] bytes, [In,Out] StringBuilder sb, string c);
 461                 void ProcessContextData ();
 462         }
 463
 464         // Base classes for tester surrogates
 465
 466         public abstract class InstanceSurrogate : IRemoteObject
 467         {
 468                 public RemoteObject RemoteObject;
 469                 public abstract int Simple ();
 470                 public abstract string PrimitiveParams (int a, uint b, char c, string d);
 471                 public abstract string PrimitiveParamsInOut (ref int a1, out int a2, ref float b1, out float b2, int filler, ref char c1, out char c2, ref string d1, out string d2);
 472                 public abstract Complex ComplexParams (ArrayList a, Complex b, string c);
 473                 public abstract Complex ComplexParamsInOut (ref ArrayList a, out Complex b, [In,Out] byte[] bytes, [In,Out] StringBuilder sb, string c);
 474                 public abstract void ProcessContextData ();
 475         }
 476
 477         public abstract class AbstractSurrogate : IRemoteObject
 478         {
 479                 public AbstractRemoteObject RemoteObject;
 480                 public abstract int Simple ();
 481                 public abstract string PrimitiveParams (int a, uint b, char c, string d);
 482                 public abstract string PrimitiveParamsInOut (ref int a1, out int a2, ref float b1, out float b2, int filler, ref char c1, out char c2, ref string d1, out string d2);
 483                 public abstract Complex ComplexParams (ArrayList a, Complex b, string c);
 484                 public abstract Complex ComplexParamsInOut (ref ArrayList a, out Complex b, [In,Out] byte[] bytes, [In,Out] StringBuilder sb, string c);
 485                 public abstract void ProcessContextData ();
 486         }
 487
 488         public abstract class InterfaceSurrogate : IRemoteObject
 489         {
 490                 public IRemoteObject RemoteObject;
 491                 public abstract int Simple ();
 492                 public abstract string PrimitiveParams (int a, uint b, char c, string d);
 493                 public abstract string PrimitiveParamsInOut (ref int a1, out int a2, ref float b1, out float b2, int filler, ref char c1, out char c2, ref string d1, out string d2);
 494                 public abstract Complex ComplexParams (ArrayList a, Complex b, string c);
 495                 public abstract Complex ComplexParamsInOut (ref ArrayList a, out Complex b, [In,Out] byte[] bytes, [In,Out] StringBuilder sb, string c);
 496                 public abstract void ProcessContextData ();
 497         }
 498
 499
 500         //
 501         // Test abstract base class
 502         //
 503
 504         public abstract class AbstractRemoteObject : MarshalByRefObject
 505         {
 506                 public abstract int Simple ();
 507                 public abstract string PrimitiveParams (int a, uint b, char c, string d);
 508                 public abstract string PrimitiveParamsInOut (ref int a1, out int a2, ref float b1, out float b2, int filler, ref char c1, out char c2, ref string d1, out string d2);
 509                 public abstract Complex ComplexParams (ArrayList a, Complex b, string c);
 510                 public abstract Complex ComplexParamsInOut (ref ArrayList a, out Complex b, [In,Out] byte[] bytes, [In,Out] StringBuilder sb, string c);
 511                 public abstract void ProcessContextData ();
 512         }
 513
 514         //
 515         // Test class
 516         //
 517
 518         public class RemoteObject : AbstractRemoteObject, IRemoteObject
 519         {
 520                 int inc = 0;
 521
 522                 public override int Simple ()
 523                 {
 524                         return 130772 + Thread.GetDomainID();
 525                 }
 526
 527                 public int ReturnOne ()
 528                 {
 529                         return 1;
 530                 }
 531
 532                 public int Increment ()
 533                 {
 534                         return inc++;
 535                 }
 536
 537                 public override string PrimitiveParams (int a, uint b, char c, string d)
 538                 {
 539                         return "" + a + "-" + b + "-" + c + "-" + d + "@" + Thread.GetDomainID();
 540                 }
 541
 542                 // declare an overload for bug #77191
 543                 public void PrimitiveParams ()
 544                 {
 545                 }
 546
 547                 public override string PrimitiveParamsInOut (ref int a1, out int a2, ref float b1, out float b2, int filler, ref char c1, out char c2, ref string d1, out string d2)
 548                 {
 549                         string res = "" + a1 + "-" + b1.ToString(CultureInfo.InvariantCulture) + "-" + c1 + "-" + d1 + "@" + Thread.GetDomainID();
 550                         a2 = 12345678;
 551                         b2 = 53455.345f;
 552                         c2 = 'g';
 553                         d2 = "sfARREG$5345DGDfgY7656gDFG>><<dasdasd";
 554                         a1 = 65748392;
 555                         b1 = 98395.654f;
 556                         c1 = 'l';
 557                         d1 = "aasbasbdyhasbduybo234243";
 558                         return res;
 559                 }
 560
 561                 public override Complex ComplexParams (ArrayList a, Complex b, string c)
 562                 {
 563                         Complex cp = new Complex (33,c+ "@" + Thread.GetDomainID());
 564                         cp.Child = b;
 565                         cp.Child.Child = (Complex)a[0];
 566                         return cp;
 567                 }
 568
 569                 public override Complex ComplexParamsInOut (ref ArrayList a, out Complex b, [In,Out] byte[] bytes, [In,Out] StringBuilder sb, string c)
 570                 {
 571                         b = new Complex (33,c+ "@" + Thread.GetDomainID());
 572                         a.Add (b);
 573                         for (byte n=0; n<100; n++) bytes[n] = (byte)(bytes[n] + 1);
 574                         sb.Append (" and from server");
 575                         return b;
 576                 }
 577
 578                 public override void ProcessContextData ()
 579                 {
 580                         string mdata = CallContext.GetData ("mustNotPass") as string;
 581                         if (mdata != null)
 582                                 throw new Exception ("mustNotPass is not null");
 583
 584                         ContextData cdata = CallContext.GetData ("clientData") as ContextData;
 585                         if (cdata == null)
 586                                 throw new Exception ("server: clientData is null");
 587                         if (cdata.data != "hi from client" || cdata.id != 1123)
 588                                 throw new Exception ("server: clientData is not valid");
 589
 590                         if (cdata.testStep == 2)
 591                                 throw new Exception ("exception from server");
 592
 593                         if (cdata.testStep != 1)
 594                                 throw new Exception ("invalid test step");
 595
 596                         cdata = new ContextData ();
 597                         cdata.data = "hi from server";
 598                         cdata.id = 3211;
 599                         CallContext.SetData ("serverData", cdata);
 600                 }
 601         }
 602
 603         [Serializable]
 604         public class Complex
 605         {
 606                 public Complex (int id, string name)
 607                 {
 608                         Id = id;
 609                         Name = name;
 610                 }
 611
 612                 public string Name;
 613                 public int Id;
 614                 public Complex Child;
 615         }
 616 }