X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fclass%2Fcorlib%2FTest%2FSystem.Collections%2FDictionaryBaseTest.cs;h=96a5eecddf076f8890a29a138b564616cc72ee83;hb=a9f497010cb7c0db3a3f7bf0e9c05acd03eb6934;hp=92866ebd4d6e57b80f696a3495664725c22fbc7d;hpb=04d1b4116331e3813b8f75304f714a5d61ba1214;p=mono.git

diff --git a/mcs/class/corlib/Test/System.Collections/DictionaryBaseTest.cs b/mcs/class/corlib/Test/System.Collections/DictionaryBaseTest.cs
index 92866ebd4d6..96a5eecddf0 100644
--- a/mcs/class/corlib/Test/System.Collections/DictionaryBaseTest.cs
+++ b/mcs/class/corlib/Test/System.Collections/DictionaryBaseTest.cs
@@ -8,30 +8,30 @@
 
 using System;
 using System.Collections;
+
 using NUnit.Framework;
 
-namespace MonoTests.System.Collections 
+namespace MonoTests.System.Collections
 {
-
 	[TestFixture]
-	public class DictionaryBaseTest: Assertion
+	public class DictionaryBaseTest
 	{
-		static void Main(string[] args)
-		{
-		}
-
 		public class ConcreteDictionary : DictionaryBase
 		{
 			public bool onInsertFired;
 			public bool onInsertCompleteFired;
 			public bool onValidateFired;
+			public bool onValidateExist;
 			public bool onRemoveFired;
+			public bool onRemoveExist;
 			public bool onRemoveCompleteFired;
 			public bool onClearFired;
 			public bool onClearCompleteFired;
 			public bool onSetFired;
+			public bool onSetExist;
 			public bool onSetCompleteFired;
 			public bool onGetFired;
+			public bool onGetExist;
 
 			public bool onInsertMustThrowException;
 			public bool onInsertCompleteMustThrowException;
@@ -44,26 +44,22 @@ namespace MonoTests.System.Collections
 			public bool onSetCompleteMustThrowException;
 			public bool onGetMustThrowException;
 
-			public ConcreteDictionary() 
+			public ConcreteDictionary ()
 			{
 			}
 
-			public ConcreteDictionary(int i) 
+			public ConcreteDictionary (int i)
 			{
-				for (int j = 0; j < i; j++) 
-				{
-					((IDictionary) this).Add(j, j*2);
-				}
-
+				for (int j = 0; j < i; j++)
+					((IDictionary) this).Add (j, j * 2);
 				ClearFlags();
 			}
 
-            public IDictionary BaseDictionary 
-			{
+			public IDictionary BaseDictionary {
 				get { return this.Dictionary; }
 			}
 
-			public void ClearFlags() 
+			public void ClearFlags ()
 			{
 				onInsertFired = false;
 				onInsertCompleteFired = false;
@@ -77,546 +73,772 @@ namespace MonoTests.System.Collections
 				onGetFired = false;
 			}
 
-			protected override void OnValidate(object key, object value)
+			protected override void OnValidate (object key, object value)
 			{
 				onValidateFired = true;
+				if (key != null)
+					Assert.AreEqual (onValidateExist, BaseDictionary.Contains (key));
 				if (onValidateMustThrowException)
-					throw new Exception();
+					throw new Exception ();
 				base.OnValidate (key, value);
 			}
 
-			protected override void OnInsert(object key, object value)
+			protected override void OnInsert (object key, object value)
 			{
 				onInsertFired = true;
+				Assert.IsFalse (BaseDictionary.Contains (key));
 				if (onInsertMustThrowException)
-					throw new Exception();
+					throw new Exception ();
 				base.OnInsert (key, value);
 			}
 
-			protected override void OnInsertComplete(object key, object value)
+			protected override void OnInsertComplete (object key, object value)
 			{
 				onInsertCompleteFired = true;
+				Assert.IsTrue (BaseDictionary.Contains (key));
 				if (onInsertCompleteMustThrowException)
-					throw new Exception();
+					throw new Exception ();
 				base.OnInsertComplete (key, value);
 			}
 
-			protected override void OnRemove(object key, object value)
+			protected override void OnRemove (object key, object value)
 			{
 				onRemoveFired = true;
+				Assert.AreEqual (onRemoveExist, BaseDictionary.Contains (key));
 				if (onRemoveMustThrowException)
-					throw new Exception();
+					throw new Exception ();
 				base.OnRemove (key, value);
 			}
 
-			protected override void OnRemoveComplete(object key, object value)
+			protected override void OnRemoveComplete (object key, object value)
 			{
 				onRemoveCompleteFired = true;
+				Assert.IsFalse (BaseDictionary.Contains (key));
 				if (onRemoveCompleteMustThrowException)
-					throw new Exception();
+					throw new Exception ();
 				base.OnRemoveComplete (key, value);
 			}
 
-
-			protected override void OnClear()
+			protected override void OnClear ()
 			{
 				onClearFired = true;
 				if (onClearMustThrowException)
-					throw new Exception();
+					throw new Exception ();
 				base.OnClear ();
 			}
 
-			protected override void OnClearComplete()
+			protected override void OnClearComplete ()
 			{
 				onClearCompleteFired = true;
+				Assert.AreEqual (0, BaseDictionary.Count);
 				if (onClearCompleteMustThrowException)
-					throw new Exception();
+					throw new Exception ();
 				base.OnClearComplete ();
 			}
 
-			protected override object OnGet(object key, object currentValue)
+			protected override object OnGet (object key, object currentValue)
 			{
 				onGetFired = true;
+				Assert.AreEqual (onGetExist, BaseDictionary.Contains (key));
 				if (onGetMustThrowException)
-					throw new Exception();
+					throw new Exception ();
 				return base.OnGet (key, currentValue);
 			}
 
-			protected override void OnSet(object key, object oldValue, object newValue)
+			protected override void OnSet (object key, object oldValue, object newValue)
 			{
 				onSetFired = true;
+				Assert.AreEqual (onSetExist, BaseDictionary.Contains (key));
 				if (onSetMustThrowException)
-					throw new Exception();
+					throw new Exception ();
 				base.OnSet (key, oldValue, newValue);
 			}
 
-			protected override void OnSetComplete(object key, object oldValue, object newValue)
+			protected override void OnSetComplete (object key, object oldValue, object newValue)
 			{
 				onSetCompleteFired = true;
+				Assert.IsTrue (BaseDictionary.Contains (key));
 				if (onSetCompleteMustThrowException)
-					throw new Exception();
+					throw new Exception ();
 				base.OnSetComplete (key, oldValue, newValue);
 			}
 		}
 
 		[Test]
-		public void Add() 
+		public void Add ()
 		{
-			ConcreteDictionary myDictionary = new ConcreteDictionary(10);
+			ConcreteDictionary myDictionary = new ConcreteDictionary (10);
 			myDictionary.BaseDictionary.Add(100, 1);
 
-			Assert("OnValidate must be fired", myDictionary.onValidateFired);
-			Assert("OnInsert must be fired", myDictionary.onInsertFired);
-			Assert("OnInsertComplete must be fired", myDictionary.onInsertCompleteFired);
-			AssertEquals("Count", 11, myDictionary.Count);
-			AssertEquals(1, myDictionary.BaseDictionary[100]);
+			Assert.IsTrue (myDictionary.onInsertFired, "#1");
+			Assert.IsTrue (myDictionary.onInsertCompleteFired, "#2");
+			Assert.IsTrue (myDictionary.onValidateFired, "#3");
+			Assert.IsFalse (myDictionary.onRemoveFired, "#4");
+			Assert.IsFalse (myDictionary.onRemoveCompleteFired, "#5");
+			Assert.IsFalse (myDictionary.onClearFired, "#6");
+			Assert.IsFalse (myDictionary.onClearCompleteFired, "#7");
+			Assert.IsFalse (myDictionary.onSetFired, "#8");
+			Assert.IsFalse (myDictionary.onSetCompleteFired, "#9");
+			Assert.IsFalse (myDictionary.onGetFired, "#10");
+			Assert.AreEqual (11, myDictionary.Count, "#11");
+			myDictionary.onGetExist = true;
+			Assert.AreEqual (1, myDictionary.BaseDictionary [100], "#12");
 		}
 
 		[Test]
-		public void AddOnValidateExcept() 
+		public void AddOnValidateExcept ()
 		{
-			bool exceptionThrown = false;
-
-			ConcreteDictionary myDictionary = new ConcreteDictionary(30);
+			ConcreteDictionary myDictionary = new ConcreteDictionary (30);
 			myDictionary.onValidateMustThrowException = true;
 
 			try {
 				myDictionary.BaseDictionary.Add(111,222);
-			} catch {
-				exceptionThrown = true;
-			} finally {
-				Assert("Exception must be thrown", exceptionThrown);
-				Assert("OnValidate must be fired", myDictionary.onValidateFired);
-				Assert("OnInsert must not be fired", !myDictionary.onInsertFired);
-				Assert("OnInsertComplete must not be fired", !myDictionary.onInsertCompleteFired);
-				AssertEquals("Count", 30, myDictionary.Count);
+				Assert.Fail ("#A1");
+			} catch (AssertionException) {
+				throw;
+			} catch (Exception ex) {
+				Assert.AreEqual (typeof (Exception), ex.GetType (), "#A2");
+				Assert.IsNull (ex.InnerException, "#A3");
+				Assert.IsNotNull (ex.Message, "#A4");
 			}
 
+			Assert.IsFalse (myDictionary.onInsertFired, "#B1");
+			Assert.IsFalse (myDictionary.onInsertCompleteFired, "#B2");
+			Assert.IsTrue (myDictionary.onValidateFired, "#B3");
+			Assert.IsFalse (myDictionary.onRemoveFired, "#B4");
+			Assert.IsFalse (myDictionary.onRemoveCompleteFired, "#B5");
+			Assert.IsFalse (myDictionary.onClearFired, "#B6");
+			Assert.IsFalse (myDictionary.onClearCompleteFired, "#B7");
+			Assert.IsFalse (myDictionary.onSetFired, "#B8");
+			Assert.IsFalse (myDictionary.onSetCompleteFired, "#B9");
+			Assert.IsFalse (myDictionary.onGetFired, "#B10");
+			Assert.AreEqual (30, myDictionary.Count, "#B11");
 		}
 
 		[Test]
-		public void AddOnInsertExcept() 
+		public void AddOnInsertExcept ()
 		{
-			bool exceptionThrown = false;
-
-			ConcreteDictionary myDictionary = new ConcreteDictionary(30);
+			ConcreteDictionary myDictionary = new ConcreteDictionary (30);
 			myDictionary.onInsertMustThrowException = true;
 
 			try {
-				myDictionary.BaseDictionary.Add(666,222);
-			} catch {
-				exceptionThrown = true;
-			} finally {
-				Assert("Exception must be thrown", exceptionThrown);
-				Assert("OnValidate must be fired", myDictionary.onValidateFired);
-				Assert("OnInsert must be fired", myDictionary.onInsertFired);
-				Assert("OnInsertComplete must not be fired", !myDictionary.onInsertCompleteFired);
-				AssertEquals("Count", 30, myDictionary.Count);
+				myDictionary.BaseDictionary.Add (666, 222);
+				Assert.Fail ("#A1");
+			} catch (AssertionException) {
+				throw;
+			} catch (Exception ex) {
+				Assert.AreEqual (typeof (Exception), ex.GetType (), "#A2");
+				Assert.IsNull (ex.InnerException, "#A3");
+				Assert.IsNotNull (ex.Message, "#A4");
 			}
 
+			Assert.IsTrue (myDictionary.onValidateFired, "#B1");
+			Assert.IsTrue (myDictionary.onInsertFired, "#B2");
+			Assert.IsFalse (myDictionary.onInsertCompleteFired, "#B3");
+			Assert.AreEqual (30, myDictionary.Count, "#B4");
 		}
 
 		[Test]
-		public void AddOnInsertCompleteExcept() 
+		public void AddOnInsertCompleteExcept ()
 		{
-			bool exceptionThrown = false;
-
-			ConcreteDictionary myDictionary = new ConcreteDictionary(5);
+			ConcreteDictionary myDictionary = new ConcreteDictionary (5);
 			myDictionary.onInsertCompleteMustThrowException = true;
 
 			try {
-				myDictionary.BaseDictionary.Add(888,999);
-			} catch {
-				exceptionThrown = true;
-			} finally {
-				Assert("Exception must be thrown", exceptionThrown);
-				Assert("OnValidate must be fired", myDictionary.onValidateFired);
-				Assert("OnInsert must be fired", myDictionary.onInsertFired);
-				Assert("OnInsertComplete must be fired", myDictionary.onInsertCompleteFired);
-				AssertEquals("Count", 5, myDictionary.Count);
+				myDictionary.BaseDictionary.Add (888, 999);
+				Assert.Fail ("#A1");
+			} catch (AssertionException) {
+				throw;
+			} catch (Exception ex) {
+				Assert.AreEqual (typeof (Exception), ex.GetType (), "#A2");
+				Assert.IsNull (ex.InnerException, "#A3");
+				Assert.IsNotNull (ex.Message, "#A4");
 			}
 
+			Assert.IsTrue (myDictionary.onValidateFired, "#B1");
+			Assert.IsTrue (myDictionary.onInsertFired, "#B2");
+			Assert.IsTrue (myDictionary.onInsertCompleteFired, "#B3");
+			Assert.AreEqual (5, myDictionary.Count, "#B4");
 		}
 
 		[Test]
-		public void AddNullKey() 
+		public void AddNullKey ()
 		{
-			bool exceptionThrown = false;
+			ConcreteDictionary myDictionary = new ConcreteDictionary ();
 
-			ConcreteDictionary myDictionary = new ConcreteDictionary();
 			try {
-				myDictionary.BaseDictionary.Add(null, 11);
-			} catch (ArgumentNullException) {
-				exceptionThrown = true;
-			} finally {
-				Assert("OnValidate must be fired", myDictionary.onValidateFired);
-				Assert("OnInsert must be fired", myDictionary.onInsertFired);
-				Assert("OnInsertComplete must not be fired", !myDictionary.onInsertCompleteFired);
-				Assert("ArgumentNullException must be thrown", exceptionThrown);
+				myDictionary.BaseDictionary.Add (null, 11);
+				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 ("key", ex.ParamName, "#A5");
 			}
+
+			Assert.IsTrue (myDictionary.onValidateFired, "#B1");
+			Assert.IsTrue (myDictionary.onInsertFired, "#B2");
+			Assert.IsFalse (myDictionary.onInsertCompleteFired, "#B3");
 		}
 
 		[Test]
-		public void Clear() 
+		public void Clear ()
 		{
-			ConcreteDictionary myDictionary = new ConcreteDictionary(30);
+			ConcreteDictionary myDictionary = new ConcreteDictionary (30);
 			myDictionary.Clear();
 
-			Assert("OnClear must be fired", myDictionary.onClearFired);
-			Assert("OnClearComplete must be fired", myDictionary.onClearCompleteFired);
-			AssertEquals("Count", 0, myDictionary.Count);
+			Assert.IsTrue (myDictionary.onClearFired, "#1");
+			Assert.IsTrue (myDictionary.onClearCompleteFired, "#2");
+			Assert.AreEqual (0, myDictionary.Count, "#3");
 		}
 
 		[Test]
-		public void ClearOnClearExcept() 
+		public void ClearOnClearExcept ()
 		{
-			bool exceptionThrown = false;
-
-			ConcreteDictionary myDictionary = new ConcreteDictionary(30);
+			ConcreteDictionary myDictionary = new ConcreteDictionary (30);
 			myDictionary.onClearMustThrowException = true;
 
 			try {
-				myDictionary.Clear();
-			} catch {
-				exceptionThrown = true;
-			} finally {
-				Assert("Exception must be thrown", exceptionThrown);
-				Assert("OnClear must be fired", myDictionary.onClearFired);
-				Assert("OnClearComplete must not be fired", !myDictionary.onClearCompleteFired);
-				AssertEquals("Count", 30, myDictionary.Count);
+				myDictionary.Clear ();
+				Assert.Fail ("#A1");
+			} catch (AssertionException) {
+				throw;
+			} catch (Exception ex) {
+				Assert.AreEqual (typeof (Exception), ex.GetType (), "#A2");
+				Assert.IsNull (ex.InnerException, "#A3");
+				Assert.IsNotNull (ex.Message, "#A4");
 			}
 
+			Assert.IsTrue (myDictionary.onClearFired, "#B1");
+			Assert.IsFalse (myDictionary.onClearCompleteFired, "#B2");
+			Assert.AreEqual (30, myDictionary.Count, "#B3");
 		}
 
 		[Test]
-		public void ClearOnClearCompleteExcept() 
+		public void ClearOnClearCompleteExcept ()
 		{
-			bool exceptionThrown = false;
-
-			ConcreteDictionary myDictionary = new ConcreteDictionary(30);
+			ConcreteDictionary myDictionary = new ConcreteDictionary (30);
 			myDictionary.onClearCompleteMustThrowException = true;
 
 			try {
 				myDictionary.Clear();
-			} catch {
-				exceptionThrown = true;
-			} finally {
-				Assert("Exception must be thrown", exceptionThrown);
-				Assert("OnClear must be fired", myDictionary.onClearFired);
-				Assert("OnClearComplete must be fired", myDictionary.onClearCompleteFired);
-				AssertEquals("Count", 0, myDictionary.Count);
+				Assert.Fail ("#A1");
+			} catch (AssertionException) {
+				throw;
+			} catch (Exception ex) {
+				Assert.AreEqual (typeof (Exception), ex.GetType (), "#A2");
+				Assert.IsNull (ex.InnerException, "#A3");
+				Assert.IsNotNull (ex.Message, "#A4");
 			}
 
+			Assert.IsFalse (myDictionary.onInsertFired, "#B1");
+			Assert.IsFalse (myDictionary.onInsertCompleteFired, "#B2");
+			Assert.IsFalse (myDictionary.onValidateFired, "#B3");
+			Assert.IsFalse (myDictionary.onRemoveFired, "#B4");
+			Assert.IsFalse (myDictionary.onRemoveCompleteFired, "#B5");
+			Assert.IsTrue (myDictionary.onClearFired, "#B6");
+			Assert.IsTrue (myDictionary.onClearCompleteFired, "#B7");
+			Assert.IsFalse (myDictionary.onSetFired, "#B8");
+			Assert.IsFalse (myDictionary.onSetCompleteFired, "#B9");
+			Assert.IsFalse (myDictionary.onGetFired, "#B10");
+			Assert.AreEqual (0, myDictionary.Count, "#B11");
 		}
 
 		[Test]
-		public void Count() 
+		public void Count ()
 		{
-			ConcreteDictionary myDictionary = new ConcreteDictionary(19);
-			AssertEquals(19, myDictionary.Count);
+			ConcreteDictionary myDictionary = new ConcreteDictionary (19);
+			Assert.AreEqual (19, myDictionary.Count);
 		}
 
 		[Test]
-		public void Remove() 
+		public void Remove ()
 		{
 			ConcreteDictionary myDictionary = new ConcreteDictionary(8);
-			myDictionary.BaseDictionary.Remove(5);
-
-			Assert("OnValidate must be fired", myDictionary.onValidateFired);
-			Assert("OnRemove must be fired", myDictionary.onRemoveFired);
-			Assert("OnRemoveComplete must be fired", myDictionary.onRemoveCompleteFired);
-			AssertEquals("Count", 7, myDictionary.Count);
-			AssertEquals(null, myDictionary.BaseDictionary[5]);
+			myDictionary.onValidateExist = true;
+			myDictionary.onRemoveExist = true;
+			myDictionary.BaseDictionary.Remove (5);
+
+			Assert.IsFalse (myDictionary.onInsertFired, "#1");
+			Assert.IsFalse (myDictionary.onInsertCompleteFired, "#2");
+			Assert.IsTrue (myDictionary.onValidateFired, "#3");
+			Assert.IsTrue (myDictionary.onRemoveFired, "#4");
+			Assert.IsTrue (myDictionary.onRemoveCompleteFired, "#5");
+			Assert.IsFalse (myDictionary.onClearFired, "#6");
+			Assert.IsFalse (myDictionary.onClearCompleteFired, "#7");
+			Assert.IsFalse (myDictionary.onSetFired, "#8");
+			Assert.IsFalse (myDictionary.onSetCompleteFired, "#9");
+			Assert.IsFalse (myDictionary.onGetFired, "#10");
+			Assert.AreEqual (7, myDictionary.Count, "#11");
+			Assert.IsNull (myDictionary.BaseDictionary [5], "#12");
 		}
 
 		[Test]
-		public void RemoveOnValidateExcept() 
+		public void RemoveOnValidateExcept ()
 		{
-			bool exceptionThrown = false;
-
-			ConcreteDictionary myDictionary = new ConcreteDictionary(28);
+			ConcreteDictionary myDictionary = new ConcreteDictionary (28);
+			myDictionary.onValidateExist = true;
 			myDictionary.onValidateMustThrowException = true;
 
 			try {
-				myDictionary.BaseDictionary.Remove(11);
-			} catch {
-				exceptionThrown = true;
-			} finally {
-				Assert("Exception must be thrown in this test", exceptionThrown);
-				Assert("OnValidate must be fired", myDictionary.onValidateFired);
-				Assert("OnRemove must not be fired", !myDictionary.onRemoveFired);
-				Assert("OnRemoveComplete must not be fired", !myDictionary.onRemoveCompleteFired);
-				AssertEquals("Count", 28, myDictionary.Count);
-				AssertEquals(22, myDictionary.BaseDictionary[11]);
+				myDictionary.BaseDictionary.Remove (11);
+				Assert.Fail ("#A1");
+			} catch (AssertionException) {
+				throw;
+			} catch (Exception ex) {
+				Assert.AreEqual (typeof (Exception), ex.GetType (), "#A2");
+				Assert.IsNull (ex.InnerException, "#A3");
+				Assert.IsNotNull (ex.Message, "#A4");
 			}
 
+			Assert.IsFalse (myDictionary.onInsertFired, "#B1");
+			Assert.IsFalse (myDictionary.onInsertCompleteFired, "#B2");
+			Assert.IsTrue (myDictionary.onValidateFired, "#B3");
+			Assert.IsFalse (myDictionary.onRemoveFired, "#B4");
+			Assert.IsFalse (myDictionary.onRemoveCompleteFired, "#B5");
+			Assert.IsFalse (myDictionary.onClearFired, "#B6");
+			Assert.IsFalse (myDictionary.onClearCompleteFired, "#B7");
+			Assert.IsFalse (myDictionary.onSetFired, "#B8");
+			Assert.IsFalse (myDictionary.onSetCompleteFired, "#B9");
+			Assert.IsFalse (myDictionary.onGetFired, "#B10");
+			Assert.AreEqual (28, myDictionary.Count, "#B11");
+			myDictionary.onGetExist = true;
+			Assert.AreEqual (22, myDictionary.BaseDictionary [11], "#B12");
 		}
 
 		[Test]
-		public void RemoveOnRemoveExcept() 
+		public void RemoveOnRemoveExcept ()
 		{
-			bool exceptionThrown = false;
-
-			ConcreteDictionary myDictionary = new ConcreteDictionary(28);
+			ConcreteDictionary myDictionary = new ConcreteDictionary (28);
+			myDictionary.onValidateExist = true;
+			myDictionary.onRemoveExist = true;
 			myDictionary.onRemoveMustThrowException = true;
 
 			try {
-				myDictionary.BaseDictionary.Remove(11);
-			} catch {
-				exceptionThrown = true;
-			} finally {
-				Assert("Exception must be thrown", exceptionThrown);
-				Assert("OnValidate must be fired", myDictionary.onValidateFired);
-				Assert("OnRemove must be fired", myDictionary.onRemoveFired);
-				Assert("OnRemoveComplete must not be fired", !myDictionary.onRemoveCompleteFired);
-				AssertEquals("Count", 28, myDictionary.Count);
-				AssertEquals(22, myDictionary.BaseDictionary[11]);
+				myDictionary.BaseDictionary.Remove (11);
+				Assert.Fail ("#A1");
+			} catch (AssertionException) {
+				throw;
+			} catch (Exception ex) {
+				Assert.AreEqual (typeof (Exception), ex.GetType (), "#A2");
+				Assert.IsNull (ex.InnerException, "#A3");
+				Assert.IsNotNull (ex.Message, "#A4");
 			}
 
+			Assert.IsFalse (myDictionary.onInsertFired, "#B1");
+			Assert.IsFalse (myDictionary.onInsertCompleteFired, "#B2");
+			Assert.IsTrue (myDictionary.onValidateFired, "#B3");
+			Assert.IsTrue (myDictionary.onRemoveFired, "#B4");
+			Assert.IsFalse (myDictionary.onRemoveCompleteFired, "#B5");
+			Assert.IsFalse (myDictionary.onClearFired, "#B6");
+			Assert.IsFalse (myDictionary.onClearCompleteFired, "#B7");
+			Assert.IsFalse (myDictionary.onSetFired, "#B8");
+			Assert.IsFalse (myDictionary.onSetCompleteFired, "#B9");
+			Assert.IsFalse (myDictionary.onGetFired, "#B10");
+			Assert.AreEqual (28, myDictionary.Count, "#B11");
+			myDictionary.onGetExist = true;
+			Assert.AreEqual (22, myDictionary.BaseDictionary [11], "#B12");
 		}
 
 		[Test]
-		public void RemoveOnRemoveCompleteExcept() 
+		public void RemoveOnRemoveCompleteExcept ()
 		{
-			bool exceptionThrown = false;
-
-			ConcreteDictionary myDictionary = new ConcreteDictionary(28);
+			ConcreteDictionary myDictionary = new ConcreteDictionary (28);
+			myDictionary.onValidateExist = true;
+			myDictionary.onRemoveExist = true;
 			myDictionary.onRemoveCompleteMustThrowException = true;
 
-			try 
-			{
-				myDictionary.BaseDictionary.Remove(11);
-			} 
-			catch 
-			{
-				exceptionThrown = true;
-			} 
-			finally 
-			{
-				Assert("Exception must be thrown", exceptionThrown);
-				Assert("OnValidate must be fired", myDictionary.onValidateFired);
-				Assert("OnRemove must be fired", myDictionary.onRemoveFired);
-				Assert("OnRemoveComplete must be fired", myDictionary.onRemoveCompleteFired);
-				AssertEquals("Count", 27, myDictionary.Count);
-				AssertEquals(null, myDictionary.BaseDictionary[11]);
+			try {
+				myDictionary.BaseDictionary.Remove (11);
+				Assert.Fail ("#A1");
+			} catch (AssertionException) {
+				throw;
+			} catch (Exception ex) {
+				Assert.AreEqual (typeof (Exception), ex.GetType (), "#A2");
+				Assert.IsNull (ex.InnerException, "#A3");
+				Assert.IsNotNull (ex.Message, "#A4");
 			}
 
+			Assert.IsFalse (myDictionary.onInsertFired, "#B1");
+			Assert.IsFalse (myDictionary.onInsertCompleteFired, "#B2");
+			Assert.IsTrue (myDictionary.onValidateFired, "#B3");
+			Assert.IsTrue (myDictionary.onRemoveFired, "#B4");
+			Assert.IsTrue (myDictionary.onRemoveCompleteFired, "#B5");
+			Assert.IsFalse (myDictionary.onClearFired, "#B6");
+			Assert.IsFalse (myDictionary.onClearCompleteFired, "#B7");
+			Assert.IsFalse (myDictionary.onSetFired, "#B8");
+			Assert.IsFalse (myDictionary.onSetCompleteFired, "#B9");
+			Assert.IsFalse (myDictionary.onGetFired, "#B10");
+#if NET_2_0
+			myDictionary.onGetExist = true;
+			Assert.AreEqual (28, myDictionary.Count, "#B11");
+			Assert.AreEqual (22, myDictionary.BaseDictionary [11], "#B12");
+#else
+			Assert.AreEqual (27, myDictionary.Count, "#B11");
+			Assert.IsNull (myDictionary.BaseDictionary [11], "#B12");
+#endif
 		}
 
 		[Test]
-		public void RemoveKeyNotInDictionary() 
-		{
-		
-			ConcreteDictionary myDictionary = new ConcreteDictionary(28);
-
-			myDictionary.BaseDictionary.Remove(80);
-			Assert("OnValidate must be fired", myDictionary.onValidateFired);
-			Assert("OnRemove must be fired", myDictionary.onRemoveFired);
-			Assert("OnRemoveComplete must be fired", myDictionary.onRemoveCompleteFired);
-                }
+		public void RemoveKeyNotInDictionary ()
+		{
+			ConcreteDictionary myDictionary = new ConcreteDictionary (28);
+			myDictionary.BaseDictionary.Remove (80);
+
+			Assert.IsFalse (myDictionary.onInsertFired, "#B1");
+			Assert.IsFalse (myDictionary.onInsertCompleteFired, "#B2");
+#if NET_2_0
+			Assert.IsFalse (myDictionary.onValidateFired, "#1");
+			Assert.IsFalse (myDictionary.onRemoveFired, "#2");
+			Assert.IsFalse (myDictionary.onRemoveCompleteFired, "#3");
+#else
+			Assert.IsTrue (myDictionary.onValidateFired, "#1");
+			Assert.IsTrue (myDictionary.onRemoveFired, "#2");
+			Assert.IsTrue (myDictionary.onRemoveCompleteFired, "#3");
+#endif
+			Assert.IsFalse (myDictionary.onClearFired, "#B6");
+			Assert.IsFalse (myDictionary.onClearCompleteFired, "#B7");
+			Assert.IsFalse (myDictionary.onSetFired, "#B8");
+			Assert.IsFalse (myDictionary.onSetCompleteFired, "#B9");
+			Assert.IsFalse (myDictionary.onGetFired, "#B10");
+		}
 
 		[Test]
-		public void Items() 
+		public void Items ()
 		{
-			ConcreteDictionary myDictionary = new ConcreteDictionary(19);
-			for (int i = 0; i < 19; i++) 
-			{
-				AssertEquals(i*2, (int) myDictionary.BaseDictionary[i]);
-			}
+			ConcreteDictionary myDictionary = new ConcreteDictionary (19);
+			myDictionary.onGetExist = true;
+
+			for (int i = 0; i < 19; i++)
+				Assert.AreEqual (i * 2, (int) myDictionary.BaseDictionary [i]);
 		}
 
 		[Test]
-		public void Contains() 
+		public void Contains ()
 		{
-			ConcreteDictionary myDictionary = new ConcreteDictionary(14);
-			for (int i = 0; i < 14; i++) 
-			{
-				Assert("Must contain " + i, myDictionary.BaseDictionary.Contains(i));
-			}
-			for (int i = 14; i < 34; i++) 
-			{
-				Assert("Must not contain " + i, !myDictionary.BaseDictionary.Contains(i));
-			}
+			ConcreteDictionary myDictionary = new ConcreteDictionary (14);
+			for (int i = 0; i < 14; i++)
+				Assert.IsTrue (myDictionary.BaseDictionary.Contains (i), "Must contain " + i);
+			for (int i = 14; i < 34; i++)
+				Assert.IsFalse (myDictionary.BaseDictionary.Contains (i), "Must not contain " + i);
 		}
 
 		[Test]
-		public void GetEnumerator() 
+		public void GetEnumerator ()
 		{
-			ConcreteDictionary myDictionary = new ConcreteDictionary(4);
-			
-			AssertNotNull(myDictionary.GetEnumerator());
+			ConcreteDictionary myDictionary = new ConcreteDictionary (4);
+			Assert.IsNotNull (myDictionary.GetEnumerator ());
 		}
 
 		[Test]
-		public void Keys() 
+		public void Keys ()
 		{
-			ConcreteDictionary myDictionary = new ConcreteDictionary(5);
+			ConcreteDictionary myDictionary = new ConcreteDictionary (5);
 			ICollection keys = myDictionary.BaseDictionary.Keys;
 
 			int total = 0;
-			foreach (int i in keys) 
+			foreach (int i in keys)
 				total += i;
-			AssertEquals(10, total);
-			AssertEquals(5, keys.Count);
+			Assert.AreEqual (10, total, "#1");
+			Assert.AreEqual (5, keys.Count, "#2");
 		}
 
 		[Test]
-		public void Values() 
+		public void Values ()
 		{
-			ConcreteDictionary myDictionary = new ConcreteDictionary(5);
+			ConcreteDictionary myDictionary = new ConcreteDictionary (5);
 			ICollection values = myDictionary.BaseDictionary.Values;
 
 			int total = 0;
-			foreach (int i in values) 
+			foreach (int i in values)
 				total += i;
-			AssertEquals(20, total);
-			AssertEquals(5, values.Count);
+			Assert.AreEqual (20, total, "#1");
+			Assert.AreEqual (5, values.Count, "#2");
 		}
 
 		[Test]
-		public void Get() 
+		public void Get ()
 		{
-			ConcreteDictionary myDictionary = new ConcreteDictionary(18);
+			ConcreteDictionary myDictionary = new ConcreteDictionary (18);
+			myDictionary.onGetExist = true;
 			int v = (int) myDictionary.BaseDictionary[10];
 
-			Assert("OnGet must be fired", myDictionary.onGetFired);
-			AssertEquals(v, 20);
+			Assert.IsFalse (myDictionary.onInsertFired, "#1");
+			Assert.IsFalse (myDictionary.onInsertCompleteFired, "#2");
+			Assert.IsFalse (myDictionary.onValidateFired, "#3");
+			Assert.IsFalse (myDictionary.onRemoveFired, "#4");
+			Assert.IsFalse (myDictionary.onRemoveCompleteFired, "#5");
+			Assert.IsFalse (myDictionary.onClearFired, "#6");
+			Assert.IsFalse (myDictionary.onClearCompleteFired, "#7");
+			Assert.IsFalse (myDictionary.onSetFired, "#8");
+			Assert.IsFalse (myDictionary.onSetCompleteFired, "#9");
+			Assert.IsTrue (myDictionary.onGetFired, "#10");
+			Assert.AreEqual (20, v, "#11");
 		}
 
 		[Test]
-		public void GetOnGetExcept() 
+		public void GetOnGetExcept ()
 		{
-			bool exceptionThrown = false;
-
-			ConcreteDictionary myDictionary = new ConcreteDictionary(18);
+			ConcreteDictionary myDictionary = new ConcreteDictionary (18);
+			myDictionary.onGetExist = true;
 			myDictionary.onGetMustThrowException = true;
 
 			try {
-				int v = (int) myDictionary.BaseDictionary[10];
-			} catch {
-				exceptionThrown = true;
-			} finally {
-				Assert("Exception must be thrown", exceptionThrown);
-				Assert("OnGet must be fired", myDictionary.onGetFired);
+				int v = (int) myDictionary.BaseDictionary [10];
+				Assert.Fail ("#1:" + v);
+			} catch (AssertionException) {
+				throw;
+			} catch (Exception ex) {
+				Assert.AreEqual (typeof (Exception), ex.GetType (), "#A2");
+				Assert.IsNull (ex.InnerException, "#A3");
+				Assert.IsNotNull (ex.Message, "#A4");
 			}
+
+			Assert.IsFalse (myDictionary.onInsertFired, "#B1");
+			Assert.IsFalse (myDictionary.onInsertCompleteFired, "#B2");
+			Assert.IsFalse (myDictionary.onValidateFired, "#B3");
+			Assert.IsFalse (myDictionary.onRemoveFired, "#B4");
+			Assert.IsFalse (myDictionary.onRemoveCompleteFired, "#B5");
+			Assert.IsFalse (myDictionary.onClearFired, "#B6");
+			Assert.IsFalse (myDictionary.onClearCompleteFired, "#B7");
+			Assert.IsFalse (myDictionary.onSetFired, "#B8");
+			Assert.IsFalse (myDictionary.onSetCompleteFired, "#B9");
+			Assert.IsTrue (myDictionary.onGetFired, "#B10");
 		}
 
 		[Test]
-		public void GetNoKey() 
+		public void GetNoKey ()
 		{
-			ConcreteDictionary myDictionary = new ConcreteDictionary(18);
-			AssertNull(myDictionary.BaseDictionary[100]);
+			ConcreteDictionary myDictionary = new ConcreteDictionary (18);
+			Assert.IsNull (myDictionary.BaseDictionary [100]);
 		}
 
 		[Test]
-		public void Set() 
+		public void Set ()
 		{
-			ConcreteDictionary myDictionary = new ConcreteDictionary(18);
+			ConcreteDictionary myDictionary = new ConcreteDictionary (18);
+			myDictionary.onValidateExist = true;
+			myDictionary.onSetExist = true;
 			myDictionary.BaseDictionary[10] = 50;
 
-			Assert("OnValidate must be fired", myDictionary.onValidateFired);
-			Assert("OnSet must be fired", myDictionary.onSetFired);
-			Assert("OnSetComplete must be fired", myDictionary.onSetCompleteFired);
-			AssertEquals(50, myDictionary.BaseDictionary[10]);
+			Assert.IsFalse (myDictionary.onInsertFired, "#1");
+			Assert.IsFalse (myDictionary.onInsertCompleteFired, "#2");
+			Assert.IsTrue (myDictionary.onValidateFired, "#3");
+			Assert.IsFalse (myDictionary.onRemoveFired, "#4");
+			Assert.IsFalse (myDictionary.onRemoveCompleteFired, "#5");
+			Assert.IsFalse (myDictionary.onClearFired, "#6");
+			Assert.IsFalse (myDictionary.onClearCompleteFired, "#7");
+			Assert.IsTrue (myDictionary.onSetFired, "#8");
+			Assert.IsTrue (myDictionary.onSetCompleteFired, "#9");
+			Assert.IsFalse (myDictionary.onGetFired, "#10");
+			myDictionary.onGetExist = true;
+			Assert.AreEqual (50, myDictionary.BaseDictionary [10], "#11");
 		}
 
 		[Test]
-		public void SetNewKey() 
+		public void SetNewKey ()
 		{
-			ConcreteDictionary myDictionary = new ConcreteDictionary(18);
+			ConcreteDictionary myDictionary = new ConcreteDictionary (18);
 			myDictionary.BaseDictionary[111] = 222;
 
-			Assert("OnValidate must be fired", myDictionary.onValidateFired);
-			Assert("OnSet must be fired", myDictionary.onSetFired);
-			Assert("OnSetComplete must be fired", myDictionary.onSetCompleteFired);
-			Assert("OnInsert must not be fired", !myDictionary.onInsertFired);
-			Assert("OnInsertComplete must not be fired", !myDictionary.onInsertCompleteFired);
-			AssertEquals(222, myDictionary.BaseDictionary[111]);
-			AssertEquals(19, myDictionary.Count);
+			Assert.IsFalse (myDictionary.onInsertFired, "#1");
+			Assert.IsFalse (myDictionary.onInsertCompleteFired, "#2");
+			Assert.IsTrue (myDictionary.onValidateFired, "#3");
+			Assert.IsFalse (myDictionary.onRemoveFired, "#4");
+			Assert.IsFalse (myDictionary.onRemoveCompleteFired, "#5");
+			Assert.IsFalse (myDictionary.onClearFired, "#6");
+			Assert.IsFalse (myDictionary.onClearCompleteFired, "#7");
+			Assert.IsTrue (myDictionary.onSetFired, "#8");
+			Assert.IsTrue (myDictionary.onSetCompleteFired, "#9");
+			Assert.IsFalse (myDictionary.onGetFired, "#10");
+			myDictionary.onGetExist = true;
+			Assert.AreEqual (222, myDictionary.BaseDictionary [111], "#11");
+			Assert.AreEqual (19, myDictionary.Count, "#12");
 		}
 
 		[Test]
-		public void SetOnValidateExcept() 
+		public void SetOnValidateExcept()
 		{
-			bool exceptionThrown = false;
-
-			ConcreteDictionary myDictionary = new ConcreteDictionary(18);
+			ConcreteDictionary myDictionary = new ConcreteDictionary (18);
+			myDictionary.onValidateExist = true;
 			myDictionary.onValidateMustThrowException = true;
 			
 			try {
 				myDictionary.BaseDictionary[10] = 50;
-			} catch {
-				exceptionThrown = true;
-			} finally {
-				Assert("Exception must be thrown", exceptionThrown);
-				Assert("OnValidate must be fired", myDictionary.onValidateFired);
-				Assert("OnSet must not be fired", !myDictionary.onSetFired);
-				Assert("OnSetComplete not must be fired", !myDictionary.onSetCompleteFired);
-				AssertEquals(20, myDictionary.BaseDictionary[10]);
+				Assert.Fail ("#A1");
+			} catch (AssertionException) {
+				throw;
+			} catch (Exception ex) {
+				Assert.AreEqual (typeof (Exception), ex.GetType (), "#A2");
+				Assert.IsNull (ex.InnerException, "#A3");
+				Assert.IsNotNull (ex.Message, "#A4");
 			}
+
+			Assert.IsFalse (myDictionary.onInsertFired, "#B1");
+			Assert.IsFalse (myDictionary.onInsertCompleteFired, "#B2");
+			Assert.IsTrue (myDictionary.onValidateFired, "#B3");
+			Assert.IsFalse (myDictionary.onRemoveFired, "#B4");
+			Assert.IsFalse (myDictionary.onRemoveCompleteFired, "#B5");
+			Assert.IsFalse (myDictionary.onClearFired, "#B6");
+			Assert.IsFalse (myDictionary.onClearCompleteFired, "#B7");
+			Assert.IsFalse (myDictionary.onSetFired, "#B8");
+			Assert.IsFalse (myDictionary.onSetCompleteFired, "#B9");
+			Assert.IsFalse (myDictionary.onGetFired, "#B10");
+			myDictionary.onGetExist = true;
+			Assert.AreEqual (20, myDictionary.BaseDictionary [10], "#B11");
 		}
 
 		[Test]
-		public void SetOnSetExcept() 
+		public void SetOnSetExcept()
 		{
-			bool exceptionThrown = false;
-
-			ConcreteDictionary myDictionary = new ConcreteDictionary(18);
+			ConcreteDictionary myDictionary = new ConcreteDictionary (18);
+			myDictionary.onValidateExist = true;
+			myDictionary.onSetExist = true;
 			myDictionary.onSetMustThrowException = true;
 			
 			try {
 				myDictionary.BaseDictionary[10] = 50;
-			} catch {
-				exceptionThrown = true;
-			} finally {
-				Assert("Exception must be thrown", exceptionThrown);
-				Assert("OnValidate must be fired", myDictionary.onValidateFired);
-				Assert("OnSet must be fired", myDictionary.onSetFired);
-				Assert("OnSetComplete must not be fired", !myDictionary.onSetCompleteFired);
-				AssertEquals(20, myDictionary.BaseDictionary[10]);
+				Assert.Fail ("#A1");
+			} catch (AssertionException) {
+				throw;
+			} catch (Exception ex) {
+				Assert.AreEqual (typeof (Exception), ex.GetType (), "#A2");
+				Assert.IsNull (ex.InnerException, "#A3");
+				Assert.IsNotNull (ex.Message, "#A4");
 			}
+
+			Assert.IsFalse (myDictionary.onInsertFired, "#B1");
+			Assert.IsFalse (myDictionary.onInsertCompleteFired, "#B2");
+			Assert.IsTrue (myDictionary.onValidateFired, "#B3");
+			Assert.IsFalse (myDictionary.onRemoveFired, "#B4");
+			Assert.IsFalse (myDictionary.onRemoveCompleteFired, "#B5");
+			Assert.IsFalse (myDictionary.onClearFired, "#B6");
+			Assert.IsFalse (myDictionary.onClearCompleteFired, "#B7");
+			Assert.IsTrue (myDictionary.onSetFired, "#B8");
+			Assert.IsFalse (myDictionary.onSetCompleteFired, "#B9");
+			Assert.IsFalse (myDictionary.onGetFired, "#B10");
+			myDictionary.onGetExist = true;
+			Assert.AreEqual (20, myDictionary.BaseDictionary [10], "#B11");
 		}
 
 		[Test]
 		public void SetOnSetCompleteExcept() 
 		{
-			bool exceptionThrown = false;
-
-			ConcreteDictionary myDictionary = new ConcreteDictionary(18);
+			ConcreteDictionary myDictionary = new ConcreteDictionary (18);
+			myDictionary.onValidateExist = true;
+			myDictionary.onSetExist = true;
 			myDictionary.onSetCompleteMustThrowException = true;
 			
 			try {
 				myDictionary.BaseDictionary[10] = 50;
-			} catch {
-				exceptionThrown = true;
-			} finally {
-				Assert("Exception must be thrown", exceptionThrown);
-				Assert("OnValidate must be fired", myDictionary.onValidateFired);
-				Assert("OnSet must be fired", myDictionary.onSetFired);
-				Assert("OnSetComplete must be fired", myDictionary.onSetCompleteFired);
-				AssertEquals(20, myDictionary.BaseDictionary[10]);
+				Assert.Fail ("#A1");
+			} catch (AssertionException) {
+				throw;
+			} catch (Exception ex) {
+				Assert.AreEqual (typeof (Exception), ex.GetType (), "#A2");
+				Assert.IsNull (ex.InnerException, "#A3");
+				Assert.IsNotNull (ex.Message, "#A4");
 			}
+
+			Assert.IsFalse (myDictionary.onInsertFired, "#B1");
+			Assert.IsFalse (myDictionary.onInsertCompleteFired, "#B2");
+			Assert.IsTrue (myDictionary.onValidateFired, "#B3");
+			Assert.IsFalse (myDictionary.onRemoveFired, "#B4");
+			Assert.IsFalse (myDictionary.onRemoveCompleteFired, "#B5");
+			Assert.IsFalse (myDictionary.onClearFired, "#B6");
+			Assert.IsFalse (myDictionary.onClearCompleteFired, "#B7");
+			Assert.IsTrue (myDictionary.onSetFired, "#B8");
+			Assert.IsTrue (myDictionary.onSetCompleteFired, "#B9");
+			Assert.IsFalse (myDictionary.onGetFired, "#B10");
+			myDictionary.onGetExist = true;
+			Assert.AreEqual (20, myDictionary.BaseDictionary [10], "#B11");
 		}
 
 		[Test]
 		public void IsReadOnly() 
 		{
-			ConcreteDictionary myDictionary = new ConcreteDictionary(1);
-			Assert(!myDictionary.BaseDictionary.IsReadOnly);
+			ConcreteDictionary myDictionary = new ConcreteDictionary (1);
+			Assert.IsFalse (myDictionary.BaseDictionary.IsReadOnly);
 		}
 
 		[Test]
 		public void IsFixedSize() 
 		{
-			ConcreteDictionary myDictionary = new ConcreteDictionary(1);
-			Assert(!myDictionary.BaseDictionary.IsFixedSize);
+			ConcreteDictionary myDictionary = new ConcreteDictionary (1);
+			Assert.IsFalse (myDictionary.BaseDictionary.IsFixedSize);
 		}
 
 		[Test]
 		public void DictionaryProperty()
 		{
-			ConcreteDictionary myDictionary = new ConcreteDictionary(1);
-			AssertEquals(myDictionary, myDictionary.BaseDictionary);
+			ConcreteDictionary myDictionary = new ConcreteDictionary (1);
+			Assert.AreEqual (myDictionary, myDictionary.BaseDictionary);
+		}
+
+		public class NullDictionary : DictionaryBase
+		{
+			protected override object OnGet (object key, object currentValue)
+			{
+				return null;
+			}
+		}
+
+		[Test]
+		public void NullDictionary_Get ()
+		{
+			IDictionary dictionary = new NullDictionary ();
+			dictionary ["a"] = "b";
+			Assert.AreEqual ("b", dictionary ["a"]);
+		}
+
+		public class ModifyDictionary : DictionaryBase
+		{
+			protected override object OnGet (object key, object currentValue)
+			{
+				(this as IDictionary) [key] = key;
+				return key;
+			}
+		}
+
+		[Test]
+		public void ModifyDictionary_Get ()
+		{
+			IDictionary dictionary = new ModifyDictionary ();
+			dictionary ["a"] = "b";
+#if NET_2_0
+			// first time we return "b" - because the value was cached
+			Assert.AreEqual ("b", dictionary ["a"], "#1");
+#else
+			Assert.AreEqual ("a", dictionary ["a"], "#1");
+#endif
+			// second time we return "a" - because it's the value in the dictionary
+			Assert.AreEqual ("a", dictionary ["a"], "#2");
+		}
+
+		public class ThrowDictionary : DictionaryBase
+		{
+			protected override object OnGet (object key, object currentValue)
+			{
+				throw new ArgumentException ((string) key, (string) currentValue);
+			}
+		}
+
+		[Test]
+		public void ThrowDictionary_Get ()
+		{
+			IDictionary dictionary = new ThrowDictionary ();
+			dictionary ["a"] = "b";
+
+			try {
+				object value = dictionary ["a"];
+				Assert.Fail ("#1: " + value);
+			} catch (ArgumentException ex) {
+				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
+				Assert.IsNull (ex.InnerException, "#3");
+				Assert.IsNotNull (ex.Message, "#4");
+				Assert.IsTrue (ex.Message.StartsWith ("a"), "#5");
+				Assert.AreEqual ("b", ex.ParamName, "#6");
+			}
 		}
 	}
 }