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
{
public void LoadFromViewState (object savedState)
{
LoadViewState (savedState);
+ }\r
+\r
+ public void DoOnDataSourceViewChanged ()\r
+ {\r
+ base.OnDataSourceViewChanged (new EventArgs());\r
}
}
[TestFixture]
- public class SqlDataSourceViewTest {
+ public class SqlDataSourceViewTest
+ {
+ [SetUp]
+ public void Setup ()
+ {
+ eventsCalled = null;
+ }
+
[Test]
public void Defaults ()
{
Assert.IsFalse (sql.CanUpdate,"A7");
Assert.AreEqual (ConflictOptions.OverwriteChanges, sql.ConflictDetection, "A8");
Assert.AreEqual ("", sql.DeleteCommand, "A9");
- Assert.AreEqual (SqlDataSourceCommandType.StoredProcedure, sql.DeleteCommandType, "A10");
+ Assert.AreEqual (SqlDataSourceCommandType.Text, sql.DeleteCommandType, "A10");
Assert.IsNotNull (sql.DeleteParameters, "A11");
Assert.AreEqual (0, sql.DeleteParameters.Count, "A12");
Assert.AreEqual ("", sql.FilterExpression, "A13");
Assert.IsNotNull (sql.FilterParameters, "A14");
Assert.AreEqual (0, sql.FilterParameters.Count, "A15");
Assert.AreEqual ("", sql.InsertCommand, "A16");
- Assert.AreEqual (SqlDataSourceCommandType.StoredProcedure, sql.InsertCommandType, "A17");
+ Assert.AreEqual (SqlDataSourceCommandType.Text, sql.InsertCommandType, "A17");
Assert.IsNotNull (sql.InsertParameters, "A18");
Assert.AreEqual (0, sql.InsertParameters.Count, "A19");
Assert.AreEqual ("{0}", sql.OldValuesParameterFormatString, "A20");
Assert.AreEqual ("", sql.SelectCommand, "A21");
- Assert.AreEqual (SqlDataSourceCommandType.StoredProcedure, sql.SelectCommandType, "A22");
+ Assert.AreEqual (SqlDataSourceCommandType.Text, sql.SelectCommandType, "A22");
Assert.IsNotNull (sql.SelectParameters, "A23");
Assert.AreEqual (0, sql.SelectParameters.Count, "A24");
Assert.AreEqual ("", sql.SortParameterName, "A25");
Assert.AreEqual ("", sql.UpdateCommand, "A26");
- Assert.AreEqual (SqlDataSourceCommandType.StoredProcedure, sql.UpdateCommandType, "A27");
+ Assert.AreEqual (SqlDataSourceCommandType.Text, sql.UpdateCommandType, "A27");
Assert.IsNotNull (sql.UpdateParameters, "A28");
Assert.AreEqual (0, sql.UpdateParameters.Count, "A29");
}
[Test]
- public void ViewState ()
+ public void ViewStateSupport ()
{
SqlDataSource ds = new SqlDataSource ();
- SqlViewPoker sql = new SqlViewPoker (ds, "DefaultView", null);
+ SqlViewPoker view = new SqlViewPoker (ds, "DefaultView", null);
- /* XXX test parameters */
+ ds.ID = "SqlDataSource1";
+ ds.SelectCommand = "Select";
- sql.CancelSelectOnNullParameter = false;
- sql.ConflictDetection = ConflictOptions.CompareAllValues;
- sql.DeleteCommandType = SqlDataSourceCommandType.Text;
- sql.DeleteCommand = "delete command";
- sql.FilterExpression = "filter expression";
- sql.InsertCommand = "insert command";
- sql.InsertCommandType = SqlDataSourceCommandType.Text;
- sql.OldValuesParameterFormatString = "{1}";
- sql.SelectCommand = "select command";
- sql.SelectCommandType = SqlDataSourceCommandType.Text;
- sql.SortParameterName = "sort parameter";
- sql.UpdateCommand = "update command";
- sql.UpdateCommandType = SqlDataSourceCommandType.Text;
-
- Assert.IsFalse (sql.CancelSelectOnNullParameter, "A1");
- Assert.AreEqual (ConflictOptions.CompareAllValues, sql.ConflictDetection, "A2");
- Assert.AreEqual ("delete command", sql.DeleteCommand, "A3");
- Assert.AreEqual (SqlDataSourceCommandType.Text, sql.DeleteCommandType, "A4");
- Assert.AreEqual ("filter expression", sql.FilterExpression, "A5");
- Assert.AreEqual ("insert command", sql.InsertCommand, "A6");
- Assert.AreEqual (SqlDataSourceCommandType.Text, sql.InsertCommandType, "A7");
- Assert.AreEqual ("{1}", sql.OldValuesParameterFormatString, "A8");
- Assert.AreEqual ("select command", sql.SelectCommand, "A9");
- Assert.AreEqual (SqlDataSourceCommandType.Text, sql.SelectCommandType, "A10");
- Assert.AreEqual ("sort parameter", sql.SortParameterName, "A11");
- Assert.AreEqual ("update command", sql.UpdateCommand, "A12");
- Assert.AreEqual (SqlDataSourceCommandType.Text, sql.UpdateCommandType, "A13");
-
- object state = sql.SaveToViewState();
-
- sql = new SqlViewPoker (ds, "DefaultView", null);
- sql.LoadFromViewState (state);
-
- Assert.IsFalse (sql.CancelSelectOnNullParameter, "B1");
- Assert.AreEqual (ConflictOptions.CompareAllValues, sql.ConflictDetection, "B2");
- Assert.AreEqual ("delete command", sql.DeleteCommand, "B3");
- Assert.AreEqual (SqlDataSourceCommandType.Text, sql.DeleteCommandType, "B4");
- Assert.AreEqual ("filter expression", sql.FilterExpression, "B5");
- Assert.AreEqual ("insert command", sql.InsertCommand, "B6");
- Assert.AreEqual (SqlDataSourceCommandType.Text, sql.InsertCommandType, "B7");
- Assert.AreEqual ("{1}", sql.OldValuesParameterFormatString, "B8");
- Assert.AreEqual ("select command", sql.SelectCommand, "B9");
- Assert.AreEqual (SqlDataSourceCommandType.Text, sql.SelectCommandType, "B10");
- Assert.AreEqual ("sort parameter", sql.SortParameterName, "B11");
- Assert.AreEqual ("update command", sql.UpdateCommand, "B12");
- Assert.AreEqual (SqlDataSourceCommandType.Text, sql.UpdateCommandType, "B13");
- }
+ Parameter p1 = new Parameter ("test", TypeCode.String);
+
+ Assert.IsTrue (((IStateManager) view).IsTrackingViewState, "IsTrackingViewState");
+ Assert.IsTrue (((IStateManager) view.FilterParameters).IsTrackingViewState, "FilterParameters.IsTrackingViewState");
+ Assert.IsTrue (((IStateManager) view.SelectParameters).IsTrackingViewState, "SelecteParameters.IsTrackingViewState");
+ Assert.IsFalse (((IStateManager) view.DeleteParameters).IsTrackingViewState, "DeleteParameters.IsTrackingViewState");
+ Assert.IsFalse (((IStateManager) view.InsertParameters).IsTrackingViewState, "InsertParameters.IsTrackingViewState");
+ Assert.IsFalse (((IStateManager) view.UpdateParameters).IsTrackingViewState, "UpdateParameters.IsTrackingViewState");
+
+ object state = ((IStateManager) view).SaveViewState ();
+ Assert.IsNull (state, "view ViewState not null");
+
+ view.DeleteParameters.Add (p1);
+ view.InsertParameters.Add (p1);
+ //view.UpdateParameters.Add (p1);
+
+ state = ((IStateManager) view).SaveViewState ();
+ Assert.IsNull (state, "view ViewState not null");
+
+ view.FilterParameters.Add (p1);
+ //view.SelectParameters.Add (p1);
+
+ state = ((IStateManager) view).SaveViewState ();
+ Assert.IsNotNull (state, "view ViewState not null");
+
+ state = ((IStateManager) view.FilterParameters).SaveViewState ();
+ Assert.IsNotNull (state, "FilterParamenters ViewState not null");
+ state = ((IStateManager) view.SelectParameters).SaveViewState ();
+ Assert.IsNull (state, "SelectParameters ViewState not null");
+
+ state = ((IStateManager) view.DeleteParameters).SaveViewState ();
+ Assert.IsNotNull (state, "DeleteParameters ViewState not null");
+ state = ((IStateManager) view.InsertParameters).SaveViewState ();
+ Assert.IsNotNull (state, "InsertParameters ViewState not null");
+ state = ((IStateManager) view.UpdateParameters).SaveViewState ();
+ Assert.IsNull (state, "UpdateParameters ViewState not null");
+ }\r
+\r
+ [Test]\r
+ public void ViewState ()\r
+ {\r
+ SqlDataSource ds = new SqlDataSource ();\r
+ SqlViewPoker sql = new SqlViewPoker (ds, "DefaultView", null);\r
+\r
+ /* XXX test parameters */\r
+\r
+ sql.CancelSelectOnNullParameter = false;\r
+ sql.ConflictDetection = ConflictOptions.CompareAllValues;\r
+ sql.DeleteCommandType = SqlDataSourceCommandType.Text;\r
+ sql.DeleteCommand = "delete command";\r
+ sql.FilterExpression = "filter expression";\r
+ sql.InsertCommand = "insert command";\r
+ sql.InsertCommandType = SqlDataSourceCommandType.Text;\r
+ sql.OldValuesParameterFormatString = "{1}";\r
+ sql.SelectCommand = "select command";\r
+ sql.SelectCommandType = SqlDataSourceCommandType.Text;\r
+ sql.SortParameterName = "sort parameter";\r
+ sql.UpdateCommand = "update command";\r
+ sql.UpdateCommandType = SqlDataSourceCommandType.Text;\r
+\r
+ Assert.IsFalse (sql.CancelSelectOnNullParameter, "A1");\r
+ Assert.AreEqual (ConflictOptions.CompareAllValues, sql.ConflictDetection, "A2");\r
+ Assert.AreEqual ("delete command", sql.DeleteCommand, "A3");\r
+ Assert.AreEqual (SqlDataSourceCommandType.Text, sql.DeleteCommandType, "A4");\r
+ Assert.AreEqual ("filter expression", sql.FilterExpression, "A5");\r
+ Assert.AreEqual ("insert command", sql.InsertCommand, "A6");\r
+ Assert.AreEqual (SqlDataSourceCommandType.Text, sql.InsertCommandType, "A7");\r
+ Assert.AreEqual ("{1}", sql.OldValuesParameterFormatString, "A8");\r
+ Assert.AreEqual ("select command", sql.SelectCommand, "A9");\r
+ Assert.AreEqual (SqlDataSourceCommandType.Text, sql.SelectCommandType, "A10");\r
+ Assert.AreEqual ("sort parameter", sql.SortParameterName, "A11");\r
+ Assert.AreEqual ("update command", sql.UpdateCommand, "A12");\r
+ Assert.AreEqual (SqlDataSourceCommandType.Text, sql.UpdateCommandType, "A13");\r
+\r
+ object state = sql.SaveToViewState ();\r
+ Assert.IsNull (state, "ViewState is null");\r
+\r
+ sql = new SqlViewPoker (ds, "DefaultView", null);\r
+ sql.LoadFromViewState (state);\r
+\r
+ Assert.IsTrue (sql.CancelSelectOnNullParameter, "B1");\r
+ Assert.IsFalse (sql.CanDelete, "B2");\r
+ Assert.IsFalse (sql.CanInsert, "B3");\r
+ Assert.IsFalse (sql.CanPage, "B4");\r
+ Assert.IsFalse (sql.CanRetrieveTotalRowCount, "B5");\r
+ Assert.IsTrue (sql.CanSort, "B6");\r
+ Assert.IsFalse (sql.CanUpdate, "B7");\r
+ Assert.AreEqual (ConflictOptions.OverwriteChanges, sql.ConflictDetection, "B8");\r
+ Assert.AreEqual ("", sql.DeleteCommand, "B9");\r
+ Assert.AreEqual (SqlDataSourceCommandType.Text, sql.DeleteCommandType, "B10");\r
+ Assert.IsNotNull (sql.DeleteParameters, "B11");\r
+ Assert.AreEqual (0, sql.DeleteParameters.Count, "B12");\r
+ Assert.AreEqual ("", sql.FilterExpression, "B13");\r
+ Assert.IsNotNull (sql.FilterParameters, "B14");\r
+ Assert.AreEqual (0, sql.FilterParameters.Count, "B15");\r
+ Assert.AreEqual ("", sql.InsertCommand, "B16");\r
+ Assert.AreEqual (SqlDataSourceCommandType.Text, sql.InsertCommandType, "B17");\r
+ Assert.IsNotNull (sql.InsertParameters, "B18");\r
+ Assert.AreEqual (0, sql.InsertParameters.Count, "B19");\r
+ Assert.AreEqual ("{0}", sql.OldValuesParameterFormatString, "B20");\r
+ Assert.AreEqual ("", sql.SelectCommand, "B21");\r
+ Assert.AreEqual (SqlDataSourceCommandType.Text, sql.SelectCommandType, "B22");\r
+ Assert.IsNotNull (sql.SelectParameters, "B23");\r
+ Assert.AreEqual (0, sql.SelectParameters.Count, "B24");\r
+ Assert.AreEqual ("", sql.SortParameterName, "B25");\r
+ Assert.AreEqual ("", sql.UpdateCommand, "B26");\r
+ Assert.AreEqual (SqlDataSourceCommandType.Text, sql.UpdateCommandType, "B27");\r
+ Assert.IsNotNull (sql.UpdateParameters, "B28");\r
+ Assert.AreEqual (0, sql.UpdateParameters.Count, "B29");\r
+ }\r
+\r
+ #region help_results\r
+ class eventAssert\r
+ {\r
+ private static int _testcounter;\r
+ private static bool _eventChecker;\r
+ private eventAssert ()\r
+ {\r
+ _testcounter = 0;\r
+ }\r
+\r
+ public static bool eventChecker\r
+ {\r
+ get\r
+ {\r
+ throw new NotImplementedException ();\r
+ }\r
+ set\r
+ {\r
+ _eventChecker = value;\r
+ }\r
+ }\r
+\r
+ static private void testAdded ()\r
+ {\r
+ _testcounter++;\r
+ _eventChecker = false;\r
+ }\r
+\r
+ public static void IsTrue (string msg)\r
+ {\r
+ Assert.IsTrue (_eventChecker, msg + "#" + _testcounter);\r
+ testAdded ();\r
+\r
+ }\r
+\r
+ public static void IsFalse (string msg)\r
+ {\r
+ Assert.IsFalse (_eventChecker, msg + "#" + _testcounter);\r
+ testAdded ();\r
+ }\r
+ }\r
+ #endregion\r
+\r
+ [Test]\r
+ [Category ("NotWorking")]\r
+ public void SqlDataSourceView_DataSourceViewChanged ()\r
+ {\r
+ SqlDataSource ds = new SqlDataSource ();\r
+ SqlViewPoker sql = new SqlViewPoker (ds, "DefaultView", null);\r
+ sql.DataSourceViewChanged += new EventHandler (sql_DataSourceViewChanged);\r
+ sql.DoOnDataSourceViewChanged ();\r
+ eventAssert.IsTrue ("SqlDataSourceView"); // Assert include counter the first is zero\r
+ /* XXX test parameters */\r
+\r
+ sql.CancelSelectOnNullParameter = false;\r
+ eventAssert.IsTrue ("SqlDataSourceView");\r
+ sql.ConflictDetection = ConflictOptions.CompareAllValues;\r
+ eventAssert.IsTrue ("SqlDataSourceView");\r
+ sql.DeleteCommandType = SqlDataSourceCommandType.Text;\r
+ eventAssert.IsFalse ("SqlDataSourceView");\r
+ sql.DeleteCommand = "delete command";\r
+ eventAssert.IsFalse ("SqlDataSourceView");\r
+ sql.FilterExpression = "filter expression";\r
+ eventAssert.IsTrue ("SqlDataSourceView");\r
+ sql.InsertCommand = "insert command";\r
+ eventAssert.IsFalse ("SqlDataSourceView");\r
+ sql.InsertCommandType = SqlDataSourceCommandType.Text;\r
+ eventAssert.IsFalse ("SqlDataSourceView");\r
+ sql.OldValuesParameterFormatString = "{1}";\r
+ eventAssert.IsTrue ("SqlDataSourceView");\r
+ sql.SelectCommand = "select command";\r
+ eventAssert.IsTrue ("SqlDataSourceView");\r
+ sql.SelectCommandType = SqlDataSourceCommandType.Text;\r
+ eventAssert.IsFalse ("SqlDataSourceView");\r
+ sql.SortParameterName = "sort parameter";\r
+ eventAssert.IsTrue ("SqlDataSourceView");\r
+ sql.UpdateCommand = "update command";\r
+ eventAssert.IsFalse ("SqlDataSourceView");\r
+ sql.UpdateCommandType = SqlDataSourceCommandType.Text;\r
+ eventAssert.IsFalse ("SqlDataSourceView");\r
+ }\r
+\r
+ void sql_DataSourceViewChanged (object sender, EventArgs e)\r
+ {\r
+ eventAssert.eventChecker = true;\r
+ }\r
[Test]
public void CanDelete ()
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,
+ }
+
+ [Test]
+ public void SelectCommand_DataSourceViewChanged2 ()
+ {
+ SqlDataSource ds = new SqlDataSource ();
+ SqlViewPoker view = new SqlViewPoker (ds, "DefaultView", null);
+ view.DataSourceViewChanged += new EventHandler (view_DataSourceViewChanged);
+
+ Assert.AreEqual ("", view.SelectCommand);
+ view.SelectCommand = null;
+ Assert.AreEqual (1, eventsCalled.Count);
+ Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [0]);
+ Assert.AreEqual ("", view.SelectCommand);
+
+ view.SelectCommand = null;
+ Assert.AreEqual (2, eventsCalled.Count);
+ Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [1]);
+ Assert.AreEqual ("", view.SelectCommand);
+
+ view.SelectCommand = "";
+ Assert.AreEqual (2, eventsCalled.Count);
+ }
+
+ [Test]
+ public void SelectCommand_DataSourceViewChanged1 ()
+ {
+ SqlDataSource ds = new SqlDataSource ();
+ SqlViewPoker view = new SqlViewPoker (ds, "DefaultView", null);
+ view.DataSourceViewChanged+=new EventHandler(view_DataSourceViewChanged);
+
+ view.SelectCommand = "select 1";
+ Assert.AreEqual (1, eventsCalled.Count);
+ Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled[0]);
+
+ view.SelectCommand = "select 2";
+ Assert.AreEqual (2, eventsCalled.Count);
+ Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [1]);
+
+ view.SelectCommand = "select 2";
+ Assert.AreEqual (2, eventsCalled.Count);
+
+ view.SelectCommandType = SqlDataSourceCommandType.StoredProcedure;
+ Assert.AreEqual (2, eventsCalled.Count);
+
+ view.SelectCommandType = SqlDataSourceCommandType.Text;
+ Assert.AreEqual (2, eventsCalled.Count);
+ }
+
+ 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));
+ }
+ }
}
}
projects / mono.git / blobdiff