2007-03-29 Adar Wesley <[email protected]>

        * ObjectDataSourceView.cs: fixed events so they are raized at the
        right times.  Added many tests to verify the correct time.
        * SqlDataSourceView.cs: fixed events so they are raized at the right
        times.  Added many tests to verify the correct time.


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

mcs/class/System.Web/System.Web.UI.WebControls/ChangeLog

@@ -1,3 +1,10 @@
+2007-03-29 Adar Wesley <[email protected]>
+
+	* ObjectDataSourceView.cs: fixed events so they are raized at the
+	right times.  Added many tests to verify the correct time.
+	* SqlDataSourceView.cs: fixed events so they are raized at the right
+	times.  Added many tests to verify the correct time.
+
 2007-03-28 Igor Zelmanovich <[email protected]>
 
 	* Menu.cs:

mcs/class/System.Web/System.Web.UI.WebControls/ObjectDataSourceView.cs

@@ -306,8 +306,8 @@ namespace System.Web.UI.WebControls
 			get {
 				return dataObjectTypeName != null ? dataObjectTypeName : string.Empty;
 			}
-			set {
-				dataObjectTypeName = value;
+			set {
+				dataObjectTypeName = value;
 				dataObjectType = null;
 			}
 		}
@@ -531,7 +531,7 @@ namespace System.Web.UI.WebControls
 		Type DataObjectType {
 			get {
 				if (dataObjectType == null) {
-					dataObjectType = LoadType (DataObjectTypeName);
+					dataObjectType = LoadType (DataObjectTypeName);
 					if (dataObjectType == null)
 						throw new InvalidOperationException ("Type not found: " + DataObjectTypeName);
 				}
@@ -568,7 +568,7 @@ namespace System.Web.UI.WebControls
 			MethodInfo method;
 			
 			if (DataObjectTypeName.Length == 0) {
-				paramValues = MergeParameterValues (InsertParameters, values, null, true);
+				paramValues = MergeParameterValues (InsertParameters, values, null);
 				method = GetObjectMethod (InsertMethod, paramValues, DataObjectMethodType.Insert);
 			} else {
 				method = ResolveDataObjectMethod (InsertMethod, values, null, out paramValues);
@@ -608,7 +608,7 @@ namespace System.Web.UI.WebControls
 			MethodInfo method;
 			
 			if (DataObjectTypeName.Length == 0) {
-				paramValues = MergeParameterValues (DeleteParameters, null, oldDataValues, true);
+				paramValues = MergeParameterValues (DeleteParameters, null, oldDataValues);
 				method = GetObjectMethod (DeleteMethod, paramValues, DataObjectMethodType.Delete);
 			} else {
 				method = ResolveDataObjectMethod (DeleteMethod, oldDataValues, null, out paramValues);
@@ -646,7 +646,7 @@ namespace System.Web.UI.WebControls
 			{
 				IDictionary dataValues;
 				dataValues = values;
-				paramValues = MergeParameterValues (UpdateParameters, dataValues, oldDataValues, false);
+				paramValues = MergeParameterValues (UpdateParameters, dataValues, oldDataValues);
 				method = GetObjectMethod (UpdateMethod, paramValues, DataObjectMethodType.Update);
 			}
 			else
@@ -715,7 +715,7 @@ namespace System.Web.UI.WebControls
 		{
 			arguments.RaiseUnsupportedCapabilitiesError (this);
 
-			IOrderedDictionary paramValues = MergeParameterValues (SelectParameters, null, null, true);
+			IOrderedDictionary paramValues = MergeParameterValues (SelectParameters, null, null);
 			ObjectDataSourceSelectingEventArgs args = new ObjectDataSourceSelectingEventArgs (paramValues, arguments, false);
 
 			object result = null;
@@ -1026,33 +1026,27 @@ namespace System.Web.UI.WebControls
 		/// <param name="allwaysAddNewValues">true for insert, as current item is
 		/// irrelevant for insert</param>
 		/// <returns>merged values</returns>
-		IOrderedDictionary MergeParameterValues (ParameterCollection viewParams, IDictionary values, IDictionary oldValues, bool allwaysAddNewValues)
+		IOrderedDictionary MergeParameterValues (ParameterCollection viewParams, IDictionary values, IDictionary oldValues)
 		{
+			IOrderedDictionary parametersValues = viewParams.GetValues (context, owner);
 			OrderedDictionary mergedValues = new OrderedDictionary (StringComparer.InvariantCultureIgnoreCase);
-			foreach (Parameter p in viewParams) {
-				bool oldAdded = false;
+			foreach (string parameterName in parametersValues.Keys) {
+				mergedValues [parameterName] = parametersValues [parameterName];
 				if (oldValues != null) {
-					object value = FindValueByName (p.Name, oldValues, true);
+					object value = FindValueByName (parameterName, oldValues, true);
 					if (value != null) {
-						object dataValue = p.ConvertValue (value);
-						mergedValues [p.Name] = dataValue;
-						oldAdded = true;
+						object dataValue = viewParams [parameterName].ConvertValue (value);
+						mergedValues [parameterName] = dataValue;
 					}
 				}
 
-				bool newAdded = false;
 				if (values != null) {
-					object value = FindValueByName (p.Name, values, false);
+					object value = FindValueByName (parameterName, values, false);
 					if (value != null) {
-						object dataValue = p.ConvertValue (value);
-						mergedValues [p.Name] = dataValue;
-						newAdded = true;
+						object dataValue = viewParams [parameterName].ConvertValue (value);
+						mergedValues [parameterName] = dataValue;
 					}
 				}
-				if ((!newAdded && !oldAdded) || allwaysAddNewValues) {
-					object val = p.GetValue (context, owner);
-					mergedValues [p.Name] = val;
-				}
 			}
 
 			if (values != null) {
@@ -1062,9 +1056,11 @@ namespace System.Web.UI.WebControls
 			}
 
 			if (oldValues != null) {
-				foreach (DictionaryEntry de in oldValues)
-					if (FindValueByName ((string) de.Key, mergedValues, true) == null)
-						mergedValues [FormatOldParameter ((string) de.Key)] = de.Value;
+				foreach (DictionaryEntry de in oldValues) {
+					string oldValueKey = FormatOldParameter ((string) de.Key);
+					if (FindValueByName (oldValueKey, mergedValues, false) == null)
+						mergedValues [oldValueKey] = de.Value;
+				}
 			}
 
 			return mergedValues;
@@ -1194,3 +1190,4 @@ namespace System.Web.UI.WebControls
 
 
 
+

mcs/class/System.Web/System.Web.UI.WebControls/SqlDataSourceView.cs

@@ -99,7 +99,7 @@ namespace System.Web.UI.WebControls {
 			else
 				oldDataValues = keys;
 			
-			InitializeParameters (command, DeleteParameters, null, oldDataValues, false);
+			InitializeParameters (command, DeleteParameters, null, oldDataValues, true);
 
 			SqlDataSourceCommandEventArgs args = new SqlDataSourceCommandEventArgs (command);
 			OnDeleting (args);
@@ -153,7 +153,7 @@ namespace System.Web.UI.WebControls {
 			else
 				command.CommandType = CommandType.StoredProcedure;
 
-			InitializeParameters (command, InsertParameters, values, null, true);
+			InitializeParameters (command, InsertParameters, values, null, false);
 
 			SqlDataSourceCommandEventArgs args = new SqlDataSourceCommandEventArgs (command);
 			OnInserting (args);
@@ -217,7 +217,7 @@ namespace System.Web.UI.WebControls {
 			}
 
 			if (SelectParameters.Count > 0)
-				InitializeParameters (command, SelectParameters, null, null, true);
+				InitializeParameters (command, SelectParameters, null, null, false);
 
 			Exception exception = null;
 			if (owner.DataSourceMode == SqlDataSourceMode.DataSet) {
@@ -344,7 +344,7 @@ namespace System.Web.UI.WebControls {
 
 			IDictionary dataValues = values;
 
-			InitializeParameters (command, UpdateParameters, dataValues, oldDataValues, ConflictDetection == ConflictOptions.CompareAllValues);
+			InitializeParameters (command, UpdateParameters, dataValues, oldDataValues, ConflictDetection == ConflictOptions.OverwriteChanges);
 
 			SqlDataSourceCommandEventArgs args = new SqlDataSourceCommandEventArgs (command);
 			OnUpdating (args);
@@ -387,35 +387,44 @@ namespace System.Web.UI.WebControls {
 				return name;
 		}
 
-		object FindValueByName (Parameter p, IDictionary values, bool format)
+		object FindValueByName (string parameterName, IDictionary values, bool format)
 		{
 			if (values == null)
 				return null;
 
 			foreach (DictionaryEntry de in values) {
 				string valueName = format == true ? FormatOldParameter (de.Key.ToString ()) : de.Key.ToString ();
-				if (p.Name == valueName)
+				if (parameterName == valueName)
 					return values [de.Key];
 			}
 			foreach (DictionaryEntry de in values) {
 				string valueName = format == true ? FormatOldParameter (de.Key.ToString ()) : de.Key.ToString ();
 				valueName = valueName.ToLower ();
-				if (p.Name.ToLower () == valueName)
+				if (parameterName.ToLower () == valueName)
 					return values [de.Key];
 			}
 			return null;
 		}
 
-		void InitializeParameters (DbCommand command, ParameterCollection parameters, IDictionary values, IDictionary oldValues, bool alwaysAddParameters)
+		void InitializeParameters (DbCommand command, ParameterCollection parameters, IDictionary values, IDictionary oldValues, bool parametersMayMatchOldValues)
 		{
-			foreach (Parameter p in parameters) {
-				object value = FindValueByName (p, values, false);
-				string valueName = p.Name;
+			IOrderedDictionary parameterValues = parameters.GetValues (context, owner);
+
+			foreach (string parameterName in parameterValues.Keys) {
+				Parameter p = parameters [parameterName];
+				object value = FindValueByName (parameterName, values, false);
+				string valueName = parameterName;
 				if (value == null)
-					value = FindValueByName (p, oldValues, true);
-				if (value == null && !alwaysAddParameters) {
-					value = FindValueByName (p, oldValues, false);
-					valueName = FormatOldParameter (p.Name);
+					value = FindValueByName (parameterName, oldValues, true);
+
+				if (value == null && parametersMayMatchOldValues) {
+					value = FindValueByName (parameterName, oldValues, false);
+					valueName = FormatOldParameter (parameterName);
+				}
+
+				if (value == null) {
+					value = parameterValues [parameterName];
+					valueName = parameterName;
 				}
 
 				if (value != null) {
@@ -425,10 +434,6 @@ namespace System.Web.UI.WebControls {
 						command.Parameters.Add (newParameter);
 					}
 				}
-				else {
-					object dbValue = p.GetValue (context, owner);
-					command.Parameters.Add (CreateDbParameter (p.Name, dbValue, p.Direction, p.Size));
-				}
 			}
 
 			if (values != null) {
@@ -860,3 +865,4 @@ namespace System.Web.UI.WebControls {
 }
 #endif
 
+

mcs/class/System.Web/Test/System.Web.UI.WebControls/ObjectDataSourceViewTest.cs

@@ -61,7 +61,7 @@ namespace MonoTests.System.Web.UI.WebControls
 			TrackViewState ();
 		}
 
-		public bool IsTrackingViewState ()
+		public bool GetIsTrackingViewState ()
 		{
 			return base.IsTrackingViewState;
 		}
@@ -153,6 +153,12 @@ namespace MonoTests.System.Web.UI.WebControls
 			WebTest.Unload ();
 		}
 
+		[SetUp()]
+		public void Setup () 
+		{
+			eventsCalled = null;
+		}
+
 		[Test]
 		public void Defaults ()
 		{
@@ -189,7 +195,7 @@ namespace MonoTests.System.Web.UI.WebControls
 			Assert.AreEqual ("startRowIndex", sql.StartRowIndexParameterName, "StartRowIndexParameterName");
 			Assert.AreEqual ("", sql.TypeName, "TypeName");
 			Assert.AreEqual ("", sql.UpdateMethod, "UpdateMethod");
-			Assert.AreEqual (true, sql.IsTrackingViewState (), "IsTrackingViewState");
+			Assert.AreEqual (true, sql.GetIsTrackingViewState (), "IsTrackingViewState");
 			Assert.IsTrue (sql.CanRetrieveTotalRowCount, "CanRetrieveTotalRowCount");
 		}
 
@@ -388,7 +394,8 @@ namespace MonoTests.System.Web.UI.WebControls
 		}
 
 		[Test]
-		public void CanRetrieveTotalRowCount () {
+		public void CanRetrieveTotalRowCount () 
+		{
 			ObjectDataSource ds = new ObjectDataSource ();
 			ObjectDataSourceView view = new ObjectDataSourceView (ds, "DefaultView", null);
 
@@ -807,6 +814,414 @@ namespace MonoTests.System.Web.UI.WebControls
 			Eventassert ("ObjectDisposing");
 		}
 
+		enum InitViewType
+		{
+			MatchParamsToValues,
+			MatchParamsToOldValues,
+			DontMatchParams,
+		}
+
+		public class DummyDataSourceObject
+		{
+			public static IEnumerable Select (string filter) 
+			{
+				if (eventsCalled == null) {
+					eventsCalled = new ArrayList ();
+				}
+				eventsCalled.Add (String.Format ("Select(filter = {0})", filter));
+				return new string [] { "one", "two", "three" };
+			}
+
+			public static int Update (string ID) 
+			{
+				if (eventsCalled == null) {
+					eventsCalled = new ArrayList ();
+				}
+				eventsCalled.Add (String.Format ("Update(ID = {0})", ID));
+				return 1;
+			}
+
+			public static int Update (string ID, string oldvalue_ID) 
+			{
+				if (eventsCalled == null) {
+					eventsCalled = new ArrayList ();
+				}
+				eventsCalled.Add (String.Format ("Update(ID = {0}, oldvalue_ID = {1})", ID, oldvalue_ID));
+				return 1;
+			}
+
+			public static int UpdateOther (string ID, string OtherValue, string oldvalue_ID) 
+			{
+				if (eventsCalled == null) {
+					eventsCalled = new ArrayList ();
+				}
+				eventsCalled.Add (String.Format ("UpdateOther(ID = {0}, OtherValue = {1}, oldvalue_ID = {2})", ID, OtherValue, oldvalue_ID));
+				return 1;
+			}
+
+			public static int Insert (string ID) 
+			{
+				if (eventsCalled == null) {
+					eventsCalled = new ArrayList ();
+				}
+				eventsCalled.Add (String.Format ("Insert(ID = {0})", ID));
+				return 1;
+			}
+
+			public static int Insert (string ID, string oldvalue_ID) 
+			{
+				if (eventsCalled == null) {
+					eventsCalled = new ArrayList ();
+				}
+				eventsCalled.Add (String.Format ("Insert(ID = {0}, oldvalue_ID = {1})", ID, oldvalue_ID));
+				return 1;
+			}
+
+			public static int InsertOther (string ID, string OtherValue) 
+			{
+				if (eventsCalled == null) {
+					eventsCalled = new ArrayList ();
+				}
+				eventsCalled.Add (String.Format ("InsertOther(ID = {0}, OtherValue = {1})", ID, OtherValue));
+				return 1;
+			}
+
+			public static int Delete (string ID, string oldvalue_ID) 
+			{
+				if (eventsCalled == null) {
+					eventsCalled = new ArrayList ();
+				}
+				eventsCalled.Add (String.Format ("Delete(ID = {0}, oldvalue_ID = {1})", ID, oldvalue_ID));
+				return 1;
+			}
+
+			public static int Delete (string oldvalue_ID) 
+			{
+				if (eventsCalled == null) {
+					eventsCalled = new ArrayList ();
+				}
+				eventsCalled.Add (String.Format ("Delete(oldvalue_ID = {0})", oldvalue_ID));
+				return 1;
+			}
+
+			public static int DeleteOther (string oldvalue_ID, string OtherValue) 
+			{
+				if (eventsCalled == null) {
+					eventsCalled = new ArrayList ();
+				}
+				eventsCalled.Add (String.Format ("DeleteOther(oldvalue_ID = {0}, OtherValue = {1})", oldvalue_ID, OtherValue));
+				return 1;
+			}
+		}
+
+		public class AlwaysChangingParameter : Parameter
+		{
+			int evaluateCount;
+
+			public AlwaysChangingParameter (string name, TypeCode type, string defaultValue)
+				: base (name, type, defaultValue) 
+			{
+				evaluateCount = 0;
+			}
+
+			protected override object Evaluate (HttpContext context, Control control) 
+			{
+				evaluateCount++;
+				return String.Format ("{0}{1}", DefaultValue, evaluateCount);
+			}
+		}
+
+		private static void InitializeView (ObjectViewPoker view, InitViewType initType, out Hashtable keys, out Hashtable old_value, out Hashtable new_value) 
+		{
+			view.TypeName = typeof (DummyDataSourceObject).AssemblyQualifiedName;
+			view.OldValuesParameterFormatString = "oldvalue_{0}";
+			view.SelectMethod = "Select";
+			if (initType == InitViewType.DontMatchParams) {
+				view.UpdateMethod = "UpdateOther";
+				view.InsertMethod = "InsertOther";
+				view.DeleteMethod = "DeleteOther";
+			}
+			else {
+				view.UpdateMethod = "Update";
+				view.InsertMethod = "Insert";
+				view.DeleteMethod = "Delete";
+			}
+
+			Parameter selectParameter = null;
+			Parameter insertParameter = null;
+			Parameter updateParameter = null;
+			Parameter deleteParameter = null;
+
+			selectParameter = new AlwaysChangingParameter ("filter", TypeCode.String, "p_ValueSelect");
+			view.SelectParameters.Add (selectParameter);
+
+			switch (initType) {
+			case InitViewType.MatchParamsToOldValues:
+				insertParameter = new AlwaysChangingParameter ("oldvalue_ID", TypeCode.String, "p_OldValueInsert");
+				view.InsertParameters.Add (insertParameter);
+				updateParameter = new AlwaysChangingParameter ("oldvalue_ID", TypeCode.String, "p_OldValueUpdate");
+				view.UpdateParameters.Add (updateParameter);
+				deleteParameter = new AlwaysChangingParameter ("oldvalue_ID", TypeCode.String, "p_OldValueDelete");
+				view.DeleteParameters.Add (deleteParameter);
+				break;
+
+			case InitViewType.MatchParamsToValues:
+				insertParameter = new AlwaysChangingParameter ("ID", TypeCode.String, "p_ValueInsert");
+				view.InsertParameters.Add (insertParameter);
+				updateParameter = new AlwaysChangingParameter ("ID", TypeCode.String, "p_ValueUpdate");
+				view.UpdateParameters.Add (updateParameter);
+				deleteParameter = new AlwaysChangingParameter ("ID", TypeCode.String, "p_ValueDelete");
+				view.DeleteParameters.Add (deleteParameter);
+				break;
+
+			case InitViewType.DontMatchParams:
+				insertParameter = new AlwaysChangingParameter ("OtherValue", TypeCode.String, "p_OtherValueInsert");
+				view.InsertParameters.Add (insertParameter);
+				updateParameter = new AlwaysChangingParameter ("OtherValue", TypeCode.String, "p_OtherValueUpdate");
+				view.UpdateParameters.Add (updateParameter);
+				deleteParameter = new AlwaysChangingParameter ("OtherValue", TypeCode.String, "p_OtherValueDelete");
+				view.DeleteParameters.Add (deleteParameter);
+				break;
+			}
+
+			view.SelectParameters.ParametersChanged += new EventHandler (SelectParameters_ParametersChanged);
+			view.InsertParameters.ParametersChanged += new EventHandler (InsertParameters_ParametersChanged);
+			view.UpdateParameters.ParametersChanged += new EventHandler (UpdateParameters_ParametersChanged);
+			view.DeleteParameters.ParametersChanged += new EventHandler (DeleteParameters_ParametersChanged);
+
+			keys = new Hashtable ();
+			keys.Add ("ID", "k_1001");
+
+			old_value = new Hashtable ();
+			old_value.Add ("ID", "ov_1001");
+
+			new_value = new Hashtable ();
+			new_value.Add ("ID", "n_1001");
+
+			view.DataSourceViewChanged += new EventHandler (view_DataSourceViewChanged);
+		}
+
+		private static IList eventsCalled;
+
+		static void view_DataSourceViewChanged (object sender, EventArgs e) 
+		{
+			if (eventsCalled == null) {
+				eventsCalled = new ArrayList ();
+			}
+			eventsCalled.Add ("view_DataSourceViewChanged");
+		}
+
+		static void SelectParameters_ParametersChanged (object sender, EventArgs e) 
+		{
+			if (eventsCalled == null) {
+				eventsCalled = new ArrayList ();
+			}
+			eventsCalled.Add ("SelectParameters_ParametersChanged");
+		}
+
+		static void InsertParameters_ParametersChanged (object sender, EventArgs e) 
+		{
+			if (eventsCalled == null) {
+				eventsCalled = new ArrayList ();
+			}
+			eventsCalled.Add ("InsertParameters_ParametersChanged");
+		}
+
+		static void UpdateParameters_ParametersChanged (object sender, EventArgs e) 
+		{
+			if (eventsCalled == null) {
+				eventsCalled = new ArrayList ();
+			}
+			eventsCalled.Add ("UpdateParameters_ParametersChanged");
+		}
+
+		static void DeleteParameters_ParametersChanged (object sender, EventArgs e) 
+		{
+			if (eventsCalled == null) {
+				eventsCalled = new ArrayList ();
+			}
+			eventsCalled.Add ("DeleteParameters_ParametersChanged");
+		}
+
+		[Test]
+		public void ParametersAndViewChangedEvent_Select () 
+		{
+			ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
+			Hashtable keys = null;
+			Hashtable old_values = null;
+			Hashtable new_values = null;
+			InitializeView (view, InitViewType.MatchParamsToValues, out keys, out old_values, out new_values);
+
+			view.Select (DataSourceSelectArguments.Empty);
+
+			Assert.IsNotNull (eventsCalled, "Events not raized");
+			Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+			Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [0], "view_DataSourceViewChanged");
+			Assert.AreEqual ("SelectParameters_ParametersChanged", eventsCalled [1], "SelectParameters_ParametersChanged");
+			Assert.AreEqual ("Select(filter = p_ValueSelect1)", eventsCalled [2], "DataSource Method params");
+		}
+
+		[Test]
+		public void ParametersAndViewChangedEvent_MatchInsert () 
+		{
+			ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
+			Hashtable keys = null;
+			Hashtable old_values = null;
+			Hashtable new_values = null;
+			InitializeView (view, InitViewType.MatchParamsToValues, out keys, out old_values, out new_values);
+
+			view.Insert (new_values);
+
+			Assert.IsNotNull (eventsCalled, "Events not raized");
+			Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+			Assert.AreEqual ("InsertParameters_ParametersChanged", eventsCalled [0], "InsertParameters_ParametersChanged");
+			Assert.AreEqual ("Insert(ID = n_1001)", eventsCalled [1], "DataSource Method params");
+			Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2], "view_DataSourceViewChanged");
+		}
+
+		[Test]
+		public void ParametersAndViewChangedEvent_MatchOldInsert () 
+		{
+			ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
+			Hashtable keys = null;
+			Hashtable old_values = null;
+			Hashtable new_values = null;
+			InitializeView (view, InitViewType.MatchParamsToOldValues, out keys, out old_values, out new_values);
+
+			view.Insert (new_values);
+
+			Assert.IsNotNull (eventsCalled, "Events not raized");
+			Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+			Assert.AreEqual ("InsertParameters_ParametersChanged", eventsCalled [0], "InsertParameters_ParametersChanged");
+			Assert.AreEqual ("Insert(ID = n_1001, oldvalue_ID = p_OldValueInsert1)", eventsCalled [1], "DataSource Method params");
+			Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2], "view_DataSourceViewChanged");
+		}
+
+		[Test]
+		public void ParametersAndViewChangedEvent_DontMatchInsert () 
+		{
+			ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
+			Hashtable keys = null;
+			Hashtable old_values = null;
+			Hashtable new_values = null;
+			InitializeView (view, InitViewType.DontMatchParams, out keys, out old_values, out new_values);
+
+			view.Insert (new_values);
+
+			Assert.IsNotNull (eventsCalled, "Events not raized");
+			Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+			Assert.AreEqual ("InsertParameters_ParametersChanged", eventsCalled [0], "InsertParameters_ParametersChanged");
+			Assert.AreEqual ("InsertOther(ID = n_1001, OtherValue = p_OtherValueInsert1)", eventsCalled [1], "DataSource Method params");
+			Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2], "view_DataSourceViewChanged");
+		}
+
+		[Test]
+		public void ParametersAndViewChangedEvent_MatchUpdate () 
+		{
+			ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
+			Hashtable keys = null;
+			Hashtable old_values = null;
+			Hashtable new_values = null;
+			InitializeView (view, InitViewType.MatchParamsToValues, out keys, out old_values, out new_values);
+
+			view.Update (keys, new_values, old_values);
+
+			Assert.IsNotNull (eventsCalled, "Events not raized");
+			Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+			Assert.AreEqual ("UpdateParameters_ParametersChanged", eventsCalled [0], "UpdateParameters_ParametersChanged");
+			Assert.AreEqual ("Update(ID = n_1001, oldvalue_ID = k_1001)", eventsCalled [1], "DataSource Method params");
+			Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2], "view_DataSourceViewChanged");
+		}
+
+		[Test]
+		public void ParametersAndViewChangedEvent_MatchOldUpdate () 
+		{
+			ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
+			Hashtable keys = null;
+			Hashtable old_values = null;
+			Hashtable new_values = null;
+			InitializeView (view, InitViewType.MatchParamsToOldValues, out keys, out old_values, out new_values);
+
+			view.Update (keys, new_values, old_values);
+
+			Assert.IsNotNull (eventsCalled, "Events not raized");
+			Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+			Assert.AreEqual ("UpdateParameters_ParametersChanged", eventsCalled [0], "UpdateParameters_ParametersChanged");
+			Assert.AreEqual ("Update(ID = n_1001, oldvalue_ID = k_1001)", eventsCalled [1], "DataSource Method params");
+			Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2], "view_DataSourceViewChanged");
+		}
+
+		[Test]
+		public void ParametersAndViewChangedEvent_DontMatchUpdate () 
+		{
+			ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
+			Hashtable keys = null;
+			Hashtable old_values = null;
+			Hashtable new_values = null;
+			InitializeView (view, InitViewType.DontMatchParams, out keys, out old_values, out new_values);
+
+			view.Update (keys, new_values, old_values);
+
+			Assert.IsNotNull (eventsCalled, "Events not raized");
+			Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+			Assert.AreEqual ("UpdateParameters_ParametersChanged", eventsCalled [0], "UpdateParameters_ParametersChanged");
+			Assert.AreEqual ("UpdateOther(ID = n_1001, OtherValue = p_OtherValueUpdate1, oldvalue_ID = k_1001)", eventsCalled [1], "DataSource Method params");
+			Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2], "view_DataSourceViewChanged");
+		}
+
+		[Test]
+		public void ParametersAndViewChangedEvent_MatchDelete () 
+		{
+			ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
+			Hashtable keys = null;
+			Hashtable old_values = null;
+			Hashtable new_values = null;
+			InitializeView (view, InitViewType.MatchParamsToValues, out keys, out old_values, out new_values);
+
+			view.Delete (keys, old_values);
+
+			Assert.IsNotNull (eventsCalled, "Events not raized");
+			Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+			Assert.AreEqual ("DeleteParameters_ParametersChanged", eventsCalled [0], "DeleteParameters_ParametersChanged");
+			Assert.AreEqual ("Delete(ID = p_ValueDelete1, oldvalue_ID = k_1001)", eventsCalled [1], "DataSource Method params");
+			Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2], "view_DataSourceViewChanged");
+		}
+
+		[Test]
+		public void ParametersAndViewChangedEvent_MatchOldDelete () 
+		{
+			ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
+			Hashtable keys = null;
+			Hashtable old_values = null;
+			Hashtable new_values = null;
+			InitializeView (view, InitViewType.MatchParamsToOldValues, out keys, out old_values, out new_values);
+
+			view.Delete (keys, old_values);
+
+			Assert.IsNotNull (eventsCalled, "Events not raized");
+			Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+			Assert.AreEqual ("DeleteParameters_ParametersChanged", eventsCalled [0], "DeleteParameters_ParametersChanged");
+			Assert.AreEqual ("Delete(oldvalue_ID = k_1001)", eventsCalled [1], "DataSource Method params");
+			Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2], "view_DataSourceViewChanged");
+		}
+
+		[Test]
+		public void ParametersAndViewChangedEvent_DontMatchDelete () 
+		{
+			ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
+			Hashtable keys = null;
+			Hashtable old_values = null;
+			Hashtable new_values = null;
+			InitializeView (view, InitViewType.DontMatchParams, out keys, out old_values, out new_values);
+
+			view.Delete (keys, old_values);
+
+			Assert.IsNotNull (eventsCalled, "Events not raized");
+			Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+			Assert.AreEqual ("DeleteParameters_ParametersChanged", eventsCalled [0], "DeleteParameters_ParametersChanged");
+			Assert.AreEqual ("DeleteOther(oldvalue_ID = k_1001, OtherValue = p_OtherValueDelete1)", eventsCalled [1], "DataSource Method params");
+			Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2], "view_DataSourceViewChanged");
+		}
 
 		/// <summary>
 		/// Helper methods

