mcs/class/System/Test/System.ComponentModel/ContainerTest.cs

   1 //
   2 // System.ComponentModel.Container test cases
   3 //
   4 // Authors:
   5 //      Gonzalo Paniagua Javier (gonzalo@ximian.com)
   6 //  Ivan N. Zlatev (contact i-nZ.net)
   7
   8 // Copyright (c) 2006 Novell, Inc. (http://www.novell.com)
   9 // Copyright (c) 2006 Ivan N. Zlatev
  10 //
  11
  12 #if !MOBILE
  13
  14 using NUnit.Framework;
  15 using System;
  16 using System.ComponentModel;
  17 using System.ComponentModel.Design;
  18
  19 namespace MonoTests.System.ComponentModel
  20 {
  21         class TestService {
  22         }
  23
  24         class TestContainer : Container {
  25                 ServiceContainer _services = new ServiceContainer ();
  26                 bool allowDuplicateNames;
  27
  28                 public TestContainer()
  29                 {
  30                         _services.AddService (typeof (TestService), new TestService ());
  31                 }
  32
  33                 public bool AllowDuplicateNames {
  34                         get { return allowDuplicateNames; }
  35                         set { allowDuplicateNames = value; }
  36                 }
  37
  38                 protected override object GetService (Type serviceType)
  39                 {
  40                         return _services.GetService (serviceType);
  41                 }
  42
  43 #if NET_2_0
  44                 public new void RemoveWithoutUnsiting (IComponent component)
  45                 {
  46                         base.RemoveWithoutUnsiting (component);
  47                 }
  48
  49                 public void InvokeValidateName (IComponent component, string name)
  50                 {
  51                         ValidateName (component, name);
  52                 }
  53
  54                 protected override void ValidateName (IComponent component, string name)
  55                 {
  56                         if (AllowDuplicateNames)
  57                                 return;
  58                         base.ValidateName (component, name);
  59                 }
  60 #endif
  61
  62                 public bool Contains (IComponent component)
  63                 {
  64                         bool found = false;
  65
  66                         foreach (IComponent c in Components) {
  67                                 if (component.Equals (c)) {
  68                                         found = true;
  69                                         break;
  70                                 }
  71                         }
  72                         return found;
  73                 }
  74
  75                 public new void Dispose (bool disposing)
  76                 {
  77                         base.Dispose (disposing);
  78                 }
  79         }
  80
  81         class TestComponent : Component {
  82                 public override ISite Site {
  83                         get {
  84                                 return base.Site;
  85                         }
  86                         set {
  87                                 base.Site = value;
  88                                 if (value != null) {
  89                                         Assert.IsNotNull (value.GetService (typeof (ISite)), "ISite");
  90                                         Assert.IsNotNull (value.GetService (typeof (TestService)), "TestService");
  91                                 }
  92                         }
  93                 }
  94
  95                 public bool IsDisposed {
  96                         get { return disposed; }
  97                 }
  98
  99                 public bool ThrowOnDispose {
 100                         get { return throwOnDispose; }
 101                         set { throwOnDispose = value; }
 102                 }
 103
 104                 protected override void Dispose (bool disposing)
 105                 {
 106                         if (ThrowOnDispose)
 107                                 throw new InvalidOperationException ();
 108
 109                         base.Dispose (disposing);
 110                         disposed = true;
 111                 }
 112
 113                 private bool disposed;
 114                 private bool throwOnDispose;
 115         }
 116
 117         [TestFixture]
 118         public class ContainerTest
 119         {
 120                 private TestContainer _container;
 121
 122                 [SetUp]
 123                 public void Init ()
 124                 {
 125                         _container = new TestContainer ();
 126                 }
 127
 128                 [Test] // Add (IComponent)
 129                 public void Add1 ()
 130                 {
 131                         TestContainer containerA = new TestContainer ();
 132                         TestContainer containerB = new TestContainer ();
 133
 134                         ISite siteA;
 135                         ISite siteB;
 136
 137                         TestComponent compA = new TestComponent ();
 138                         Assert.IsNull (compA.Site);
 139                         TestComponent compB = new TestComponent ();
 140                         Assert.IsNull (compB.Site);
 141                         Assert.AreEqual (0, containerA.Components.Count);
 142                         Assert.AreEqual (0, containerB.Components.Count);
 143
 144                         containerA.Add (compA);
 145                         siteA = compA.Site;
 146                         Assert.IsNotNull (siteA);
 147                         Assert.AreSame (compA, siteA.Component);
 148                         Assert.AreSame (containerA, siteA.Container);
 149                         Assert.IsFalse (siteA.DesignMode);
 150                         Assert.IsNull (siteA.Name);
 151                         containerA.Add (compB);
 152                         siteB = compB.Site;
 153                         Assert.IsNotNull (siteB);
 154                         Assert.AreSame (compB, siteB.Component);
 155                         Assert.AreSame (containerA, siteB.Container);
 156                         Assert.IsFalse (siteB.DesignMode);
 157                         Assert.IsNull (siteB.Name);
 158
 159                         Assert.IsFalse (object.ReferenceEquals (siteA, siteB));
 160                         Assert.AreEqual (2, containerA.Components.Count);
 161                         Assert.AreEqual (0, containerB.Components.Count);
 162                         Assert.AreSame (compA, containerA.Components [0]);
 163                         Assert.AreSame (compB, containerA.Components [1]);
 164
 165                         // check effect of adding component that is already member of
 166                         // another container
 167                         containerB.Add (compA);
 168                         Assert.IsFalse (object.ReferenceEquals (siteA, compA.Site));
 169                         siteA = compA.Site;
 170                         Assert.IsNotNull (siteA);
 171                         Assert.AreSame (compA, siteA.Component);
 172                         Assert.AreSame (containerB, siteA.Container);
 173                         Assert.IsFalse (siteA.DesignMode);
 174                         Assert.IsNull (siteA.Name);
 175
 176                         Assert.AreEqual (1, containerA.Components.Count);
 177                         Assert.AreEqual (1, containerB.Components.Count);
 178                         Assert.AreSame (compB, containerA.Components [0]);
 179                         Assert.AreSame (compA, containerB.Components [0]);
 180
 181                         // check effect of add component twice to same container
 182                         containerB.Add (compA);
 183                         Assert.AreSame (siteA, compA.Site);
 184
 185                         Assert.AreEqual (1, containerA.Components.Count);
 186                         Assert.AreEqual (1, containerB.Components.Count);
 187                         Assert.AreSame (compB, containerA.Components [0]);
 188                         Assert.AreSame (compA, containerB.Components [0]);
 189                 }
 190
 191                 [Test]
 192                 public void Add1_Component_Null ()
 193                 {
 194                         _container.Add ((IComponent) null);
 195                         Assert.AreEqual (0, _container.Components.Count);
 196                 }
 197
 198                 [Test] // Add (IComponent, String)
 199                 public void Add2 ()
 200                 {
 201                         TestContainer containerA = new TestContainer ();
 202                         TestContainer containerB = new TestContainer ();
 203
 204                         ISite siteA;
 205                         ISite siteB;
 206
 207                         TestComponent compA = new TestComponent ();
 208                         Assert.IsNull (compA.Site);
 209                         TestComponent compB = new TestComponent ();
 210                         Assert.IsNull (compB.Site);
 211                         Assert.AreEqual (0, containerA.Components.Count);
 212                         Assert.AreEqual (0, containerB.Components.Count);
 213
 214                         containerA.Add (compA, "A");
 215                         siteA = compA.Site;
 216                         Assert.IsNotNull (siteA);
 217                         Assert.AreSame (compA, siteA.Component);
 218                         Assert.AreSame (containerA, siteA.Container);
 219                         Assert.IsFalse (siteA.DesignMode);
 220                         Assert.AreEqual ("A", siteA.Name);
 221                         containerA.Add (compB, "B");
 222                         siteB = compB.Site;
 223                         Assert.IsNotNull (siteB);
 224                         Assert.AreSame (compB, siteB.Component);
 225                         Assert.AreSame (containerA, siteB.Container);
 226                         Assert.IsFalse (siteB.DesignMode);
 227                         Assert.AreEqual ("B", siteB.Name);
 228
 229                         Assert.IsFalse (object.ReferenceEquals (siteA, siteB));
 230                         Assert.AreEqual (2, containerA.Components.Count);
 231                         Assert.AreEqual (0, containerB.Components.Count);
 232                         Assert.AreSame (compA, containerA.Components [0]);
 233                         Assert.AreSame (compB, containerA.Components [1]);
 234
 235                         // check effect of adding component that is already member of
 236                         // another container
 237                         containerB.Add (compA, "A2");
 238                         Assert.IsFalse (object.ReferenceEquals (siteA, compA.Site));
 239                         siteA = compA.Site;
 240                         Assert.IsNotNull (siteA);
 241                         Assert.AreSame (compA, siteA.Component);
 242                         Assert.AreSame (containerB, siteA.Container);
 243                         Assert.IsFalse (siteA.DesignMode);
 244                         Assert.AreEqual ("A2", siteA.Name);
 245
 246                         Assert.AreEqual (1, containerA.Components.Count);
 247                         Assert.AreEqual (1, containerB.Components.Count);
 248                         Assert.AreSame (compB, containerA.Components [0]);
 249                         Assert.AreSame (compA, containerB.Components [0]);
 250
 251                         // check effect of add component twice to same container
 252                         containerB.Add (compA, "A2");
 253                         Assert.AreSame (siteA, compA.Site);
 254                         Assert.AreEqual ("A2", siteA.Name);
 255
 256                         Assert.AreEqual (1, containerA.Components.Count);
 257                         Assert.AreEqual (1, containerB.Components.Count);
 258                         Assert.AreSame (compB, containerA.Components [0]);
 259                         Assert.AreSame (compA, containerB.Components [0]);
 260
 261                         // add again with different name
 262                         containerB.Add (compA, "A3");
 263                         Assert.AreSame (siteA, compA.Site);
 264                         Assert.AreEqual ("A2", siteA.Name);
 265
 266                         Assert.AreEqual (1, containerA.Components.Count);
 267                         Assert.AreEqual (1, containerB.Components.Count);
 268                         Assert.AreSame (compB, containerA.Components [0]);
 269                         Assert.AreSame (compA, containerB.Components [0]);
 270
 271                         // check effect of add component twice to same container
 272                         containerB.Add (compA, "A2");
 273                         Assert.AreSame (siteA, compA.Site);
 274                         Assert.AreEqual ("A2", siteA.Name);
 275                 }
 276
 277                 [Test]
 278                 public void Add2_Component_Null ()
 279                 {
 280                         _container.Add ((IComponent) null, "A");
 281                         Assert.AreEqual (0, _container.Components.Count);
 282                         _container.Add (new TestComponent (), "A");
 283                         Assert.AreEqual (1, _container.Components.Count);
 284                         _container.Add ((IComponent) null, "A");
 285                         Assert.AreEqual (1, _container.Components.Count);
 286                 }
 287
 288                 [Test]
 289                 public void Add2_Name_Duplicate ()
 290                 {
 291                         TestContainer container = new TestContainer ();
 292                         TestComponent c1 = new TestComponent ();
 293                         container.Add (c1, "dup");
 294
 295                         // new component, same case
 296                         TestComponent c2 = new TestComponent ();
 297                         try {
 298                                 container.Add (c2, "dup");
 299                                 Assert.Fail ("#A1");
 300                         } catch (ArgumentException ex) {
 301                                 // Duplicate component name 'dup'.  Component names must be
 302                                 // unique and case-insensitive
 303                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 304                                 Assert.IsNull (ex.InnerException, "#A3");
 305                                 Assert.IsNotNull (ex.Message, "#A4");
 306                                 Assert.IsTrue (ex.Message.IndexOf ("'dup'") != -1, "#A5");
 307                                 Assert.IsNull (ex.ParamName, "#A6");
 308                                 Assert.AreEqual (1, container.Components.Count, "#A7");
 309                         }
 310
 311                         // new component, different case
 312                         TestComponent c3 = new TestComponent ();
 313                         try {
 314                                 container.Add (c3, "duP");
 315                                 Assert.Fail ("#B1");
 316                         } catch (ArgumentException ex) {
 317                                 // Duplicate component name 'duP'.  Component names must be
 318                                 // unique and case-insensitive
 319                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 320                                 Assert.IsNull (ex.InnerException, "#B3");
 321                                 Assert.IsNotNull (ex.Message, "#B4");
 322                                 Assert.IsTrue (ex.Message.IndexOf ("'duP'") != -1, "#B5");
 323                                 Assert.IsNull (ex.ParamName, "#B6");
 324                                 Assert.AreEqual (1, container.Components.Count, "#B7");
 325                         }
 326
 327                         // existing component, same case
 328                         TestComponent c4 = new TestComponent ();
 329                         container.Add (c4, "C4");
 330                         Assert.AreEqual (2, container.Components.Count, "#C1");
 331                         container.Add (c4, "dup");
 332                         Assert.AreEqual (2, container.Components.Count, "#C2");
 333                         Assert.AreEqual ("C4", c4.Site.Name, "#C3");
 334
 335                         // component of other container, same case
 336                         TestContainer container2 = new TestContainer ();
 337                         TestComponent c5 = new TestComponent ();
 338                         container2.Add (c5, "C5");
 339                         try {
 340                                 container.Add (c5, "dup");
 341                                 Assert.Fail ("#D1");
 342                         } catch (ArgumentException ex) {
 343                                 // Duplicate component name 'dup'.  Component names must be
 344                                 // unique and case-insensitive
 345                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
 346                                 Assert.IsNull (ex.InnerException, "#D3");
 347                                 Assert.IsNotNull (ex.Message, "#D4");
 348                                 Assert.IsTrue (ex.Message.IndexOf ("'dup'") != -1, "#D5");
 349                                 Assert.IsNull (ex.ParamName, "#D6");
 350                                 Assert.AreEqual (2, container.Components.Count, "#D7");
 351                         }
 352                         Assert.AreEqual (1, container2.Components.Count, "#D8");
 353                         Assert.AreSame (c5, container2.Components [0], "#D9");
 354
 355 #if NET_2_0
 356                         container.AllowDuplicateNames = true;
 357                         TestComponent c6 = new TestComponent ();
 358                         container.Add (c6, "dup");
 359                         Assert.AreEqual (3, container.Components.Count, "#E1");
 360                         Assert.IsNotNull (c1.Site, "#E2");
 361                         Assert.AreEqual ("dup", c1.Site.Name, "#E3");
 362                         Assert.IsNotNull (c6.Site, "#E4");
 363                         Assert.AreEqual ("dup", c6.Site.Name, "#E5");
 364                         Assert.IsFalse (object.ReferenceEquals (c1.Site, c6.Site), "#E6");
 365 #endif
 366                 }
 367
 368                 [Test]
 369                 public void AddRemove ()
 370                 {
 371                         TestComponent component = new TestComponent ();
 372
 373                         _container.Add (component);
 374                         Assert.IsNotNull (component.Site, "#1");
 375                         Assert.IsTrue (_container.Contains (component), "#2");
 376
 377                         _container.Remove (component);
 378                         Assert.IsNull (component.Site, "#3");
 379                         Assert.IsFalse (_container.Contains (component), "#4");
 380                 }
 381
 382                 [Test] // Dispose ()
 383                 public void Dispose1 ()
 384                 {
 385                         TestComponent compA;
 386                         TestComponent compB;
 387
 388                         compA = new TestComponent ();
 389                         _container.Add (compA);
 390                         compB = new TestComponent ();
 391                         _container.Add (compB);
 392
 393                         _container.Dispose ();
 394
 395                         Assert.AreEqual (0, _container.Components.Count, "#A1");
 396                         Assert.IsTrue (compA.IsDisposed, "#A2");
 397                         Assert.IsNull (compA.Site, "#A3");
 398                         Assert.IsTrue (compB.IsDisposed, "#A4");
 399                         Assert.IsNull (compB.Site, "#A5");
 400
 401                         _container = new TestContainer ();
 402                         compA = new TestComponent ();
 403                         compA.ThrowOnDispose = true;
 404                         _container.Add (compA);
 405                         compB = new TestComponent ();
 406                         _container.Add (compB);
 407
 408                         // assert that component is not removed from components until after
 409                         // Dispose of component has succeeded
 410                         try {
 411                                 _container.Dispose ();
 412                                 Assert.Fail ("#B1");
 413                         } catch (InvalidOperationException) {
 414                                 Assert.AreEqual (0, _container.Components.Count, "#B2");
 415                                 Assert.IsFalse (compA.IsDisposed, "#B4");
 416                                 Assert.IsNull (compA.Site, "#B5");
 417                                 Assert.IsTrue (compB.IsDisposed, "#B6");
 418                                 Assert.IsNull (compB.Site, "#B7");
 419                         } finally {
 420                                 compA.ThrowOnDispose = false;
 421                         }
 422
 423                         _container = new TestContainer ();
 424                         compA = new TestComponent ();
 425                         _container.Add (compA);
 426                         compB = new TestComponent ();
 427                         compB.ThrowOnDispose = true;
 428                         _container.Add (compB);
 429
 430                         try {
 431                                 _container.Dispose ();
 432                                 Assert.Fail ("#C1");
 433                         } catch (InvalidOperationException) {
 434                                 Assert.AreEqual (1, _container.Components.Count, "#C2");
 435                                 Assert.AreSame (compA, _container.Components [0], "#C3");
 436                                 Assert.IsFalse (compA.IsDisposed, "#C4");
 437                                 Assert.IsNotNull (compA.Site, "#C5");
 438                                 Assert.IsFalse (compB.IsDisposed, "#C6");
 439                                 Assert.IsNull (compB.Site, "#C7");
 440                         } finally {
 441                                 compB.ThrowOnDispose = false;
 442                         }
 443                 }
 444
 445                 [Test] // Dispose (Boolean)
 446                 public void Dispose2 ()
 447                 {
 448                         TestComponent compA;
 449                         TestComponent compB;
 450
 451                         compA = new TestComponent ();
 452                         _container.Add (compA);
 453                         compB = new TestComponent ();
 454                         _container.Add (compB);
 455
 456                         _container.Dispose (false);
 457
 458                         Assert.AreEqual (2, _container.Components.Count, "#A1");
 459                         Assert.IsFalse (compA.IsDisposed, "#A2");
 460                         Assert.IsNotNull (compA.Site, "#A3");
 461                         Assert.IsFalse (compB.IsDisposed, "#A4");
 462                         Assert.IsNotNull (compB.Site, "#A5");
 463
 464                         _container.Dispose (true);
 465
 466                         Assert.AreEqual (0, _container.Components.Count, "#B1");
 467                         Assert.IsTrue (compA.IsDisposed, "#B2");
 468                         Assert.IsNull (compA.Site, "#B3");
 469                         Assert.IsTrue (compB.IsDisposed, "#B4");
 470                         Assert.IsNull (compB.Site, "#B5");
 471
 472                         compA = new TestComponent ();
 473                         _container.Add (compA);
 474                         compB = new TestComponent ();
 475                         _container.Add (compB);
 476
 477                         Assert.AreEqual (2, _container.Components.Count, "#C1");
 478                         Assert.IsFalse (compA.IsDisposed, "#C2");
 479                         Assert.IsNotNull (compA.Site, "#C3");
 480                         Assert.IsFalse (compB.IsDisposed, "#C4");
 481                         Assert.IsNotNull (compB.Site, "#C5");
 482
 483                         _container.Dispose (true);
 484
 485                         Assert.AreEqual (0, _container.Components.Count, "#D1");
 486                         Assert.IsTrue (compA.IsDisposed, "#D2");
 487                         Assert.IsNull (compA.Site, "#D3");
 488                         Assert.IsTrue (compB.IsDisposed, "#D4");
 489                         Assert.IsNull (compB.Site, "#D5");
 490                 }
 491
 492                 [Test] // bug #522474
 493                 public void Dispose_Recursive ()
 494                 {
 495                         MyComponent comp = new MyComponent ();
 496                         Container container = comp.CreateContainer ();
 497                         comp.Dispose ();
 498                         Assert.AreEqual (0, container.Components.Count);
 499                 }
 500
 501                 [Test]
 502                 public void GetService ()
 503                 {
 504                         object service;
 505
 506                         GetServiceContainer container = new GetServiceContainer ();
 507                         container.Add (new MyComponent ());
 508                         service = container.GetService (typeof (MyComponent));
 509                         Assert.IsNull (service, "#1");
 510                         service = container.GetService (typeof (Component));
 511                         Assert.IsNull (service, "#2");
 512                         service = container.GetService (typeof (IContainer));
 513                         Assert.AreSame (container, service, "#3");
 514                         service = container.GetService ((Type) null);
 515                         Assert.IsNull (service, "#4");
 516                 }
 517
 518                 [Test]
 519                 public void Remove ()
 520                 {
 521                         TestComponent compA;
 522                         TestComponent compB;
 523                         ISite siteA;
 524                         ISite siteB;
 525
 526                         compA = new TestComponent ();
 527                         _container.Add (compA);
 528                         siteA = compA.Site;
 529                         compB = new TestComponent ();
 530                         _container.Add (compB);
 531                         siteB = compB.Site;
 532                         _container.Remove (compB);
 533                         Assert.AreSame (siteA, compA.Site, "#A1");
 534                         Assert.IsNull (compB.Site, "#A2");
 535                         Assert.AreEqual (1, _container.Components.Count, "#A3");
 536                         Assert.AreSame (compA, _container.Components [0], "#A4");
 537
 538                         // remove component with no site
 539                         compB = new TestComponent ();
 540                         _container.Remove (compB);
 541                         Assert.AreSame (siteA, compA.Site, "#B1");
 542                         Assert.IsNull (compB.Site, "#B2");
 543                         Assert.AreEqual (1, _container.Components.Count, "#B3");
 544                         Assert.AreSame (compA, _container.Components [0], "#B4");
 545
 546                         // remove component associated with other container
 547                         TestContainer container2 = new TestContainer ();
 548                         compB = new TestComponent ();
 549                         container2.Add (compB);
 550                         siteB = compB.Site;
 551                         _container.Remove (compB);
 552                         Assert.AreSame (siteA, compA.Site, "#C1");
 553                         Assert.AreSame (siteB, compB.Site, "#C2");
 554                         Assert.AreEqual (1, _container.Components.Count, "#C3");
 555                         Assert.AreSame (compA, _container.Components [0], "#C4");
 556                         Assert.AreEqual (1, container2.Components.Count, "#C5");
 557                         Assert.AreSame (compB, container2.Components [0], "#C6");
 558                 }
 559
 560                 [Test]
 561                 public void Remove_Component_Null ()
 562                 {
 563                         _container.Add (new TestComponent ());
 564                         _container.Remove ((IComponent) null);
 565                         Assert.AreEqual (1, _container.Components.Count);
 566                 }
 567
 568 #if NET_2_0
 569                 [Test]
 570                 public void RemoveWithoutUnsiting ()
 571                 {
 572                         TestComponent compA;
 573                         TestComponent compB;
 574                         ISite siteA;
 575                         ISite siteB;
 576
 577                         compA = new TestComponent ();
 578                         _container.Add (compA);
 579                         siteA = compA.Site;
 580                         compB = new TestComponent ();
 581                         _container.Add (compB);
 582                         siteB = compB.Site;
 583                         _container.RemoveWithoutUnsiting (compB);
 584                         Assert.AreSame (siteA, compA.Site, "#A1");
 585                         Assert.AreSame (siteB, compB.Site, "#A2");
 586                         Assert.AreEqual (1, _container.Components.Count, "#A3");
 587                         Assert.AreSame (compA, _container.Components [0], "#A4");
 588
 589                         // remove component with no site
 590                         compB = new TestComponent ();
 591                         _container.RemoveWithoutUnsiting (compB);
 592                         Assert.AreSame (siteA, compA.Site, "#B1");
 593                         Assert.IsNull (compB.Site, "#B2");
 594                         Assert.AreEqual (1, _container.Components.Count, "#B3");
 595                         Assert.AreSame (compA, _container.Components [0], "#B4");
 596
 597                         // remove component associated with other container
 598                         TestContainer container2 = new TestContainer ();
 599                         compB = new TestComponent ();
 600                         container2.Add (compB);
 601                         siteB = compB.Site;
 602                         _container.RemoveWithoutUnsiting (compB);
 603                         Assert.AreSame (siteA, compA.Site, "#C1");
 604                         Assert.AreSame (siteB, compB.Site, "#C2");
 605                         Assert.AreEqual (1, _container.Components.Count, "#C3");
 606                         Assert.AreSame (compA, _container.Components [0], "#C4");
 607                         Assert.AreEqual (1, container2.Components.Count, "#C5");
 608                         Assert.AreSame (compB, container2.Components [0], "#C6");
 609                 }
 610
 611                 [Test]
 612                 public void RemoveWithoutUnsiting_Component_Null ()
 613                 {
 614                         ISite site;
 615                         TestComponent component;
 616
 617                         component = new TestComponent ();
 618                         _container.Add (component);
 619                         site = component.Site;
 620                         _container.RemoveWithoutUnsiting ((IComponent) null);
 621                         Assert.AreSame (site, component.Site, "#1");
 622                         Assert.AreEqual (1, _container.Components.Count, "#2");
 623                         Assert.AreSame (component, _container.Components [0], "#3");
 624                 }
 625
 626                 [Test]
 627                 public void ValidateName_Component_Null ()
 628                 {
 629                         try {
 630                                 _container.InvokeValidateName ((IComponent) null, "A");
 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 ("component", ex.ParamName, "#5");
 637                         }
 638                 }
 639
 640                 [Test]
 641                 public void ValidateName_Name_Null ()
 642                 {
 643                         TestComponent compA = new TestComponent ();
 644                         _container.Add (compA, (string) null);
 645                         TestComponent compB = new TestComponent ();
 646                         _container.InvokeValidateName (compB, (string) null);
 647                 }
 648
 649                 [Test]
 650                 public void ValidateName_Name_Duplicate ()
 651                 {
 652                         TestComponent compA = new TestComponent ();
 653                         _container.Add (compA, "dup");
 654
 655                         // same component, same case
 656                         _container.InvokeValidateName (compA, "dup");
 657
 658                         // existing component, same case
 659                         TestComponent compB = new TestComponent ();
 660                         _container.Add (compB, "B");
 661                         try {
 662                                 _container.InvokeValidateName (compB, "dup");
 663                                 Assert.Fail ("#A1");
 664                         } catch (ArgumentException ex) {
 665                                 // Duplicate component name 'duP'.  Component names must be
 666                                 // unique and case-insensitive
 667                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 668                                 Assert.IsNull (ex.InnerException, "#A3");
 669                                 Assert.IsNotNull (ex.Message, "#A4");
 670                                 Assert.IsTrue (ex.Message.IndexOf ("'dup'") != -1, "#A5");
 671                                 Assert.IsNull (ex.ParamName, "#A6");
 672                                 Assert.AreEqual (2, _container.Components.Count, "#A7");
 673                         }
 674                         _container.InvokeValidateName (compB, "whatever");
 675
 676                         // new component, different case
 677                         TestComponent compC = new TestComponent ();
 678                         try {
 679                                 _container.InvokeValidateName (compC, "dup");
 680                                 Assert.Fail ("#B1");
 681                         } catch (ArgumentException ex) {
 682                                 // Duplicate component name 'duP'.  Component names must be
 683                                 // unique and case-insensitive
 684                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 685                                 Assert.IsNull (ex.InnerException, "#B3");
 686                                 Assert.IsNotNull (ex.Message, "#B4");
 687                                 Assert.IsTrue (ex.Message.IndexOf ("'dup'") != -1, "#B5");
 688                                 Assert.IsNull (ex.ParamName, "#B6");
 689                                 Assert.AreEqual (2, _container.Components.Count, "#B7");
 690                         }
 691                         _container.InvokeValidateName (compC, "whatever");
 692
 693                         // component of other container, different case
 694                         TestContainer container2 = new TestContainer ();
 695                         TestComponent compD = new TestComponent ();
 696                         container2.Add (compD, "B");
 697                         try {
 698                                 _container.InvokeValidateName (compD, "dup");
 699                                 Assert.Fail ("#C1");
 700                         } catch (ArgumentException ex) {
 701                                 // Duplicate component name 'duP'.  Component names must be
 702                                 // unique and case-insensitive
 703                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
 704                                 Assert.IsNull (ex.InnerException, "#C3");
 705                                 Assert.IsNotNull (ex.Message, "#C4");
 706                                 Assert.IsTrue (ex.Message.IndexOf ("'dup'") != -1, "#C5");
 707                                 Assert.IsNull (ex.ParamName, "#C6");
 708                                 Assert.AreEqual (2, _container.Components.Count, "#C7");
 709                         }
 710                         _container.InvokeValidateName (compD, "whatever");
 711                         Assert.AreEqual (1, container2.Components.Count, "#C8");
 712                         Assert.AreSame (compD, container2.Components [0], "#C9");
 713                 }
 714 #endif
 715
 716                 class MyComponent : Component
 717                 {
 718                         private Container container;
 719
 720                         protected override void Dispose (bool disposing)
 721                         {
 722                                 if (container != null)
 723                                         container.Dispose ();
 724                                 base.Dispose (disposing);
 725                         }
 726
 727                         public Container CreateContainer ()
 728                         {
 729                                 if (container != null)
 730                                         throw new InvalidOperationException ();
 731                                 container = new Container ();
 732                                 container.Add (new MyComponent ());
 733                                 container.Add (this);
 734                                 return container;
 735                         }
 736
 737                         public Container Container {
 738                                 get { return container; }
 739                         }
 740                 }
 741
 742                 class MyContainer : IContainer
 743                 {
 744                         private ComponentCollection components = new ComponentCollection (
 745                                 new Component [0]);
 746
 747                         public ComponentCollection Components {
 748                                 get { return components; }
 749                         }
 750
 751                         public void Add (IComponent component)
 752                         {
 753                         }
 754
 755                         public void Add (IComponent component, string name)
 756                         {
 757                         }
 758
 759                         public void Remove (IComponent component)
 760                         {
 761                         }
 762
 763                         public void Dispose ()
 764                         {
 765                         }
 766                 }
 767
 768                 public class GetServiceContainer : Container
 769                 {
 770                         public new object GetService (Type service)
 771                         {
 772                                 return base.GetService (service);
 773                         }
 774                 }
 775         }
 776 }
 777
 778 #endif