Author: adar
Date: 2007-03-29 08:37:36 -0500 (Thu, 29 Mar 2007)
New Revision: 75137

Modified:
   trunk/mcs/class/System.Web/System.Web.UI.WebControls/ChangeLog
   trunk/mcs/class/System.Web/System.Web.UI.WebControls/ObjectDataSourceView.cs
   trunk/mcs/class/System.Web/System.Web.UI.WebControls/SqlDataSourceView.cs
   
trunk/mcs/class/System.Web/Test/System.Web.UI.WebControls/ObjectDataSourceViewTest.cs
   
trunk/mcs/class/System.Web/Test/System.Web.UI.WebControls/SqlDataSourceViewTest.cs
Log:
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.



Modified: trunk/mcs/class/System.Web/System.Web.UI.WebControls/ChangeLog
===================================================================
--- trunk/mcs/class/System.Web/System.Web.UI.WebControls/ChangeLog      
2007-03-29 13:24:34 UTC (rev 75136)
+++ trunk/mcs/class/System.Web/System.Web.UI.WebControls/ChangeLog      
2007-03-29 13:37:36 UTC (rev 75137)
@@ -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:

Modified: 
trunk/mcs/class/System.Web/System.Web.UI.WebControls/ObjectDataSourceView.cs
===================================================================
--- 
trunk/mcs/class/System.Web/System.Web.UI.WebControls/ObjectDataSourceView.cs    
    2007-03-29 13:24:34 UTC (rev 75136)
+++ 
trunk/mcs/class/System.Web/System.Web.UI.WebControls/ObjectDataSourceView.cs    
    2007-03-29 13:37:36 UTC (rev 75137)
@@ -306,8 +306,8 @@
                        get {
                                return dataObjectTypeName != null ? 
dataObjectTypeName : string.Empty;
                        }
-                       set {
-                               dataObjectTypeName = value;
+                       set {
+                               dataObjectTypeName = value;
                                dataObjectType = null;
                        }
                }
@@ -531,7 +531,7 @@
                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 @@
                        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 @@
                        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 @@
                        {
                                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 @@
                {
                        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 @@
                /// <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 @@
                        }
 
                        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 @@
 
 
 
+

Modified: 
trunk/mcs/class/System.Web/System.Web.UI.WebControls/SqlDataSourceView.cs
===================================================================
--- trunk/mcs/class/System.Web/System.Web.UI.WebControls/SqlDataSourceView.cs   
2007-03-29 13:24:34 UTC (rev 75136)
+++ trunk/mcs/class/System.Web/System.Web.UI.WebControls/SqlDataSourceView.cs   
2007-03-29 13:37:36 UTC (rev 75137)
@@ -99,7 +99,7 @@
                        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 @@
                        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 @@
                        }
 
                        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 @@
 
                        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,37 +387,46 @@
                                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) {
                                        object dbValue = p.ConvertValue (value);
                                        DbParameter newParameter = 
CreateDbParameter (valueName, dbValue, p.Direction, p.Size);
@@ -425,10 +434,6 @@
                                                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 @@
 }
 #endif
 
+

Modified: 
trunk/mcs/class/System.Web/Test/System.Web.UI.WebControls/ObjectDataSourceViewTest.cs
===================================================================
--- 
trunk/mcs/class/System.Web/Test/System.Web.UI.WebControls/ObjectDataSourceViewTest.cs
       2007-03-29 13:24:34 UTC (rev 75136)
+++ 
trunk/mcs/class/System.Web/Test/System.Web.UI.WebControls/ObjectDataSourceViewTest.cs
       2007-03-29 13:37:36 UTC (rev 75137)
@@ -61,7 +61,7 @@
                        TrackViewState ();
                }
 
-               public bool IsTrackingViewState ()
+               public bool GetIsTrackingViewState ()
                {
                        return base.IsTrackingViewState;
                }
@@ -153,6 +153,12 @@
                        WebTest.Unload ();
                }
 
+               [SetUp()]
+               public void Setup () 
+               {
+                       eventsCalled = null;
+               }
+
                [Test]
                public void Defaults ()
                {
@@ -189,7 +195,7 @@
                        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 @@
                }
 
                [Test]
-               public void CanRetrieveTotalRowCount () {
+               public void CanRetrieveTotalRowCount () 
+               {
                        ObjectDataSource ds = new ObjectDataSource ();
                        ObjectDataSourceView view = new ObjectDataSourceView 
(ds, "DefaultView", null);
 
@@ -807,7 +814,415 @@
                        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
                /// </summary>

Modified: 
trunk/mcs/class/System.Web/Test/System.Web.UI.WebControls/SqlDataSourceViewTest.cs
===================================================================
--- 
trunk/mcs/class/System.Web/Test/System.Web.UI.WebControls/SqlDataSourceViewTest.cs
  2007-03-29 13:24:34 UTC (rev 75136)
+++ 
trunk/mcs/class/System.Web/Test/System.Web.UI.WebControls/SqlDataSourceViewTest.cs
  2007-03-29 13:37:36 UTC (rev 75137)
@@ -39,6 +39,9 @@
 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 @@
        [TestFixture]
        public class SqlDataSourceViewTest 
        {
+               [SetUp]
+               public void Setup () 
+               {
+                       eventsCalled = null;
+               }
+
                [Test]
                public void Defaults ()
                {
@@ -343,6 +352,596 @@
                        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));
+                       }
+               }
        }
 
 }

_______________________________________________
Mono-patches maillist  -  [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches

Reply via email to