// DataTableTest.cs - NUnit Test Cases for testing the DataTable
//
-// Franklin Wise (gracenote@earthlink.net)
+// Authors:
+// Franklin Wise (gracenote@earthlink.net)
+// Martin Willemoes Hansen (mwh@sysrq.dk)
//
// (C) Franklin Wise
+// (C) 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;
+using System.Data.SqlTypes;
+using System.Globalization;
+using System.IO;
+using System.Runtime.Serialization.Formatters.Binary;
+using System.Xml;
namespace MonoTests.System.Data
{
-
- public class DataTableTest : TestCase
+ [TestFixture]
+ public class DataTableTest : Assertion
{
-
- public DataTableTest() : base ("MonoTest.System.Data.DataTableTest") {}
- public DataTableTest(string name) : base(name) {}
-
- protected override void SetUp() {}
-
- protected override void TearDown() {}
-
- public static ITest Suite
- {
- get
- {
- return new TestSuite(typeof(DataTableTest));
- }
- }
-
- public void TestCtor()
+ [Test]
+ public void Ctor()
{
DataTable dt = new DataTable();
- Assertion.AssertEquals("CaseSensitive must be false." ,false,dt.CaseSensitive);
- Assertion.Assert("Col",dt.Columns != null);
- //Assertion.Assert(dt.ChildRelations != null);
- Assertion.Assert("Const", dt.Constraints != null);
- Assertion.Assert("ds", dt.DataSet == null);
- Assertion.Assert("dv", dt.DefaultView != null);
- Assertion.Assert("de", dt.DisplayExpression == "");
- Assertion.Assert("ep", dt.ExtendedProperties != null);
- Assertion.Assert("he", dt.HasErrors == false);
- Assertion.Assert("lc", dt.Locale != null);
- Assertion.Assert("mc", dt.MinimumCapacity == 50); //LAMESPEC:
- Assertion.Assert("ns", dt.Namespace == "");
- //Assertion.Assert(dt.ParentRelations != null);
- Assertion.Assert("pf", dt.Prefix == "");
- Assertion.Assert("pk", dt.PrimaryKey != null);
- Assertion.Assert("rows", dt.Rows != null);
- Assertion.Assert("Site", dt.Site == null);
- Assertion.Assert("tname", dt.TableName == "");
+ AssertEquals("CaseSensitive must be false." ,false,dt.CaseSensitive);
+ Assert("Col",dt.Columns != null);
+ //Assert(dt.ChildRelations != null);
+ Assert("Const", dt.Constraints != null);
+ Assert("ds", dt.DataSet == null);
+ Assert("dv", dt.DefaultView != null);
+ Assert("de", dt.DisplayExpression == "");
+ Assert("ep", dt.ExtendedProperties != null);
+ Assert("he", dt.HasErrors == false);
+ Assert("lc", dt.Locale != null);
+ Assert("mc", dt.MinimumCapacity == 50); //LAMESPEC:
+ Assert("ns", dt.Namespace == "");
+ //Assert(dt.ParentRelations != null);
+ Assert("pf", dt.Prefix == "");
+ Assert("pk", dt.PrimaryKey != null);
+ Assert("rows", dt.Rows != null);
+ Assert("Site", dt.Site == null);
+ Assert("tname", dt.TableName == "");
}
- public void TestSelect ()
+ [Test]
+ public void Select ()
{
DataSet Set = new DataSet ();
DataTable Mom = new DataTable ("Mom");
Row [0] = "Teresa";
Row [1] = "Mack";
Mom.Rows.Add (Row);
+
+ Row = Mom.NewRow ();
+ Row [0] = "'Jhon O'' Collenal'";
+ Row [1] = "Pack";
+ Mom.Rows.Add (Row);
Row = Child.NewRow ();
Row [0] = "Nick";
Row [0] = "Mack";
Row [1] = 99;
Child.Rows.Add (Row);
+
+ Row = Child.NewRow ();
+ Row [0] = "Pack";
+ Row [1] = 66;
+ Child.Rows.Add (Row);
DataRow [] Rows = Mom.Select ("Name = 'Teresa'");
AssertEquals ("test#01", 2, Rows.Length);
+
+ // test with apos escaped
+ Rows = Mom.Select ("Name = '''Jhon O'''' Collenal'''");
+ AssertEquals ("test#01.1", 1, Rows.Length);
Rows = Mom.Select ("Name = 'Teresa' and ChildName = 'Nick'");
AssertEquals ("test#02", 0, Rows.Length);
AssertEquals ("test#04", "Mack", Rows [0] [1]);
Rows = Mom.Select ("Name = 'Teresa' or ChildName <> 'Jack'");
- AssertEquals ("test#05", 5, Rows.Length);
-
+ AssertEquals ("test#05", 6, Rows.Length);
+
Rows = Child.Select ("age = 20 - 1");
AssertEquals ("test#06", 1, Rows.Length);
-
+
Rows = Child.Select ("age <= 20");
AssertEquals ("test#07", 3, Rows.Length);
-
+
Rows = Child.Select ("age >= 20");
- AssertEquals ("test#08", 3, Rows.Length);
+ AssertEquals ("test#08", 4, Rows.Length);
Rows = Child.Select ("age >= 20 and name = 'Mack' or name = 'Nick'");
AssertEquals ("test#09", 2, Rows.Length);
Rows = Child.Select ("age >= 20 and (name = 'Mack' or name = 'Nick')");
AssertEquals ("test#10", 1, Rows.Length);
AssertEquals ("test#11", "Mack", Rows [0] [0]);
-
+
+ Rows = Child.Select ("not (Name = 'Jack')");
+ AssertEquals ("test#12", 6, Rows.Length);
}
- public void TestSelect2 ()
+ [Test]
+ public void Select2 ()
{
DataSet Set = new DataSet ();
- DataTable Child = new DataTable ("Child");
- //Set.Tables.Add (Child);
+ DataTable Child = new DataTable ("Child");
+
+ Set.Tables.Add (Child);
DataColumn Col3 = new DataColumn ("Name");
DataColumn Col4 = new DataColumn ("Age");
}
- public void TestSelectParsing ()
+ [Test]
+ public void SelectParsing ()
{
DataTable T = new DataTable ("test");
DataColumn C = new DataColumn ("name");
T.Rows.Add (Row);
AssertEquals ("test#01", 12, T.Select ("age<=10").Length);
- AssertEquals ("test#02", 12, T.Select ("age\n\t<\n\t=\t\n10").Length);
+ AssertEquals ("test#02", 12, T.Select ("age\n\t<\n\t=\t\n10").Length);
+
try {
T.Select ("name = 1human ");
Fail ("test#03");
}
AssertEquals ("test#07", 1, T.Select ("age = '13'").Length);
+
}
- public void TestSelectOperators ()
+ [Test]
+ public void SelectOperators ()
{
DataTable T = new DataTable ("test");
DataColumn C = new DataColumn ("name");
Row [1] = 1;
Row [2] = 1;
T.Rows.Add (Row);
-
+
AssertEquals ("test#01", 11, T.Select ("age < 10").Length);
- AssertEquals ("test#02", 12, T.Select ("age <= 10").Length);
- AssertEquals ("test#03", 12, T.Select ("age< =10").Length);
+ AssertEquals ("test#02", 12, T.Select ("age <= 10").Length);
+ AssertEquals ("test#03", 12, T.Select ("age< =10").Length);
AssertEquals ("test#04", 89, T.Select ("age > 10").Length);
AssertEquals ("test#05", 90, T.Select ("age >= 10").Length);
AssertEquals ("test#06", 100, T.Select ("age <> 10").Length);
AssertEquals ("test#07", 3, T.Select ("name < 'human10'").Length);
AssertEquals ("test#08", 3, T.Select ("id < '10'").Length);
- AssertEquals ("test#09", 25, T.Select ("id < 10").Length);
+ // FIXME: Somebody explain how this can be possible.
+ // it seems that it is no matter between 10 - 30. The
+ // result is allways 25 :-P
+ //AssertEquals ("test#09", 25, T.Select ("id < 10").Length);
+
}
- public void TestSelectExceptions ()
+ [Test]
+ public void SelectExceptions ()
{
DataTable T = new DataTable ("test");
DataColumn C = new DataColumn ("name");
}
}
- public void TestSelectStringOperators ()
+ [Test]
+ public void SelectStringOperators ()
{
DataTable T = new DataTable ("test");
DataColumn C = new DataColumn ("name");
}
- public void TestSelectAggregates ()
+ [Test]
+ public void SelectAggregates ()
{
DataTable T = new DataTable ("test");
DataColumn C = new DataColumn ("name");
AssertEquals ("test#07", 1000, T.Select ("var(age) < 83417 and var(age) > 83416").Length);
}
- public void TestSelectFunctions ()
+ [Test]
+ public void SelectFunctions ()
{
DataTable T = new DataTable ("test");
DataColumn C = new DataColumn ("name");
T.Rows.Add (Row);
//TODO: How to test Convert-function
- AssertEquals ("test#01", 25, T.Select ("age = 5*5") [0]["age"]);
-
+ AssertEquals ("test#01", 25, T.Select ("age = 5*5") [0]["age"]);
AssertEquals ("test#02", 901, T.Select ("len(name) > 7").Length);
-
AssertEquals ("test#03", 125, T.Select ("age = 5*5*5 AND len(name)>7") [0]["age"]);
-
- AssertEquals ("test#04", 1, T.Select ("isnull(id, 'test') = 'test'").Length);
-
- AssertEquals ("test#05", 1000, T.Select ("iif(id = '56', 'test', 'false') = 'false'").Length);
+ AssertEquals ("test#04", 1, T.Select ("isnull(id, 'test') = 'test'").Length);
+ AssertEquals ("test#05", 1000, T.Select ("iif(id = '56', 'test', 'false') = 'false'").Length);
AssertEquals ("test#06", 1, T.Select ("iif(id = '56', 'test', 'false') = 'test'").Length);
AssertEquals ("test#07", 9, T.Select ("substring(id, 2, 3) = '23'").Length);
AssertEquals ("test#08", "123", T.Select ("substring(id, 2, 3) = '23'") [0] ["id"]);
}
- public void TestToString()
+ [Test]
+ public void SelectRelations ()
+ {
+ DataSet Set = new DataSet ();
+ DataTable Mom = new DataTable ("Mom");
+ DataTable Child = new DataTable ("Child");
+
+ Set.Tables.Add (Mom);
+ Set.Tables.Add (Child);
+
+ DataColumn Col = new DataColumn ("Name");
+ DataColumn Col2 = new DataColumn ("ChildName");
+ Mom.Columns.Add (Col);
+ Mom.Columns.Add (Col2);
+
+ DataColumn Col3 = new DataColumn ("Name");
+ DataColumn Col4 = new DataColumn ("Age");
+ Col4.DataType = Type.GetType ("System.Int16");
+ Child.Columns.Add (Col3);
+ Child.Columns.Add (Col4);
+
+ DataRelation Relation = new DataRelation ("Rel", Mom.Columns [1], Child.Columns [0]);
+ Set.Relations.Add (Relation);
+
+ DataRow Row = Mom.NewRow ();
+ Row [0] = "Laura";
+ Row [1] = "Nick";
+ Mom.Rows.Add (Row);
+
+ Row = Mom.NewRow ();
+ Row [0] = "Laura";
+ Row [1] = "Dick";
+ Mom.Rows.Add (Row);
+
+ Row = Mom.NewRow ();
+ Row [0] = "Laura";
+ Row [1] = "Mick";
+ Mom.Rows.Add (Row);
+
+ Row = Mom.NewRow ();
+ Row [0] = "Teresa";
+ Row [1] = "Jack";
+ Mom.Rows.Add (Row);
+
+ Row = Mom.NewRow ();
+ Row [0] = "Teresa";
+ Row [1] = "Mack";
+ Mom.Rows.Add (Row);
+
+ Row = Child.NewRow ();
+ Row [0] = "Nick";
+ Row [1] = 15;
+ Child.Rows.Add (Row);
+
+ Row = Child.NewRow ();
+ Row [0] = "Dick";
+ Row [1] = 25;
+ Child.Rows.Add (Row);
+
+ Row = Child.NewRow ();
+ Row [0] = "Mick";
+ Row [1] = 35;
+ Child.Rows.Add (Row);
+
+ Row = Child.NewRow ();
+ Row [0] = "Jack";
+ Row [1] = 10;
+ Child.Rows.Add (Row);
+
+ Row = Child.NewRow ();
+ Row [0] = "Mack";
+ Row [1] = 19;
+ Child.Rows.Add (Row);
+
+ Row = Child.NewRow ();
+ Row [0] = "Mack";
+ Row [1] = 99;
+ Child.Rows.Add (Row);
+
+ DataRow [] Rows = Child.Select ("name = Parent.Childname");
+ AssertEquals ("test#01", 6, Rows.Length);
+ Rows = Child.Select ("Parent.childname = 'Jack'");
+ AssertEquals ("test#02", 1, Rows.Length);
+
+ /*
+ try {
+ // FIXME: LAMESPEC: Why the exception is thrown why... why...
+ Mom.Select ("Child.Name = 'Jack'");
+ Fail ("test#03");
+ } catch (Exception e) {
+ AssertEquals ("test#04", typeof (SyntaxErrorException), e.GetType ());
+ AssertEquals ("test#05", "Cannot interpret token 'Child' at position 1.", e.Message);
+ }
+ */
+
+ Rows = Child.Select ("Parent.name = 'Laura'");
+ AssertEquals ("test#06", 3, Rows.Length);
+
+ DataTable Parent2 = new DataTable ("Parent2");
+ Col = new DataColumn ("Name");
+ Col2 = new DataColumn ("ChildName");
+
+ Parent2.Columns.Add (Col);
+ Parent2.Columns.Add (Col2);
+ Set.Tables.Add (Parent2);
+
+ Row = Parent2.NewRow ();
+ Row [0] = "Laura";
+ Row [1] = "Nick";
+ Parent2.Rows.Add (Row);
+
+ Row = Parent2.NewRow ();
+ Row [0] = "Laura";
+ Row [1] = "Dick";
+ Parent2.Rows.Add (Row);
+
+ Row = Parent2.NewRow ();
+ Row [0] = "Laura";
+ Row [1] = "Mick";
+ Parent2.Rows.Add (Row);
+
+ Row = Parent2.NewRow ();
+ Row [0] = "Teresa";
+ Row [1] = "Jack";
+ Parent2.Rows.Add (Row);
+
+ Row = Parent2.NewRow ();
+ Row [0] = "Teresa";
+ Row [1] = "Mack";
+ Parent2.Rows.Add (Row);
+
+ Relation = new DataRelation ("Rel2", Parent2.Columns [1], Child.Columns [0]);
+ Set.Relations.Add (Relation);
+
+ try {
+ Rows = Child.Select ("Parent.ChildName = 'Jack'");
+ Fail ("test#07");
+ } catch (Exception e) {
+ AssertEquals ("test#08", typeof (EvaluateException), e.GetType ());
+ //AssertEquals ("test#09", "The table [Child] involved in more than one relation. You must explicitly mention a relation name in the expression 'parent.[ChildName]'.", e.Message);
+ }
+
+ Rows = Child.Select ("Parent(rel).ChildName = 'Jack'");
+ AssertEquals ("test#10", 1, Rows.Length);
+
+ Rows = Child.Select ("Parent(Rel2).ChildName = 'Jack'");
+ AssertEquals ("test#10", 1, Rows.Length);
+
+ try {
+ Mom.Select ("Parent.name = 'John'");
+ } catch (Exception e) {
+ AssertEquals ("test#11", typeof (IndexOutOfRangeException), e.GetType ());
+ AssertEquals ("test#12", "Cannot find relation 0.", e.Message);
+ }
+
+ }
+
+ [Test]
+ public void SelectRowState()
+ {
+ DataTable d = new DataTable();
+ d.Columns.Add (new DataColumn ("aaa"));
+ DataRow [] rows = d.Select (null, null, DataViewRowState.Deleted);
+ AssertEquals(0, rows.Length);
+ d.Rows.Add (new object [] {"bbb"});
+ d.Rows.Add (new object [] {"bbb"});
+ rows = d.Select (null, null, DataViewRowState.Deleted);
+ AssertEquals(0, rows.Length);
+ }
+
+ [Test]
+ public void ToStringTest()
{
DataTable dt = new DataTable();
dt.Columns.Add("Col1",typeof(int));
- dt.TableName = "Myzable";
+ dt.TableName = "Mytable";
dt.DisplayExpression = "Col1";
- string cmpr = dt.TableName + " " + dt.DisplayExpression;
- Assertion.AssertEquals(cmpr,dt.ToString());
+ string cmpr = dt.TableName + " + " + dt.DisplayExpression;
+ AssertEquals(cmpr,dt.ToString());
+ }
+
+ [Test]
+ public void PrimaryKey ()
+ {
+ DataTable dt = new DataTable ();
+ DataColumn Col = new DataColumn ();
+ Col.AllowDBNull = false;
+ Col.DataType = typeof (int);
+ dt.Columns.Add (Col);
+ dt.Columns.Add ();
+ dt.Columns.Add ();
+ dt.Columns.Add ();
+
+ AssertEquals ("test#01", 0, dt.PrimaryKey.Length);
+
+ dt.PrimaryKey = new DataColumn [] {dt.Columns [0]};
+ AssertEquals ("test#02", 1, dt.PrimaryKey.Length);
+ AssertEquals ("test#03", "Column1", dt.PrimaryKey [0].ColumnName);
+
+ dt.PrimaryKey = null;
+ AssertEquals ("test#04", 0, dt.PrimaryKey.Length);
+
+ Col = new DataColumn ("failed");
+
+ try {
+ dt.PrimaryKey = new DataColumn [] {Col};
+ Fail ("test#05");
+ } catch (Exception e) {
+ AssertEquals ("test#06", typeof (ArgumentException), e.GetType ());
+ AssertEquals ("test#07", "Column must belong to a table.", e.Message);
+ }
+
+ DataTable dt2 = new DataTable ();
+ dt2.Columns.Add ();
+
+ try {
+ dt.PrimaryKey = new DataColumn [] {dt2.Columns [0]};
+ Fail ("test#08");
+ } catch (Exception e) {
+ AssertEquals ("test#09", typeof (ArgumentException), e.GetType ());
+ AssertEquals ("test#10", "PrimaryKey columns do not belong to this table.", e.Message);
+ }
+
+
+ AssertEquals ("test#11", 0, dt.Constraints.Count);
+
+ dt.PrimaryKey = new DataColumn [] {dt.Columns [0], dt.Columns [1]};
+ AssertEquals ("test#12", 2, dt.PrimaryKey.Length);
+ AssertEquals ("test#13", 1, dt.Constraints.Count);
+ AssertEquals ("test#14", true, dt.Constraints [0] is UniqueConstraint);
+ AssertEquals ("test#15", "Column1", dt.PrimaryKey [0].ColumnName);
+ AssertEquals ("test#16", "Column2", dt.PrimaryKey [1].ColumnName);
+
+ }
+
+ [Test]
+ public void PropertyExceptions ()
+ {
+ DataSet set = new DataSet ();
+ DataTable table = new DataTable ();
+ DataTable table1 = new DataTable ();
+ 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 ();
+ col.ColumnName = "Name";
+ col.DataType = Type.GetType ("System.String");
+ table.Columns.Add (col);
+
+ 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);
+
+ DataRelation dr = new DataRelation ("DR", table.Columns[0], table1.Columns[0]);
+ set.Relations.Add (dr);
+
+ try {
+ table.CaseSensitive = true;
+ table1.CaseSensitive = true;
+ Fail ("#A01");
+ }
+ catch (Exception e) {
+ if (e.GetType () != typeof (AssertionException))
+ AssertEquals ("#A02", "Cannot change CaseSensitive or Locale property. This change would lead to at least one DataRelation or Constraint to have different Locale or CaseSensitive settings between its related tables.",e.Message);
+ else
+ Console.WriteLine (e);
+ }
+ try {
+ CultureInfo cultureInfo = new CultureInfo ("en-gb");
+ table.Locale = cultureInfo;
+ table1.Locale = cultureInfo;
+ Fail ("#A03");
+ }
+ catch (Exception e) {
+ if (e.GetType () != typeof (AssertionException))
+ AssertEquals ("#A04", "Cannot change CaseSensitive or Locale property. This change would lead to at least one DataRelation or Constraint to have different Locale or CaseSensitive settings between its related tables.",e.Message);
+ else
+ Console.WriteLine (e);
+ }
+ try {
+ table.Prefix = "Prefix#1";
+ Fail ("#A05");
+ }
+ catch (Exception e){
+ if (e.GetType () != typeof (AssertionException))
+ AssertEquals ("#A06", "Prefix 'Prefix#1' is not valid, because it contains special characters.",e.Message);
+ else
+ Console.WriteLine (e);
+
+ }
+ }
+
+ [Test]
+ public void GetErrors ()
+ {
+ DataTable table = new DataTable ();
+
+ DataColumn col = new DataColumn ();
+ 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");
+ table.Columns.Add (col);
+
+ DataRow row = table.NewRow ();
+ row ["Id"] = 147;
+ row ["name"] = "Abc";
+ row.RowError = "Error#1";
+ table.Rows.Add (row);
+
+ AssertEquals ("#A01", 1, table.GetErrors ().Length);
+ AssertEquals ("#A02", "Error#1", (table.GetErrors ())[0].RowError);
+ }
+ [Test]
+ public void CloneCopyTest ()
+ {
+ DataTable table = new DataTable ();
+ table.TableName = "Table#1";
+ DataTable table1 = new DataTable ();
+ table1.TableName = "Table#2";
+
+ table.AcceptChanges ();
+
+ DataSet set = new DataSet ("Data Set#1");
+ set.DataSetName = "Dataset#1";
+ 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);
+
+ 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");
+ table.Columns.Add (col);
+
+ col = new DataColumn ();
+ col.ColumnName = "Name";
+ col.DataType = Type.GetType ("System.String");
+ table1.Columns.Add (col);
+ DataRow row = table.NewRow ();
+ row ["Id"] = 147;
+ row ["name"] = "Abc";
+ row.RowError = "Error#1";
+ table.Rows.Add (row);
+
+ row = table.NewRow ();
+ row ["Id"] = 47;
+ row ["name"] = "Efg";
+ table.Rows.Add (row);
+ table.AcceptChanges ();
+
+ table.CaseSensitive = true;
+ table1.CaseSensitive = true;
+ table.MinimumCapacity = 100;
+ table.Prefix = "PrefixNo:1";
+ table.Namespace = "Namespace#1";
+ table.DisplayExpression = "Id / Name + (Id * Id)";
+ DataColumn[] colArray = {table.Columns[0]};
+ table.PrimaryKey = colArray;
+ table.ExtendedProperties.Add ("TimeStamp", DateTime.Now);
+#if NET_1_1 // This prevents further tests after .NET 1.1.
+#else
+ CultureInfo cultureInfo = new CultureInfo ("en-gb");
+ table.Locale = cultureInfo;
+#endif
+
+ row = table1.NewRow ();
+ row ["Name"] = "Abc";
+ row ["Id"] = 147;
+ table1.Rows.Add (row);
+
+ row = table1.NewRow ();
+ row ["Id"] = 47;
+ row ["Name"] = "Efg";
+ table1.Rows.Add (row);
+
+ DataRelation dr = new DataRelation ("DR", table.Columns[0], table1.Columns[0]);
+ set.Relations.Add (dr);
+
+ //Testing properties of clone
+ DataTable cloneTable = table.Clone ();
+ AssertEquals ("#A01",true ,cloneTable.CaseSensitive);
+ AssertEquals ("#A02", 0 , cloneTable.ChildRelations.Count);
+ AssertEquals ("#A03", 0 , cloneTable.ParentRelations.Count);
+ AssertEquals ("#A04", 2, cloneTable.Columns.Count);
+ AssertEquals ("#A05", 1, cloneTable.Constraints.Count);
+ AssertEquals ("#A06", "Id / Name + (Id * Id)", cloneTable.DisplayExpression);
+ AssertEquals ("#A07", 1 ,cloneTable.ExtendedProperties.Count);
+ AssertEquals ("#A08", false ,cloneTable.HasErrors);
+#if NET_1_1
+#else
+ AssertEquals ("#A09", 2057, cloneTable.Locale.LCID);
+#endif
+ AssertEquals ("#A10", 100, cloneTable.MinimumCapacity);
+ AssertEquals ("#A11","Namespace#1", cloneTable.Namespace);
+ AssertEquals ("#A12", "PrefixNo:1",cloneTable.Prefix);
+ AssertEquals ("#A13", "Id", cloneTable.PrimaryKey[0].ColumnName);
+ AssertEquals ("#A14",0 , cloneTable.Rows.Count );
+ AssertEquals ("#A15", "Table#1", cloneTable.TableName);
+
+ //Testing properties of copy
+ DataTable copyTable = table.Copy ();
+ AssertEquals ("#A16",true ,copyTable.CaseSensitive);
+ AssertEquals ("#A17", 0 , copyTable.ChildRelations.Count);
+ AssertEquals ("#A18", 0 , copyTable.ParentRelations.Count);
+ AssertEquals ("#A19", 2, copyTable.Columns.Count);
+ AssertEquals ("#A20", 1, copyTable.Constraints.Count);
+ AssertEquals ("#A21", "Id / Name + (Id * Id)", copyTable.DisplayExpression);
+ AssertEquals ("#A22", 1 ,copyTable.ExtendedProperties.Count);
+ AssertEquals ("#A23", true ,copyTable.HasErrors);
+#if NET_1_1
+#else
+ AssertEquals ("#A24", 2057, copyTable.Locale.LCID);
+#endif
+ AssertEquals ("#A25", 100, copyTable.MinimumCapacity);
+ AssertEquals ("#A26","Namespace#1", copyTable.Namespace);
+ AssertEquals ("#A27", "PrefixNo:1",copyTable.Prefix);
+ AssertEquals ("#A28", "Id", copyTable.PrimaryKey[0].ColumnName);
+ AssertEquals ("#A29", 2 , copyTable.Rows.Count );
+ AssertEquals ("#A30", "Table#1", copyTable.TableName);
+ }
+
+ [Test]
+ public void LoadDataException ()
+ {
+ DataTable table = new DataTable ();
+ DataColumn col = new DataColumn ();
+ col.ColumnName = "Id";
+ col.DataType = Type.GetType ("System.Int32");
+ col.DefaultValue = 47;
+ table.Columns.Add (col);
+ UniqueConstraint uc = new UniqueConstraint ("UK1", table.Columns[0] );
+ table.Constraints.Add (uc);
+
+ col = new DataColumn ();
+ col.ColumnName = "Name";
+ col.DataType = Type.GetType ("System.String");
+ col.DefaultValue = "Hello";
+ table.Columns.Add (col);
+
+ table.BeginLoadData();
+ object[] row = {147, "Abc"};
+ DataRow newRow = table.LoadDataRow (row, true);
+
+ object[] row1 = {147, "Efg"};
+ DataRow newRow1 = table.LoadDataRow (row1, true);
+
+ object[] row2 = {143, "Hij"};
+ DataRow newRow2 = table.LoadDataRow (row2, true);
+
+ try {
+ table.EndLoadData ();
+ Fail ("#A01");
+ }
+ catch (ConstraintException) {
+ }
+ }
+ [Test]
+ public void Changes () //To test GetChanges and RejectChanges
+ {
+ DataTable table = new DataTable ();
+
+ 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);
+
+ 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";
+ table.Rows.Add (row);
+ table.AcceptChanges ();
+
+ row = table.NewRow ();
+ row ["Id"] = 47;
+ row ["name"] = "Efg";
+ table.Rows.Add (row);
+
+ //Testing GetChanges
+ DataTable changesTable = table.GetChanges ();
+ AssertEquals ("#A01", 1 ,changesTable.Rows.Count);
+ AssertEquals ("#A02","Efg" ,changesTable.Rows[0]["Name"]);
+ table.AcceptChanges ();
+ changesTable = table.GetChanges ();
+ try {
+ int cnt = changesTable.Rows.Count;
+ }
+ catch(Exception e) {
+ if (e.GetType () != typeof (AssertionException))
+ AssertEquals ("#A03",typeof(NullReferenceException) ,e.GetType ());
+ else
+ Console.WriteLine (e);
+ }
+
+ //Testing RejectChanges
+ row = table.NewRow ();
+ row ["Id"] = 247;
+ row ["name"] = "Hij";
+ table.Rows.Add (row);
+
+ (table.Rows [0])["Name"] = "AaBbCc";
+ table.RejectChanges ();
+ AssertEquals ("#A03", "Abc" , (table.Rows [0]) ["Name"]);
+ AssertEquals ("#A04", 2, table.Rows.Count);
+ }
+
+ [Test]
+ public void ImportRowTest ()
+ {
+ // build source table
+ DataTable src = new DataTable ();
+ src.Columns.Add ("id", typeof (int));
+ src.Columns.Add ("name", typeof (string));
+
+ src.PrimaryKey = new DataColumn [] {src.Columns [0]} ;
+
+ src.Rows.Add (new object [] { 1, "mono 1" });
+ src.Rows.Add (new object [] { 2, "mono 2" });
+ src.Rows.Add (new object [] { 3, "mono 3" });
+ src.AcceptChanges ();
+
+ src.Rows [0] [1] = "mono changed 1"; // modify 1st row
+ src.Rows [1].Delete (); // delete 2nd row
+ // 3rd row is unchanged
+ src.Rows.Add (new object [] { 4, "mono 4" }); // add 4th row
+
+ // build target table
+ DataTable target = new DataTable ();
+ target.Columns.Add ("id", typeof (int));
+ target.Columns.Add ("name", typeof (string));
+
+ target.PrimaryKey = new DataColumn [] {target.Columns [0]} ;
+
+ // import all rows
+ target.ImportRow (src.Rows [0]); // import 1st row
+ target.ImportRow (src.Rows [1]); // import 2nd row
+ target.ImportRow (src.Rows [2]); // import 3rd row
+ target.ImportRow (src.Rows [3]); // import 4th row
+
+ try {
+ target.ImportRow (src.Rows [2]); // import 3rd row again
+ Fail ("#AA1 Should have thrown exception violativ PK");
+ } catch (ConstraintException e) {}
+
+ // check row states
+ AssertEquals ("#A1", src.Rows [0].RowState, target.Rows [0].RowState);
+ AssertEquals ("#A2", src.Rows [1].RowState, target.Rows [1].RowState);
+ AssertEquals ("#A3", src.Rows [2].RowState, target.Rows [2].RowState);
+ AssertEquals ("#A4", src.Rows [3].RowState, target.Rows [3].RowState);
+
+ // check for modified row (1st row)
+ AssertEquals ("#B1", (string) src.Rows [0] [1], (string) target.Rows [0] [1]);
+ AssertEquals ("#B2", (string) src.Rows [0] [1, DataRowVersion.Default], (string) target.Rows [0] [1, DataRowVersion.Default]);
+ AssertEquals ("#B3", (string) src.Rows [0] [1, DataRowVersion.Original], (string) target.Rows [0] [1, DataRowVersion.Original]);
+ AssertEquals ("#B4", (string) src.Rows [0] [1, DataRowVersion.Current], (string) target.Rows [0] [1, DataRowVersion.Current]);
+ AssertEquals ("#B5", false, target.Rows [0].HasVersion(DataRowVersion.Proposed));
+
+ // check for deleted row (2nd row)
+ AssertEquals ("#C1", (string) src.Rows [1] [1, DataRowVersion.Original], (string) target.Rows [1] [1, DataRowVersion.Original]);
+
+ // check for unchanged row (3rd row)
+ AssertEquals ("#D1", (string) src.Rows [2] [1], (string) target.Rows [2] [1]);
+ AssertEquals ("#D2", (string) src.Rows [2] [1, DataRowVersion.Default], (string) target.Rows [2] [1, DataRowVersion.Default]);
+ AssertEquals ("#D3", (string) src.Rows [2] [1, DataRowVersion.Original], (string) target.Rows [2] [1, DataRowVersion.Original]);
+ AssertEquals ("#D4", (string) src.Rows [2] [1, DataRowVersion.Current], (string) target.Rows [2] [1, DataRowVersion.Current]);
+
+ // check for newly added row (4th row)
+ AssertEquals ("#E1", (string) src.Rows [3] [1], (string) target.Rows [3] [1]);
+ AssertEquals ("#E2", (string) src.Rows [3] [1, DataRowVersion.Default], (string) target.Rows [3] [1, DataRowVersion.Default]);
+ AssertEquals ("#E3", (string) src.Rows [3] [1, DataRowVersion.Current], (string) target.Rows [3] [1, DataRowVersion.Current]);
+ }
+
+ [Test]
+ public void ImportRowDetachedTest ()
+ {
+ DataTable table = new DataTable ();
+ DataColumn col = new DataColumn ();
+ col.ColumnName = "Id";
+ col.DataType = Type.GetType ("System.Int32");
+ table.Columns.Add (col);
+
+ 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);
+
+ //if RowState is detached, then dont import the row.
+ AssertEquals ("#1", 0, table.Rows.Count);
+ }
+
+ [Test]
+ [Category ("NotWorking")]
+ public void ImportRowDeletedTest ()
+ {
+ DataTable table = new DataTable ();
+ table.Columns.Add ("col", typeof (int));
+ table.Columns.Add ("col1", typeof (int));
+
+ DataRow row = table.Rows.Add (new object[] {1,2});
+ table.PrimaryKey = new DataColumn[] {table.Columns[0]};
+ table.AcceptChanges ();
+
+ // If row is in Deleted state, then ImportRow loads the
+ // row.
+ row.Delete ();
+ table.ImportRow (row);
+ AssertEquals ("#1", 2, table.Rows.Count);
+
+ // Both the deleted rows shud be now gone
+ table.AcceptChanges ();
+ AssertEquals ("#2", 0, table.Rows.Count);
+
+ //just add another row
+ row = table.Rows.Add (new object[] {1,2});
+ // no exception shud be thrown
+ table.AcceptChanges ();
+
+ // If row is in Deleted state, then ImportRow loads the
+ // row and validate only on RejectChanges
+ row.Delete ();
+ table.ImportRow (row);
+ AssertEquals ("#3", 2, table.Rows.Count);
+ AssertEquals ("#4", DataRowState.Deleted, table.Rows[1].RowState);
+
+ //FIXME : Currenty this fails.
+ try {
+ table.RejectChanges ();
+ Fail ("#5");
+ } catch (ConstraintException e) {
+ }
+ }
+
+ [Test]
+ public void ClearReset () //To test Clear and Reset methods
+ {
+ DataTable table = new DataTable ("table");
+ DataTable table1 = new DataTable ("table1");
+
+ DataSet set = new DataSet ();
+ set.Tables.Add (table);
+ set.Tables.Add (table1);
+
+ 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 ();
+ row ["Id"] = 147;
+ row ["name"] = "Roopa";
+ table.Rows.Add (row);
+
+ row = table.NewRow ();
+ row ["Id"] = 47;
+ row ["Name"] = "roopa";
+ table.Rows.Add (row);
+
+ AssertEquals (2, table.Rows.Count);
+ AssertEquals (1, table.ChildRelations.Count);
+ try {
+ table.Reset ();
+ Fail ("#A01, should have thrown ArgumentException");
+ }
+ catch (ArgumentException) {
+ }
+ AssertEquals ("#CT01", 0, table.Rows.Count);
+ AssertEquals ("#CT02", 0, table.ChildRelations.Count);
+ AssertEquals ("#CT03", 0, table.ParentRelations.Count);
+ AssertEquals ("#CT04", 0, table.Constraints.Count);
+
+ 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", 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 ()
+ {
+ MemoryStream fs = new MemoryStream ();
+
+ // Construct a BinaryFormatter and use it
+ // to serialize the data to the stream.
+ BinaryFormatter formatter = new BinaryFormatter();
+
+ // Create an array with multiple elements refering to
+ // the one Singleton object.
+ DataTable dt = new DataTable();
+
+
+ dt.Columns.Add(new DataColumn("Id", typeof(string)));
+ dt.Columns.Add(new DataColumn("ContactName", typeof(string)));
+ dt.Columns.Add(new DataColumn("ContactTitle", typeof(string)));
+ dt.Columns.Add(new DataColumn("ContactAreaCode", typeof(string)));
+ dt.Columns.Add(new DataColumn("ContactPhone", typeof(string)));
+
+ DataRow loRowToAdd;
+ loRowToAdd = dt.NewRow();
+ loRowToAdd[0] = "a";
+ loRowToAdd[1] = "b";
+ loRowToAdd[2] = "c";
+ loRowToAdd[3] = "d";
+ loRowToAdd[4] = "e";
+
+ dt.Rows.Add(loRowToAdd);
+
+ DataTable[] dtarr = new DataTable[] {dt};
+
+ // Serialize the array elements.
+ formatter.Serialize(fs, dtarr);
+
+ // Deserialize the array elements.
+ fs.Position = 0;
+ DataTable[] a2 = (DataTable[]) formatter.Deserialize(fs);
+
+ DataSet ds = new DataSet();
+ ds.Tables.Add(a2[0]);
+
+ StringWriter sw = new StringWriter ();
+ ds.WriteXml(sw);
+ XmlDocument doc = new XmlDocument ();
+ doc.LoadXml (sw.ToString ());
+ AssertEquals (5, doc.DocumentElement.FirstChild.ChildNodes.Count);
+ }
+
+ [Test]
+ [ExpectedException (typeof (DataException))]
+ 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});
+ }
+
+ [Test]
+ public void PrimaryKey_CheckSetsAllowDBNull ()
+ {
+ DataTable table = new DataTable ();
+ DataColumn col1 = table.Columns.Add ("col1", typeof (int));
+ DataColumn col2 = table.Columns.Add ("col2", typeof (int));
+
+ AssertEquals ("#1" , true, col1.AllowDBNull);
+ AssertEquals ("#2" , true, col2.AllowDBNull);
+ AssertEquals ("#3" , false, col2.Unique);
+ AssertEquals ("#4" , false, col2.Unique);
+
+ table.PrimaryKey = new DataColumn[] {col1,col2};
+ AssertEquals ("#5" , false, col1.AllowDBNull);
+ AssertEquals ("#6" , false, col2.AllowDBNull);
+ // LAMESPEC or bug ??
+ AssertEquals ("#7" , false, col1.Unique);
+ AssertEquals ("#8" , false, col2.Unique);
+ }
+
+ 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()
+ {
+ MyDataTable dt1 = new MyDataTable();
+ 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);
+
+ }
+ }
+
+ [Test]
+ public void ColumnObjectTypeTest() {
+ DataTable dt = new DataTable();\r
+ dt.Columns.Add("Series Label", typeof(SqlInt32));\r
+ dt.Rows.Add(new object[] {"sss"});
+ AssertEquals(1, dt.Rows.Count);
+ }
+
+ public void OnRowChanging (object src, DataRowChangeEventArgs args)
+ {
+ rowActionChanging = args.Action;
+ }
+
+ public void OnRowChanged (object src, DataRowChangeEventArgs args)
+ {
+ rowActionChanged = args.Action;
+ }
+
+
+ }
+
+
+ public class MyDataTable:DataTable {
+
+ public static int count = 0;
+
+ public MyDataTable() {
+
+ count++;
+ }
+
+ }
+
+ [Serializable]
+ [TestFixture]
+ public class AppDomainsAndFormatInfo
+ {
+ public void Remote ()
+ {
+ int n = (int) Convert.ChangeType ("5", typeof (int));
+ Assertion.AssertEquals ("n", 5, n);
+ }
+#if !TARGET_JVM
+ [Test]
+ public void NFIFromBug55978 ()
+ {
+ AppDomain domain = AppDomain.CreateDomain ("testdomain");
+ AppDomainsAndFormatInfo test = new AppDomainsAndFormatInfo ();
+ test.Remote ();
+ domain.DoCallBack (new CrossAppDomainDelegate (test.Remote));
+ AppDomain.Unload (domain);
+ }
+#endif
+
+ [Test]
+ public void Bug55978 ()
+ {
+ DataTable dt = new DataTable ();
+ dt.Columns.Add ("StartDate", typeof (DateTime));
+
+ DataRow dr;
+ DateTime date = DateTime.Now;
+
+ for (int i = 0; i < 10; i++) {
+ dr = dt.NewRow ();
+ dr ["StartDate"] = date.AddDays (i);
+ dt.Rows.Add (dr);
+ }
+
+ DataView dv = dt.DefaultView;
+ dv.RowFilter = "StartDate >= '" + DateTime.Now.AddDays (2) + "' and StartDate <= '" + DateTime.Now.AddDays (4) + "'";
+ Assertion.AssertEquals ("Table", 10, dt.Rows.Count);
+ Assertion.AssertEquals ("View", 2, dv.Count);
}
}
}
projects / mono.git / blobdiff