* ServiceContainer.cs: In AddService, first check parent and end flow

after adding service to parent, throw ArgumentNullException when
serviceInstance or callback is null. In RemoveService, when promote is
false the service must be removed from current container. Fixes bug
#397824. On 1.0 profile, IServiceContainer is a default service offered
by containers. Minor code formatting.
* ServiceContainerTest.cs: Added test for argument checks in
AddService and RemoveService overloads. Added tests for AddService
and RemoveService.

svn path=/trunk/mcs/; revision=105232

mcs/class/System/System.ComponentModel.Design/Changelog

@@ -1,3 +1,12 @@
+2008-06-07  Gert Driesen  <[email protected]>
+
+	* ServiceContainer.cs: In AddService, first check parent and end flow
+	after adding service to parent, throw ArgumentNullException when
+	serviceInstance or callback is null. In RemoveService, when promote is
+	false the service must be removed from current container. Fixes bug
+	#397824. On 1.0 profile, IServiceContainer is a default service offered
+	by containers. Minor code formatting.
+
 2008-01-06  Ivan N. Zlatev  <[email protected]>
 
 	* ServiceContainer.cs: Check DefaultServices in GetService in 2.0.

mcs/class/System/System.ComponentModel.Design/ServiceContainer.cs

@@ -36,18 +36,16 @@ using System.Collections;
 
 namespace System.ComponentModel.Design
 {
-
 #if NET_2_0
 	public class ServiceContainer : IServiceContainer, IServiceProvider, IDisposable
 #else
 	public sealed class ServiceContainer : IServiceContainer, IServiceProvider
 #endif
 	{
-
 		private IServiceProvider parentProvider;
 		private Hashtable services = new Hashtable ();
 #if NET_2_0
-		private bool _disposed = false;
+		private bool _disposed;
 #endif
 		
 		public ServiceContainer()
@@ -75,18 +73,25 @@ namespace System.ComponentModel.Design
 #else
 		public
 #endif
-		void AddService (Type serviceType, 
+		void AddService (Type serviceType,
 					object serviceInstance,
 					bool promote)
 		{
-			if (serviceType == null)
-				throw new ArgumentNullException ("serviceType", "Cannot be null");
-			if (promote)
-				if (parentProvider != null)
-					((IServiceContainer)parentProvider.GetService(typeof(IServiceContainer))).AddService (serviceType, serviceInstance, promote);
-			if (services.Contains (serviceType)) {
-					throw new ArgumentException (string.Format ("The service {0} already exists in the service container.", serviceType.ToString()));
+			if (promote && parentProvider != null) {
+				IServiceContainer container = (IServiceContainer)
+					parentProvider.GetService (typeof (IServiceContainer));
+				container.AddService (serviceType, serviceInstance, promote);
+				return;
 			}
+
+			if (serviceType == null)
+				throw new ArgumentNullException ("serviceType");
+			if (serviceInstance == null)
+				throw new ArgumentNullException ("serviceInstance");
+			if (services.Contains (serviceType))
+				throw new ArgumentException (string.Format (
+					"The service {0} already exists in the service container.",
+					serviceType.ToString ()), "serviceType");
 			services.Add (serviceType, serviceInstance);
 		}
 
@@ -99,14 +104,21 @@ namespace System.ComponentModel.Design
 					ServiceCreatorCallback callback,
 					bool promote)
 		{
-			if (serviceType == null)
-				throw new ArgumentNullException ("serviceType", "Cannot be null");
-			if (promote)
-				if (parentProvider != null)
-					((IServiceContainer)parentProvider.GetService(typeof(IServiceContainer))).AddService (serviceType, callback, promote);
-			if (services.Contains (serviceType)) {
-					throw new ArgumentException (string.Format ("The service {0} already exists in the service container.", serviceType.ToString()));
+			if (promote && parentProvider != null) {
+				IServiceContainer container = (IServiceContainer)
+					parentProvider.GetService (typeof (IServiceContainer));
+				container.AddService (serviceType, callback, promote);
+				return;
 			}
+
+			if (serviceType == null)
+				throw new ArgumentNullException ("serviceType");
+			if (callback == null)
+				throw new ArgumentNullException ("callback");
+			if (services.Contains (serviceType))
+				throw new ArgumentException (string.Format (
+					"The service {0} already exists in the service container.",
+					serviceType.ToString ()), "serviceType");
 			services.Add (serviceType, callback);
 		}
 
@@ -114,20 +126,23 @@ namespace System.ComponentModel.Design
 		{
 			RemoveService (serviceType, false);
 		}
-        
+
 #if NET_2_0
 		public virtual void RemoveService (Type serviceType, bool promote)
 #else
-        public void RemoveService (Type serviceType, bool promote)
+		public void RemoveService (Type serviceType, bool promote)
 #endif
 		{
+			if (promote && parentProvider != null) {
+				IServiceContainer container = (IServiceContainer)
+					parentProvider.GetService (typeof (IServiceContainer));
+				container.RemoveService (serviceType, promote);
+				return;
+			}
+
 			if (serviceType == null)
-				throw new ArgumentNullException ("serviceType", "Cannot be null");
-			if (promote)
-				if (parentProvider != null)
-					((IServiceContainer)parentProvider.GetService(typeof(IServiceContainer))).RemoveService (serviceType, promote);
-			else
-				services.Remove (serviceType);
+				throw new ArgumentNullException ("serviceType");
+			services.Remove (serviceType);
 		}
 
 #if NET_2_0
@@ -137,8 +152,8 @@ namespace System.ComponentModel.Design
 #endif
 		object GetService (Type serviceType)
 		{
-#if NET_2_0
 			object result = null;
+
 			Type[] defaultServices = this.DefaultServices;
 			for (int i=0; i < defaultServices.Length; i++) {
 				if (defaultServices[i] == serviceType) {
@@ -147,51 +162,55 @@ namespace System.ComponentModel.Design
 				}
 			}
 			if (result == null)
-				result = services[serviceType];
-#else
-			object result = services[serviceType];
-#endif
+				result = services [serviceType];
 			if (result == null && parentProvider != null)
 				result = parentProvider.GetService (serviceType);
 			if (result != null) {
-				ServiceCreatorCallback	cb = result as ServiceCreatorCallback;
+				ServiceCreatorCallback cb = result as ServiceCreatorCallback;
 				if (cb != null) {
 					result = cb (this, serviceType);
-					services[serviceType] = result;
+					services [serviceType] = result;
 				}
-				
 			}
 			return result;
 		}
 
 #if NET_2_0
-		protected virtual Type [] DefaultServices {
-			get { return new Type [] { typeof (IServiceContainer), typeof (ServiceContainer)}; }
+		protected virtual
+#endif
+		Type [] DefaultServices {
+			get {
+#if NET_2_0
+				return new Type [] { typeof (IServiceContainer), typeof (ServiceContainer)};
+#else
+				return new Type [] { typeof (IServiceContainer) };
+#endif
+			}
 		}
 
+#if NET_2_0
 		public void Dispose ()
 		{
 			this.Dispose (true);
-			GC.SuppressFinalize(this);
+			GC.SuppressFinalize (this);
 		}
 
 		protected virtual void Dispose (bool disposing)
 		{
 			if (!_disposed) {
 				if (disposing) {
-					if (this.services != null) {
-						foreach (object obj in this.services) {
+					if (services != null) {
+						foreach (object obj in services) {
 							if (obj is IDisposable) {
 								((IDisposable) obj).Dispose ();
 							}
 						}
-						this.services = null;
+						services = null;
 					}
 				}
 				_disposed = true;
 			}
 		}
 #endif
-		
 	}
 }

mcs/class/System/Test/System.ComponentModel.Design/ChangeLog

@@ -1,3 +1,9 @@
+2008-06-07  Gert Driesen  <[email protected]>
+
+	* ServiceContainerTest.cs: Added test for argument checks in
+	AddService and RemoveService overloads. Added tests for AddService
+	and RemoveService.
+
 2008-01-06  Ivan N. Zlatev  <[email protected]>
 
 	* ServiceContainerTest.cs: Test that DefaultServices is checked in

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

@@ -5,107 +5,629 @@
 // (C) Alexandre Pigolkine ([email protected])
 // 
 
-using NUnit.Framework;
 using System;
 using System.ComponentModel.Design;
+using System.Collections;
+
+using NUnit.Framework;
 
 namespace MonoTests.System.ComponentModel.Design
 {
-
-// Helper classes
-	
-	class NotInSvc 
+	class NotInSvc
 	{
-		public NotInSvc() 
+		public NotInSvc ()
 		{
 		}
 	}
 	
-	class Svc 
+	class Svc
 	{
-		public Svc () 
+		public Svc ()
 		{
 		}
 		
-		private static int objectsCreatedByCallback = 0;
+		private static int objectsCreatedByCallback;
 		
 		public static int TotalObjectsCreatedByCallback {
 			get { return objectsCreatedByCallback; }
 		}
+
+		public static void Reset ()
+		{
+			objectsCreatedByCallback = 0;
+		}
 		
 		public static object ServiceCreator (IServiceContainer isc, Type tp) 
 		{
-			Assertion.AssertEquals ("ServiceCreator#01", tp, typeof (Svc));
+			Assert.AreEqual (typeof (Svc), tp, "ServiceCreator#01");
 			++objectsCreatedByCallback;
-			return new Svc();
+			return new Svc ();
 		}
 	}
-	
-[TestFixture]
-public class ServiceContainerTest : Assertion {
-	
-	[Test]
-	public void GeneralTest1 () 
-	{
-		ServiceContainer sc = new ServiceContainer ();
-			
-		sc.AddService (typeof (Svc), new Svc());
-		Svc service1 = sc.GetService (typeof (Svc)) as Svc;
-		AssertNotNull ("GT1#01", service1);
-		AssertEquals ("GT1#02", service1, sc.GetService (typeof (Svc)));	
-		AssertNull ("GT1#04", sc.GetService (typeof (NotInSvc)));
-	}
 
-	[Test, ExpectedException (typeof (ArgumentException))]
-	public void GeneralTest2 () 
+	[TestFixture]
+	public class ServiceContainerTest
 	{
-		ServiceContainer sc = new ServiceContainer ();
-			
-		sc.AddService (typeof (Svc), new Svc());
-		Svc service1 = sc.GetService (typeof (Svc)) as Svc;
-		AssertNotNull ("GT1#01", service1);
-		AssertEquals ("GT1#02", service1, sc.GetService (typeof (Svc)));
-			
-		sc.AddService (typeof (Svc), new Svc());
-	}
+		[SetUp]
+		public void SetUp ()
+		{
+			Svc.Reset ();
+		}
+
+		[Test]
+		public void AddService1 ()
+		{
+			object service;
+			ServiceContainer parent;
+			ServiceContainer sc;
+
+			object serviceInstance1 = new ArrayList ();
+			object serviceInstance2 = new Hashtable ();
+			object callback1 = new ServiceCreatorCallback (
+				Svc.ServiceCreator);
+
+			sc = new ServiceContainer ();
+			sc.AddService (typeof (ICollection), serviceInstance1);
+			sc.AddService (typeof (IEnumerable), serviceInstance2);
+			sc.AddService (typeof (Svc), callback1);
+
+			service = sc.GetService (typeof (ICollection));
+			Assert.IsNotNull (service, "#A1");
+			Assert.AreSame (serviceInstance1, service, "#A2");
+
+			service = sc.GetService (typeof (IEnumerable));
+			Assert.IsNotNull (service, "#B1");
+			Assert.AreSame (serviceInstance2, service, "#B2");
+
+			service = sc.GetService (typeof (ArrayList));
+			Assert.IsNull (service, "#C1");
+
+			service = sc.GetService (typeof (ICloneable));
+			Assert.IsNull (service, "#D1");
+
+			Assert.AreEqual (0, Svc.TotalObjectsCreatedByCallback, "#E1");
+			service = sc.GetService (typeof (Svc));
+			Assert.IsNotNull (service, "#E2");
+			Assert.IsTrue (service is Svc, "#E3");
+			Assert.AreEqual (1, Svc.TotalObjectsCreatedByCallback, "#E4");
+			Assert.AreSame (service, sc.GetService (typeof (Svc)), "#E5");
+			Assert.AreEqual (1, Svc.TotalObjectsCreatedByCallback, "#E6");
+
+			parent = new ServiceContainer ();
+			sc = new ServiceContainer (parent);
+
+			sc.AddService (typeof (ICollection), serviceInstance1);
+
+			Assert.AreSame (serviceInstance1, sc.GetService (typeof (ICollection)), "#F1");
+			Assert.IsNull (parent.GetService (typeof (ICollection)), "#F2");
+		}
+
+		[Test] // AddService (Type, Object)
+		public void AddService1_ServiceInstance_Null ()
+		{
+			ServiceContainer sc = new ServiceContainer ();
+
+			try {
+				sc.AddService (typeof (IList), (object) null);
+				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 ("serviceInstance", ex.ParamName, "#5");
+			}
+		}
+
+		[Test]
+		public void AddService1_ServiceType_Exists ()
+		{
+			ServiceContainer sc = new ServiceContainer ();
+
+			Svc serviceInstance1 = new Svc ();
+			Svc serviceInstance2 = new Svc ();
+
+			sc.AddService (typeof (Svc), serviceInstance1);
+			Assert.AreSame (serviceInstance1, sc.GetService (typeof (Svc)), "#A");
+
+			try {
+				sc.AddService (typeof (Svc), serviceInstance1);
+				Assert.Fail ("#B1");
+			} catch (ArgumentException ex) {
+				// The service MonoTests.System.ComponentModel.Design.Svc
+				// already exists in the service container
+				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
+				Assert.IsNull (ex.InnerException, "#B3");
+				Assert.IsNotNull (ex.Message, "#B4");
+				Assert.IsTrue (ex.Message.IndexOf (typeof (Svc).FullName) != -1, "#B5");
+				Assert.AreEqual ("serviceType", ex.ParamName, "#B6");
+			}
+
+			try {
+				sc.AddService (typeof (Svc), serviceInstance2);
+				Assert.Fail ("#C1");
+			} catch (ArgumentException ex) {
+				// The service MonoTests.System.ComponentModel.Design.Svc
+				// already exists in the service container
+				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
+				Assert.IsNull (ex.InnerException, "#C3");
+				Assert.IsNotNull (ex.Message, "#C4");
+				Assert.IsTrue (ex.Message.IndexOf (typeof (Svc).FullName) != -1, "#C5");
+				Assert.AreEqual ("serviceType", ex.ParamName, "#C6");
+			}
+		}
+
+		[Test] // AddService (Type, Object)
+		public void AddService1_ServiceType_Null ()
+		{
+			ServiceContainer sc = new ServiceContainer ();
+
+			try {
+				sc.AddService ((Type) null, new ArrayList ());
+				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 ("serviceType", ex.ParamName, "#5");
+			}
+		}
+
+		[Test] // AddService (Type, ServiceCreatorCallback)
+		public void AddService2_Callback_Null ()
+		{
+			ServiceContainer sc = new ServiceContainer ();
+			ServiceCreatorCallback callback = null;
+
+			try {
+				sc.AddService (typeof (IList), callback);
+				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 ("callback", ex.ParamName, "#5");
+			}
+		}
+
+		[Test] // AddService (Type, ServiceCreatorCallback)
+		public void AddService2_ServiceType_Null ()
+		{
+			ServiceContainer sc = new ServiceContainer ();
+			ServiceCreatorCallback callback = new ServiceCreatorCallback (
+				Svc.ServiceCreator);
+
+			try {
+				sc.AddService ((Type) null, callback);
+				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 ("serviceType", ex.ParamName, "#5");
+			}
+		}
+
+		[Test] // AddService (Type, Object, Boolean)
+		public void AddService3 ()
+		{
+			ServiceContainer sc;
+			ServiceContainer parent = new ServiceContainer ();
+
+			ArrayList serviceInstance1 = new ArrayList ();
+			ArrayList serviceInstance2 = new ArrayList ();
+
+			Type serviceType1 = typeof (IList);
+			Type serviceType2 = typeof (IEnumerable);
+
+			sc = new ServiceContainer (parent);
+			sc.AddService (serviceType1, serviceInstance1, true);
+			sc.AddService (serviceType2, serviceInstance2, false);
+
+			Assert.AreSame (serviceInstance1, parent.GetService (serviceType1), "#A1");
+			Assert.IsNull (parent.GetService (serviceType2), "#A2");
+			Assert.AreSame (serviceInstance1, sc.GetService (serviceType1), "#A3");
+			Assert.AreSame (serviceInstance2, sc.GetService (serviceType2), "#A4");
+
+			sc = new ServiceContainer ();
+			sc.AddService (serviceType1, serviceInstance1, true);
+			sc.AddService (serviceType2, serviceInstance2, false);
+
+			Assert.AreSame (serviceInstance1, sc.GetService (serviceType1), "#B1");
+			Assert.AreSame (serviceInstance2, sc.GetService (serviceType2), "#B2");
+
+			parent = new ServiceContainer ();
+			sc = new ServiceContainer (parent);
+			sc.AddService (serviceType1, serviceInstance1, true);
+			sc.AddService (serviceType1, serviceInstance2, false);
+
+			Assert.AreSame (serviceInstance2, sc.GetService (serviceType1), "#C1");
+			Assert.AreSame (serviceInstance1, parent.GetService (serviceType1), "#C2");
+		}
+
+		[Test] // AddService (Type, Object, Boolean)
+		public void AddService3_ServiceInstance_Null ()
+		{
+			ServiceContainer sc = new ServiceContainer ();
+
+			try {
+				sc.AddService (typeof (IList), (object) null, false);
+				Assert.Fail ("#A1");
+			} catch (ArgumentNullException ex) {
+				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
+				Assert.IsNull (ex.InnerException, "#A3");
+				Assert.IsNotNull (ex.Message, "#A4");
+				Assert.AreEqual ("serviceInstance", ex.ParamName, "#A5");
+			}
+
+			try {
+				sc.AddService (typeof (IList), (object) null, true);
+				Assert.Fail ("#B1");
+			} catch (ArgumentNullException ex) {
+				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
+				Assert.IsNull (ex.InnerException, "#B3");
+				Assert.IsNotNull (ex.Message, "#B4");
+				Assert.AreEqual ("serviceInstance", ex.ParamName, "#B5");
+			}
+		}
+
+		[Test] // AddService (Type, Object, Boolean)
+		public void AddService3_ServiceType_Null ()
+		{
+			ServiceContainer sc = new ServiceContainer ();
+
+			try {
+				sc.AddService ((Type) null, new ArrayList (), false);
+				Assert.Fail ("#A1");
+			} catch (ArgumentNullException ex) {
+				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
+				Assert.IsNull (ex.InnerException, "#A3");
+				Assert.IsNotNull (ex.Message, "#A4");
+				Assert.AreEqual ("serviceType", ex.ParamName, "#A5");
+			}
+
+			try {
+				sc.AddService ((Type) null, new ArrayList (), true);
+				Assert.Fail ("#B1");
+			} catch (ArgumentNullException ex) {
+				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
+				Assert.IsNull (ex.InnerException, "#B3");
+				Assert.IsNotNull (ex.Message, "#B4");
+				Assert.AreEqual ("serviceType", ex.ParamName, "#B5");
+			}
+		}
+
+		[Test] // AddService (Type, ServiceCreatorCallback, Boolean)
+		public void AddService4_Callback_Null ()
+		{
+			ServiceContainer sc = new ServiceContainer ();
+			ServiceCreatorCallback callback = null;
+
+			try {
+				sc.AddService (typeof (IList), callback, false);
+				Assert.Fail ("#A1");
+			} catch (ArgumentNullException ex) {
+				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
+				Assert.IsNull (ex.InnerException, "#A3");
+				Assert.IsNotNull (ex.Message, "#A4");
+				Assert.AreEqual ("callback", ex.ParamName, "#A5");
+			}
+
+			try {
+				sc.AddService (typeof (IList), callback, true);
+				Assert.Fail ("#B1");
+			} catch (ArgumentNullException ex) {
+				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
+				Assert.IsNull (ex.InnerException, "#B3");
+				Assert.IsNotNull (ex.Message, "#B4");
+				Assert.AreEqual ("callback", ex.ParamName, "#B5");
+			}
+		}
+
+		[Test] // AddService (Type, ServiceCreatorCallback, Boolean)
+		public void AddService4_ServiceType_Null ()
+		{
+			ServiceContainer sc = new ServiceContainer ();
+			ServiceCreatorCallback callback = new ServiceCreatorCallback (
+				Svc.ServiceCreator);
+
+			try {
+				sc.AddService ((Type) null, callback, false);
+				Assert.Fail ("#A1");
+			} catch (ArgumentNullException ex) {
+				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
+				Assert.IsNull (ex.InnerException, "#A3");
+				Assert.IsNotNull (ex.Message, "#A4");
+				Assert.AreEqual ("serviceType", ex.ParamName, "#A5");
+			}
+
+			try {
+				sc.AddService ((Type) null, callback, true);
+				Assert.Fail ("#B1");
+			} catch (ArgumentNullException ex) {
+				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
+				Assert.IsNull (ex.InnerException, "#B3");
+				Assert.IsNotNull (ex.Message, "#B4");
+				Assert.AreEqual ("serviceType", ex.ParamName, "#B5");
+			}
+		}
+
+		[Test]
+		public void GeneralTest1 ()
+		{
+			ServiceContainer sc = new ServiceContainer ();
+
+			sc.AddService (typeof (Svc), new Svc ());
+			Svc service1 = sc.GetService (typeof (Svc)) as Svc;
+			Assert.IsNotNull (service1, "#1");
+			Assert.AreEqual (service1, sc.GetService (typeof (Svc)), "#2");
+			Assert.IsNull (sc.GetService (typeof (NotInSvc)), "#3");
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentException))]
+		public void GeneralTest2 ()
+		{
+			ServiceContainer sc = new ServiceContainer ();
 
+			sc.AddService (typeof (Svc), new Svc ());
+			Svc service1 = sc.GetService (typeof (Svc)) as Svc;
+			Assert.IsNotNull (service1, "#1");
+			Assert.AreEqual (service1, sc.GetService (typeof (Svc)), "#2");
+			sc.AddService (typeof (Svc), new Svc());
+		}
+
+		[Test]
+		public void GetService_DefaultServices ()
+		{
+			ServiceContainer sc1 = new ServiceContainer ();
+
+			Assert.AreSame (sc1, sc1.GetService (typeof (IServiceContainer)), "#A1");
 #if NET_2_0
-	[Test]
-	public void TestGetServiceDefaultServices ()
-	{
-		ServiceContainer sc = new ServiceContainer ();
-		AssertEquals ("TGDS#01", sc.GetService (typeof(IServiceContainer)), sc);
-		AssertEquals ("TGDS#02", sc.GetService (typeof(ServiceContainer)), sc);
-	}
+			Assert.AreSame (sc1, sc1.GetService (typeof(ServiceContainer)), "#A2");
+#else
+			Assert.IsNull (sc1.GetService (typeof (ServiceContainer)), "#A2");
 #endif
-	[Test]
-	public void TestServiceCreator () 
-	{
-		ServiceContainer sc = new ServiceContainer ();
-		sc.AddService(typeof(Svc), new ServiceCreatorCallback(Svc.ServiceCreator));
-		AssertNull ("TSC#01", sc.GetService (typeof(NotInSvc)));
-		
-		Svc service1 = sc.GetService (typeof(Svc)) as Svc;
-		AssertNotNull ("TSC#02", service1);
-		AssertEquals ("TSC#03", Svc.TotalObjectsCreatedByCallback, 1);
-		
-		Svc service2 = sc.GetService (typeof(Svc)) as Svc;
-		AssertEquals ("TSC#04", service2, service1);
-		AssertEquals ("TSC#05", Svc.TotalObjectsCreatedByCallback, 1);
-	}
+
+			ServiceContainer sc2 = new ServiceContainer ();
+			sc1.AddService (typeof (IServiceContainer), sc2);
+			sc1.AddService (typeof (ServiceContainer), sc2);
+
+			Assert.AreSame (sc1, sc1.GetService (typeof (IServiceContainer)), "#B1");
+#if NET_2_0
+			Assert.AreSame (sc1, sc1.GetService (typeof(ServiceContainer)), "#B2");
+#else
+			Assert.AreSame (sc2, sc1.GetService (typeof (ServiceContainer)), "#B2");
+#endif
+		}
+
+		[Test]
+		public void TestServiceCreator ()
+		{
+			ServiceContainer sc = new ServiceContainer ();
+			sc.AddService (typeof(Svc), new ServiceCreatorCallback (Svc.ServiceCreator));
+			Assert.IsNull (sc.GetService (typeof (NotInSvc)), "#A");
+
+			Svc service1 = sc.GetService (typeof (Svc)) as Svc;
+			Assert.IsNotNull (service1, "#B1");
+			Assert.AreEqual (1, Svc.TotalObjectsCreatedByCallback, "#B2");
+
+			Svc service2 = sc.GetService (typeof (Svc)) as Svc;
+			Assert.AreEqual (service1, service2, "#C1");
+			Assert.AreEqual (1, Svc.TotalObjectsCreatedByCallback, "#C2");
+		}
 	
-	[Test]
-	public void TestParentService () 
-	{
-		ServiceContainer scParent = new ServiceContainer();
-		ServiceContainer sc = new ServiceContainer(scParent);
-		
-		scParent.AddService(typeof(Svc), new Svc());
+		[Test]
+		public void ParentService ()
+		{
+			ServiceContainer scParent = new ServiceContainer ();
+			ServiceContainer sc = new ServiceContainer (scParent);
+
+			scParent.AddService(typeof(Svc), new Svc ());
+
+			Svc service1 = sc.GetService (typeof (Svc)) as Svc;
+			Assert.IsNotNull (service1, "#1");
+		}
+
+		[Test] // RemoveService (Type)
+		public void RemoveService1 ()
+		{
+			ServiceContainer sc;
+			ServiceContainer parent;
 			
-		Svc service1 = sc.GetService (typeof(Svc)) as Svc;
-		AssertNotNull ("TPS#01", service1);
-		
-	}
+			ArrayList serviceInstance1 = new ArrayList ();
+			ArrayList serviceInstance2 = new ArrayList ();
 
-}
+			Type serviceType1 = typeof (IList);
+			Type serviceType2 = typeof (IEnumerable);
+
+			parent = null;
+			sc = new ServiceContainer (parent);
+			sc.AddService (serviceType1, serviceInstance1);
+			sc.AddService (serviceType2, serviceInstance2);
+
+			sc.RemoveService (typeof (DateTime));
+
+			Assert.AreSame (serviceInstance1, sc.GetService (serviceType1), "#A1");
+			Assert.AreSame (serviceInstance2, sc.GetService (serviceType2), "#A2");
+
+			sc.RemoveService (serviceType2);
+
+			Assert.AreSame (serviceInstance1, sc.GetService (serviceType1), "#B1");
+			Assert.IsNull (sc.GetService (serviceType2), "#B2");
+
+			sc.RemoveService (serviceType1);
+
+			Assert.IsNull (sc.GetService (serviceType1), "#C1");
+			Assert.IsNull (sc.GetService (serviceType2), "#C2");
+
+			sc.AddService (serviceType1, serviceInstance1);
+			sc.AddService (serviceType2, serviceInstance2);
+
+			Assert.AreSame (serviceInstance1, sc.GetService (serviceType1), "#D1");
+			Assert.AreSame (serviceInstance2, sc.GetService (serviceType2), "#D2");
+
+			parent = new ServiceContainer ();
+			sc = new ServiceContainer (parent);
+			sc.AddService (serviceType1, serviceInstance1, true);
+			sc.AddService (serviceType2, serviceInstance2, false);
+
+			sc.RemoveService (serviceType1);
+
+			Assert.AreSame (serviceInstance1, sc.GetService (serviceType1), "#E1");
+			Assert.AreSame (serviceInstance2, sc.GetService (serviceType2), "#E2");
+
+			sc.RemoveService (serviceType2);
+
+			Assert.AreSame (serviceInstance1, sc.GetService (serviceType1), "#F1");
+			Assert.IsNull (sc.GetService (serviceType2), "#F2");
+
+			parent.RemoveService (serviceType1);
+
+			Assert.IsNull (sc.GetService (serviceType1), "#G1");
+			Assert.IsNull (sc.GetService (serviceType2), "#G2");
+
+			parent = new ServiceContainer ();
+			sc = new ServiceContainer (parent);
+			sc.AddService (serviceType1, serviceInstance1, true);
+			sc.AddService (serviceType1, serviceInstance2, false);
+
+			sc.RemoveService (serviceType1);
+
+			Assert.AreSame (serviceInstance1, sc.GetService (serviceType1), "#H1");
+			Assert.AreSame (serviceInstance1, parent.GetService (serviceType1), "#H2");
+
+			sc.RemoveService (serviceType1);
+
+			Assert.AreSame (serviceInstance1, sc.GetService (serviceType1), "#I1");
+			Assert.AreSame (serviceInstance1, parent.GetService (serviceType1), "#I2");
+
+			parent.RemoveService (serviceType1);
+
+			Assert.IsNull (sc.GetService (serviceType1), "#J1");
+			Assert.IsNull (parent.GetService (serviceType1), "#J2");
+
+			parent = new ServiceContainer ();
+			sc = new ServiceContainer (parent);
+			sc.AddService (serviceType1, serviceInstance1, true);
+			sc.AddService (serviceType1, serviceInstance2, false);
+
+			parent.RemoveService (serviceType1);
+
+			Assert.AreSame (serviceInstance2, sc.GetService (serviceType1), "#K1");
+			Assert.IsNull (parent.GetService (serviceType1), "#K2");
+		}
+
+		[Test] // RemoveService (Type)
+		public void RemoveService1_ServiceType_Null ()
+		{
+			ServiceContainer sc = new ServiceContainer ();
+
+			try {
+				sc.RemoveService ((Type) null);
+				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 ("serviceType", ex.ParamName, "#5");
+			}
+		}
+
+		[Test] // RemoveService (Type, Boolean)
+		public void RemoveService2 ()
+		{
+			ServiceContainer sc;
+			ServiceContainer parent;
+
+			ArrayList serviceInstance1 = new ArrayList ();
+			ArrayList serviceInstance2 = new ArrayList ();
+
+			Type serviceType1 = typeof (IList);
+			Type serviceType2 = typeof (IEnumerable);
+
+			parent = new ServiceContainer ();
+			sc = new ServiceContainer (parent);
+			sc.AddService (serviceType1, serviceInstance1, true);
+			sc.AddService (serviceType2, serviceInstance2, false);
+
+			sc.RemoveService (serviceType1, false);
+			sc.RemoveService (serviceType2, false);
+
+			Assert.AreSame (serviceInstance1, sc.GetService (serviceType1), "#A1");
+			Assert.IsNull (sc.GetService (serviceType2), "#A2");
+
+			sc.RemoveService (serviceType1, true);
+			sc.RemoveService (serviceType2, true);
+
+			Assert.IsNull (sc.GetService (serviceType1), "#B1");
+			Assert.IsNull (sc.GetService (serviceType2), "#B2");
+
+			sc.AddService (serviceType1, serviceInstance1, true);
+			Assert.AreSame (serviceInstance1, sc.GetService (serviceType1), "#C1");
+			parent.RemoveService (serviceType1);
+			Assert.IsNull (sc.GetService (serviceType1), "#C2");
+
+			parent = new ServiceContainer ();
+			sc = new ServiceContainer (parent);
+			sc.AddService (serviceType1, serviceInstance1, true);
+			sc.AddService (serviceType2, serviceInstance2, false);
+
+			sc.RemoveService (serviceType1, true);
+			sc.RemoveService (serviceType2, true);
+
+			Assert.IsNull (sc.GetService (serviceType1), "#D1");
+			Assert.AreSame (serviceInstance2, sc.GetService (serviceType2), "#D2");
+
+			sc = new ServiceContainer ();
+			sc.AddService (serviceType1, serviceInstance1, true);
+			sc.RemoveService (serviceType1, true);
+			Assert.IsNull (sc.GetService (serviceType1), "#E");
+
+			parent = new ServiceContainer ();
+			sc = new ServiceContainer (parent);
+			sc.AddService (serviceType1, serviceInstance1, true);
+			sc.AddService (serviceType1, serviceInstance2, false);
+
+			sc.RemoveService (serviceType1, true);
+
+			Assert.AreSame (serviceInstance2, sc.GetService (serviceType1), "#F1");
+			Assert.IsNull (parent.GetService (serviceType1), "#F2");
+
+			sc.RemoveService (serviceType1, true);
+
+			Assert.AreSame (serviceInstance2, sc.GetService (serviceType1), "#G1");
+			Assert.IsNull (parent.GetService (serviceType1), "#G2");
+
+			sc.RemoveService (serviceType1, false);
+
+			Assert.IsNull (sc.GetService (serviceType1), "#H1");
+			Assert.IsNull (parent.GetService (serviceType1), "#H2");
+		}
+
+		[Test] // RemoveService (Type, Boolean)
+		public void RemoveService2_ServiceType_Null ()
+		{
+			ServiceContainer sc = new ServiceContainer ();
+
+			try {
+				sc.RemoveService ((Type) null, false);
+				Assert.Fail ("#A1");
+			} catch (ArgumentNullException ex) {
+				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
+				Assert.IsNull (ex.InnerException, "#A3");
+				Assert.IsNotNull (ex.Message, "#A4");
+				Assert.AreEqual ("serviceType", ex.ParamName, "#A5");
+			}
+
+			try {
+				sc.RemoveService ((Type) null, true);
+				Assert.Fail ("#B1");
+			} catch (ArgumentNullException ex) {
+				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
+				Assert.IsNull (ex.InnerException, "#B3");
+				Assert.IsNotNull (ex.Message, "#B4");
+				Assert.AreEqual ("serviceType", ex.ParamName, "#B5");
+			}
+		}
+	}
 }