From 506ae3239bad50e208b65f723adc5142a674081b Mon Sep 17 00:00:00 2001 From: Gert Driesen Date: Sat, 18 Jul 2009 08:20:49 +0000 Subject: * ContainerTest.cs: Added tests for Add, Dispose, ValidateName and GetService. * Container.cs: Changed Dispose(bool) behaviour to match .NET, based on patch by Tom Hindle (tom_hindle@sil.org). Also use ValidateName in Add overloads on 1.0 profile by making it available as private method. Use case-insensitive comparison of component name. svn path=/trunk/mcs/; revision=138174 --- .../System/Test/System.ComponentModel/ChangeLog | 5 + .../Test/System.ComponentModel/ContainerTest.cs | 565 ++++++++++++++++++++- 2 files changed, 548 insertions(+), 22 deletions(-) (limited to 'mcs/class/System/Test') diff --git a/mcs/class/System/Test/System.ComponentModel/ChangeLog b/mcs/class/System/Test/System.ComponentModel/ChangeLog index 9c4191317dd..b6a2aa7fb87 100644 --- a/mcs/class/System/Test/System.ComponentModel/ChangeLog +++ b/mcs/class/System/Test/System.ComponentModel/ChangeLog @@ -1,3 +1,8 @@ +2009-07-18 Gert Driesen + + * ContainerTest.cs: Added tests for Add, Dispose, ValidateName and + GetService. + 2009-06-26 Robert Jordan * EventHandlerListTests.cs, LicenseManagerTests.cs: diff --git a/mcs/class/System/Test/System.ComponentModel/ContainerTest.cs b/mcs/class/System/Test/System.ComponentModel/ContainerTest.cs index 78e0f153320..28f3045a17a 100644 --- a/mcs/class/System/Test/System.ComponentModel/ContainerTest.cs +++ b/mcs/class/System/Test/System.ComponentModel/ContainerTest.cs @@ -20,14 +20,22 @@ namespace MonoTests.System.ComponentModel } class TestContainer : Container { - ServiceContainer _services = new ServiceContainer(); + ServiceContainer _services = new ServiceContainer (); + bool allowDuplicateNames; - public TestContainer() { - _services.AddService( typeof(TestService), new TestService() ); + public TestContainer() + { + _services.AddService (typeof (TestService), new TestService ()); } - - protected override object GetService( Type serviceType ) { - return _services.GetService( serviceType ); + + public bool AllowDuplicateNames { + get { return allowDuplicateNames; } + set { allowDuplicateNames = value; } + } + + protected override object GetService (Type serviceType) + { + return _services.GetService (serviceType); } #if NET_2_0 @@ -35,8 +43,20 @@ namespace MonoTests.System.ComponentModel { base.RemoveWithoutUnsiting (component); } + + public void InvokeValidateName (IComponent component, string name) + { + ValidateName (component, name); + } + + protected override void ValidateName (IComponent component, string name) + { + if (AllowDuplicateNames) + return; + base.ValidateName (component, name); + } #endif - + public bool Contains (IComponent component) { bool found = false; @@ -49,6 +69,11 @@ namespace MonoTests.System.ComponentModel } return found; } + + public new void Dispose (bool disposing) + { + base.Dispose (disposing); + } } class TestComponent : Component { @@ -59,26 +84,285 @@ namespace MonoTests.System.ComponentModel set { base.Site = value; if (value != null) { - Assert.IsNotNull (value.GetService (typeof (ISite))); - Assert.IsNotNull (value.GetService (typeof (TestService))); + Assert.IsNotNull (value.GetService (typeof (ISite)), "ISite"); + Assert.IsNotNull (value.GetService (typeof (TestService)), "TestService"); } } } + + public bool IsDisposed { + get { return disposed; } + } + + public bool ThrowOnDispose { + get { return throwOnDispose; } + set { throwOnDispose = value; } + } + + protected override void Dispose (bool disposing) + { + if (ThrowOnDispose) + throw new InvalidOperationException (); + + base.Dispose (disposing); + disposed = true; + } + + private bool disposed; + private bool throwOnDispose; } [TestFixture] public class ContainerTest { - private TestContainer _container; - + [SetUp] public void Init () { _container = new TestContainer (); } - + [Test] // Add (IComponent) + public void Add1 () + { + TestContainer containerA = new TestContainer (); + TestContainer containerB = new TestContainer (); + + ISite siteA; + ISite siteB; + + TestComponent compA = new TestComponent (); + Assert.IsNull (compA.Site); + TestComponent compB = new TestComponent (); + Assert.IsNull (compB.Site); + Assert.AreEqual (0, containerA.Components.Count); + Assert.AreEqual (0, containerB.Components.Count); + + containerA.Add (compA); + siteA = compA.Site; + Assert.IsNotNull (siteA); + Assert.AreSame (compA, siteA.Component); + Assert.AreSame (containerA, siteA.Container); + Assert.IsFalse (siteA.DesignMode); + Assert.IsNull (siteA.Name); + containerA.Add (compB); + siteB = compB.Site; + Assert.IsNotNull (siteB); + Assert.AreSame (compB, siteB.Component); + Assert.AreSame (containerA, siteB.Container); + Assert.IsFalse (siteB.DesignMode); + Assert.IsNull (siteB.Name); + + Assert.IsFalse (object.ReferenceEquals (siteA, siteB)); + Assert.AreEqual (2, containerA.Components.Count); + Assert.AreEqual (0, containerB.Components.Count); + Assert.AreSame (compA, containerA.Components [0]); + Assert.AreSame (compB, containerA.Components [1]); + + // check effect of adding component that is already member of + // another container + containerB.Add (compA); + Assert.IsFalse (object.ReferenceEquals (siteA, compA.Site)); + siteA = compA.Site; + Assert.IsNotNull (siteA); + Assert.AreSame (compA, siteA.Component); + Assert.AreSame (containerB, siteA.Container); + Assert.IsFalse (siteA.DesignMode); + Assert.IsNull (siteA.Name); + + Assert.AreEqual (1, containerA.Components.Count); + Assert.AreEqual (1, containerB.Components.Count); + Assert.AreSame (compB, containerA.Components [0]); + Assert.AreSame (compA, containerB.Components [0]); + + // check effect of add component twice to same container + containerB.Add (compA); + Assert.AreSame (siteA, compA.Site); + + Assert.AreEqual (1, containerA.Components.Count); + Assert.AreEqual (1, containerB.Components.Count); + Assert.AreSame (compB, containerA.Components [0]); + Assert.AreSame (compA, containerB.Components [0]); + } + + [Test] + public void Add1_Component_Null () + { + _container.Add ((IComponent) null); + Assert.AreEqual (0, _container.Components.Count); + } + + [Test] // Add (IComponent, String) + public void Add2 () + { + TestContainer containerA = new TestContainer (); + TestContainer containerB = new TestContainer (); + + ISite siteA; + ISite siteB; + + TestComponent compA = new TestComponent (); + Assert.IsNull (compA.Site); + TestComponent compB = new TestComponent (); + Assert.IsNull (compB.Site); + Assert.AreEqual (0, containerA.Components.Count); + Assert.AreEqual (0, containerB.Components.Count); + + containerA.Add (compA, "A"); + siteA = compA.Site; + Assert.IsNotNull (siteA); + Assert.AreSame (compA, siteA.Component); + Assert.AreSame (containerA, siteA.Container); + Assert.IsFalse (siteA.DesignMode); + Assert.AreEqual ("A", siteA.Name); + containerA.Add (compB, "B"); + siteB = compB.Site; + Assert.IsNotNull (siteB); + Assert.AreSame (compB, siteB.Component); + Assert.AreSame (containerA, siteB.Container); + Assert.IsFalse (siteB.DesignMode); + Assert.AreEqual ("B", siteB.Name); + + Assert.IsFalse (object.ReferenceEquals (siteA, siteB)); + Assert.AreEqual (2, containerA.Components.Count); + Assert.AreEqual (0, containerB.Components.Count); + Assert.AreSame (compA, containerA.Components [0]); + Assert.AreSame (compB, containerA.Components [1]); + + // check effect of adding component that is already member of + // another container + containerB.Add (compA, "A2"); + Assert.IsFalse (object.ReferenceEquals (siteA, compA.Site)); + siteA = compA.Site; + Assert.IsNotNull (siteA); + Assert.AreSame (compA, siteA.Component); + Assert.AreSame (containerB, siteA.Container); + Assert.IsFalse (siteA.DesignMode); + Assert.AreEqual ("A2", siteA.Name); + + Assert.AreEqual (1, containerA.Components.Count); + Assert.AreEqual (1, containerB.Components.Count); + Assert.AreSame (compB, containerA.Components [0]); + Assert.AreSame (compA, containerB.Components [0]); + + // check effect of add component twice to same container + containerB.Add (compA, "A2"); + Assert.AreSame (siteA, compA.Site); + Assert.AreEqual ("A2", siteA.Name); + + Assert.AreEqual (1, containerA.Components.Count); + Assert.AreEqual (1, containerB.Components.Count); + Assert.AreSame (compB, containerA.Components [0]); + Assert.AreSame (compA, containerB.Components [0]); + + // add again with different name + containerB.Add (compA, "A3"); + Assert.AreSame (siteA, compA.Site); + Assert.AreEqual ("A2", siteA.Name); + + Assert.AreEqual (1, containerA.Components.Count); + Assert.AreEqual (1, containerB.Components.Count); + Assert.AreSame (compB, containerA.Components [0]); + Assert.AreSame (compA, containerB.Components [0]); + + // check effect of add component twice to same container + containerB.Add (compA, "A2"); + Assert.AreSame (siteA, compA.Site); + Assert.AreEqual ("A2", siteA.Name); + } + + [Test] + public void Add2_Component_Null () + { + _container.Add ((IComponent) null, "A"); + Assert.AreEqual (0, _container.Components.Count); + _container.Add (new TestComponent (), "A"); + Assert.AreEqual (1, _container.Components.Count); + _container.Add ((IComponent) null, "A"); + Assert.AreEqual (1, _container.Components.Count); + } + + [Test] + public void Add2_Name_Duplicate () + { + TestContainer container = new TestContainer (); + TestComponent c1 = new TestComponent (); + container.Add (c1, "dup"); + + // new component, same case + TestComponent c2 = new TestComponent (); + try { + container.Add (c2, "dup"); + Assert.Fail ("#A1"); + } catch (ArgumentException ex) { + // Duplicate component name 'dup'. Component names must be + // unique and case-insensitive + Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + Assert.IsTrue (ex.Message.IndexOf ("'dup'") != -1, "#A5"); + Assert.IsNull (ex.ParamName, "#A6"); + Assert.AreEqual (1, container.Components.Count, "#A7"); + } + + // new component, different case + TestComponent c3 = new TestComponent (); + try { + container.Add (c3, "duP"); + Assert.Fail ("#B1"); + } catch (ArgumentException ex) { + // Duplicate component name 'duP'. Component names must be + // unique and case-insensitive + Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + Assert.IsTrue (ex.Message.IndexOf ("'duP'") != -1, "#B5"); + Assert.IsNull (ex.ParamName, "#B6"); + Assert.AreEqual (1, container.Components.Count, "#B7"); + } + + // existing component, same case + TestComponent c4 = new TestComponent (); + container.Add (c4, "C4"); + Assert.AreEqual (2, container.Components.Count, "#C1"); + container.Add (c4, "dup"); + Assert.AreEqual (2, container.Components.Count, "#C2"); + Assert.AreEqual ("C4", c4.Site.Name, "#C3"); + + // component of other container, same case + TestContainer container2 = new TestContainer (); + TestComponent c5 = new TestComponent (); + container2.Add (c5, "C5"); + try { + container.Add (c5, "dup"); + Assert.Fail ("#D1"); + } catch (ArgumentException ex) { + // Duplicate component name 'dup'. Component names must be + // unique and case-insensitive + Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2"); + Assert.IsNull (ex.InnerException, "#D3"); + Assert.IsNotNull (ex.Message, "#D4"); + Assert.IsTrue (ex.Message.IndexOf ("'dup'") != -1, "#D5"); + Assert.IsNull (ex.ParamName, "#D6"); + Assert.AreEqual (2, container.Components.Count, "#D7"); + } + Assert.AreEqual (1, container2.Components.Count, "#D8"); + Assert.AreSame (c5, container2.Components [0], "#D9"); + +#if NET_2_0 + container.AllowDuplicateNames = true; + TestComponent c6 = new TestComponent (); + container.Add (c6, "dup"); + Assert.AreEqual (3, container.Components.Count, "#E1"); + Assert.IsNotNull (c1.Site, "#E2"); + Assert.AreEqual ("dup", c1.Site.Name, "#E3"); + Assert.IsNotNull (c6.Site, "#E4"); + Assert.AreEqual ("dup", c6.Site.Name, "#E5"); + Assert.IsFalse (object.ReferenceEquals (c1.Site, c6.Site), "#E6"); +#endif + } + [Test] public void AddRemove () { @@ -91,7 +375,7 @@ namespace MonoTests.System.ComponentModel _container.Remove (component); Assert.IsNull (component.Site, "#3"); Assert.IsFalse (_container.Contains (component), "#4"); - + #if NET_2_0 _container.Add (component); _container.Remove_WithoutUnsiting (component); @@ -100,23 +384,260 @@ namespace MonoTests.System.ComponentModel #endif } + [Test] // Dispose () + public void Dispose1 () + { + TestComponent compA; + TestComponent compB; + + compA = new TestComponent (); + _container.Add (compA); + compB = new TestComponent (); + _container.Add (compB); + + _container.Dispose (); + + Assert.AreEqual (0, _container.Components.Count, "#A1"); + Assert.IsTrue (compA.IsDisposed, "#A2"); + Assert.IsNull (compA.Site, "#A3"); + Assert.IsTrue (compB.IsDisposed, "#A4"); + Assert.IsNull (compB.Site, "#A5"); + + _container = new TestContainer (); + compA = new TestComponent (); + compA.ThrowOnDispose = true; + _container.Add (compA); + compB = new TestComponent (); + _container.Add (compB); + + // assert that component is not removed from components until after + // Dispose of component has succeeded + try { + _container.Dispose (); + Assert.Fail ("#B1"); + } catch (InvalidOperationException) { + Assert.AreEqual (0, _container.Components.Count, "#B2"); + Assert.IsFalse (compA.IsDisposed, "#B4"); + Assert.IsNull (compA.Site, "#B5"); + Assert.IsTrue (compB.IsDisposed, "#B6"); + Assert.IsNull (compB.Site, "#B7"); + } finally { + compA.ThrowOnDispose = false; + } + + _container = new TestContainer (); + compA = new TestComponent (); + _container.Add (compA); + compB = new TestComponent (); + compB.ThrowOnDispose = true; + _container.Add (compB); + + try { + _container.Dispose (); + Assert.Fail ("#C1"); + } catch (InvalidOperationException) { + Assert.AreEqual (1, _container.Components.Count, "#C2"); + Assert.AreSame (compA, _container.Components [0], "#C3"); + Assert.IsFalse (compA.IsDisposed, "#C4"); + Assert.IsNotNull (compA.Site, "#C5"); + Assert.IsFalse (compB.IsDisposed, "#C6"); + Assert.IsNull (compB.Site, "#C7"); + } finally { + compB.ThrowOnDispose = false; + } + } + + [Test] // Dispose (Boolean) + public void Dispose2 () + { + TestComponent compA; + TestComponent compB; + + compA = new TestComponent (); + _container.Add (compA); + compB = new TestComponent (); + _container.Add (compB); + + _container.Dispose (false); + + Assert.AreEqual (2, _container.Components.Count, "#A1"); + Assert.IsFalse (compA.IsDisposed, "#A2"); + Assert.IsNotNull (compA.Site, "#A3"); + Assert.IsFalse (compB.IsDisposed, "#A4"); + Assert.IsNotNull (compB.Site, "#A5"); + + _container.Dispose (true); + + Assert.AreEqual (0, _container.Components.Count, "#B1"); + Assert.IsTrue (compA.IsDisposed, "#B2"); + Assert.IsNull (compA.Site, "#B3"); + Assert.IsTrue (compB.IsDisposed, "#B4"); + Assert.IsNull (compB.Site, "#B5"); + + compA = new TestComponent (); + _container.Add (compA); + compB = new TestComponent (); + _container.Add (compB); + + Assert.AreEqual (2, _container.Components.Count, "#C1"); + Assert.IsFalse (compA.IsDisposed, "#C2"); + Assert.IsNotNull (compA.Site, "#C3"); + Assert.IsFalse (compB.IsDisposed, "#C4"); + Assert.IsNotNull (compB.Site, "#C5"); + + _container.Dispose (true); + + Assert.AreEqual (0, _container.Components.Count, "#D1"); + Assert.IsTrue (compA.IsDisposed, "#D2"); + Assert.IsNull (compA.Site, "#D3"); + Assert.IsTrue (compB.IsDisposed, "#D4"); + Assert.IsNull (compB.Site, "#D5"); + } + [Test] - public void GetService1 () + public void GetService () { - _container.Add (new TestComponent ()); + object service; + + GetServiceContainer container = new GetServiceContainer (); + container.Add (new MyComponent ()); + service = container.GetService (typeof (MyComponent)); + Assert.IsNull (service, "#1"); + service = container.GetService (typeof (Component)); + Assert.IsNull (service, "#2"); + service = container.GetService (typeof (IContainer)); + Assert.AreSame (container, service, "#3"); + service = container.GetService ((Type) null); + Assert.IsNull (service, "#4"); } #if NET_2_0 [Test] - [ExpectedException (typeof (ArgumentException))] - public void ValidateName () + public void ValidateName_Component_Null () { - TestContainer container = new TestContainer (); - TestComponent c1 = new TestComponent (); - container.Add (c1, "dup"); - TestComponent c2 = new TestComponent (); - container.Add (c2, "dup"); + try { + _container.InvokeValidateName ((IComponent) null, "A"); + Assert.Fail ("#1"); + } catch (ArgumentNullException ex) { + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("component", ex.ParamName, "#5"); + } + } + + [Test] + public void ValidateName_Name_Null () + { + TestComponent compA = new TestComponent (); + _container.Add (compA, (string) null); + TestComponent compB = new TestComponent (); + _container.InvokeValidateName (compB, (string) null); + } + + [Test] + public void ValidateName_Name_Duplicate () + { + TestComponent compA = new TestComponent (); + _container.Add (compA, "dup"); + + // same component, same case + _container.InvokeValidateName (compA, "dup"); + + // existing component, same case + TestComponent compB = new TestComponent (); + _container.Add (compB, "B"); + try { + _container.InvokeValidateName (compB, "dup"); + Assert.Fail ("#A1"); + } catch (ArgumentException ex) { + // Duplicate component name 'duP'. Component names must be + // unique and case-insensitive + Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + Assert.IsTrue (ex.Message.IndexOf ("'dup'") != -1, "#A5"); + Assert.IsNull (ex.ParamName, "#A6"); + Assert.AreEqual (2, _container.Components.Count, "#A7"); + } + _container.InvokeValidateName (compB, "whatever"); + + // new component, different case + TestComponent compC = new TestComponent (); + try { + _container.InvokeValidateName (compC, "dup"); + Assert.Fail ("#B1"); + } catch (ArgumentException ex) { + // Duplicate component name 'duP'. Component names must be + // unique and case-insensitive + Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + Assert.IsTrue (ex.Message.IndexOf ("'dup'") != -1, "#B5"); + Assert.IsNull (ex.ParamName, "#B6"); + Assert.AreEqual (2, _container.Components.Count, "#B7"); + } + _container.InvokeValidateName (compC, "whatever"); + + // component of other container, different case + TestContainer container2 = new TestContainer (); + TestComponent compD = new TestComponent (); + container2.Add (compD, "B"); + try { + _container.InvokeValidateName (compD, "dup"); + Assert.Fail ("#C1"); + } catch (ArgumentException ex) { + // Duplicate component name 'duP'. Component names must be + // unique and case-insensitive + Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2"); + Assert.IsNull (ex.InnerException, "#C3"); + Assert.IsNotNull (ex.Message, "#C4"); + Assert.IsTrue (ex.Message.IndexOf ("'dup'") != -1, "#C5"); + Assert.IsNull (ex.ParamName, "#C6"); + Assert.AreEqual (2, _container.Components.Count, "#C7"); + } + _container.InvokeValidateName (compD, "whatever"); + Assert.AreEqual (1, container2.Components.Count, "#C8"); + Assert.AreSame (compD, container2.Components [0], "#C9"); } #endif + + class MyComponent : Component + { + } + + class MyContainer : IContainer + { + private ComponentCollection components = new ComponentCollection ( + new Component [0]); + + public ComponentCollection Components { + get { return components; } + } + + public void Add (IComponent component) + { + } + + public void Add (IComponent component, string name) + { + } + + public void Remove (IComponent component) + { + } + + public void Dispose () + { + } + } + + public class GetServiceContainer : Container + { + public new object GetService (Type service) + { + return base.GetService (service); + } + } } } -- cgit v1.2.3