You've already forked linux-packaging-mono
664 lines
22 KiB
C#
664 lines
22 KiB
C#
// DataColumnCollectionTest.cs - NUnit Test Cases for System.Data.DataColumnCollection
|
|
//
|
|
// Authors:
|
|
// Franklin Wise <gracenote@earthlink.net>
|
|
// Ville Palo <vi64pa@kolumbus.fi>
|
|
// Martin Willemoes Hansen <mwh@sysrq.dk>
|
|
//
|
|
// (C) Copyright 2002 Franklin Wise
|
|
// (C) Copyright 2003 Ville Palo
|
|
// (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;
|
|
using System.Xml;
|
|
|
|
namespace MonoTests.System.Data
|
|
{
|
|
[TestFixture]
|
|
public class DataColumnCollectionTest
|
|
{
|
|
//private DataTable _tbl;
|
|
|
|
[SetUp]
|
|
public void GetReady ()
|
|
{
|
|
//_tbl = new DataTable();
|
|
}
|
|
|
|
//TODO
|
|
[Test]
|
|
public void AddValidationExceptions()
|
|
{
|
|
|
|
//Set DefaultValue and AutoIncr == true
|
|
//And get an exception
|
|
}
|
|
|
|
[Test]
|
|
public void Add ()
|
|
{
|
|
DataTable Table = new DataTable ("test_table");
|
|
DataColumnCollection Cols = Table.Columns;
|
|
DataColumn C = null;
|
|
Cols.Add ();
|
|
Cols.Add ();
|
|
|
|
C = Cols [0];
|
|
Assert.IsTrue (C.AllowDBNull, "test#01");
|
|
Assert.IsFalse (C.AutoIncrement, "test#02");
|
|
Assert.AreEqual (0L, C.AutoIncrementSeed, "test#03");
|
|
Assert.AreEqual (1L, C.AutoIncrementStep, "test#04");
|
|
Assert.AreEqual ("Column1", C.Caption, "test#05");
|
|
Assert.AreEqual ("Element", C.ColumnMapping.ToString (), "test#06");
|
|
Assert.AreEqual ("Column1", C.ColumnName, "test#07");
|
|
Assert.IsNull (C.Container, "test#08");
|
|
Assert.AreEqual (typeof (string), C.DataType, "test#09");
|
|
Assert.AreEqual (DBNull.Value, C.DefaultValue, "test#10");
|
|
Assert.IsFalse (C.DesignMode, "test#11");
|
|
Assert.AreEqual ("", C.Expression, "test#12");
|
|
Assert.AreEqual (0, C.ExtendedProperties.Count, "test#13");
|
|
Assert.AreEqual (-1, C.MaxLength, "test#14");
|
|
Assert.AreEqual ("", C.Namespace, "test#15");
|
|
Assert.AreEqual (0, C.Ordinal, "test#16");
|
|
Assert.AreEqual ("", C.Prefix, "test#17");
|
|
Assert.IsFalse (C.ReadOnly, "test#18");
|
|
Assert.IsNull (C.Site, "test#19");
|
|
Assert.AreEqual ("test_table", C.Table.TableName, "test#20");
|
|
Assert.AreEqual ("Column1", C.ToString (), "test#21");
|
|
Assert.IsFalse (C.Unique, "test#22");
|
|
|
|
C = Cols [1];
|
|
Assert.IsTrue (C.AllowDBNull, "test#23");
|
|
Assert.IsFalse (C.AutoIncrement, "test#24");
|
|
Assert.AreEqual (0L, C.AutoIncrementSeed, "test#25");
|
|
Assert.AreEqual (1L, C.AutoIncrementStep, "test#26");
|
|
Assert.AreEqual ("Column2", C.Caption, "test#27");
|
|
Assert.AreEqual ("Element", C.ColumnMapping.ToString (), "test#28");
|
|
Assert.AreEqual ("Column2", C.ColumnName, "test#29");
|
|
Assert.IsNull (C.Container, "test#30");
|
|
Assert.AreEqual (typeof (string), C.DataType, "test#31");
|
|
Assert.AreEqual (DBNull.Value, C.DefaultValue, "test#32");
|
|
Assert.IsFalse (C.DesignMode, "test#33");
|
|
Assert.AreEqual ("", C.Expression, "test#34");
|
|
Assert.AreEqual (0, C.ExtendedProperties.Count, "test#35");
|
|
Assert.AreEqual (-1, C.MaxLength, "test#36");
|
|
Assert.AreEqual ("", C.Namespace, "test#37");
|
|
Assert.AreEqual (1, C.Ordinal, "test#38");
|
|
Assert.AreEqual ("", C.Prefix, "test#39");
|
|
Assert.IsFalse (C.ReadOnly, "test#40");
|
|
Assert.IsNull (C.Site, "test#41");
|
|
Assert.AreEqual ("test_table", C.Table.TableName, "test#42");
|
|
Assert.AreEqual ("Column2", C.ToString (), "test#43");
|
|
Assert.IsFalse (C.Unique, "test#44");
|
|
|
|
Cols.Add ("test1", typeof (int), "");
|
|
Cols.Add ("test2", typeof (string), "Column1 + Column2");
|
|
|
|
C = Cols [2];
|
|
Assert.IsTrue (C.AllowDBNull, "test#45");
|
|
Assert.IsFalse (C.AutoIncrement, "test#46");
|
|
Assert.AreEqual (0L, C.AutoIncrementSeed, "test#47");
|
|
Assert.AreEqual (1L, C.AutoIncrementStep, "test#48");
|
|
Assert.AreEqual ("test1", C.Caption, "test#49");
|
|
Assert.AreEqual ("Element", C.ColumnMapping.ToString (), "test#50");
|
|
Assert.AreEqual ("test1", C.ColumnName, "test#51");
|
|
Assert.IsNull (C.Container, "test#52");
|
|
Assert.AreEqual (typeof (int), C.DataType, "test#53");
|
|
Assert.AreEqual (DBNull.Value, C.DefaultValue, "test#54");
|
|
Assert.IsFalse (C.DesignMode, "test#55");
|
|
Assert.AreEqual ("", C.Expression, "test#56");
|
|
Assert.AreEqual (0, C.ExtendedProperties.Count, "test#57");
|
|
Assert.AreEqual (-1, C.MaxLength, "test#58");
|
|
Assert.AreEqual ("", C.Namespace, "test#59");
|
|
Assert.AreEqual (2, C.Ordinal, "test#60");
|
|
Assert.AreEqual ("", C.Prefix, "test#61");
|
|
Assert.IsFalse (C.ReadOnly, "test#62");
|
|
Assert.IsNull (C.Site, "test#63");
|
|
Assert.AreEqual ("test_table", C.Table.TableName, "test#64");
|
|
Assert.AreEqual ("test1", C.ToString (), "test#65");
|
|
Assert.IsFalse (C.Unique, "test#66");
|
|
|
|
C = Cols [3];
|
|
Assert.IsTrue (C.AllowDBNull, "test#67");
|
|
Assert.IsFalse (C.AutoIncrement, "test#68");
|
|
Assert.AreEqual (0L, C.AutoIncrementSeed, "test#69");
|
|
Assert.AreEqual (1L, C.AutoIncrementStep, "test#70");
|
|
Assert.AreEqual ("test2", C.Caption, "test#71");
|
|
Assert.AreEqual ("Element", C.ColumnMapping.ToString (), "test#72");
|
|
Assert.AreEqual ("test2", C.ColumnName, "test#73");
|
|
Assert.IsNull (C.Container, "test#74");
|
|
Assert.AreEqual (typeof (string), C.DataType, "test#75");
|
|
Assert.AreEqual (DBNull.Value, C.DefaultValue, "test#76");
|
|
Assert.IsFalse (C.DesignMode, "test#77");
|
|
Assert.AreEqual ("Column1 + Column2", C.Expression, "test#78");
|
|
Assert.AreEqual (0, C.ExtendedProperties.Count, "test#79");
|
|
Assert.AreEqual (-1, C.MaxLength, "test#80");
|
|
Assert.AreEqual ("", C.Namespace, "test#81");
|
|
Assert.AreEqual (3, C.Ordinal, "test#82");
|
|
Assert.AreEqual ("", C.Prefix, "test#83");
|
|
Assert.IsTrue (C.ReadOnly, "test#84");
|
|
Assert.IsNull (C.Site, "test#85");
|
|
Assert.AreEqual ("test_table", C.Table.TableName, "test#86");
|
|
Assert.AreEqual ("test2 + Column1 + Column2", C.ToString (), "test#87");
|
|
Assert.IsFalse (C.Unique, "test#88");
|
|
|
|
C = new DataColumn ("test3", typeof (int));
|
|
Cols.Add (C);
|
|
|
|
C = Cols [4];
|
|
Assert.IsTrue (C.AllowDBNull, "test#89");
|
|
Assert.IsFalse (C.AutoIncrement, "test#90");
|
|
Assert.AreEqual (0L, C.AutoIncrementSeed, "test#91");
|
|
Assert.AreEqual (1L, C.AutoIncrementStep, "test#92");
|
|
Assert.AreEqual ("test3", C.Caption, "test#93");
|
|
Assert.AreEqual ("Element", C.ColumnMapping.ToString (), "test#94");
|
|
Assert.AreEqual ("test3", C.ColumnName, "test#95");
|
|
Assert.IsNull (C.Container, "test#96");
|
|
Assert.AreEqual (typeof (int), C.DataType, "test#97");
|
|
Assert.AreEqual (DBNull.Value, C.DefaultValue, "test#98");
|
|
Assert.IsFalse (C.DesignMode, "test#99");
|
|
Assert.AreEqual ("", C.Expression, "test#100");
|
|
Assert.AreEqual (0, C.ExtendedProperties.Count, "test#101");
|
|
Assert.AreEqual (-1, C.MaxLength, "test#102");
|
|
Assert.AreEqual ("", C.Namespace, "test#103");
|
|
Assert.AreEqual (4, C.Ordinal, "test#104");
|
|
Assert.AreEqual ("", C.Prefix, "test#105");
|
|
Assert.IsFalse (C.ReadOnly, "test#106");
|
|
Assert.IsNull (C.Site, "test#107");
|
|
Assert.AreEqual ("test_table", C.Table.TableName, "test#108");
|
|
Assert.AreEqual ("test3", C.ToString (), "test#109");
|
|
Assert.IsFalse (C.Unique, "test#110");
|
|
}
|
|
|
|
[Test] // Add (String)
|
|
public void Add3_ColumnName_Empty ()
|
|
{
|
|
DataTable table = new DataTable ();
|
|
DataColumnCollection cols = table.Columns;
|
|
DataColumn col;
|
|
|
|
col = cols.Add (string.Empty);
|
|
Assert.AreEqual (1, cols.Count, "#A1");
|
|
Assert.AreEqual ("Column1", col.ColumnName, "#A2");
|
|
Assert.AreSame (table, col.Table, "#A3");
|
|
|
|
col = cols.Add (string.Empty);
|
|
Assert.AreEqual (2, cols.Count, "#B1");
|
|
Assert.AreEqual ("Column2", col.ColumnName, "#B2");
|
|
Assert.AreSame (table, col.Table, "#B3");
|
|
|
|
cols.RemoveAt (1);
|
|
|
|
col = cols.Add (string.Empty);
|
|
Assert.AreEqual (2, cols.Count, "#C1");
|
|
Assert.AreEqual ("Column2", col.ColumnName, "#C2");
|
|
Assert.AreSame (table, col.Table, "#C3");
|
|
|
|
cols.Clear ();
|
|
|
|
col = cols.Add (string.Empty);
|
|
Assert.AreEqual (1, cols.Count, "#D1");
|
|
Assert.AreEqual ("Column1", col.ColumnName, "#D2");
|
|
Assert.AreSame (table, col.Table, "#D3");
|
|
}
|
|
|
|
[Test] // Add (String)
|
|
public void Add3_ColumnName_Null ()
|
|
{
|
|
DataTable table = new DataTable ();
|
|
DataColumnCollection cols = table.Columns;
|
|
DataColumn col;
|
|
|
|
col = cols.Add ((string) null);
|
|
Assert.AreEqual (1, cols.Count, "#A1");
|
|
Assert.AreEqual ("Column1", col.ColumnName, "#A2");
|
|
Assert.AreSame (table, col.Table, "#A3");
|
|
|
|
col = cols.Add ((string) null);
|
|
Assert.AreEqual (2, cols.Count, "#B1");
|
|
Assert.AreEqual ("Column2", col.ColumnName, "#B2");
|
|
Assert.AreSame (table, col.Table, "#B3");
|
|
|
|
cols.RemoveAt (1);
|
|
|
|
col = cols.Add ((string) null);
|
|
Assert.AreEqual (2, cols.Count, "#C1");
|
|
Assert.AreEqual ("Column2", col.ColumnName, "#C2");
|
|
Assert.AreSame (table, col.Table, "#C3");
|
|
|
|
cols.Clear ();
|
|
|
|
col = cols.Add ((string) null);
|
|
Assert.AreEqual (1, cols.Count, "#D1");
|
|
Assert.AreEqual ("Column1", col.ColumnName, "#D2");
|
|
Assert.AreSame (table, col.Table, "#D3");
|
|
}
|
|
|
|
[Test]
|
|
public void AddExceptions ()
|
|
{
|
|
DataTable Table = new DataTable ("test_table");
|
|
DataTable Table2 = new DataTable ("test_table2");
|
|
DataColumnCollection Cols = Table.Columns;
|
|
DataColumn C = null;
|
|
|
|
try {
|
|
Cols.Add (C);
|
|
Assert.Fail ("test#01");
|
|
} catch (Exception e) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), e.GetType (), "test#02");
|
|
}
|
|
|
|
C = new DataColumn ("test");
|
|
Cols.Add (C);
|
|
|
|
try {
|
|
Cols.Add (C);
|
|
Assert.Fail ("test#04");
|
|
} catch (ArgumentException e) {
|
|
// Assert.AreEqual (typeof (ArgumentException), e.GetType (), "test#05");
|
|
// Assert.AreEqual ("Column 'test' already belongs to this or another DataTable.", e.Message, "test#06");
|
|
}
|
|
|
|
try {
|
|
Table2.Columns.Add (C);
|
|
Assert.Fail ("test#07");
|
|
} catch (ArgumentException e) {
|
|
// Assert.AreEqual (typeof (ArgumentException), e.GetType (), "test#08");
|
|
// Assert.AreEqual ("Column 'test' already belongs to this or another DataTable.", e.Message, "test#09");
|
|
}
|
|
|
|
DataColumn C2 = new DataColumn ("test");
|
|
|
|
try {
|
|
Cols.Add (C2);
|
|
Assert.Fail ("test#10");
|
|
} catch (DuplicateNameException e) {
|
|
// Assert.AreEqual (typeof (DuplicateNameException), e.GetType (), "test#11");
|
|
// Assert.AreEqual ("A DataColumn named 'test' already belongs to this DataTable.", e.Message, "test#12");
|
|
}
|
|
|
|
try {
|
|
Cols.Add ("test2", typeof (string), "substring ('fdsafewq', 2)");
|
|
Assert.Fail ("test#13");
|
|
} catch (InvalidExpressionException e) {
|
|
// Assert.IsTrue (e is InvalidExpressionException, "test#14");
|
|
// Assert.AreEqual ("Expression 'substring ('fdsafewq', 2)' is invalid.", e.Message, "test#15");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void AddRange ()
|
|
{
|
|
DataTable Table = new DataTable ("test_table");
|
|
DataTable Table2 = new DataTable ("test_table2");
|
|
DataColumnCollection Cols = Table.Columns;
|
|
DataColumn C = null;
|
|
DataColumn [] ColArray = new DataColumn [2];
|
|
|
|
C = new DataColumn ("test1");
|
|
ColArray [0] = C;
|
|
|
|
C = new DataColumn ("test2");
|
|
C.AllowDBNull = false;
|
|
C.Caption = "Test_caption";
|
|
C.DataType = typeof (XmlReader);
|
|
ColArray [1] = C;
|
|
|
|
Cols.AddRange (ColArray);
|
|
|
|
C = Cols [0];
|
|
Assert.IsTrue (C.AllowDBNull, "test#01");
|
|
Assert.IsFalse (C.AutoIncrement, "test#02");
|
|
Assert.AreEqual (0L, C.AutoIncrementSeed, "test#03");
|
|
Assert.AreEqual (1L, C.AutoIncrementStep, "test#04");
|
|
Assert.AreEqual ("test1", C.Caption, "test#05");
|
|
Assert.AreEqual ("Element", C.ColumnMapping.ToString (), "test#06");
|
|
Assert.AreEqual ("test1", C.ColumnName, "test#07");
|
|
Assert.IsNull (C.Container, "test#08");
|
|
Assert.AreEqual (typeof (string), C.DataType, "test#09");
|
|
Assert.AreEqual (DBNull.Value, C.DefaultValue, "test#10");
|
|
Assert.IsFalse (C.DesignMode, "test#11");
|
|
Assert.AreEqual ("", C.Expression, "test#12");
|
|
Assert.AreEqual (0, C.ExtendedProperties.Count, "test#13");
|
|
Assert.AreEqual (-1, C.MaxLength, "test#14");
|
|
Assert.AreEqual ("", C.Namespace, "test#15");
|
|
Assert.AreEqual (0, C.Ordinal, "test#16");
|
|
Assert.AreEqual ("", C.Prefix, "test#17");
|
|
Assert.IsFalse (C.ReadOnly, "test#18");
|
|
Assert.IsNull (C.Site, "test#19");
|
|
Assert.AreEqual ("test_table", C.Table.TableName, "test#20");
|
|
Assert.AreEqual ("test1", C.ToString (), "test#21");
|
|
Assert.IsFalse (C.Unique, "test#22");
|
|
|
|
C = Cols [1];
|
|
Assert.IsFalse (C.AllowDBNull, "test#01");
|
|
Assert.IsFalse (C.AutoIncrement, "test#02");
|
|
Assert.AreEqual (0L, C.AutoIncrementSeed, "test#03");
|
|
Assert.AreEqual (1L, C.AutoIncrementStep, "test#04");
|
|
Assert.AreEqual ("Test_caption", C.Caption, "test#05");
|
|
Assert.AreEqual ("Element", C.ColumnMapping.ToString (), "test#06");
|
|
Assert.AreEqual ("test2", C.ColumnName, "test#07");
|
|
Assert.IsNull (C.Container, "test#08");
|
|
Assert.AreEqual (typeof (XmlReader), C.DataType, "test#09");
|
|
Assert.AreEqual (DBNull.Value, C.DefaultValue, "test#10");
|
|
Assert.IsFalse (C.DesignMode, "test#11");
|
|
Assert.AreEqual ("", C.Expression, "test#12");
|
|
Assert.AreEqual (0, C.ExtendedProperties.Count, "test#13");
|
|
Assert.AreEqual (-1, C.MaxLength, "test#14");
|
|
Assert.AreEqual ("", C.Namespace, "test#15");
|
|
Assert.AreEqual (1, C.Ordinal, "test#16");
|
|
Assert.AreEqual ("", C.Prefix, "test#17");
|
|
Assert.IsFalse (C.ReadOnly, "test#18");
|
|
Assert.IsNull (C.Site, "test#19");
|
|
Assert.AreEqual ("test_table", C.Table.TableName, "test#20");
|
|
Assert.AreEqual ("test2", C.ToString (), "test#21");
|
|
Assert.IsFalse (C.Unique, "test#22");
|
|
}
|
|
|
|
[Test]
|
|
public void CanRemove ()
|
|
{
|
|
DataTable Table = new DataTable ("test_table");
|
|
DataTable Table2 = new DataTable ("test_table_2");
|
|
DataColumnCollection Cols = Table.Columns;
|
|
DataColumn C = new DataColumn ("test1");
|
|
Cols.Add ();
|
|
|
|
// LAMESPEC: MSDN says that if C doesn't belong to Cols
|
|
// Exception is thrown.
|
|
Assert.IsFalse (Cols.CanRemove (C), "test#01");
|
|
|
|
Cols.Add (C);
|
|
Assert.IsTrue (Cols.CanRemove (C), "test#02");
|
|
|
|
C = new DataColumn ();
|
|
C.Expression = "test1 + 2";
|
|
Cols.Add (C);
|
|
|
|
C = Cols ["test2"];
|
|
Assert.IsFalse (Cols.CanRemove (C), "test#03");
|
|
|
|
C = new DataColumn ("t");
|
|
Table2.Columns.Add (C);
|
|
DataColumnCollection Cols2 = Table2.Columns;
|
|
Assert.IsTrue (Cols2.CanRemove (C), "test#04");
|
|
|
|
DataSet Set = new DataSet ();
|
|
Set.Tables.Add (Table);
|
|
Set.Tables.Add (Table2);
|
|
DataRelation Rel = new DataRelation ("Rel", Table.Columns [0], Table2.Columns [0]);
|
|
Set.Relations.Add (Rel);
|
|
|
|
Assert.IsFalse (Cols2.CanRemove (C), "test#05");
|
|
Assert.IsFalse (Cols.CanRemove (null), "test#06");
|
|
}
|
|
|
|
[Test]
|
|
public void Clear ()
|
|
{
|
|
DataTable Table = new DataTable ("test_table");
|
|
DataTable Table2 = new DataTable ("test_table2");
|
|
DataSet Set = new DataSet ();
|
|
Set.Tables.Add (Table);
|
|
Set.Tables.Add (Table2);
|
|
DataColumnCollection Cols = Table.Columns;
|
|
DataColumnCollection Cols2 = Table2.Columns;
|
|
|
|
Cols.Add ();
|
|
Cols.Add ("testi");
|
|
|
|
Cols.Clear ();
|
|
Assert.AreEqual (0, Cols.Count, "test#01");
|
|
|
|
Cols.Add ();
|
|
Cols.Add ("testi");
|
|
Cols2.Add ();
|
|
Cols2.Add ();
|
|
|
|
DataRelation Rel = new DataRelation ("Rel", Cols [0], Cols2 [0]);
|
|
Set.Relations.Add (Rel);
|
|
try {
|
|
Cols.Clear ();
|
|
Assert.Fail ("test#02");
|
|
} catch (Exception e) {
|
|
Assert.AreEqual (typeof (ArgumentException), e.GetType (), "test#03");
|
|
// Never premise English.
|
|
//Assert.AreEqual ("Cannot remove this column, because it is part of the parent key for relationship Rel.", e.Message, "test#04");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void Clear_ExpressionColumn ()
|
|
{
|
|
DataTable table = new DataTable ("test");
|
|
table.Columns.Add ("col1", typeof(int));
|
|
table.Columns.Add ("col2", typeof (int), "sum(col1)");
|
|
|
|
//shudnt throw an exception.
|
|
table.Columns.Clear ();
|
|
Assert.AreEqual (0, table.Columns.Count, "#1");
|
|
}
|
|
|
|
[Test]
|
|
public void Contains ()
|
|
{
|
|
DataTable Table = new DataTable ("test_table");
|
|
DataColumnCollection Cols = Table.Columns;
|
|
|
|
Cols.Add ("test");
|
|
Cols.Add ("tesT2");
|
|
|
|
Assert.IsTrue (Cols.Contains ("test"), "test#01");
|
|
Assert.IsFalse (Cols.Contains ("_test"), "test#02");
|
|
Assert.IsTrue (Cols.Contains ("TEST"), "test#03");
|
|
Table.CaseSensitive = true;
|
|
Assert.IsTrue (Cols.Contains ("TEST"), "test#04");
|
|
Assert.IsTrue (Cols.Contains ("test2"), "test#05");
|
|
Assert.IsFalse (Cols.Contains ("_test2"), "test#06");
|
|
Assert.IsTrue (Cols.Contains ("TEST2"), "test#07");
|
|
}
|
|
|
|
[Test]
|
|
public void CopyTo ()
|
|
{
|
|
DataTable Table = new DataTable ("test_table");
|
|
DataColumnCollection Cols = Table.Columns;
|
|
|
|
Cols.Add ("test");
|
|
Cols.Add ("test2");
|
|
Cols.Add ("test3");
|
|
Cols.Add ("test4");
|
|
|
|
DataColumn [] array = new DataColumn [4];
|
|
Cols.CopyTo (array, 0);
|
|
Assert.AreEqual (4, array.Length, "test#01");
|
|
Assert.AreEqual ("test", array [0].ColumnName, "test#02");
|
|
Assert.AreEqual ("test2", array [1].ColumnName, "test#03");
|
|
Assert.AreEqual ("test3", array [2].ColumnName, "test#04");
|
|
Assert.AreEqual ("test4", array [3].ColumnName, "test#05");
|
|
|
|
array = new DataColumn [6];
|
|
Cols.CopyTo (array, 2);
|
|
Assert.AreEqual (6, array.Length, "test#06");
|
|
Assert.AreEqual ("test", array [2].ColumnName, "test#07");
|
|
Assert.AreEqual ("test2", array [3].ColumnName, "test#08");
|
|
Assert.AreEqual ("test3", array [4].ColumnName, "test#09");
|
|
Assert.AreEqual ("test4", array [5].ColumnName, "test#10");
|
|
Assert.IsNull (array [0], "test#11");
|
|
Assert.IsNull (array [1], "test#12");
|
|
}
|
|
|
|
[Test]
|
|
public void Equals ()
|
|
{
|
|
DataTable Table = new DataTable ("test_table");
|
|
DataTable Table2 = new DataTable ("test_table");
|
|
DataColumnCollection Cols = Table.Columns;
|
|
DataColumnCollection Cols2 = Table2.Columns;
|
|
|
|
Assert.IsFalse (Cols.Equals (Cols2), "test#01");
|
|
Assert.IsFalse (Cols2.Equals (Cols), "test#02");
|
|
Assert.IsFalse (Object.Equals (Cols, Cols2), "test#03");
|
|
Assert.IsTrue (Cols.Equals (Cols), "test#04");
|
|
Assert.IsTrue (Cols2.Equals (Cols2), "test#05");
|
|
Assert.IsTrue (Object.Equals (Cols2, Cols2), "test#06");
|
|
}
|
|
|
|
[Test]
|
|
public void IndexOf ()
|
|
{
|
|
DataTable Table = new DataTable ("test_table");
|
|
DataColumnCollection Cols = Table.Columns;
|
|
|
|
Cols.Add ("test");
|
|
Cols.Add ("test2");
|
|
Cols.Add ("test3");
|
|
Cols.Add ("test4");
|
|
|
|
Assert.AreEqual (0, Cols.IndexOf ("test"), "test#01");
|
|
Assert.AreEqual (1, Cols.IndexOf ("TEST2"), "test#02");
|
|
Table.CaseSensitive = true;
|
|
Assert.AreEqual (1, Cols.IndexOf ("TEST2"), "test#03");
|
|
|
|
Assert.AreEqual (3, Cols.IndexOf (Cols [3]), "test#04");
|
|
DataColumn C = new DataColumn ("error");
|
|
Assert.AreEqual (-1, Cols.IndexOf (C), "test#05");
|
|
Assert.AreEqual (-1, Cols.IndexOf ("_error_"), "test#06");
|
|
}
|
|
|
|
[Test]
|
|
public void Remove ()
|
|
{
|
|
DataTable Table = new DataTable ("test_table");
|
|
DataColumnCollection Cols = Table.Columns;
|
|
|
|
Cols.Add ("test");
|
|
Cols.Add ("test2");
|
|
Cols.Add ("test3");
|
|
Cols.Add ("test4");
|
|
|
|
Assert.AreEqual (4, Cols.Count, "test#01");
|
|
Cols.Remove ("test2");
|
|
Assert.AreEqual (3, Cols.Count, "test#02");
|
|
Cols.Remove ("TEST3");
|
|
Assert.AreEqual (2, Cols.Count, "test#03");
|
|
|
|
try {
|
|
Cols.Remove ("_test_");
|
|
Assert.Fail ("test#04");
|
|
} catch (Exception e) {
|
|
Assert.AreEqual (typeof (ArgumentException), e.GetType (), "test#05");
|
|
// Never premise English.
|
|
//Assert.AreEqual ("Column '_test_' does not belong to table test_table.", e.Message, "test#06");
|
|
}
|
|
|
|
Cols.Add ();
|
|
Cols.Add ();
|
|
Cols.Add ();
|
|
Cols.Add ();
|
|
|
|
Assert.AreEqual (6, Cols.Count, "test#07");
|
|
Cols.Remove (Cols [0]);
|
|
Cols.Remove (Cols [0]);
|
|
Assert.AreEqual (4, Cols.Count, "test#08");
|
|
Assert.AreEqual ("Column1", Cols [0].ColumnName, "test#09");
|
|
|
|
try {
|
|
Cols.Remove (new DataColumn ("Column10"));
|
|
Assert.Fail ("test#10");
|
|
} catch (Exception e) {
|
|
Assert.AreEqual (typeof (ArgumentException), e.GetType (), "test#11");
|
|
// Never premise English.
|
|
//Assert.AreEqual ("Cannot remove a column that doesn't belong to this table.", e.Message, "test#12");
|
|
}
|
|
|
|
Cols.Add ();
|
|
Cols.Add ();
|
|
Cols.Add ();
|
|
Cols.Add ();
|
|
|
|
Assert.AreEqual (8, Cols.Count, "test#13");
|
|
Cols.RemoveAt (7);
|
|
Cols.RemoveAt (1);
|
|
Cols.RemoveAt (0);
|
|
Cols.RemoveAt (0);
|
|
Assert.AreEqual (4, Cols.Count, "test#14");
|
|
Assert.AreEqual ("Column4", Cols [0].ColumnName, "test#15");
|
|
Assert.AreEqual ("Column5", Cols [1].ColumnName, "test#16");
|
|
|
|
try {
|
|
Cols.RemoveAt (10);
|
|
Assert.Fail ("test#17");
|
|
} catch (Exception e) {
|
|
Assert.AreEqual (typeof (IndexOutOfRangeException), e.GetType (), "test#18");
|
|
// Never premise English.
|
|
//Assert.AreEqual ("Cannot find column 10.", e.Message, "test#19");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void Remove_Dep_Rel_Col ()
|
|
{
|
|
DataSet ds = new DataSet ();
|
|
ds.Tables.Add ("test");
|
|
ds.Tables.Add ("test1");
|
|
ds.Tables[0].Columns.Add ("col1", typeof(int));
|
|
ds.Tables[1].Columns.Add ("col2", typeof(int));
|
|
|
|
ds.Relations.Add ("rel1", ds.Tables[0].Columns[0], ds.Tables[1].Columns[0]);
|
|
ds.Tables[0].Columns.RemoveAt (0);
|
|
}
|
|
|
|
[Test]
|
|
public void ToStringTest ()
|
|
{
|
|
DataTable Table = new DataTable ("test_table");
|
|
DataColumnCollection Cols = Table.Columns;
|
|
|
|
Cols.Add ("test");
|
|
Cols.Add ("test2");
|
|
Cols.Add ("test3");
|
|
Assert.AreEqual ("System.Data.DataColumnCollection", Cols.ToString (), "test#01");
|
|
}
|
|
|
|
[Test]
|
|
public void CaseSensitiveIndexOfTest ()
|
|
{
|
|
DataTable dt = new DataTable ("TestCaseSensitiveIndexOf");
|
|
dt.Columns.Add ("nom_colonne1", typeof (string));
|
|
dt.Columns.Add ("NOM_COLONNE1", typeof (string));
|
|
dt.Columns.Remove ("nom_colonne1");
|
|
int i=dt.Columns.IndexOf ("nom_colonne1");
|
|
Assert.AreEqual (0, dt.Columns.IndexOf ("nom_colonne1"));
|
|
}
|
|
}
|
|
}
|