X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fclass%2FSystem.Data%2FTest%2FSystem.Data%2FDataTableTest.cs;h=34f6eeb1190bc7b6d16eecee834d4d9e779952f6;hb=8a6fcaf4c29c6090f1190b8ffa6d03ddf82bb75f;hp=91cc0cf6cde807803e2b864caab45a5af28f750a;hpb=0abc2e6270020edc4a5b4c66f93b4ae582815f20;p=mono.git diff --git a/mcs/class/System.Data/Test/System.Data/DataTableTest.cs b/mcs/class/System.Data/Test/System.Data/DataTableTest.cs index 91cc0cf6cde..34f6eeb1190 100644 --- a/mcs/class/System.Data/Test/System.Data/DataTableTest.cs +++ b/mcs/class/System.Data/Test/System.Data/DataTableTest.cs @@ -1084,7 +1084,7 @@ namespace MonoTests.System.Data col.ColumnName = "Id"; col.DataType = Type.GetType ("System.Int32"); table.Columns.Add (col); - + col = new DataColumn (); col.ColumnName = "Name"; col.DataType = Type.GetType ("System.String"); @@ -1111,40 +1111,50 @@ namespace MonoTests.System.Data AssertEquals ("#A03", DataRowState.Modified, table.Rows [2].RowState); AssertEquals ("#A04", DataRowState.Added, table.Rows [3].RowState); } - [Test] - public void ClearReset () //To test Clear and Reset methods + + [Test] + public void ImportRowDetachedTest () { DataTable table = new DataTable (); - DataTable table1 = new DataTable (); - - DataSet set = new DataSet (); - set.Tables.Add (table); - set.Tables.Add (table1); - DataColumn col = new DataColumn (); col.ColumnName = "Id"; col.DataType = Type.GetType ("System.Int32"); table.Columns.Add (col); - UniqueConstraint uc = new UniqueConstraint ("UK1", table.Columns[0] ); - table.Constraints.Add (uc); - table.CaseSensitive = false; - - col = new DataColumn (); + + table.PrimaryKey = new DataColumn [] {col}; + + col = new DataColumn (); col.ColumnName = "Name"; col.DataType = Type.GetType ("System.String"); table.Columns.Add (col); + + DataRow row = table.NewRow (); + row ["Id"] = 147; + row ["name"] = "Abc"; + + // keep silent as ms.net ;-), though this is not useful. + table.ImportRow (row); + } + + [Test] + public void ClearReset () //To test Clear and Reset methods + { + DataTable table = new DataTable ("table"); + DataTable table1 = new DataTable ("table1"); - col = new DataColumn (); - col.ColumnName = "Id"; - col.DataType = Type.GetType ("System.Int32"); - table1.Columns.Add (col); - - col = new DataColumn (); - col.ColumnName = "Name"; - col.DataType = Type.GetType ("System.String"); - table1.Columns.Add (col); + DataSet set = new DataSet (); + set.Tables.Add (table); + set.Tables.Add (table1); - DataRelation dr = new DataRelation ("DR", table.Columns[0], table1.Columns[0]); + table.Columns.Add ("Id", typeof (int)); + table.Columns.Add ("Name", typeof (string)); + table.Constraints.Add (new UniqueConstraint ("UK1", table.Columns [0])); + table.CaseSensitive = false; + + table1.Columns.Add ("Id", typeof (int)); + table1.Columns.Add ("Name", typeof (string)); + + DataRelation dr = new DataRelation ("DR", table.Columns[0], table1.Columns[0]); set.Relations.Add (dr); DataRow row = table.NewRow (); @@ -1157,48 +1167,77 @@ namespace MonoTests.System.Data row ["Name"] = "roopa"; table.Rows.Add (row); + AssertEquals (2, table.Rows.Count); + AssertEquals (1, table.ChildRelations.Count); try { table.Reset (); - Fail ("#A01"); + Fail ("#A01, should have thrown ArgumentException"); } - catch (InvalidConstraintException) { - } - try { - table.Clear (); -//#if NET_1_1 -//#else - Fail ("#A03"); -//#endif + catch (ArgumentException) { } - catch (Exception e) { + AssertEquals ("#CT01", 0, table.Rows.Count); + AssertEquals ("#CT02", 0, table.ChildRelations.Count); + AssertEquals ("#CT03", 0, table.ParentRelations.Count); + AssertEquals ("#CT04", 0, table.Constraints.Count); -#if NET_1_1 - - AssertEquals ("#A04", "Cannot clear table Parent because ForeignKeyConstraint DR enforces Child.", e.Message); - AssertEquals ("#A11", typeof (InvalidConstraintException), e.GetType()); -#else - if (e.GetType () != typeof (AssertionException)) { - // FIXME: Don't depend on localizable error messages. - AssertEquals ("#A04", "Cannot clear table Parent because ForeignKeyConstraint DR enforces Child.", e.Message); - } - else throw e; -#endif - } table1.Reset (); AssertEquals ("#A05", 0, table1.Rows.Count); AssertEquals ("#A06", 0, table1.Constraints.Count); AssertEquals ("#A07", 0, table1.ParentRelations.Count); + // clear test table.Clear (); AssertEquals ("#A08", 0, table.Rows.Count); #if NET_1_1 - AssertEquals ("#A09", 1, table.Constraints.Count); + AssertEquals ("#A09", 0, table.Constraints.Count); #else AssertEquals ("#A09", 1, table.Constraints.Count); #endif AssertEquals ("#A10", 0, table.ChildRelations.Count); + } + [Test] + public void ClearTest () + { + DataTable table = new DataTable ("test"); + table.Columns.Add ("id", typeof (int)); + table.Columns.Add ("name", typeof (string)); + + table.PrimaryKey = new DataColumn [] { table.Columns [0] } ; + + table.Rows.Add (new object [] { 1, "mono 1" }); + table.Rows.Add (new object [] { 2, "mono 2" }); + table.Rows.Add (new object [] { 3, "mono 3" }); + table.Rows.Add (new object [] { 4, "mono 4" }); + + table.AcceptChanges (); +#if NET_2_0 + _tableClearedEventFired = false; + table.TableCleared += new DataTableClearEventHandler (OnTableCleared); +#endif // NET_2_0 + + table.Clear (); +#if NET_2_0 + AssertEquals ("#0 should have fired cleared event", true, _tableClearedEventFired); +#endif // NET_2_0 + + DataRow r = table.Rows.Find (1); + AssertEquals ("#1 should have cleared", true, r == null); + + // try adding new row. indexes should have cleared + table.Rows.Add (new object [] { 2, "mono 2" }); + AssertEquals ("#2 should add row", 1, table.Rows.Count); + } +#if NET_2_0 + private bool _tableClearedEventFired = false; + private void OnTableCleared (object src, DataTableClearEventArgs args) + { + _tableClearedEventFired = true; + } +#endif // NET_2_0 + + [Test] public void Serialize () { @@ -1248,6 +1287,67 @@ namespace MonoTests.System.Data AssertEquals (5, doc.DocumentElement.FirstChild.ChildNodes.Count); } + [Test] + [ExpectedException (typeof (DataException))] + [NUnit.Framework.Category ("NotWorking")] + public void SetPrimaryKeyAssertsNonNull () + { + DataTable dt = new DataTable ("table"); + dt.Columns.Add ("col1"); + dt.Columns.Add ("col2"); + dt.Constraints.Add (new UniqueConstraint (dt.Columns [0])); + dt.Rows.Add (new object [] {1, 3}); + dt.Rows.Add (new object [] {DBNull.Value, 3}); + + dt.PrimaryKey = new DataColumn [] {dt.Columns [0]}; + } + + [Test] + [ExpectedException (typeof (NoNullAllowedException))] + public void PrimaryKeyColumnChecksNonNull () + { + DataTable dt = new DataTable ("table"); + dt.Columns.Add ("col1"); + dt.Columns.Add ("col2"); + dt.Constraints.Add (new UniqueConstraint (dt.Columns [0])); + dt.PrimaryKey = new DataColumn [] {dt.Columns [0]}; + dt.Rows.Add (new object [] {1, 3}); + dt.Rows.Add (new object [] {DBNull.Value, 3}); + } + + void RowChanging (object o, DataRowChangeEventArgs e) + { + AssertEquals ("changing.Action", rowChangingExpectedAction, e.Action); + rowChangingRowChanging = true; + } + + void RowChanged (object o, DataRowChangeEventArgs e) + { + AssertEquals ("changed.Action", rowChangingExpectedAction, e.Action); + rowChangingRowChanged = true; + } + + bool rowChangingRowChanging, rowChangingRowChanged; + DataRowAction rowChangingExpectedAction; + + [Test] + public void RowChanging () + { + DataTable dt = new DataTable ("table"); + dt.Columns.Add ("col1"); + dt.Columns.Add ("col2"); + dt.RowChanging += new DataRowChangeEventHandler (RowChanging); + dt.RowChanged += new DataRowChangeEventHandler (RowChanged); + rowChangingExpectedAction = DataRowAction.Add; + dt.Rows.Add (new object [] {1, 2}); + Assert ("changing,Added", rowChangingRowChanging); + Assert ("changed,Added", rowChangingRowChanged); + rowChangingExpectedAction = DataRowAction.Change; + dt.Rows [0] [0] = 2; + Assert ("changing,Changed", rowChangingRowChanging); + Assert ("changed,Changed", rowChangingRowChanged); + } + [Test] public void CloneSubClassTest() { @@ -1255,6 +1355,47 @@ namespace MonoTests.System.Data MyDataTable dt = (MyDataTable)(dt1.Clone()); AssertEquals("A#01",2,MyDataTable.count); } + + DataRowAction rowActionChanging = DataRowAction.Nothing; + DataRowAction rowActionChanged = DataRowAction.Nothing; + [Test] + public void AcceptChangesTest () + { + DataTable dt = new DataTable ("test"); + dt.Columns.Add ("id", typeof (int)); + dt.Columns.Add ("name", typeof (string)); + + dt.Rows.Add (new object [] { 1, "mono 1" }); + + dt.RowChanged += new DataRowChangeEventHandler (OnRowChanged); + dt.RowChanging += new DataRowChangeEventHandler (OnRowChanging); + + try { + rowActionChanged = rowActionChanging = DataRowAction.Nothing; + dt.AcceptChanges (); + + AssertEquals ("#1 should have fired event and set action to commit", + DataRowAction.Commit, rowActionChanging); + AssertEquals ("#2 should have fired event and set action to commit", + DataRowAction.Commit, rowActionChanged); + + } finally { + dt.RowChanged -= new DataRowChangeEventHandler (OnRowChanged); + dt.RowChanging -= new DataRowChangeEventHandler (OnRowChanging); + + } + } + + public void OnRowChanging (object src, DataRowChangeEventArgs args) + { + rowActionChanging = args.Action; + } + + public void OnRowChanged (object src, DataRowChangeEventArgs args) + { + rowActionChanged = args.Action; + } + }