mcs/class/System.Runtime.Remoting/Test/RemotingServicesTest.cs

   1 //
   2 // System.Runtime.Remoting.RemotingServices NUnit V2.0 test class
   3 //
   4 // Author Jean-Marc ANDRE (jean-marc.andre@polymtl.ca)
   5 //
   6 // ToDo: I didn't write test functions for the method not yep
   7 // implemented by Mono
   8
   9 using System;
  10 using System.Collections;
  11 using NUnit.Framework;
  12 using System.Reflection;
  13 using System.Runtime.Remoting;
  14 using System.Threading;
  15 using System.Runtime.Remoting.Activation;
  16 using System.Runtime.Remoting.Messaging;
  17 using System.Runtime.Remoting.Proxies;
  18 using System.Runtime.Remoting.Channels;
  19 using System.Runtime.Remoting.Channels.Tcp;
  20
  21 namespace MonoTests.System.Runtime.Remoting.RemotingServicesInternal
  22 {
  23         // We need our own proxy to intercept messages to remote object
  24         // and forward them using RemotingServices.ExecuteMessage
  25         public class MyProxy: RealProxy
  26         {
  27                 MarshalByRefObject target;
  28                 IMessageSink _sink;
  29                 MethodBase _mthBase;
  30                 bool methodOverloaded = false;
  31
  32                 public MethodBase MthBase
  33                 {
  34                         get{ return _mthBase;}
  35                 }
  36
  37                 public bool IsMethodOverloaded
  38                 {
  39                         get{return methodOverloaded;}
  40                 }
  41
  42                 public MyProxy(Type serverType, MarshalByRefObject target): base(serverType)
  43                 {
  44                         this.target = target;
  45
  46                         IChannel[] registeredChannels = ChannelServices.RegisteredChannels;
  47                         string ObjectURI;
  48
  49                         // A new IMessageSink chain has to be created
  50                         // since the RemotingServices.GetEnvoyChainForProxy() is not yet
  51                         // implemented.
  52                         foreach(IChannel channel in registeredChannels)
  53                         {
  54                                 IChannelSender channelSender = channel as IChannelSender;
  55                                 if(channelSender != null)
  56                                 {
  57                                         _sink = (IMessageSink) channelSender.CreateMessageSink(RemotingServices.GetObjectUri(target), null, out ObjectURI);
  58                                 }
  59                         }
  60
  61                 }
  62
  63                 // Messages will be intercepted here and redirected
  64                 // to another object.
  65                 public override IMessage Invoke(IMessage msg)
  66                 {
  67                         try
  68                         {
  69                                 if(msg is IConstructionCallMessage)
  70                                 {
  71                                         IActivator remActivator = (IActivator) RemotingServices.Connect(typeof(IActivator), "tcp://localhost:1234/RemoteActivationService.rem");
  72                                         IConstructionReturnMessage crm = remActivator.Activate((IConstructionCallMessage)msg);
  73                                         return crm;
  74                                 }
  75                                 else
  76                                 {
  77                                         methodOverloaded = RemotingServices.IsMethodOverloaded((IMethodMessage)msg);
  78
  79                                         _mthBase = RemotingServices.GetMethodBaseFromMethodMessage((IMethodMessage)msg);
  80                                         MethodCallMessageWrapper mcm = new MethodCallMessageWrapper((IMethodCallMessage) msg);
  81                                         mcm.Uri = RemotingServices.GetObjectUri((MarshalByRefObject)target);
  82                                         MarshalByRefObject objRem = (MarshalByRefObject)Activator.CreateInstance(GetProxiedType());
  83                                         RemotingServices.ExecuteMessage((MarshalByRefObject)objRem, (IMethodCallMessage)msg);
  84                                         IMessage rtnMsg = null;
  85
  86                                         try
  87                                         {
  88                                                 rtnMsg = _sink.SyncProcessMessage(msg);
  89                                         }
  90                                         catch(Exception e)
  91                                         {
  92                                                 Console.WriteLine(e.Message);
  93                                         }
  94
  95                                         Console.WriteLine ("RR:" + rtnMsg);
  96                                         return rtnMsg;
  97                                 }
  98                         }
  99                         catch (Exception ex)
 100                         {
 101                                 Console.WriteLine (ex);
 102                                 return null;
 103                         }
 104                 }
 105         } // end MyProxy
 106
 107         // This class is used to create "CAO"
 108         public class MarshalObjectFactory: MarshalByRefObject
 109         {
 110                 public MarshalObject GetNewMarshalObject()
 111                 {
 112                         return new MarshalObject();
 113                 }
 114         }
 115
 116         // A class used by the tests
 117         public class MarshalObject: ContextBoundObject
 118         {
 119                 public MarshalObject()
 120                 {
 121
 122                 }
 123
 124                 public MarshalObject(int id, string uri)
 125                 {
 126                         this.id = id;
 127                         this.uri = uri;
 128                 }
 129                 public int Id
 130                 {
 131                         get{return id;}
 132                         set{id = value;}
 133                 }
 134                 public string Uri
 135                 {
 136                         get{return uri;}
 137                 }
 138
 139                 public void Method1()
 140                 {
 141                         _called++;
 142                         methodOneWay = RemotingServices.IsOneWay(MethodBase.GetCurrentMethod());
 143                 }
 144
 145                 public void Method2()
 146                 {
 147                         methodOneWay = RemotingServices.IsOneWay(MethodBase.GetCurrentMethod());
 148                 }
 149
 150                 public void Method2(int i)
 151                 {
 152                         methodOneWay = RemotingServices.IsOneWay(MethodBase.GetCurrentMethod());
 153
 154                 }
 155
 156                 [OneWay()]
 157                 public void Method3()
 158                 {
 159                         methodOneWay = RemotingServices.IsOneWay(MethodBase.GetCurrentMethod());
 160
 161                 }
 162
 163                 public static int Called
 164                 {
 165                         get{return _called;}
 166                 }
 167
 168                 public static bool IsMethodOneWay
 169                 {
 170                         get{return methodOneWay;}
 171                 }
 172
 173
 174                 private static int _called;
 175                 private int id = 0;
 176                 private string uri;
 177                 private static bool methodOneWay = false;
 178         }
 179
 180         // Another class used by the tests
 181         public class DerivedMarshalObject: MarshalObject
 182         {
 183                 public DerivedMarshalObject(){}
 184
 185                 public DerivedMarshalObject(int id, string uri): base(id, uri) {}
 186         }
 187
 188         interface A
 189         {
 190         }
 191
 192         interface B: A
 193         {
 194         }
 195
 196         public class CC: MarshalByRefObject
 197         {
 198         }
 199
 200         public class DD: MarshalByRefObject
 201         {
 202         }
 203
 204
 205 } // namespace MonoTests.System.Runtime.Remoting.RemotingServicesInternal
 206
 207 namespace MonoTests.Remoting
 208 {
 209         using MonoTests.System.Runtime.Remoting.RemotingServicesInternal;
 210
 211         // The main test class
 212         [TestFixture]
 213         public class RemotingServicesTest : Assertion
 214         {
 215                 private static int MarshalObjectId = 0;
 216
 217                 public RemotingServicesTest()
 218                 {
 219                         MarshalObjectId = 0;
 220                 }
 221
 222                 // Helper function that create a new
 223                 // MarshalObject with an unique ID
 224                 private static MarshalObject NewMarshalObject()
 225                 {
 226                         string uri = "MonoTests.System.Runtime.Remoting.RemotingServicesTest.MarshalObject" + MarshalObjectId.ToString();
 227                         MarshalObject objMarshal = new MarshalObject(MarshalObjectId, uri);
 228
 229                         MarshalObjectId++;
 230
 231                         return objMarshal;
 232                 }
 233
 234                 // Another helper function
 235                 private DerivedMarshalObject NewDerivedMarshalObject()
 236                 {
 237                         string uri = "MonoTests.System.Runtime.Remoting.RemotingServicesTest.DerivedMarshalObject" + MarshalObjectId.ToString();
 238                         DerivedMarshalObject objMarshal = new DerivedMarshalObject(MarshalObjectId, uri);
 239
 240                         MarshalObjectId++;
 241
 242                         return objMarshal;
 243                 }
 244
 245                 // The two folling method test RemotingServices.Marshal()
 246                 [Test]
 247                 public void Marshal1()
 248                 {
 249
 250                         MarshalObject objMarshal = NewMarshalObject();
 251                         ObjRef objRef = RemotingServices.Marshal(objMarshal);
 252
 253                         Assert("#A01", objRef.URI != null);
 254
 255                         MarshalObject objRem = (MarshalObject) RemotingServices.Unmarshal(objRef);
 256                         AssertEquals("#A02", objMarshal.Id, objRem.Id);
 257
 258                         objRem.Id = 2;
 259                         AssertEquals("#A03", objMarshal.Id, objRem.Id);
 260
 261                         // TODO: uncomment when RemotingServices.Disconnect is implemented
 262                         //RemotingServices.Disconnect(objMarshal);
 263
 264                         objMarshal = NewMarshalObject();
 265
 266                         objRef = RemotingServices.Marshal(objMarshal, objMarshal.Uri);
 267
 268                         Assert("#A04", objRef.URI.EndsWith(objMarshal.Uri));
 269                         // TODO: uncomment when RemotingServices.Disconnect is implemented
 270                         //RemotingServices.Disconnect(objMarshal);
 271                 }
 272
 273                 [Test]
 274                 public void Marshal2()
 275                 {
 276                         DerivedMarshalObject derivedObjMarshal = NewDerivedMarshalObject();
 277
 278                         ObjRef objRef = RemotingServices.Marshal(derivedObjMarshal, derivedObjMarshal.Uri, typeof(MarshalObject));
 279
 280                         // Check that the type of the marshaled object is MarshalObject
 281                         Assert("#A05", objRef.TypeInfo.TypeName.StartsWith((typeof(MarshalObject)).ToString()));
 282
 283                         // TODO: uncomment when RemotingServices.Disconnect is implemented
 284                         //RemotingServices.Disconnect(derivedObjMarshal);
 285                 }
 286
 287                 // Tests RemotingServices.GetObjectUri()
 288                 [Test]
 289                 public void GetObjectUri()
 290                 {
 291                         MarshalObject objMarshal = NewMarshalObject();
 292
 293                         Assert("#A06", RemotingServices.GetObjectUri(objMarshal) == null);
 294
 295                         ObjRef objRef = RemotingServices.Marshal(objMarshal);
 296
 297                         Assert("#A07", RemotingServices.GetObjectUri(objMarshal) != null);
 298                         // TODO: uncomment when RemotingServices.Disconnect is implemented
 299                         //RemotingServices.Disconnect(objMarshal);
 300                 }
 301
 302                 // Tests RemotingServices.Connect
 303                 [Test]
 304                 public void Connect()
 305                 {
 306                         MarshalObject objMarshal = NewMarshalObject();
 307
 308                         IDictionary props = new Hashtable();
 309                         props["name"] = objMarshal.Uri;
 310                         props["port"] = 1236;
 311                         TcpChannel chn = new TcpChannel(props, null, null);
 312                         ChannelServices.RegisterChannel(chn);
 313
 314                         RemotingServices.Marshal(objMarshal,objMarshal.Uri);
 315
 316                         MarshalObject objRem = (MarshalObject) RemotingServices.Connect(typeof(MarshalObject), "tcp://localhost:1236/" + objMarshal.Uri);
 317
 318                         Assert("#A08", RemotingServices.IsTransparentProxy(objRem));
 319
 320                         ChannelServices.UnregisterChannel(chn);
 321
 322                         RemotingServices.Disconnect(objMarshal);
 323                 }
 324
 325                 // Tests RemotingServices.Marshal()
 326                 [Test]
 327                 [ExpectedException(typeof(RemotingException))]
 328                 public void MarshalThrowException()
 329                 {
 330                         MarshalObject objMarshal = NewMarshalObject();
 331
 332                         IDictionary props = new Hashtable();
 333                         props["name"] = objMarshal.Uri;
 334                         props["port"] = 1237;
 335                         TcpChannel chn = new TcpChannel(props, null, null);
 336                         ChannelServices.RegisterChannel(chn);
 337
 338                         RemotingServices.Marshal(objMarshal,objMarshal.Uri);
 339
 340                         MarshalObject objRem = (MarshalObject) RemotingServices.Connect(typeof(MarshalObject), "tcp://localhost:1237/" + objMarshal.Uri);
 341                         // This line sould throw a RemotingException
 342                         // It is forbidden to export an object which is not
 343                         // a real object
 344                         try
 345                         {
 346                                 RemotingServices.Marshal(objRem, objMarshal.Uri);
 347                         }
 348                         catch(Exception e)
 349                         {
 350                                 ChannelServices.UnregisterChannel(chn);
 351
 352                         // TODO: uncomment when RemotingServices.Disconnect is implemented
 353                         //RemotingServices.Disconnect(objMarshal);
 354
 355                                 throw e;
 356                         }
 357                 }
 358
 359                 // Tests RemotingServices.ExecuteMessage()
 360                 // also tests GetMethodBaseFromMessage()
 361                 // IsMethodOverloaded()
 362                 [Test]
 363                 public void ExecuteMessage()
 364                 {
 365                         TcpChannel chn = null;
 366                         try
 367                         {
 368                                 chn = new TcpChannel(1235);
 369                                 ChannelServices.RegisterChannel(chn);
 370
 371                                 MarshalObject objMarshal = NewMarshalObject();
 372                                 RemotingConfiguration.RegisterWellKnownServiceType(typeof(MarshalObject), objMarshal.Uri, WellKnownObjectMode.SingleCall);
 373
 374                                 // use a proxy to catch the Message
 375                                 MyProxy proxy = new MyProxy(typeof(MarshalObject), (MarshalObject) Activator.GetObject(typeof(MarshalObject), "tcp://localhost:1235/" + objMarshal.Uri));
 376
 377                                 MarshalObject objRem = (MarshalObject) proxy.GetTransparentProxy();
 378
 379                                 objRem.Method1();
 380
 381                                 // Tests RemotingServices.GetMethodBaseFromMethodMessage()
 382                                 AssertEquals("#A09","Method1",proxy.MthBase.Name);
 383                                 Assert("#A09.1", !proxy.IsMethodOverloaded);
 384
 385                                 objRem.Method2();
 386                                 Assert("#A09.2", proxy.IsMethodOverloaded);
 387
 388                                 // Tests RemotingServices.ExecuteMessage();
 389                                 // If ExecuteMessage does it job well, Method1 should be called 2 times
 390                                 AssertEquals("#A10", 2, MarshalObject.Called);
 391                         }
 392                         finally
 393                         {
 394                                 if(chn != null) ChannelServices.UnregisterChannel(chn);
 395                         }
 396                 }
 397
 398                 // Tests the IsOneWay method
 399                 [Test]
 400                 public void IsOneWay()
 401                 {
 402                         TcpChannel chn = null;
 403                         try
 404                         {
 405                                 chn = new TcpChannel(1238);
 406                                 ChannelServices.RegisterChannel(chn);
 407                                 RemotingConfiguration.RegisterWellKnownServiceType(typeof(MarshalObject), "MarshalObject.rem", WellKnownObjectMode.Singleton);
 408
 409                                 MarshalObject objRem = (MarshalObject) Activator.GetObject(typeof(MarshalObject), "tcp://localhost:1238/MarshalObject.rem");
 410
 411                                 Assert("#A10.1", RemotingServices.IsTransparentProxy(objRem));
 412
 413                                 objRem.Method1();
 414                                 Thread.Sleep(20);
 415                                 Assert("#A10.2", !MarshalObject.IsMethodOneWay);
 416                                 objRem.Method3();
 417                                 Thread.Sleep(20);
 418                                 Assert("#A10.3", MarshalObject.IsMethodOneWay);
 419                         }
 420                         finally
 421                         {
 422                                 if(chn != null) ChannelServices.UnregisterChannel(chn);
 423                         }
 424                 }
 425
 426                 [Test]
 427                 public void GetObjRefForProxy()
 428                 {
 429                         TcpChannel chn = null;
 430                         try
 431                         {
 432                                 chn = new TcpChannel(1239);
 433                                 ChannelServices.RegisterChannel(chn);
 434
 435                                 // Register le factory as a SAO
 436                                 RemotingConfiguration.RegisterWellKnownServiceType(typeof(MarshalObjectFactory), "MonoTests.System.Runtime.Remoting.RemotingServicesTest.Factory.soap", WellKnownObjectMode.Singleton);
 437
 438                                 MarshalObjectFactory objFactory = (MarshalObjectFactory) Activator.GetObject(typeof(MarshalObjectFactory), "tcp://localhost:1239/MonoTests.System.Runtime.Remoting.RemotingServicesTest.Factory.soap");
 439
 440                                 // Get a new "CAO"
 441                                 MarshalObject objRem = objFactory.GetNewMarshalObject();
 442
 443                                 ObjRef objRefRem = RemotingServices.GetObjRefForProxy((MarshalByRefObject)objRem);
 444
 445                                 Assert("#A11", objRefRem != null);
 446                         }
 447                         finally
 448                         {
 449                                 if(chn != null) ChannelServices.UnregisterChannel(chn);
 450                         }
 451                 }
 452
 453                 // Tests GetRealProxy
 454                 [Test]
 455                 public void GetRealProxy()
 456                 {
 457                         TcpChannel chn = null;
 458                         try
 459                         {
 460                                 chn = new TcpChannel(1241);
 461                                 ChannelServices.RegisterChannel(chn);
 462
 463                                 RemotingConfiguration.RegisterWellKnownServiceType(typeof(MarshalObject), "MonoTests.System.Runtime.Remoting.RemotingServicesTest.MarshalObject.soap", WellKnownObjectMode.Singleton);
 464
 465                                 MyProxy proxy = new  MyProxy(typeof(MarshalObject), (MarshalByRefObject)Activator.GetObject(typeof(MarshalObject), "tcp://localhost:1241/MonoTests.System.Runtime.Remoting.RemotingServicesTest.MarshalObject.soap"));
 466                                 MarshalObject objRem = (MarshalObject) proxy.GetTransparentProxy();
 467
 468                                 RealProxy rp = RemotingServices.GetRealProxy(objRem);
 469
 470                                 Assert("#A12", rp != null);
 471                                 AssertEquals("#A13", "MonoTests.System.Runtime.Remoting.RemotingServicesInternal.MyProxy", rp.GetType().ToString());
 472                         }
 473                         finally
 474                         {
 475                                 if(chn != null) ChannelServices.UnregisterChannel(chn);
 476                         }
 477                 }
 478
 479                 // Tests SetObjectUriForMarshal()
 480                 [Test]
 481                 public void SetObjectUriForMarshal()
 482                 {
 483                         TcpChannel chn = null;
 484                         try
 485                         {
 486                                 chn = new TcpChannel(1242);
 487                                 ChannelServices.RegisterChannel(chn);
 488
 489                                 MarshalObject objRem = NewMarshalObject();
 490                                 RemotingServices.SetObjectUriForMarshal(objRem, objRem.Uri);
 491                                 RemotingServices.Marshal(objRem);
 492
 493                                 objRem = (MarshalObject) Activator.GetObject(typeof(MarshalObject), "tcp://localhost:1242/"+objRem.Uri);
 494                                 Assert("#A14", objRem != null);
 495                         }
 496                         finally
 497                         {
 498                                 if(chn != null) ChannelServices.UnregisterChannel(chn);
 499                         }
 500
 501                 }
 502
 503                 // Tests GetServeurTypeForUri()
 504                 [Test]
 505                 public void GetServeurTypeForUri()
 506                 {
 507                         TcpChannel chn = null;
 508                         Type type = typeof(MarshalObject);
 509                         try
 510                         {
 511                                 chn = new TcpChannel(1243);
 512                                 ChannelServices.RegisterChannel(chn);
 513
 514                                 MarshalObject objRem = NewMarshalObject();
 515                                 RemotingServices.SetObjectUriForMarshal(objRem, objRem.Uri);
 516                                 RemotingServices.Marshal(objRem);
 517
 518                                 Type typeRem = RemotingServices.GetServerTypeForUri(RemotingServices.GetObjectUri(objRem));
 519                                 AssertEquals("#A15", type, typeRem);
 520                         }
 521                         finally
 522                         {
 523                                 if(chn != null) ChannelServices.UnregisterChannel(chn);
 524                         }
 525                 }
 526
 527                 // Tests IsObjectOutOfDomain
 528                 // Tests IsObjectOutOfContext
 529                 [Test]
 530                 public void IsObjectOutOf()
 531                 {
 532                         TcpChannel chn = null;
 533                         try
 534                         {
 535                                 chn = new TcpChannel(1245);
 536                                 ChannelServices.RegisterChannel(chn);
 537
 538                                 RemotingConfiguration.RegisterWellKnownServiceType(typeof(MarshalObject), "MarshalObject2.rem", WellKnownObjectMode.Singleton);
 539
 540                                 MarshalObject objRem = (MarshalObject) Activator.GetObject(typeof(MarshalObject), "tcp://localhost:1245/MarshalObject2.rem");
 541
 542                                 Assert("#A16", RemotingServices.IsObjectOutOfAppDomain(objRem));
 543                                 Assert("#A17", RemotingServices.IsObjectOutOfContext(objRem));
 544
 545                                 MarshalObject objMarshal = new MarshalObject();
 546                                 Assert("#A18", !RemotingServices.IsObjectOutOfAppDomain(objMarshal));
 547                                 Assert("#A19", !RemotingServices.IsObjectOutOfContext(objMarshal));
 548                         }
 549                         finally
 550                         {
 551                                 ChannelServices.UnregisterChannel(chn);
 552                         }
 553                 }
 554
 555                 [Test]
 556                 public void ConnectProxyCast ()
 557                 {
 558                         object o;
 559                         RemotingConfiguration.Configure (null);
 560
 561                         o = RemotingServices.Connect (typeof(MarshalByRefObject), "tcp://localhost:3434/ff1.rem");
 562                         Assert ("#m1", o is DD);
 563                         Assert ("#m2", o is A);
 564                         Assert ("#m3", o is B);
 565                         Assert ("#m4", !(o is CC));
 566
 567                         o = RemotingServices.Connect (typeof(A), "tcp://localhost:3434/ff3.rem");
 568                         Assert ("#a1", o is DD);
 569                         Assert ("#a2", o is A);
 570                         Assert ("#a3", o is B);
 571                         Assert ("#a4", !(o is CC));
 572
 573                         o = RemotingServices.Connect (typeof(DD), "tcp://localhost:3434/ff4.rem");
 574                         Assert ("#d1", o is DD);
 575                         Assert ("#d2", o is A);
 576                         Assert ("#d3", o is B);
 577                         Assert ("#d4", !(o is CC));
 578
 579                         o = RemotingServices.Connect (typeof(CC), "tcp://localhost:3434/ff5.rem");
 580                         Assert ("#c1", !(o is DD));
 581                         Assert ("#c2", o is A);
 582                         Assert ("#c3", o is B);
 583                         Assert ("#c4", o is CC);
 584                 }
 585
 586         } // end class RemotingServicesTest
 587 } // end of namespace MonoTests.Remoting