mcs/class/System/Test/System.ComponentModel.Design/ServiceContainerTest.cs

   1 // ServiceContainerTest.cs - NUnit Test Cases for System.ComponentModel.Design.ServiceContainer
   2 //
   3 // Alexandre Pigolkine (pigolkine@gmx.de)
   4 //
   5 // (C) Alexandre Pigolkine (pigolkine@gmx.de)
   6 //
   7
   8 #if !MOBILE
   9
  10 using System;
  11 using System.ComponentModel.Design;
  12 using System.Collections;
  13
  14 using NUnit.Framework;
  15
  16 namespace MonoTests.System.ComponentModel.Design
  17 {
  18         class NotInSvc
  19         {
  20                 public NotInSvc ()
  21                 {
  22                 }
  23         }
  24
  25         class Svc
  26         {
  27                 public Svc ()
  28                 {
  29                 }
  30
  31                 private static int objectsCreatedByCallback;
  32
  33                 public static int TotalObjectsCreatedByCallback {
  34                         get { return objectsCreatedByCallback; }
  35                 }
  36
  37                 public static void Reset ()
  38                 {
  39                         objectsCreatedByCallback = 0;
  40                 }
  41
  42                 public static object ServiceCreator (IServiceContainer isc, Type tp)
  43                 {
  44                         Assert.AreEqual (typeof (Svc), tp, "ServiceCreator#01");
  45                         ++objectsCreatedByCallback;
  46                         return new Svc ();
  47                 }
  48         }
  49
  50         [TestFixture]
  51         public class ServiceContainerTest
  52         {
  53                 [SetUp]
  54                 public void SetUp ()
  55                 {
  56                         Svc.Reset ();
  57                 }
  58
  59                 [Test]
  60                 public void AddService1 ()
  61                 {
  62                         object service;
  63                         ServiceContainer parent;
  64                         ServiceContainer sc;
  65
  66                         object serviceInstance1 = new ArrayList ();
  67                         object serviceInstance2 = new Hashtable ();
  68                         object callback1 = new ServiceCreatorCallback (
  69                                 Svc.ServiceCreator);
  70
  71                         sc = new ServiceContainer ();
  72                         sc.AddService (typeof (ICollection), serviceInstance1);
  73                         sc.AddService (typeof (IEnumerable), serviceInstance2);
  74                         sc.AddService (typeof (Svc), callback1);
  75
  76                         service = sc.GetService (typeof (ICollection));
  77                         Assert.IsNotNull (service, "#A1");
  78                         Assert.AreSame (serviceInstance1, service, "#A2");
  79
  80                         service = sc.GetService (typeof (IEnumerable));
  81                         Assert.IsNotNull (service, "#B1");
  82                         Assert.AreSame (serviceInstance2, service, "#B2");
  83
  84                         service = sc.GetService (typeof (ArrayList));
  85                         Assert.IsNull (service, "#C1");
  86
  87                         service = sc.GetService (typeof (ICloneable));
  88                         Assert.IsNull (service, "#D1");
  89
  90                         Assert.AreEqual (0, Svc.TotalObjectsCreatedByCallback, "#E1");
  91                         service = sc.GetService (typeof (Svc));
  92                         Assert.IsNotNull (service, "#E2");
  93                         Assert.IsTrue (service is Svc, "#E3");
  94                         Assert.AreEqual (1, Svc.TotalObjectsCreatedByCallback, "#E4");
  95                         Assert.AreSame (service, sc.GetService (typeof (Svc)), "#E5");
  96                         Assert.AreEqual (1, Svc.TotalObjectsCreatedByCallback, "#E6");
  97
  98                         parent = new ServiceContainer ();
  99                         sc = new ServiceContainer (parent);
 100
 101                         sc.AddService (typeof (ICollection), serviceInstance1);
 102
 103                         Assert.AreSame (serviceInstance1, sc.GetService (typeof (ICollection)), "#F1");
 104                         Assert.IsNull (parent.GetService (typeof (ICollection)), "#F2");
 105                 }
 106
 107                 [Test]
 108                 public void AddService1_Disposed ()
 109                 {
 110                         object service;
 111                         ServiceContainer sc;
 112
 113                         object serviceInstance1 = new ArrayList ();
 114                         object serviceInstance2 = new Hashtable ();
 115
 116                         sc = new ServiceContainer ();
 117                         sc.AddService (typeof (ICollection), serviceInstance1);
 118                         service = sc.GetService (typeof (ICollection));
 119                         Assert.IsNotNull (service, "#A1");
 120                         Assert.AreSame (serviceInstance1, service, "#A2");
 121
 122                         sc.Dispose ();
 123
 124                         service = sc.GetService (typeof (ICollection));
 125                         Assert.IsNull (service, "#B");
 126
 127                         sc.AddService (typeof (ICollection), serviceInstance2);
 128                         service = sc.GetService (typeof (ICollection));
 129                         Assert.IsNotNull (service, "#C1");
 130                         Assert.AreSame (serviceInstance2, service, "#C2");
 131                 }
 132
 133                 [Test] // AddService (Type, Object)
 134                 public void AddService1_ServiceInstance_Null ()
 135                 {
 136                         ServiceContainer sc = new ServiceContainer ();
 137
 138                         try {
 139                                 sc.AddService (typeof (IList), (object) null);
 140                                 Assert.Fail ("#1");
 141                         } catch (ArgumentNullException ex) {
 142                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 143                                 Assert.IsNull (ex.InnerException, "#3");
 144                                 Assert.IsNotNull (ex.Message, "#4");
 145                                 Assert.AreEqual ("serviceInstance", ex.ParamName, "#5");
 146                         }
 147                 }
 148
 149                 [Test]
 150                 public void AddService1_ServiceType_Exists ()
 151                 {
 152                         ServiceContainer sc = new ServiceContainer ();
 153
 154                         Svc serviceInstance1 = new Svc ();
 155                         Svc serviceInstance2 = new Svc ();
 156
 157                         sc.AddService (typeof (Svc), serviceInstance1);
 158                         Assert.AreSame (serviceInstance1, sc.GetService (typeof (Svc)), "#A");
 159
 160                         try {
 161                                 sc.AddService (typeof (Svc), serviceInstance1);
 162                                 Assert.Fail ("#B1");
 163                         } catch (ArgumentException ex) {
 164                                 // The service MonoTests.System.ComponentModel.Design.Svc
 165                                 // already exists in the service container
 166                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 167                                 Assert.IsNull (ex.InnerException, "#B3");
 168                                 Assert.IsNotNull (ex.Message, "#B4");
 169                                 Assert.IsTrue (ex.Message.IndexOf (typeof (Svc).FullName) != -1, "#B5");
 170                                 Assert.AreEqual ("serviceType", ex.ParamName, "#B6");
 171                         }
 172
 173                         try {
 174                                 sc.AddService (typeof (Svc), serviceInstance2);
 175                                 Assert.Fail ("#C1");
 176                         } catch (ArgumentException ex) {
 177                                 // The service MonoTests.System.ComponentModel.Design.Svc
 178                                 // already exists in the service container
 179                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
 180                                 Assert.IsNull (ex.InnerException, "#C3");
 181                                 Assert.IsNotNull (ex.Message, "#C4");
 182                                 Assert.IsTrue (ex.Message.IndexOf (typeof (Svc).FullName) != -1, "#C5");
 183                                 Assert.AreEqual ("serviceType", ex.ParamName, "#C6");
 184                         }
 185                 }
 186
 187                 [Test] // AddService (Type, Object)
 188                 public void AddService1_ServiceType_Null ()
 189                 {
 190                         ServiceContainer sc = new ServiceContainer ();
 191
 192                         try {
 193                                 sc.AddService ((Type) null, new ArrayList ());
 194                                 Assert.Fail ("#1");
 195                         } catch (ArgumentNullException ex) {
 196                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 197                                 Assert.IsNull (ex.InnerException, "#3");
 198                                 Assert.IsNotNull (ex.Message, "#4");
 199                                 Assert.AreEqual ("serviceType", ex.ParamName, "#5");
 200                         }
 201                 }
 202
 203                 [Test] // AddService (Type, ServiceCreatorCallback)
 204                 public void AddService2_Callback_Null ()
 205                 {
 206                         ServiceContainer sc = new ServiceContainer ();
 207                         ServiceCreatorCallback callback = null;
 208
 209                         try {
 210                                 sc.AddService (typeof (IList), callback);
 211                                 Assert.Fail ("#1");
 212                         } catch (ArgumentNullException ex) {
 213                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 214                                 Assert.IsNull (ex.InnerException, "#3");
 215                                 Assert.IsNotNull (ex.Message, "#4");
 216                                 Assert.AreEqual ("callback", ex.ParamName, "#5");
 217                         }
 218                 }
 219
 220                 [Test] // AddService (Type, ServiceCreatorCallback)
 221                 public void AddService2_Disposed ()
 222                 {
 223                         object service;
 224                         ServiceContainer sc;
 225
 226                         object callback = new ServiceCreatorCallback (
 227                                 Svc.ServiceCreator);
 228
 229                         sc = new ServiceContainer ();
 230                         sc.AddService (typeof (Svc), callback);
 231                         service = sc.GetService (typeof (Svc));
 232                         Assert.IsNotNull (service, "#A");
 233
 234                         sc.Dispose ();
 235
 236                         service = sc.GetService (typeof (Svc));
 237                         Assert.IsNull (service, "#B");
 238
 239                         sc.AddService (typeof (Svc), callback);
 240                         service = sc.GetService (typeof (Svc));
 241                         Assert.IsNotNull (service, "#C");
 242                 }
 243
 244                 [Test] // AddService (Type, ServiceCreatorCallback)
 245                 public void AddService2_ServiceType_Null ()
 246                 {
 247                         ServiceContainer sc = new ServiceContainer ();
 248                         ServiceCreatorCallback callback = new ServiceCreatorCallback (
 249                                 Svc.ServiceCreator);
 250
 251                         try {
 252                                 sc.AddService ((Type) null, callback);
 253                                 Assert.Fail ("#1");
 254                         } catch (ArgumentNullException ex) {
 255                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 256                                 Assert.IsNull (ex.InnerException, "#3");
 257                                 Assert.IsNotNull (ex.Message, "#4");
 258                                 Assert.AreEqual ("serviceType", ex.ParamName, "#5");
 259                         }
 260                 }
 261
 262                 [Test] // AddService (Type, Object, Boolean)
 263                 public void AddService3 ()
 264                 {
 265                         ServiceContainer sc;
 266                         ServiceContainer parent = new ServiceContainer ();
 267
 268                         ArrayList serviceInstance1 = new ArrayList ();
 269                         ArrayList serviceInstance2 = new ArrayList ();
 270
 271                         Type serviceType1 = typeof (IList);
 272                         Type serviceType2 = typeof (IEnumerable);
 273
 274                         sc = new ServiceContainer (parent);
 275                         sc.AddService (serviceType1, serviceInstance1, true);
 276                         sc.AddService (serviceType2, serviceInstance2, false);
 277
 278                         Assert.AreSame (serviceInstance1, parent.GetService (serviceType1), "#A1");
 279                         Assert.IsNull (parent.GetService (serviceType2), "#A2");
 280                         Assert.AreSame (serviceInstance1, sc.GetService (serviceType1), "#A3");
 281                         Assert.AreSame (serviceInstance2, sc.GetService (serviceType2), "#A4");
 282
 283                         sc = new ServiceContainer ();
 284                         sc.AddService (serviceType1, serviceInstance1, true);
 285                         sc.AddService (serviceType2, serviceInstance2, false);
 286
 287                         Assert.AreSame (serviceInstance1, sc.GetService (serviceType1), "#B1");
 288                         Assert.AreSame (serviceInstance2, sc.GetService (serviceType2), "#B2");
 289
 290                         parent = new ServiceContainer ();
 291                         sc = new ServiceContainer (parent);
 292                         sc.AddService (serviceType1, serviceInstance1, true);
 293                         sc.AddService (serviceType1, serviceInstance2, false);
 294
 295                         Assert.AreSame (serviceInstance2, sc.GetService (serviceType1), "#C1");
 296                         Assert.AreSame (serviceInstance1, parent.GetService (serviceType1), "#C2");
 297                 }
 298
 299                 [Test] // AddService (Type, Object, Boolean)
 300                 public void AddService3_Disposed ()
 301                 {
 302                         ServiceContainer sc;
 303                         ServiceContainer parent = new ServiceContainer ();
 304
 305                         ArrayList serviceInstance1 = new ArrayList ();
 306                         ArrayList serviceInstance2 = new ArrayList ();
 307
 308                         Type serviceType1 = typeof (IList);
 309                         Type serviceType2 = typeof (IEnumerable);
 310
 311                         sc = new ServiceContainer (parent);
 312                         sc.AddService (serviceType1, serviceInstance1, true);
 313                         sc.AddService (serviceType2, serviceInstance2, false);
 314
 315                         sc.Dispose ();
 316
 317                         Assert.AreSame (serviceInstance1, parent.GetService (serviceType1), "#A1");
 318                         Assert.IsNull (parent.GetService (serviceType2), "#A2");
 319                         Assert.AreSame (serviceInstance1, sc.GetService (serviceType1), "#A3");
 320                         Assert.IsNull (sc.GetService (serviceType2), "#A4");
 321
 322                         sc.AddService (serviceType2, serviceInstance2, false);
 323
 324                         Assert.AreSame (serviceInstance1, parent.GetService (serviceType1), "#B1");
 325                         Assert.IsNull (parent.GetService (serviceType2), "#B2");
 326                         Assert.AreSame (serviceInstance1, sc.GetService (serviceType1), "#B3");
 327                         Assert.AreSame (serviceInstance2, sc.GetService (serviceType2), "#B4");
 328                 }
 329
 330                 [Test] // AddService (Type, Object, Boolean)
 331                 public void AddService3_ServiceInstance_Null ()
 332                 {
 333                         ServiceContainer sc = new ServiceContainer ();
 334
 335                         try {
 336                                 sc.AddService (typeof (IList), (object) null, false);
 337                                 Assert.Fail ("#A1");
 338                         } catch (ArgumentNullException ex) {
 339                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 340                                 Assert.IsNull (ex.InnerException, "#A3");
 341                                 Assert.IsNotNull (ex.Message, "#A4");
 342                                 Assert.AreEqual ("serviceInstance", ex.ParamName, "#A5");
 343                         }
 344
 345                         try {
 346                                 sc.AddService (typeof (IList), (object) null, true);
 347                                 Assert.Fail ("#B1");
 348                         } catch (ArgumentNullException ex) {
 349                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
 350                                 Assert.IsNull (ex.InnerException, "#B3");
 351                                 Assert.IsNotNull (ex.Message, "#B4");
 352                                 Assert.AreEqual ("serviceInstance", ex.ParamName, "#B5");
 353                         }
 354                 }
 355
 356                 [Test] // AddService (Type, Object, Boolean)
 357                 public void AddService3_ServiceType_Null ()
 358                 {
 359                         ServiceContainer sc = new ServiceContainer ();
 360
 361                         try {
 362                                 sc.AddService ((Type) null, new ArrayList (), false);
 363                                 Assert.Fail ("#A1");
 364                         } catch (ArgumentNullException ex) {
 365                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 366                                 Assert.IsNull (ex.InnerException, "#A3");
 367                                 Assert.IsNotNull (ex.Message, "#A4");
 368                                 Assert.AreEqual ("serviceType", ex.ParamName, "#A5");
 369                         }
 370
 371                         try {
 372                                 sc.AddService ((Type) null, new ArrayList (), true);
 373                                 Assert.Fail ("#B1");
 374                         } catch (ArgumentNullException ex) {
 375                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
 376                                 Assert.IsNull (ex.InnerException, "#B3");
 377                                 Assert.IsNotNull (ex.Message, "#B4");
 378                                 Assert.AreEqual ("serviceType", ex.ParamName, "#B5");
 379                         }
 380                 }
 381
 382                 [Test] // AddService (Type, ServiceCreatorCallback, Boolean)
 383                 public void AddService4_Callback_Null ()
 384                 {
 385                         ServiceContainer sc = new ServiceContainer ();
 386                         ServiceCreatorCallback callback = null;
 387
 388                         try {
 389                                 sc.AddService (typeof (IList), callback, false);
 390                                 Assert.Fail ("#A1");
 391                         } catch (ArgumentNullException ex) {
 392                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 393                                 Assert.IsNull (ex.InnerException, "#A3");
 394                                 Assert.IsNotNull (ex.Message, "#A4");
 395                                 Assert.AreEqual ("callback", ex.ParamName, "#A5");
 396                         }
 397
 398                         try {
 399                                 sc.AddService (typeof (IList), callback, true);
 400                                 Assert.Fail ("#B1");
 401                         } catch (ArgumentNullException ex) {
 402                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
 403                                 Assert.IsNull (ex.InnerException, "#B3");
 404                                 Assert.IsNotNull (ex.Message, "#B4");
 405                                 Assert.AreEqual ("callback", ex.ParamName, "#B5");
 406                         }
 407                 }
 408
 409                 [Test] // AddService (Type, ServiceCreatorCallback, Boolean)
 410                 public void AddService4_ServiceType_Null ()
 411                 {
 412                         ServiceContainer sc = new ServiceContainer ();
 413                         ServiceCreatorCallback callback = new ServiceCreatorCallback (
 414                                 Svc.ServiceCreator);
 415
 416                         try {
 417                                 sc.AddService ((Type) null, callback, false);
 418                                 Assert.Fail ("#A1");
 419                         } catch (ArgumentNullException ex) {
 420                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 421                                 Assert.IsNull (ex.InnerException, "#A3");
 422                                 Assert.IsNotNull (ex.Message, "#A4");
 423                                 Assert.AreEqual ("serviceType", ex.ParamName, "#A5");
 424                         }
 425
 426                         try {
 427                                 sc.AddService ((Type) null, callback, true);
 428                                 Assert.Fail ("#B1");
 429                         } catch (ArgumentNullException ex) {
 430                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
 431                                 Assert.IsNull (ex.InnerException, "#B3");
 432                                 Assert.IsNotNull (ex.Message, "#B4");
 433                                 Assert.AreEqual ("serviceType", ex.ParamName, "#B5");
 434                         }
 435                 }
 436
 437                 [Test]
 438                 public void GeneralTest1 ()
 439                 {
 440                         ServiceContainer sc = new ServiceContainer ();
 441
 442                         sc.AddService (typeof (Svc), new Svc ());
 443                         Svc service1 = sc.GetService (typeof (Svc)) as Svc;
 444                         Assert.IsNotNull (service1, "#1");
 445                         Assert.AreEqual (service1, sc.GetService (typeof (Svc)), "#2");
 446                         Assert.IsNull (sc.GetService (typeof (NotInSvc)), "#3");
 447                 }
 448
 449                 [Test]
 450                 public void GeneralTest2 ()
 451                 {
 452                         ServiceContainer sc = new ServiceContainer ();
 453
 454                         sc.AddService (typeof (Svc), new Svc ());
 455                         Svc service1 = sc.GetService (typeof (Svc)) as Svc;
 456                         Assert.IsNotNull (service1, "#A");
 457                         Assert.AreEqual (service1, sc.GetService (typeof (Svc)), "#2");
 458
 459                         try {
 460                                 sc.AddService (typeof (Svc), new Svc ());
 461                                 Assert.Fail ("#B1");
 462                         } catch (ArgumentException ex) {
 463                                 // The service MonoTests.System.ComponentModel.Design.Svc
 464                                 // already exists in the service container
 465                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 466                                 Assert.IsNull (ex.InnerException, "#B3");
 467                                 Assert.IsNotNull (ex.Message, "#B4");
 468                                 Assert.IsTrue (ex.Message.IndexOf (typeof (Svc).FullName) != -1, "#B5");
 469                                 Assert.AreEqual ("serviceType", ex.ParamName, "#B6");
 470                         }
 471                 }
 472
 473                 [Test]
 474                 public void GetService_DefaultServices ()
 475                 {
 476                         ServiceContainer sc1 = new ServiceContainer ();
 477
 478                         Assert.AreSame (sc1, sc1.GetService (typeof (IServiceContainer)), "#A1");
 479                         Assert.AreSame (sc1, sc1.GetService (typeof(ServiceContainer)), "#A2");
 480
 481                         ServiceContainer sc2 = new ServiceContainer ();
 482                         sc1.AddService (typeof (IServiceContainer), sc2);
 483                         sc1.AddService (typeof (ServiceContainer), sc2);
 484
 485                         Assert.AreSame (sc1, sc1.GetService (typeof (IServiceContainer)), "#B1");
 486                         Assert.AreSame (sc1, sc1.GetService (typeof(ServiceContainer)), "#B2");
 487                 }
 488
 489                 [Test]
 490                 public void TestServiceCreator ()
 491                 {
 492                         ServiceContainer sc = new ServiceContainer ();
 493                         sc.AddService (typeof(Svc), new ServiceCreatorCallback (Svc.ServiceCreator));
 494                         Assert.IsNull (sc.GetService (typeof (NotInSvc)), "#A");
 495
 496                         Svc service1 = sc.GetService (typeof (Svc)) as Svc;
 497                         Assert.IsNotNull (service1, "#B1");
 498                         Assert.AreEqual (1, Svc.TotalObjectsCreatedByCallback, "#B2");
 499
 500                         Svc service2 = sc.GetService (typeof (Svc)) as Svc;
 501                         Assert.AreEqual (service1, service2, "#C1");
 502                         Assert.AreEqual (1, Svc.TotalObjectsCreatedByCallback, "#C2");
 503                 }
 504
 505                 [Test]
 506                 public void ParentService ()
 507                 {
 508                         ServiceContainer scParent = new ServiceContainer ();
 509                         ServiceContainer sc = new ServiceContainer (scParent);
 510
 511                         scParent.AddService(typeof(Svc), new Svc ());
 512
 513                         Svc service1 = sc.GetService (typeof (Svc)) as Svc;
 514                         Assert.IsNotNull (service1, "#1");
 515                 }
 516
 517                 [Test] // RemoveService (Type)
 518                 public void RemoveService1 ()
 519                 {
 520                         ServiceContainer sc;
 521                         ServiceContainer parent;
 522
 523                         ArrayList serviceInstance1 = new ArrayList ();
 524                         ArrayList serviceInstance2 = new ArrayList ();
 525
 526                         Type serviceType1 = typeof (IList);
 527                         Type serviceType2 = typeof (IEnumerable);
 528
 529                         parent = null;
 530                         sc = new ServiceContainer (parent);
 531                         sc.AddService (serviceType1, serviceInstance1);
 532                         sc.AddService (serviceType2, serviceInstance2);
 533
 534                         sc.RemoveService (typeof (DateTime));
 535
 536                         Assert.AreSame (serviceInstance1, sc.GetService (serviceType1), "#A1");
 537                         Assert.AreSame (serviceInstance2, sc.GetService (serviceType2), "#A2");
 538
 539                         sc.RemoveService (serviceType2);
 540
 541                         Assert.AreSame (serviceInstance1, sc.GetService (serviceType1), "#B1");
 542                         Assert.IsNull (sc.GetService (serviceType2), "#B2");
 543
 544                         sc.RemoveService (serviceType1);
 545
 546                         Assert.IsNull (sc.GetService (serviceType1), "#C1");
 547                         Assert.IsNull (sc.GetService (serviceType2), "#C2");
 548
 549                         sc.AddService (serviceType1, serviceInstance1);
 550                         sc.AddService (serviceType2, serviceInstance2);
 551
 552                         Assert.AreSame (serviceInstance1, sc.GetService (serviceType1), "#D1");
 553                         Assert.AreSame (serviceInstance2, sc.GetService (serviceType2), "#D2");
 554
 555                         parent = new ServiceContainer ();
 556                         sc = new ServiceContainer (parent);
 557                         sc.AddService (serviceType1, serviceInstance1, true);
 558                         sc.AddService (serviceType2, serviceInstance2, false);
 559
 560                         sc.RemoveService (serviceType1);
 561
 562                         Assert.AreSame (serviceInstance1, sc.GetService (serviceType1), "#E1");
 563                         Assert.AreSame (serviceInstance2, sc.GetService (serviceType2), "#E2");
 564
 565                         sc.RemoveService (serviceType2);
 566
 567                         Assert.AreSame (serviceInstance1, sc.GetService (serviceType1), "#F1");
 568                         Assert.IsNull (sc.GetService (serviceType2), "#F2");
 569
 570                         parent.RemoveService (serviceType1);
 571
 572                         Assert.IsNull (sc.GetService (serviceType1), "#G1");
 573                         Assert.IsNull (sc.GetService (serviceType2), "#G2");
 574
 575                         parent = new ServiceContainer ();
 576                         sc = new ServiceContainer (parent);
 577                         sc.AddService (serviceType1, serviceInstance1, true);
 578                         sc.AddService (serviceType1, serviceInstance2, false);
 579
 580                         sc.RemoveService (serviceType1);
 581
 582                         Assert.AreSame (serviceInstance1, sc.GetService (serviceType1), "#H1");
 583                         Assert.AreSame (serviceInstance1, parent.GetService (serviceType1), "#H2");
 584
 585                         sc.RemoveService (serviceType1);
 586
 587                         Assert.AreSame (serviceInstance1, sc.GetService (serviceType1), "#I1");
 588                         Assert.AreSame (serviceInstance1, parent.GetService (serviceType1), "#I2");
 589
 590                         parent.RemoveService (serviceType1);
 591
 592                         Assert.IsNull (sc.GetService (serviceType1), "#J1");
 593                         Assert.IsNull (parent.GetService (serviceType1), "#J2");
 594
 595                         parent = new ServiceContainer ();
 596                         sc = new ServiceContainer (parent);
 597                         sc.AddService (serviceType1, serviceInstance1, true);
 598                         sc.AddService (serviceType1, serviceInstance2, false);
 599
 600                         parent.RemoveService (serviceType1);
 601
 602                         Assert.AreSame (serviceInstance2, sc.GetService (serviceType1), "#K1");
 603                         Assert.IsNull (parent.GetService (serviceType1), "#K2");
 604                 }
 605
 606                 [Test] // RemoveService (Type)
 607                 public void RemoveService1_Disposed ()
 608                 {
 609                         ServiceContainer sc;
 610                         ServiceContainer parent;
 611
 612                         ArrayList serviceInstance1 = new ArrayList ();
 613
 614                         Type serviceType1 = typeof (IList);
 615
 616                         parent = null;
 617                         sc = new ServiceContainer (parent);
 618                         sc.AddService (serviceType1, serviceInstance1);
 619                         sc.Dispose ();
 620
 621                         sc.RemoveService (typeof (DateTime));
 622                 }
 623
 624                 [Test] // RemoveService (Type)
 625                 public void RemoveService1_ServiceType_Null ()
 626                 {
 627                         ServiceContainer sc = new ServiceContainer ();
 628
 629                         try {
 630                                 sc.RemoveService ((Type) null);
 631                                 Assert.Fail ("#1");
 632                         } catch (ArgumentNullException ex) {
 633                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 634                                 Assert.IsNull (ex.InnerException, "#3");
 635                                 Assert.IsNotNull (ex.Message, "#4");
 636                                 Assert.AreEqual ("serviceType", ex.ParamName, "#5");
 637                         }
 638                 }
 639
 640                 [Test] // RemoveService (Type, Boolean)
 641                 public void RemoveService2 ()
 642                 {
 643                         ServiceContainer sc;
 644                         ServiceContainer parent;
 645
 646                         ArrayList serviceInstance1 = new ArrayList ();
 647                         ArrayList serviceInstance2 = new ArrayList ();
 648
 649                         Type serviceType1 = typeof (IList);
 650                         Type serviceType2 = typeof (IEnumerable);
 651
 652                         parent = new ServiceContainer ();
 653                         sc = new ServiceContainer (parent);
 654                         sc.AddService (serviceType1, serviceInstance1, true);
 655                         sc.AddService (serviceType2, serviceInstance2, false);
 656
 657                         sc.RemoveService (serviceType1, false);
 658                         sc.RemoveService (serviceType2, false);
 659
 660                         Assert.AreSame (serviceInstance1, sc.GetService (serviceType1), "#A1");
 661                         Assert.IsNull (sc.GetService (serviceType2), "#A2");
 662
 663                         sc.RemoveService (serviceType1, true);
 664                         sc.RemoveService (serviceType2, true);
 665
 666                         Assert.IsNull (sc.GetService (serviceType1), "#B1");
 667                         Assert.IsNull (sc.GetService (serviceType2), "#B2");
 668
 669                         sc.AddService (serviceType1, serviceInstance1, true);
 670                         Assert.AreSame (serviceInstance1, sc.GetService (serviceType1), "#C1");
 671                         parent.RemoveService (serviceType1);
 672                         Assert.IsNull (sc.GetService (serviceType1), "#C2");
 673
 674                         parent = new ServiceContainer ();
 675                         sc = new ServiceContainer (parent);
 676                         sc.AddService (serviceType1, serviceInstance1, true);
 677                         sc.AddService (serviceType2, serviceInstance2, false);
 678
 679                         sc.RemoveService (serviceType1, true);
 680                         sc.RemoveService (serviceType2, true);
 681
 682                         Assert.IsNull (sc.GetService (serviceType1), "#D1");
 683                         Assert.AreSame (serviceInstance2, sc.GetService (serviceType2), "#D2");
 684
 685                         sc = new ServiceContainer ();
 686                         sc.AddService (serviceType1, serviceInstance1, true);
 687                         sc.RemoveService (serviceType1, true);
 688                         Assert.IsNull (sc.GetService (serviceType1), "#E");
 689
 690                         parent = new ServiceContainer ();
 691                         sc = new ServiceContainer (parent);
 692                         sc.AddService (serviceType1, serviceInstance1, true);
 693                         sc.AddService (serviceType1, serviceInstance2, false);
 694
 695                         sc.RemoveService (serviceType1, true);
 696
 697                         Assert.AreSame (serviceInstance2, sc.GetService (serviceType1), "#F1");
 698                         Assert.IsNull (parent.GetService (serviceType1), "#F2");
 699
 700                         sc.RemoveService (serviceType1, true);
 701
 702                         Assert.AreSame (serviceInstance2, sc.GetService (serviceType1), "#G1");
 703                         Assert.IsNull (parent.GetService (serviceType1), "#G2");
 704
 705                         sc.RemoveService (serviceType1, false);
 706
 707                         Assert.IsNull (sc.GetService (serviceType1), "#H1");
 708                         Assert.IsNull (parent.GetService (serviceType1), "#H2");
 709                 }
 710
 711                 [Test] // RemoveService (Type, Boolean)
 712                 public void RemoveService2_Disposed ()
 713                 {
 714                         ServiceContainer sc;
 715                         ServiceContainer parent;
 716
 717                         ArrayList serviceInstance1 = new ArrayList ();
 718                         ArrayList serviceInstance2 = new ArrayList ();
 719
 720                         Type serviceType1 = typeof (IList);
 721                         Type serviceType2 = typeof (IEnumerable);
 722
 723                         parent = new ServiceContainer ();
 724                         sc = new ServiceContainer (parent);
 725                         sc.AddService (serviceType1, serviceInstance1, true);
 726                         sc.AddService (serviceType2, serviceInstance2, false);
 727
 728                         sc.Dispose ();
 729
 730                         sc.RemoveService (serviceType1, false);
 731                         sc.RemoveService (serviceType2, false);
 732
 733                         Assert.AreSame (serviceInstance1, sc.GetService (serviceType1), "#A1");
 734                         Assert.IsNull (sc.GetService (serviceType2), "#A2");
 735
 736                         sc.RemoveService (serviceType1, true);
 737                         sc.RemoveService (serviceType2, true);
 738
 739                         Assert.IsNull (sc.GetService (serviceType1), "#B1");
 740                         Assert.IsNull (sc.GetService (serviceType2), "#B2");
 741                 }
 742
 743                 [Test] // RemoveService (Type, Boolean)
 744                 public void RemoveService2_ServiceType_Null ()
 745                 {
 746                         ServiceContainer sc = new ServiceContainer ();
 747
 748                         try {
 749                                 sc.RemoveService ((Type) null, false);
 750                                 Assert.Fail ("#A1");
 751                         } catch (ArgumentNullException ex) {
 752                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 753                                 Assert.IsNull (ex.InnerException, "#A3");
 754                                 Assert.IsNotNull (ex.Message, "#A4");
 755                                 Assert.AreEqual ("serviceType", ex.ParamName, "#A5");
 756                         }
 757
 758                         try {
 759                                 sc.RemoveService ((Type) null, true);
 760                                 Assert.Fail ("#B1");
 761                         } catch (ArgumentNullException ex) {
 762                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
 763                                 Assert.IsNull (ex.InnerException, "#B3");
 764                                 Assert.IsNotNull (ex.Message, "#B4");
 765                                 Assert.AreEqual ("serviceType", ex.ParamName, "#B5");
 766                         }
 767                 }
 768         }
 769 }
 770
 771 #endif