866 lines
26 KiB
C#
866 lines
26 KiB
C#
// DataRowCollectionTest.cs - NUnit Test Cases for System.DataRowCollection
|
|
//
|
|
// Authors:
|
|
// Franklin Wise (gracenote@earthlink.net)
|
|
// Martin Willemoes Hansen (mwh@sysrq.dk)
|
|
//
|
|
// (C) Copyright 2002 Franklin Wise
|
|
// (C) Copyright 2003 Martin Willemoes Hansen
|
|
//
|
|
|
|
//
|
|
// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining
|
|
// a copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to
|
|
// permit persons to whom the Software is furnished to do so, subject to
|
|
// the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
//
|
|
|
|
|
|
using NUnit.Framework;
|
|
using System;
|
|
using System.Data;
|
|
|
|
namespace MonoTests.System.Data
|
|
{
|
|
[TestFixture]
|
|
public class DataRowCollectionTest
|
|
{
|
|
private DataTable _tbl;
|
|
|
|
[SetUp]
|
|
public void GetReady()
|
|
{
|
|
_tbl = new DataTable();
|
|
}
|
|
|
|
[Test]
|
|
public void AutoIncrement()
|
|
{
|
|
DataColumn col = new DataColumn("Auto");
|
|
col.AutoIncrement = true;
|
|
col.AutoIncrementSeed = 0;
|
|
col.AutoIncrementStep = 1;
|
|
|
|
_tbl.Columns.Add(col);
|
|
_tbl.Rows.Add(_tbl.NewRow());
|
|
|
|
Assert.AreEqual (0, Convert.ToInt32(_tbl.Rows[0]["Auto"] ), "test#01" );
|
|
|
|
_tbl.Rows.Add(_tbl.NewRow());
|
|
Assert.AreEqual (1, Convert.ToInt32(_tbl.Rows[1]["Auto"] ), "test#02" );
|
|
|
|
col.AutoIncrement = false;
|
|
Assert.AreEqual (1, Convert.ToInt32(_tbl.Rows[1]["Auto"] ), "test#03" );
|
|
|
|
_tbl.Rows.Add(_tbl.NewRow());
|
|
Assert.AreEqual (DBNull.Value, _tbl.Rows[2]["Auto"], "test#04" );
|
|
|
|
col.AutoIncrement = true;
|
|
col.AutoIncrementSeed = 10;
|
|
col.AutoIncrementStep = 2;
|
|
|
|
_tbl.Rows.Add(_tbl.NewRow());
|
|
Assert.AreEqual (10, Convert.ToInt32(_tbl.Rows[3]["Auto"] ), "test#05" );
|
|
_tbl.Rows.Add(_tbl.NewRow());
|
|
Assert.AreEqual (12, Convert.ToInt32(_tbl.Rows[4]["Auto"] ), "test#06" );
|
|
|
|
col = new DataColumn ("Auto2");
|
|
col.DataType = typeof(string);
|
|
col.AutoIncrement = true;
|
|
col.AutoIncrementSeed = 0;
|
|
col.AutoIncrementStep = 1;
|
|
_tbl.Columns.Add (col);
|
|
|
|
_tbl.Rows.Add(_tbl.NewRow());
|
|
Assert.AreEqual (typeof (int), _tbl.Columns [1].DataType, "test#07");
|
|
Assert.AreEqual (typeof (int), _tbl.Rows[5]["Auto2"].GetType (), "test#08" );
|
|
|
|
col = new DataColumn ("Auto3");
|
|
col.AutoIncrement = true;
|
|
col.AutoIncrementSeed = 0;
|
|
col.AutoIncrementStep = 1;
|
|
col.DataType = typeof(string);
|
|
Assert.AreEqual (typeof (string), col.DataType, "test#09");
|
|
Assert.IsFalse (col.AutoIncrement, "test#10");
|
|
}
|
|
|
|
[Test]
|
|
public void Add ()
|
|
{
|
|
_tbl.Columns.Add ();
|
|
_tbl.Columns.Add ();
|
|
DataRow Row = _tbl.NewRow ();
|
|
DataRowCollection Rows = _tbl.Rows;
|
|
|
|
Rows.Add (Row);
|
|
Assert.AreEqual (1, Rows.Count, "test#01");
|
|
Assert.IsFalse (Rows.IsReadOnly, "test#02");
|
|
Assert.IsFalse (Rows.IsSynchronized, "test#03");
|
|
Assert.AreEqual ("System.Data.DataRowCollection", Rows.ToString (), "test#04");
|
|
|
|
string [] cols = new string [2];
|
|
cols [0] = "first";
|
|
cols [1] = "second";
|
|
|
|
Rows.Add (cols);
|
|
cols [0] = "something";
|
|
cols [1] = "else";
|
|
Rows.Add (cols);
|
|
|
|
Assert.AreEqual (3, Rows.Count, "test#05");
|
|
Assert.AreEqual ("System.Data.DataRow", Rows [0].ToString (), "test#06");
|
|
Assert.AreEqual (DBNull.Value, Rows [0] [0], "test#07");
|
|
Assert.AreEqual (DBNull.Value, Rows [0] [1], "test#08");
|
|
Assert.AreEqual ("first", Rows [1] [0], "test#09");
|
|
Assert.AreEqual ("something", Rows [2] [0], "test#10");
|
|
Assert.AreEqual ("second", Rows [1] [1], "test#11");
|
|
Assert.AreEqual ("else", Rows [2] [1], "test#12");
|
|
|
|
try {
|
|
Rows.Add (Row);
|
|
Assert.Fail ("test#13");
|
|
} catch (Exception e) {
|
|
Assert.AreEqual (typeof (ArgumentException), e.GetType (), "test#14");
|
|
// Never premise English.
|
|
//Assert.AreEqual ("This row already belongs to this table.", e.Message, "test#15");
|
|
}
|
|
|
|
try {
|
|
Row = null;
|
|
Rows.Add (Row);
|
|
Assert.Fail ("test#16");
|
|
} catch (Exception e) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), e.GetType (), "test#17");
|
|
//Assert.AreEqual ("'row' argument cannot be null.\r\nParameter name: row", e.Message, "test#18");
|
|
}
|
|
|
|
DataColumn Column = new DataColumn ("not_null");
|
|
Column.AllowDBNull = false;
|
|
_tbl.Columns.Add (Column);
|
|
|
|
cols = new string [3];
|
|
cols [0] = "first";
|
|
cols [1] = "second";
|
|
cols [2] = null;
|
|
|
|
try {
|
|
Rows.Add (cols);
|
|
Assert.Fail ("test#19");
|
|
} catch (Exception e) {
|
|
Assert.AreEqual (typeof (NoNullAllowedException), e.GetType (), "test#20");
|
|
//Assert.AreEqual ("Column 'not_null' does not allow nulls.", e.Message, "test#21");
|
|
}
|
|
|
|
Column = _tbl.Columns [0];
|
|
Column.Unique = true;
|
|
|
|
cols = new string [3];
|
|
cols [0] = "first";
|
|
cols [1] = "second";
|
|
cols [2] = "blabal";
|
|
|
|
try {
|
|
Rows.Add (cols);
|
|
Assert.Fail ("test#22");
|
|
} catch (Exception e) {
|
|
Assert.AreEqual (typeof (ConstraintException), e.GetType (), "test#23");
|
|
// Never premise English.
|
|
//Assert.AreEqual ("Column 'Column1' is constrained to be unique. Value 'first' is already present.", e.Message, "test#24");
|
|
}
|
|
|
|
Column = new DataColumn ("integer");
|
|
Column.DataType = typeof (short);
|
|
_tbl.Columns.Add (Column);
|
|
|
|
object [] obs = new object [4];
|
|
obs [0] = "_first";
|
|
obs [1] = "second";
|
|
obs [2] = "blabal";
|
|
obs [3] = "ads";
|
|
|
|
try {
|
|
Rows.Add (obs);
|
|
Assert.Fail ("test#25");
|
|
} catch (ArgumentException e) {
|
|
// LAMESPEC: MSDN says this exception is InvalidCastException
|
|
// Assert.AreEqual (typeof (ArgumentException), e.GetType (), "test#26");
|
|
}
|
|
|
|
object [] obs1 = new object [5];
|
|
obs1 [0] = "A";
|
|
obs1 [1] = "B";
|
|
obs1 [2] = "C";
|
|
obs1 [3] = 38;
|
|
obs1 [4] = "Extra";
|
|
try {
|
|
Rows.Add (obs1);
|
|
Assert.Fail ("test#27");
|
|
} catch (Exception e) {
|
|
Assert.AreEqual (typeof(ArgumentException), e.GetType (), "test#28");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void Add_ByValuesNullTest ()
|
|
{
|
|
DataTable t = new DataTable ("test");
|
|
t.Columns.Add ("id", typeof (int));
|
|
t.Columns.Add ("name", typeof (string));
|
|
t.Columns.Add ("nullable", typeof (string));
|
|
|
|
t.Columns [0].AutoIncrement = true;
|
|
t.Columns [0].AutoIncrementSeed = 10;
|
|
t.Columns [0].AutoIncrementStep = 5;
|
|
|
|
t.Columns [1].DefaultValue = "testme";
|
|
|
|
|
|
// null test & missing columns
|
|
DataRow r = t.Rows.Add (new object [] { null, null});
|
|
Assert.AreEqual (10, (int) r [0], "#ABV1");
|
|
Assert.AreEqual ("testme", (string) r [1], "#ABV2");
|
|
Assert.AreEqual (DBNull.Value, r [2], "#ABV3");
|
|
|
|
// dbNull test
|
|
r = t.Rows.Add (new object [] { DBNull.Value, DBNull.Value, DBNull.Value});
|
|
Assert.AreEqual (DBNull.Value, r [0], "#ABV4");
|
|
Assert.AreEqual (DBNull.Value, r [1], "#ABV5");
|
|
Assert.AreEqual (DBNull.Value, r [2], "#ABV6");
|
|
|
|
// ai test & no default value test
|
|
r = t.Rows.Add (new object [] { null, null, null});
|
|
Assert.AreEqual (15, (int) r [0], "#ABV7");
|
|
Assert.AreEqual ("testme", (string) r [1], "#ABV8");
|
|
Assert.AreEqual (DBNull.Value, r [2], "#ABV9");
|
|
}
|
|
|
|
[Test]
|
|
public void Clear ()
|
|
{
|
|
DataRowCollection Rows = _tbl.Rows;
|
|
DataTable Table = new DataTable ("child");
|
|
Table.Columns.Add ("first", typeof (int));
|
|
Table.Columns.Add ("second", typeof (string));
|
|
|
|
_tbl.Columns.Add ("first", typeof (int));
|
|
_tbl.Columns.Add ("second", typeof (float));
|
|
|
|
string [] cols = new string [2];
|
|
cols [0] = "1";
|
|
cols [1] = "1,1";
|
|
Rows.Add (cols);
|
|
|
|
cols [0] = "2";
|
|
cols [1] = "2,1";
|
|
Rows.Add (cols);
|
|
|
|
cols [0] = "3";
|
|
cols [1] = "3,1";
|
|
Rows.Add (cols);
|
|
|
|
Assert.AreEqual (3, Rows.Count, "test#01");
|
|
Rows.Clear ();
|
|
|
|
// hmm... TODO: better tests
|
|
Assert.AreEqual (0, Rows.Count, "test#02");
|
|
|
|
cols [0] = "1";
|
|
cols [1] = "1,1";
|
|
Rows.Add (cols);
|
|
|
|
cols [0] = "2";
|
|
cols [1] = "2,1";
|
|
Rows.Add (cols);
|
|
|
|
cols [0] = "3";
|
|
cols [1] = "3,1";
|
|
Rows.Add (cols);
|
|
|
|
cols [0] = "1";
|
|
cols [1] = "test";
|
|
Table.Rows.Add (cols);
|
|
|
|
cols [0] = "2";
|
|
cols [1] = "test2";
|
|
Table.Rows.Add (cols);
|
|
|
|
cols [0] = "3";
|
|
cols [1] = "test3";
|
|
Table.Rows.Add (cols);
|
|
|
|
DataRelation Rel = new DataRelation ("REL", _tbl.Columns [0], Table.Columns [0]);
|
|
DataSet Set = new DataSet ();
|
|
Set.Tables.Add (_tbl);
|
|
Set.Tables.Add (Table);
|
|
Set.Relations.Add (Rel);
|
|
|
|
try {
|
|
Rows.Clear ();
|
|
Assert.Fail ("test#03");
|
|
} catch (InvalidConstraintException) {
|
|
}
|
|
|
|
Assert.AreEqual (3, Table.Rows.Count, "test#06");
|
|
Table.Rows.Clear ();
|
|
Assert.AreEqual (0, Table.Rows.Count, "test#07");
|
|
}
|
|
|
|
[Test]
|
|
public void Contains ()
|
|
{
|
|
DataColumn C = new DataColumn ("key");
|
|
C.Unique = true;
|
|
C.DataType = typeof (int);
|
|
C.AutoIncrement = true;
|
|
C.AutoIncrementSeed = 0;
|
|
C.AutoIncrementStep = 1;
|
|
_tbl.Columns.Add (C);
|
|
_tbl.Columns.Add ("first", typeof (string));
|
|
_tbl.Columns.Add ("second", typeof (decimal));
|
|
|
|
DataRowCollection Rows = _tbl.Rows;
|
|
|
|
DataRow Row = _tbl.NewRow ();
|
|
_tbl.Rows.Add (Row);
|
|
Row = _tbl.NewRow ();
|
|
_tbl.Rows.Add (Row);
|
|
Row = _tbl.NewRow ();
|
|
_tbl.Rows.Add (Row);
|
|
Row = _tbl.NewRow ();
|
|
_tbl.Rows.Add (Row);
|
|
|
|
Rows [0] [1] = "test0";
|
|
Rows [0] [2] = 0;
|
|
Rows [1] [1] = "test1";
|
|
Rows [1] [2] = 1;
|
|
Rows [2] [1] = "test2";
|
|
Rows [2] [2] = 2;
|
|
Rows [3] [1] = "test3";
|
|
Rows [3] [2] = 3;
|
|
|
|
Assert.AreEqual (3, _tbl.Columns.Count, "test#01");
|
|
Assert.AreEqual (4, _tbl.Rows.Count, "test#02");
|
|
Assert.AreEqual (0, _tbl.Rows [0] [0], "test#03");
|
|
Assert.AreEqual (1, _tbl.Rows [1] [0], "test#04");
|
|
Assert.AreEqual (2, _tbl.Rows [2] [0], "test#05");
|
|
Assert.AreEqual (3, _tbl.Rows [3] [0], "test#06");
|
|
|
|
try {
|
|
Rows.Contains (1);
|
|
Assert.Fail ("test#07");
|
|
} catch (Exception e) {
|
|
Assert.AreEqual (typeof (MissingPrimaryKeyException), e.GetType (), "test#08");
|
|
// Never premise English.
|
|
//Assert.AreEqual ("Table doesn't have a primary key.", e.Message, "test#09");
|
|
}
|
|
|
|
_tbl.PrimaryKey = new DataColumn [] {_tbl.Columns [0]};
|
|
Assert.IsTrue (Rows.Contains (1), "test#10");
|
|
Assert.IsTrue (Rows.Contains (2), "test#11");
|
|
Assert.IsFalse (Rows.Contains (4), "test#12");
|
|
|
|
try {
|
|
Rows.Contains (new object [] {64, "test0"});
|
|
Assert.Fail ("test#13");
|
|
} catch (Exception e) {
|
|
Assert.AreEqual (typeof (ArgumentException), e.GetType (), "test#14");
|
|
// Never premise English.
|
|
//Assert.AreEqual ("Expecting 1 value(s) for the key being indexed, but received 2 value(s).", e.Message, "test#15");
|
|
}
|
|
|
|
_tbl.PrimaryKey = new DataColumn [] {_tbl.Columns [0], _tbl.Columns [1]};
|
|
Assert.IsFalse (Rows.Contains (new object [] {64, "test0"}), "test#16");
|
|
Assert.IsFalse (Rows.Contains (new object [] {0, "test1"}), "test#17");
|
|
Assert.IsTrue (Rows.Contains (new object [] {1, "test1"}), "test#18");
|
|
Assert.IsTrue (Rows.Contains (new object [] {2, "test2"}), "test#19");
|
|
|
|
try {
|
|
Rows.Contains (new object [] {2});
|
|
Assert.Fail ("test#20");
|
|
} catch (Exception e) {
|
|
Assert.AreEqual (typeof (ArgumentException), e.GetType (), "test#21");
|
|
// Never premise English.
|
|
//Assert.AreEqual ("Expecting 2 value(s) for the key being indexed, but received 1 value(s).", e.Message, "test#22");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void CopyTo ()
|
|
{
|
|
_tbl.Columns.Add ();
|
|
_tbl.Columns.Add ();
|
|
_tbl.Columns.Add ();
|
|
|
|
DataRowCollection Rows = _tbl.Rows;
|
|
|
|
Rows.Add (new object [] {"1", "1", "1"});
|
|
Rows.Add (new object [] {"2", "2", "2"});
|
|
Rows.Add (new object [] {"3", "3", "3"});
|
|
Rows.Add (new object [] {"4", "4", "4"});
|
|
Rows.Add (new object [] {"5", "5", "5"});
|
|
Rows.Add (new object [] {"6", "6", "6"});
|
|
Rows.Add (new object [] {"7", "7", "7"});
|
|
|
|
DataRow [] dr = new DataRow [10];
|
|
|
|
try {
|
|
Rows.CopyTo (dr, 4);
|
|
Assert.Fail ("test#01");
|
|
} catch (Exception e) {
|
|
Assert.AreEqual (typeof (ArgumentException), e.GetType (), "test#02");
|
|
//Assert.AreEqual ("Destination array was not long enough. Check destIndex and length, and the array's lower bounds.", e.Message, "test#03");
|
|
}
|
|
|
|
dr = new DataRow [11];
|
|
Rows.CopyTo (dr, 4);
|
|
|
|
Assert.IsNull (dr [0], "test#04");
|
|
Assert.IsNull (dr [1], "test#05");
|
|
Assert.IsNull (dr [2], "test#06");
|
|
Assert.IsNull (dr [3], "test#07");
|
|
Assert.AreEqual ("1", dr [4] [0], "test#08");
|
|
Assert.AreEqual ("2", dr [5] [0], "test#09");
|
|
Assert.AreEqual ("3", dr [6] [0], "test#10");
|
|
Assert.AreEqual ("4", dr [7] [0], "test#11");
|
|
Assert.AreEqual ("5", dr [8] [0], "test#12");
|
|
Assert.AreEqual ("6", dr [9] [0], "test#13");
|
|
}
|
|
|
|
[Test]
|
|
public void Equals ()
|
|
{
|
|
_tbl.Columns.Add ();
|
|
_tbl.Columns.Add ();
|
|
_tbl.Columns.Add ();
|
|
|
|
DataRowCollection Rows1 = _tbl.Rows;
|
|
|
|
Rows1.Add (new object [] {"1", "1", "1"});
|
|
Rows1.Add (new object [] {"2", "2", "2"});
|
|
Rows1.Add (new object [] {"3", "3", "3"});
|
|
Rows1.Add (new object [] {"4", "4", "4"});
|
|
Rows1.Add (new object [] {"5", "5", "5"});
|
|
Rows1.Add (new object [] {"6", "6", "6"});
|
|
Rows1.Add (new object [] {"7", "7", "7"});
|
|
|
|
DataRowCollection Rows2 = _tbl.Rows;
|
|
|
|
Assert.IsTrue (Rows2.Equals (Rows1), "test#01");
|
|
Assert.IsTrue (Rows1.Equals (Rows2), "test#02");
|
|
Assert.IsTrue (Rows1.Equals (Rows1), "test#03");
|
|
|
|
DataTable Table = new DataTable ();
|
|
Table.Columns.Add ();
|
|
Table.Columns.Add ();
|
|
Table.Columns.Add ();
|
|
DataRowCollection Rows3 = Table.Rows;
|
|
|
|
Rows3.Add (new object [] {"1", "1", "1"});
|
|
Rows3.Add (new object [] {"2", "2", "2"});
|
|
Rows3.Add (new object [] {"3", "3", "3"});
|
|
Rows3.Add (new object [] {"4", "4", "4"});
|
|
Rows3.Add (new object [] {"5", "5", "5"});
|
|
Rows3.Add (new object [] {"6", "6", "6"});
|
|
Rows3.Add (new object [] {"7", "7", "7"});
|
|
|
|
Assert.IsFalse (Rows3.Equals (Rows1), "test#04");
|
|
Assert.IsFalse (Rows3.Equals (Rows2), "test#05");
|
|
Assert.IsFalse (Rows1.Equals (Rows3), "test#06");
|
|
Assert.IsFalse (Rows2.Equals (Rows3), "test#07");
|
|
}
|
|
|
|
[Test]
|
|
public void Find ()
|
|
{
|
|
DataColumn Col = new DataColumn ("test_1");
|
|
Col.AllowDBNull = false;
|
|
Col.Unique = true;
|
|
Col.DataType = typeof (long);
|
|
_tbl.Columns.Add (Col);
|
|
|
|
Col = new DataColumn ("test_2");
|
|
Col.DataType = typeof (string);
|
|
_tbl.Columns.Add (Col);
|
|
|
|
DataRowCollection Rows = _tbl.Rows;
|
|
|
|
Rows.Add (new object [] {1, "first"});
|
|
Rows.Add (new object [] {2, "second"});
|
|
Rows.Add (new object [] {3, "third"});
|
|
Rows.Add (new object [] {4, "fourth"});
|
|
Rows.Add (new object [] {5, "fifth"});
|
|
|
|
try {
|
|
Rows.Find (1);
|
|
Assert.Fail ("test#01");
|
|
} catch (Exception e) {
|
|
Assert.AreEqual (typeof (MissingPrimaryKeyException), e.GetType (), "test#02");
|
|
// Never premise English.
|
|
//Assert.AreEqual ("Table doesn't have a primary key.", e.Message, "test#03");
|
|
}
|
|
|
|
_tbl.PrimaryKey = new DataColumn [] {_tbl.Columns [0]};
|
|
DataRow row = Rows.Find (1);
|
|
Assert.AreEqual (1L, row [0], "test#04");
|
|
row = Rows.Find (2);
|
|
Assert.AreEqual (2L, row [0], "test#05");
|
|
row = Rows.Find ("2");
|
|
Assert.AreEqual (2L, row [0], "test#06");
|
|
|
|
try {
|
|
row = Rows.Find ("test");
|
|
Assert.Fail ("test#07");
|
|
} catch (Exception e) {
|
|
Assert.AreEqual (typeof (FormatException), e.GetType (), "test#08");
|
|
//Assert.AreEqual ("Input string was not in a correct format.", e.Message, "test#09");
|
|
}
|
|
|
|
String tes = null;
|
|
row = Rows.Find (tes);
|
|
Assert.IsNull (row, "test#10");
|
|
_tbl.PrimaryKey = null;
|
|
|
|
try {
|
|
Rows.Find (new object [] {1, "fir"});
|
|
Assert.Fail ("test#11");
|
|
} catch (Exception e) {
|
|
Assert.AreEqual (typeof (MissingPrimaryKeyException), e.GetType (), "test#12");
|
|
// Never premise English.
|
|
//Assert.AreEqual ("Table doesn't have a primary key.", e.Message, "tets#13");
|
|
}
|
|
|
|
_tbl.PrimaryKey = new DataColumn [] {_tbl.Columns [0], _tbl.Columns [1]};
|
|
|
|
try {
|
|
Rows.Find (1);
|
|
Assert.Fail ("test#14");
|
|
} catch (Exception e) {
|
|
Assert.AreEqual (typeof (ArgumentException), e.GetType (), "test#15");
|
|
// Never premise English.
|
|
//Assert.AreEqual ("Expecting 2 value(s) for the key being indexed, but received 1 value(s).", e.Message, "test#16");
|
|
}
|
|
|
|
row = Rows.Find (new object [] {1, "fir"});
|
|
Assert.IsNull (row, "test#16");
|
|
row = Rows.Find (new object [] {1, "first"});
|
|
Assert.AreEqual (1L, row [0], "test#17");
|
|
}
|
|
|
|
[Test]
|
|
public void Find2 ()
|
|
{
|
|
DataSet ds = new DataSet ();
|
|
ds.EnforceConstraints = false;
|
|
|
|
DataTable dt = new DataTable ();
|
|
ds.Tables.Add (dt);
|
|
|
|
DataColumn dc = new DataColumn ("Column A");
|
|
dt.Columns.Add (dc);
|
|
|
|
dt.PrimaryKey = new DataColumn [] {dc};
|
|
|
|
DataRow dr = dt.NewRow ();
|
|
dr [0] = "a";
|
|
dt.Rows.Add (dr);
|
|
|
|
dr = dt.NewRow ();
|
|
dr [0] = "b";
|
|
dt.Rows.Add (dr);
|
|
|
|
dr = dt.NewRow ();
|
|
dr [0] = "c";
|
|
dt.Rows.Add (dr);
|
|
|
|
DataRow row = (DataRow) ds.Tables [0].Rows.Find (new object [] {"a"});
|
|
|
|
Assert.IsNotNull (row);
|
|
}
|
|
|
|
[Test]
|
|
public void InsertAt ()
|
|
{
|
|
_tbl.Columns.Add ();
|
|
_tbl.Columns.Add ();
|
|
_tbl.Columns.Add ();
|
|
DataRowCollection Rows = _tbl.Rows;
|
|
|
|
Rows.Add (new object [] {"a", "aa", "aaa"});
|
|
Rows.Add (new object [] {"b", "bb", "bbb"});
|
|
Rows.Add (new object [] {"c", "cc", "ccc"});
|
|
Rows.Add (new object [] {"d", "dd", "ddd"});
|
|
|
|
DataRow Row = _tbl.NewRow ();
|
|
Row [0] = "e";
|
|
Row [1] = "ee";
|
|
Row [2] = "eee";
|
|
|
|
try {
|
|
Rows.InsertAt (Row, -1);
|
|
Assert.Fail ("test#01");
|
|
} catch (Exception e) {
|
|
Assert.AreEqual (typeof (IndexOutOfRangeException), e.GetType (), "test#02");
|
|
// Never premise English.
|
|
//Assert.AreEqual ("The row insert position -1 is invalid.", e.Message, "test#03");
|
|
}
|
|
|
|
Rows.InsertAt (Row, 0);
|
|
Assert.AreEqual ("e", Rows [0][0], "test#04");
|
|
Assert.AreEqual ("a", Rows [1][0], "test#05");
|
|
|
|
Row = _tbl.NewRow ();
|
|
Row [0] = "f";
|
|
Row [1] = "ff";
|
|
Row [2] = "fff";
|
|
|
|
Rows.InsertAt (Row, 5);
|
|
Assert.AreEqual ("f", Rows [5][0], "test#06");
|
|
|
|
Row = _tbl.NewRow ();
|
|
Row [0] = "g";
|
|
Row [1] = "gg";
|
|
Row [2] = "ggg";
|
|
|
|
Rows.InsertAt (Row, 500);
|
|
Assert.AreEqual ("g", Rows [6][0], "test#07");
|
|
|
|
try {
|
|
Rows.InsertAt (Row, 6); //Row already belongs to the table
|
|
Assert.Fail ("test#08");
|
|
}
|
|
catch (Exception e) {
|
|
Assert.AreEqual (typeof (ArgumentException), e.GetType (), "test#09");
|
|
// Never premise English.
|
|
//Assert.AreEqual ("This row already belongs to this table.", e.Message, "test#10");
|
|
}
|
|
|
|
DataTable table = new DataTable ();
|
|
DataColumn col = new DataColumn ("Name");
|
|
table.Columns.Add (col);
|
|
Row = table.NewRow ();
|
|
Row ["Name"] = "Abc";
|
|
table.Rows.Add (Row);
|
|
try {
|
|
Rows.InsertAt (Row, 6);
|
|
Assert.Fail ("test#11");
|
|
}
|
|
catch (Exception e) {
|
|
Assert.AreEqual (typeof (ArgumentException), e.GetType (), "test#12");
|
|
// Never premise English.
|
|
//Assert.AreEqual ("This row already belongs to another table.", e.Message, "test#13");
|
|
}
|
|
|
|
table = new DataTable ();
|
|
col = new DataColumn ("Name");
|
|
col.DataType = typeof (string);
|
|
table.Columns.Add (col);
|
|
UniqueConstraint uk = new UniqueConstraint (col);
|
|
table.Constraints.Add (uk);
|
|
|
|
Row = table.NewRow ();
|
|
Row ["Name"] = "aaa";
|
|
table.Rows.InsertAt (Row, 0);
|
|
|
|
Row = table.NewRow ();
|
|
Row ["Name"] = "aaa";
|
|
try {
|
|
table.Rows.InsertAt (Row, 1);
|
|
Assert.Fail ("test#14");
|
|
}
|
|
catch (Exception e) {
|
|
Assert.AreEqual (typeof (ConstraintException), e.GetType (), "test#15");
|
|
}
|
|
try {
|
|
table.Rows.InsertAt (null, 1);
|
|
}
|
|
catch (Exception e) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), e.GetType (), "test#16");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void Remove ()
|
|
{
|
|
_tbl.Columns.Add ();
|
|
_tbl.Columns.Add ();
|
|
_tbl.Columns.Add ();
|
|
DataRowCollection Rows = _tbl.Rows;
|
|
|
|
Rows.Add (new object [] {"a", "aa", "aaa"});
|
|
Rows.Add (new object [] {"b", "bb", "bbb"});
|
|
Rows.Add (new object [] {"c", "cc", "ccc"});
|
|
Rows.Add (new object [] {"d", "dd", "ddd"});
|
|
|
|
Assert.AreEqual (4, _tbl.Rows.Count, "test#01");
|
|
|
|
Rows.Remove (_tbl.Rows [1]);
|
|
Assert.AreEqual (3, _tbl.Rows.Count, "test#02");
|
|
Assert.AreEqual ("a", _tbl.Rows [0] [0], "test#03");
|
|
Assert.AreEqual ("c", _tbl.Rows [1] [0], "test#04");
|
|
Assert.AreEqual ("d", _tbl.Rows [2] [0], "test#05");
|
|
|
|
try {
|
|
Rows.Remove (null);
|
|
Assert.Fail ("test#06");
|
|
} catch (Exception e) {
|
|
Assert.AreEqual (typeof (IndexOutOfRangeException), e.GetType (), "test#07");
|
|
// Never premise English.
|
|
//Assert.AreEqual ("The given datarow is not in the current DataRowCollection.", e.Message, "test#08");
|
|
}
|
|
|
|
DataRow Row = new DataTable ().NewRow ();
|
|
|
|
try {
|
|
Rows.Remove (Row);
|
|
Assert.Fail ("test#09");
|
|
} catch (Exception e) {
|
|
Assert.AreEqual (typeof (IndexOutOfRangeException), e.GetType (), "test#10");
|
|
// Never premise English.
|
|
//Assert.AreEqual ("The given datarow is not in the current DataRowCollection.", e.Message, "test#11");
|
|
}
|
|
|
|
try {
|
|
Rows.RemoveAt (-1);
|
|
Assert.Fail ("test#12");
|
|
} catch (Exception e) {
|
|
Assert.AreEqual (typeof (IndexOutOfRangeException), e.GetType (), "test#13");
|
|
// Never premise English.
|
|
//Assert.AreEqual ("There is no row at position -1.", e.Message, "test#14");
|
|
}
|
|
|
|
try {
|
|
Rows.RemoveAt (64);
|
|
Assert.Fail ("test#15");
|
|
} catch (Exception e) {
|
|
Assert.AreEqual (typeof (IndexOutOfRangeException), e.GetType (), "test#16");
|
|
// Never premise English.
|
|
//Assert.AreEqual ("There is no row at position 64.", e.Message, "test#17");
|
|
}
|
|
|
|
Rows.RemoveAt (0);
|
|
Rows.RemoveAt (1);
|
|
Assert.AreEqual (1, Rows.Count, "test#18");
|
|
Assert.AreEqual ("c", Rows [0] [0], "test#19");
|
|
}
|
|
|
|
#if NET_2_0
|
|
[Test]
|
|
public void IndexOf () {
|
|
DataSet ds = new DataSet ();
|
|
|
|
DataTable dt = new DataTable ();
|
|
ds.Tables.Add (dt);
|
|
|
|
DataColumn dc = new DataColumn ("Column A");
|
|
dt.Columns.Add (dc);
|
|
|
|
dt.PrimaryKey = new DataColumn[] { dc };
|
|
|
|
DataRow dr1 = dt.NewRow ();
|
|
dr1[0] = "a";
|
|
dt.Rows.Add (dr1);
|
|
|
|
DataRow dr2 = dt.NewRow ();
|
|
dr2[0] = "b";
|
|
dt.Rows.Add (dr2);
|
|
|
|
DataRow dr3 = dt.NewRow ();
|
|
dr3[0] = "c";
|
|
dt.Rows.Add (dr3);
|
|
|
|
DataRow dr4 = dt.NewRow ();
|
|
dr4[0] = "d";
|
|
dt.Rows.Add (dr4);
|
|
|
|
DataRow dr5 = dt.NewRow ();
|
|
dr5[0] = "e";
|
|
|
|
int index = ds.Tables[0].Rows.IndexOf (dr3);
|
|
Assert.AreEqual (2, index, "IndexOf-Yes");
|
|
|
|
index = ds.Tables[0].Rows.IndexOf (dr5);
|
|
Assert.AreEqual (-1, index, "IndexOf-No");
|
|
}
|
|
[Test]
|
|
public void IndexOfTest()
|
|
{
|
|
DataTable dt = new DataTable("TestWriteXmlSchema");
|
|
dt.Columns.Add("Col1", typeof(int));
|
|
dt.Columns.Add("Col2", typeof(int));
|
|
DataRow dr = dt.NewRow();
|
|
dr[0] = 10;
|
|
dr[1] = 20;
|
|
dt.Rows.Add(dr);
|
|
DataRow dr1 = dt.NewRow();
|
|
dr1[0] = 10;
|
|
dr1[1] = 20;
|
|
dt.Rows.Add(dr1);
|
|
DataRow dr2 = dt.NewRow();
|
|
dr2[0] = 10;
|
|
dr2[1] = 20;
|
|
dt.Rows.Add(dr2);
|
|
Assert.AreEqual (1, dt.Rows.IndexOf (dr1));
|
|
DataTable dt1 = new DataTable("HelloWorld");
|
|
dt1.Columns.Add("T1", typeof(int));
|
|
dt1.Columns.Add("T2", typeof(int));
|
|
DataRow dr3 = dt1.NewRow();
|
|
dr3[0] = 10;
|
|
dr3[1] = 20;
|
|
dt1.Rows.Add(dr3);
|
|
Assert.AreEqual (-1, dt.Rows.IndexOf (dr3));
|
|
Assert.AreEqual (-1, dt.Rows.IndexOf (null));
|
|
}
|
|
#endif
|
|
|
|
[Test]
|
|
public void Find_DoesntThrowWithNullObjectInArray () // Novell bug 519648
|
|
{
|
|
var dt = new DataTable ("datatable");
|
|
|
|
var column = new DataColumn ();
|
|
dt.Columns.Add (column);
|
|
var columns = new DataColumn [] { column };
|
|
dt.PrimaryKey = columns;
|
|
|
|
try {
|
|
Assert.AreEqual (null, dt.Rows.Find (new object [] { null }));
|
|
} catch (IndexOutOfRangeException) {
|
|
Assert.Fail ("Bug #519648 (https://bugzilla.novell.com/show_bug.cgi?id=519648) is not fixed.");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void Find_DoesntThrowWithNullObject () // Novell bug 519648
|
|
{
|
|
var dt = new DataTable ("datatable");
|
|
|
|
var column = new DataColumn ();
|
|
dt.Columns.Add (column);
|
|
var columns = new DataColumn [] { column };
|
|
dt.PrimaryKey = columns;
|
|
|
|
try {
|
|
Assert.AreEqual (null, dt.Rows.Find ( (object)null));
|
|
} catch (IndexOutOfRangeException) {
|
|
Assert.Fail ("Bug #519648 (https://bugzilla.novell.com/show_bug.cgi?id=519648) is not fixed.");
|
|
}
|
|
}
|
|
}
|
|
}
|