mcs/class/System.Web/Test/System.Web.UI.WebControls/SqlDataSourceViewTest.cs

@@ -39,6 +39,9 @@ using System.Globalization;
 using System.Web;
 using System.Web.UI;
 using System.Web.UI.WebControls;
+using System.Collections;
+using System.Data.SqlClient;
+using System.Text;
 
 namespace MonoTests.System.Web.UI.WebControls
 {
@@ -63,6 +66,12 @@ namespace MonoTests.System.Web.UI.WebControls
 	[TestFixture]
 	public class SqlDataSourceViewTest 
 	{
+		[SetUp]
+		public void Setup () 
+		{
+			eventsCalled = null;
+		}
+
 		[Test]
 		public void Defaults ()
 		{
@@ -343,6 +352,596 @@ namespace MonoTests.System.Web.UI.WebControls
 			ds.CancelSelectOnNullParameter = true;
 			Assert.IsFalse (sql.CancelSelectOnNullParameter, "A3");
 		}
+
+		public class AlwaysChangingParameter : Parameter
+		{
+			int evaluateCount;
+
+			public AlwaysChangingParameter (string name, TypeCode type, string defaultValue)
+				: base (name, type, defaultValue) {
+				evaluateCount = 0;
+			}
+
+			protected override object Evaluate (HttpContext context, Control control) {
+				evaluateCount++;
+				return String.Format ("{0}{1}", DefaultValue, evaluateCount);
+			}
+		}
+
+		enum InitViewType
+		{
+			MatchParamsToValues,
+			MatchParamsToOldValues,
+			DontMatchParams,
+		}
+
+		private static SqlViewPoker InitializeView (InitViewType initType, ConflictOptions conflictDetection, out Hashtable keys, out Hashtable old_value, out Hashtable new_value) 
+		{
+			SqlDataSource ds = new SqlDataSource ();
+			ds.ConnectionString = "Data Source=fake\\SQLEXPRESS;Initial Catalog=Northwind;User ID=sa";
+			ds.ProviderName = "System.Data.SqlClient";
+			SqlViewPoker view = new SqlViewPoker (ds, "DefaultView", null);
+
+			view.ConflictDetection = conflictDetection;
+			view.OldValuesParameterFormatString = "oldvalue_{0}";
+			view.SelectCommandType = SqlDataSourceCommandType.Text;
+			view.InsertCommandType = SqlDataSourceCommandType.Text;
+			view.UpdateCommandType = SqlDataSourceCommandType.Text;
+			view.DeleteCommandType = SqlDataSourceCommandType.Text;
+
+			view.SelectCommand = "SELECT * FROM Customers WHERE ID = @ID";
+			view.InsertCommand = "INSERT INTO Customers (ID) VALUES (@ID)";
+			view.UpdateCommand = "UPDATE Customers SET ID = @ID WHERE ID = @oldvalue_ID";
+			view.DeleteCommand = "DELETE * FROM Customers WHERE ID = @ID";
+
+			Parameter selectParameter = null;
+			Parameter insertParameter = null;
+			Parameter updateParameter = null;
+			Parameter deleteParameter = null;
+
+			selectParameter = new AlwaysChangingParameter ("ID", TypeCode.String, "p_ValueSelect");
+			view.SelectParameters.Add (selectParameter);
+
+			switch (initType) {
+			case InitViewType.MatchParamsToOldValues:
+				insertParameter = new AlwaysChangingParameter ("oldvalue_ID", TypeCode.String, "p_OldValueInsert");
+				view.InsertParameters.Add (insertParameter);
+				updateParameter = new AlwaysChangingParameter ("oldvalue_ID", TypeCode.String, "p_OldValueUpdate");
+				view.UpdateParameters.Add (updateParameter);
+				deleteParameter = new AlwaysChangingParameter ("oldvalue_ID", TypeCode.String, "p_OldValueDelete");
+				view.DeleteParameters.Add (deleteParameter);
+				break;
+
+			case InitViewType.MatchParamsToValues:
+				insertParameter = new AlwaysChangingParameter ("ID", TypeCode.String, "p_ValueInsert");
+				view.InsertParameters.Add (insertParameter);
+				updateParameter = new AlwaysChangingParameter ("ID", TypeCode.String, "p_ValueUpdate");
+				view.UpdateParameters.Add (updateParameter);
+				deleteParameter = new AlwaysChangingParameter ("ID", TypeCode.String, "p_ValueDelete");
+				view.DeleteParameters.Add (deleteParameter);
+				break;
+
+			case InitViewType.DontMatchParams:
+				insertParameter = new AlwaysChangingParameter ("OtherValue", TypeCode.String, "p_OtherValueInsert");
+				view.InsertParameters.Add (insertParameter);
+				updateParameter = new AlwaysChangingParameter ("OtherValue", TypeCode.String, "p_OtherValueUpdate");
+				view.UpdateParameters.Add (updateParameter);
+				deleteParameter = new AlwaysChangingParameter ("OtherValue", TypeCode.String, "p_OtherValueDelete");
+				view.DeleteParameters.Add (deleteParameter);
+				break;
+			}
+
+			view.SelectParameters.ParametersChanged += new EventHandler (SelectParameters_ParametersChanged);
+			view.InsertParameters.ParametersChanged += new EventHandler (InsertParameters_ParametersChanged);
+			view.UpdateParameters.ParametersChanged += new EventHandler (UpdateParameters_ParametersChanged);
+			view.DeleteParameters.ParametersChanged += new EventHandler (DeleteParameters_ParametersChanged);
+
+			keys = new Hashtable ();
+			keys.Add ("ID", "k_1001");
+
+			old_value = new Hashtable ();
+			old_value.Add ("ID", "ov_1001");
+
+			new_value = new Hashtable ();
+			new_value.Add ("ID", "n_1001");
+
+			view.DataSourceViewChanged += new EventHandler (view_DataSourceViewChanged);
+
+			view.Selecting += new SqlDataSourceSelectingEventHandler (view_Selecting);
+			view.Inserting += new SqlDataSourceCommandEventHandler (view_Inserting);
+			view.Updating += new SqlDataSourceCommandEventHandler (view_Updating);
+			view.Deleting += new SqlDataSourceCommandEventHandler (view_Deleting);
+			return view;
+		}
+
+		static void view_Selecting (object source, SqlDataSourceSelectingEventArgs e) 
+		{
+			if (eventsCalled == null) {
+				eventsCalled = new ArrayList ();
+			}
+			eventsCalled.Add (e.Arguments.ToString ());
+			eventsCalled.Add ("view_Selecting");
+			eventsCalled.Add (FormatParameters ((SqlParameterCollection)e.Command.Parameters));
+			e.Cancel = true;
+		}
+
+		static void view_Inserting (object source, SqlDataSourceCommandEventArgs e) 
+		{
+			if (eventsCalled == null) {
+				eventsCalled = new ArrayList ();
+			}
+			eventsCalled.Add ("view_Inserting");
+			eventsCalled.Add (FormatParameters ((SqlParameterCollection) e.Command.Parameters));
+			e.Cancel = true;
+		}
+
+		static void view_Updating (object source, SqlDataSourceCommandEventArgs e) 
+		{
+			if (eventsCalled == null) {
+				eventsCalled = new ArrayList ();
+			}
+			eventsCalled.Add ("view_Updating");
+			eventsCalled.Add (FormatParameters ((SqlParameterCollection) e.Command.Parameters));
+			e.Cancel = true;
+		}
+
+		static void view_Deleting (object source, SqlDataSourceCommandEventArgs e) 
+		{
+			if (eventsCalled == null) {
+				eventsCalled = new ArrayList ();
+			}
+			eventsCalled.Add ("view_Deleting");
+			eventsCalled.Add (FormatParameters ((SqlParameterCollection) e.Command.Parameters));
+			e.Cancel = true;
+		}
+
+		private static string FormatParameters (SqlParameterCollection sqlParameterCollection) 
+		{
+			StringBuilder sb = new StringBuilder ();
+			foreach (SqlParameter p in sqlParameterCollection) {
+				if (sb.Length > 0) {
+					sb.Append (", ");
+				}
+				sb.AppendFormat ("{0}:{1}={2}", p.DbType, p.ParameterName, p.Value);
+			}
+			return sb.ToString ();
+		}
+
+		private static IList eventsCalled;
+
+		static void view_DataSourceViewChanged (object sender, EventArgs e) 
+		{
+			if (eventsCalled == null) {
+				eventsCalled = new ArrayList ();
+			}
+			eventsCalled.Add ("view_DataSourceViewChanged");
+		}
+
+		static void SelectParameters_ParametersChanged (object sender, EventArgs e) 
+		{
+			if (eventsCalled == null) {
+				eventsCalled = new ArrayList ();
+			}
+			eventsCalled.Add ("SelectParameters_ParametersChanged");
+		}
+
+		static void InsertParameters_ParametersChanged (object sender, EventArgs e) 
+		{
+			if (eventsCalled == null) {
+				eventsCalled = new ArrayList ();
+			}
+			eventsCalled.Add ("InsertParameters_ParametersChanged");
+		}
+
+		static void UpdateParameters_ParametersChanged (object sender, EventArgs e) 
+		{
+			if (eventsCalled == null) {
+				eventsCalled = new ArrayList ();
+			}
+			eventsCalled.Add ("UpdateParameters_ParametersChanged");
+		}
+
+		static void DeleteParameters_ParametersChanged (object sender, EventArgs e) 
+		{
+			if (eventsCalled == null) {
+				eventsCalled = new ArrayList ();
+			}
+			eventsCalled.Add ("DeleteParameters_ParametersChanged");
+		}
+
+		[Test]
+		public void ParametersAndViewChangedEvent_Select () 
+		{
+			Hashtable keys = null;
+			Hashtable old_values = null;
+			Hashtable new_values = null;
+			SqlViewPoker view = InitializeView (InitViewType.MatchParamsToValues, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
+
+			view.Select (DataSourceSelectArguments.Empty);
+
+			Assert.IsNotNull (eventsCalled, "Events not raized");
+			Assert.AreEqual (5, eventsCalled.Count, "Events Count");
+			Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [0], "view_DataSourceViewChanged");
+			Assert.AreEqual ("SelectParameters_ParametersChanged", eventsCalled [1], "SelectParameters_ParametersChanged");
+			Assert.AreEqual ("System.Web.UI.DataSourceSelectArguments", eventsCalled [2], "DataSourceSelectArguments");
+			Assert.AreEqual ("view_Selecting", eventsCalled [3], "view_Selecting");
+			string [] expectedParams = new string []
+						{ 
+							"String:@ID=p_ValueSelect1"
+						};
+			string [] actualValues = ((string)eventsCalled [4]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+			Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_Select Params count");
+			ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_Select expecte '{0}'");
+		}
+
+		[Test]
+		public void ParametersAndViewChangedEvent_MatchInsert () 
+		{
+			Hashtable keys = null;
+			Hashtable old_values = null;
+			Hashtable new_values = null;
+			SqlViewPoker view = InitializeView (InitViewType.MatchParamsToValues, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
+
+			view.Insert (new_values);
+
+			Assert.IsNotNull (eventsCalled, "Events not raized");
+			Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+			Assert.AreEqual ("InsertParameters_ParametersChanged", eventsCalled [0], "InsertParameters_ParametersChanged");
+			Assert.AreEqual ("view_Inserting", eventsCalled [1], "view_Inserting");
+			string [] expectedParams = new string []
+						{ 
+							"String:@ID=n_1001"
+						};
+			string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+			Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchInsert Params count");
+			ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchInsert expecte '{0}'");
+		}
+
+		[Test]
+		public void ParametersAndViewChangedEvent_MatchInsertAllValues () 
+		{
+			Hashtable keys = null;
+			Hashtable old_values = null;
+			Hashtable new_values = null;
+			SqlViewPoker view = InitializeView (InitViewType.MatchParamsToValues, ConflictOptions.CompareAllValues, out keys, out old_values, out new_values);
+
+			view.Insert (new_values);
+
+			Assert.IsNotNull (eventsCalled, "Events not raized");
+			Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+			Assert.AreEqual ("InsertParameters_ParametersChanged", eventsCalled [0], "InsertParameters_ParametersChanged");
+			Assert.AreEqual ("view_Inserting", eventsCalled [1], "view_Inserting");
+			string [] expectedParams = new string []
+						{ 
+							"String:@ID=n_1001"
+						};
+			string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+			Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchInsert Params count");
+			ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchInsert expecte '{0}'");
+		}
+
+		[Test]
+		public void ParametersAndViewChangedEvent_MatchOldInsert () 
+		{
+			Hashtable keys = null;
+			Hashtable old_values = null;
+			Hashtable new_values = null;
+			SqlViewPoker view = InitializeView (InitViewType.MatchParamsToOldValues, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
+
+			view.Insert (new_values);
+
+			Assert.IsNotNull (eventsCalled, "Events not raized");
+			Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+			Assert.AreEqual ("InsertParameters_ParametersChanged", eventsCalled [0], "InsertParameters_ParametersChanged");
+			Assert.AreEqual ("view_Inserting", eventsCalled [1], "view_Inserting");
+			string [] expectedParams = new string []
+						{ 
+							"String:@oldvalue_ID=p_OldValueInsert1", 
+							"String:@ID=n_1001"
+						};
+			string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+			Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchOldInsert Params count");
+			ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchOldInsert expecte '{0}'");
+		}
+
+		[Test]
+		public void ParametersAndViewChangedEvent_MatchOldInsertAllValues () 
+		{
+			Hashtable keys = null;
+			Hashtable old_values = null;
+			Hashtable new_values = null;
+			SqlViewPoker view = InitializeView (InitViewType.MatchParamsToOldValues, ConflictOptions.CompareAllValues, out keys, out old_values, out new_values);
+
+			view.Insert (new_values);
+			
+			Assert.IsNotNull (eventsCalled, "Events not raized");
+			Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+			Assert.AreEqual ("InsertParameters_ParametersChanged", eventsCalled [0], "InsertParameters_ParametersChanged");
+			Assert.AreEqual ("view_Inserting", eventsCalled [1], "view_Inserting");
+			string [] expectedParams = new string []
+						{ 
+							"String:@oldvalue_ID=p_OldValueInsert1", 
+							"String:@ID=n_1001"
+						};
+			string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+			Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchOldInsert Params count");
+			ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchOldInsert expecte '{0}'");
+		}
+
+		[Test]
+		public void ParametersAndViewChangedEvent_DontMatchInsert () 
+		{
+			Hashtable keys = null;
+			Hashtable old_values = null;
+			Hashtable new_values = null;
+			SqlViewPoker view = InitializeView (InitViewType.DontMatchParams, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
+
+			view.Insert (new_values);
+
+			Assert.IsNotNull (eventsCalled, "Events not raized");
+			Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+			Assert.AreEqual ("InsertParameters_ParametersChanged", eventsCalled [0], "InsertParameters_ParametersChanged");
+			Assert.AreEqual ("view_Inserting", eventsCalled [1], "view_Inserting");
+			string [] expectedParams = new string []
+						{ 
+							"String:@OtherValue=p_OtherValueInsert1", 
+							"String:@ID=n_1001"
+						};
+			string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+			Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_DontMatchInsert Params count");
+			ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_DontMatchInsert expecte '{0}'");
+		}
+
+		[Test]
+		public void ParametersAndViewChangedEvent_MatchUpdate () 
+		{
+			Hashtable keys = null;
+			Hashtable old_values = null;
+			Hashtable new_values = null;
+			SqlViewPoker view = InitializeView (InitViewType.MatchParamsToValues, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
+
+			view.Update (keys, new_values, old_values);
+
+			Assert.IsNotNull (eventsCalled, "Events not raized");
+			Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+			Assert.AreEqual ("UpdateParameters_ParametersChanged", eventsCalled [0], "UpdateParameters_ParametersChanged");
+			Assert.AreEqual ("view_Updating", eventsCalled [1], "view_Updating");
+			string [] expectedParams = new string []
+						{ 
+							"String:@oldvalue_ID=k_1001", 
+							"String:@ID=n_1001"
+						};
+			string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+			Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchUpdate Params count");
+			ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchUpdate expecte '{0}'");
+		}
+
+		[Test]
+		public void ParametersAndViewChangedEvent_MatchUpdateAllValues () 
+		{
+			Hashtable keys = null;
+			Hashtable old_values = null;
+			Hashtable new_values = null;
+			SqlViewPoker view = InitializeView (InitViewType.MatchParamsToValues, ConflictOptions.CompareAllValues, out keys, out old_values, out new_values);
+
+			view.Update (keys, new_values, old_values);
+
+			Assert.IsNotNull (eventsCalled, "Events not raized");
+			Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+			Assert.AreEqual ("UpdateParameters_ParametersChanged", eventsCalled [0], "UpdateParameters_ParametersChanged");
+			Assert.AreEqual ("view_Updating", eventsCalled [1], "view_Updating");
+			string [] expectedParams = new string []
+						{ 
+							"String:@oldvalue_ID=ov_1001", 
+							"String:@ID=n_1001"
+						};
+			string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+			Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchUpdate Params count");
+			ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchUpdate expecte '{0}'");
+		}
+
+		[Test]
+		public void ParametersAndViewChangedEvent_MatchOldUpdate () 
+		{
+			Hashtable keys = null;
+			Hashtable old_values = null;
+			Hashtable new_values = null;
+			SqlViewPoker view = InitializeView (InitViewType.MatchParamsToOldValues, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
+
+			view.Update (keys, new_values, old_values);
+
+			Assert.IsNotNull (eventsCalled, "Events not raized");
+			Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+			Assert.AreEqual ("UpdateParameters_ParametersChanged", eventsCalled [0], "UpdateParameters_ParametersChanged");
+			Assert.AreEqual ("view_Updating", eventsCalled [1], "view_Updating");
+			string [] expectedParams = new string []
+						{ 
+							"String:@oldvalue_ID=k_1001", 
+							"String:@ID=n_1001"
+						};
+			string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+			Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchUpdate Params count");
+			ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchUpdate expecte '{0}'");
+		}
+
+		[Test]
+		public void ParametersAndViewChangedEvent_MatchOldUpdateAllValues () 
+		{
+			Hashtable keys = null;
+			Hashtable old_values = null;
+			Hashtable new_values = null;
+			SqlViewPoker view = InitializeView (InitViewType.MatchParamsToOldValues, ConflictOptions.CompareAllValues, out keys, out old_values, out new_values);
+
+			view.Update (keys, new_values, old_values);
+
+			Assert.IsNotNull (eventsCalled, "Events not raized");
+			Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+			Assert.AreEqual ("UpdateParameters_ParametersChanged", eventsCalled [0], "UpdateParameters_ParametersChanged");
+			Assert.AreEqual ("view_Updating", eventsCalled [1], "view_Updating");
+			string [] expectedParams = new string []
+						{ 
+							"String:@oldvalue_ID=ov_1001", 
+							"String:@ID=n_1001"
+						};
+			string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+			Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchUpdate Params count");
+			ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchUpdate expecte '{0}'");
+		}
+
+		[Test]
+		public void ParametersAndViewChangedEvent_DontMatchUpdate () 
+		{
+			Hashtable keys = null;
+			Hashtable old_values = null;
+			Hashtable new_values = null;
+			SqlViewPoker view = InitializeView (InitViewType.DontMatchParams, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
+
+			view.Update (keys, new_values, old_values);
+
+			Assert.IsNotNull (eventsCalled, "Events not raized");
+			Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+			Assert.AreEqual ("UpdateParameters_ParametersChanged", eventsCalled [0], "UpdateParameters_ParametersChanged");
+			Assert.AreEqual ("view_Updating", eventsCalled [1], "view_Updating");
+			string [] expectedParams = new string []
+						{ 
+							"String:@oldvalue_ID=k_1001", 
+							"String:@ID=n_1001",
+							"String:@OtherValue=p_OtherValueUpdate1"
+						};
+			string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+			Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_DontMatchUpdate Params count");
+			ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_DontMatchUpdate expecte '{0}'");
+		}
+
+		[Test]
+		public void ParametersAndViewChangedEvent_MatchDelete () 
+		{
+			Hashtable keys = null;
+			Hashtable old_values = null;
+			Hashtable new_values = null;
+			SqlViewPoker view = InitializeView (InitViewType.MatchParamsToValues, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
+
+			view.Delete (keys, old_values);
+
+			Assert.IsNotNull (eventsCalled, "Events not raized");
+			Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+			Assert.AreEqual ("DeleteParameters_ParametersChanged", eventsCalled [0], "DeleteParameters_ParametersChanged");
+			Assert.AreEqual ("view_Deleting", eventsCalled [1], "view_Deleting");
+			string [] expectedParams = new string []
+						{ 
+							"String:@oldvalue_ID=k_1001", 
+						};
+			string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+			Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchDelete Params count");
+			ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchDelete expecte '{0}'");
+		}
+
+		[Test]
+		public void ParametersAndViewChangedEvent_MatchDeleteAllValues () 
+		{
+			Hashtable keys = null;
+			Hashtable old_values = null;
+			Hashtable new_values = null;
+			SqlViewPoker view = InitializeView (InitViewType.MatchParamsToValues, ConflictOptions.CompareAllValues, out keys, out old_values, out new_values);
+
+			view.Delete (keys, old_values);
+
+			Assert.IsNotNull (eventsCalled, "Events not raized");
+			Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+			Assert.AreEqual ("DeleteParameters_ParametersChanged", eventsCalled [0], "DeleteParameters_ParametersChanged");
+			Assert.AreEqual ("view_Deleting", eventsCalled [1], "view_Deleting");
+			string [] expectedParams = new string []
+						{ 
+							"String:@oldvalue_ID=ov_1001", 
+						};
+			string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+			Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchDelete Params count");
+			ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchDelete expecte '{0}'");
+		}
+
+		[Test]
+		public void ParametersAndViewChangedEvent_MatchOldDelete () 
+		{
+			Hashtable keys = null;
+			Hashtable old_values = null;
+			Hashtable new_values = null;
+			SqlViewPoker view = InitializeView (InitViewType.MatchParamsToOldValues, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
+
+			view.Delete (keys, old_values);
+
+			Assert.IsNotNull (eventsCalled, "Events not raized");
+			Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+			Assert.AreEqual ("DeleteParameters_ParametersChanged", eventsCalled [0], "DeleteParameters_ParametersChanged");
+			Assert.AreEqual ("view_Deleting", eventsCalled [1], "view_Deleting");
+			string [] expectedParams = new string []
+						{ 
+							"String:@oldvalue_ID=k_1001", 
+						};
+			string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+			Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchOldDelete Params count");
+			ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchOldDelete expecte '{0}'");
+		}
+
+		[Test]
+		public void ParametersAndViewChangedEvent_MatchOldDeleteAllValues () 
+		{
+			Hashtable keys = null;
+			Hashtable old_values = null;
+			Hashtable new_values = null;
+			SqlViewPoker view = InitializeView (InitViewType.MatchParamsToOldValues, ConflictOptions.CompareAllValues, out keys, out old_values, out new_values);
+
+			view.Delete (keys, old_values);
+
+			Assert.IsNotNull (eventsCalled, "Events not raized");
+			Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+			Assert.AreEqual ("DeleteParameters_ParametersChanged", eventsCalled [0], "DeleteParameters_ParametersChanged");
+			Assert.AreEqual ("view_Deleting", eventsCalled [1], "view_Deleting");
+			string [] expectedParams = new string []
+						{ 
+							"String:@oldvalue_ID=ov_1001", 
+						};
+			string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+			Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchOldDelete Params count");
+			ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchOldDelete expecte '{0}'");
+		}
+
+		[Test]
+		public void ParametersAndViewChangedEvent_DontMatchDelete () 
+		{
+			Hashtable keys = null;
+			Hashtable old_values = null;
+			Hashtable new_values = null;
+			SqlViewPoker view = InitializeView (InitViewType.DontMatchParams, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
+
+			view.Delete (keys, old_values);
+
+			Assert.IsNotNull (eventsCalled, "Events not raized");
+			Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+			Assert.AreEqual ("DeleteParameters_ParametersChanged", eventsCalled [0], "DeleteParameters_ParametersChanged");
+			Assert.AreEqual ("view_Deleting", eventsCalled [1], "view_Deleting");
+			string [] expectedParams = new string []
+						{ 
+							"String:@oldvalue_ID=k_1001", 
+							"String:@OtherValue=p_OtherValueDelete1"
+						};
+			string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+			Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchOldDelete Params count");
+			ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchOldDelete expecte '{0}'");
+		}
+
+		private static void ValidatePassedParams (string [] expectedParams, string [] actualValues, string errorMessageFormat) 
+		{
+			foreach (string eps in expectedParams) {
+				bool found = false;
+				foreach (string aps in actualValues) {
+					if (eps == aps) {
+						found = true;
+						break;
+					}
+				}
+				Assert.IsTrue (found, String.Format (errorMessageFormat, eps));
+			}
+		}
 	}
 
 }