mcs/class/System.Data/Test/ProviderTests/System.Data.SqlClient/SqlDataReaderTest.cs

   1 //
   2 // SqlDataReaderTest.cs - NUnit Test Cases for testing the
   3 //                          SqlDataReader class
   4 // Author:
   5 //      Umadevi S (sumadevi@novell.com)
   6 //      Kornél Pál <http://www.kornelpal.hu/>
   7 //      Sureshkumar T (tsureshkumar@novell.com)
   8 //      Senganal T (tsenganal@novell.com)
   9 //      Veerapuram Varadhan (vvaradhan@novell.com)
  10 //
  11 // Copyright (c) 2004 Novell Inc., and the individuals listed
  12 // on the ChangeLog entries.
  13 //
  14 // Permission is hereby granted, free of charge, to any person obtaining
  15 // a copy of this software and associated documentation files (the
  16 // "Software"), to deal in the Software without restriction, including
  17 // without limitation the rights to use, copy, modify, merge, publish,
  18 // distribute, sublicense, and/or sell copies of the Software, and to
  19 // permit persons to whom the Software is furnished to do so, subject to
  20 // the following conditions:
  21 //
  22 // The above copyright notice and this permission notice shall be
  23 // included in all copies or substantial portions of the Software.
  24 //
  25 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  26 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  27 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  28 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  29 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  30 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  31 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  32 //
  33
  34 using System;
  35 using System.Data;
  36 using System.Data.Common;
  37 using System.Data.SqlClient;
  38 using System.Data.SqlTypes;
  39 using System.Globalization;
  40 using System.Text;
  41
  42 using NUnit.Framework;
  43
  44 namespace MonoTests.System.Data.SqlClient
  45 {
  46         [TestFixture]
  47         [Category ("sqlserver")]
  48         public class SqlDataReaderTest
  49         {
  50                 static byte [] long_bytes = new byte [] {
  51                         0x00, 0x66, 0x06, 0x66, 0x97, 0x00, 0x66, 0x06, 0x66,
  52                         0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
  53                         0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
  54                         0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
  55                         0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
  56                         0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
  57                         0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
  58                         0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
  59                         0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
  60                         0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
  61                         0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
  62                         0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
  63                         0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
  64                         0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
  65                         0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
  66                         0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
  67                         0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
  68                         0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
  69                         0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
  70                         0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
  71                         0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
  72                         0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
  73                         0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
  74                         0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
  75                         0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
  76                         0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
  77                         0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
  78                         0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
  79                         0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
  80                         0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
  81                         0x06, 0x66, 0x06, 0x66, 0x98};
  82
  83                 SqlConnection conn = null;
  84                 SqlCommand cmd = null;
  85                 SqlDataReader reader = null;
  86                 String query = "Select type_{0},type_{2},convert({1},null) from numeric_family where id=1";
  87                 DataSet sqlDataset = null;
  88                 EngineConfig engine;
  89
  90                 DataTable numericDataTable =null;
  91                 DataTable stringDataTable =null;
  92                 DataTable binaryDataTable =null;
  93                 DataTable datetimeDataTable =null;
  94
  95                 DataRow numericRow = null;
  96                 DataRow stringRow = null;
  97                 DataRow binaryRow = null;
  98                 DataRow datetimeRow = null;
  99
 100                 [TestFixtureSetUp]
 101                 public void init ()
 102                 {
 103                         conn = new SqlConnection (ConnectionManager.Singleton.ConnectionString);
 104                         cmd = conn.CreateCommand ();
 105
 106                         sqlDataset = (new DataProvider()).GetDataSet ();
 107
 108                         numericDataTable = sqlDataset.Tables["numeric_family"];
 109                         stringDataTable = sqlDataset.Tables["string_family"];
 110                         binaryDataTable = sqlDataset.Tables["binary_family"];
 111                         datetimeDataTable = sqlDataset.Tables["datetime_family"];
 112
 113                         numericRow = numericDataTable.Select ("id=1")[0];
 114                         stringRow = stringDataTable.Select ("id=1")[0];
 115                         binaryRow = binaryDataTable.Select ("id=1")[0];
 116                         datetimeRow = datetimeDataTable.Select ("id=1")[0];
 117
 118                 }
 119
 120                 [SetUp]
 121                 public void Setup ()
 122                 {
 123                         conn.Open ();
 124                         engine = ConnectionManager.Singleton.Engine;
 125                 }
 126
 127                 [TearDown]
 128                 public void TearDown ()
 129                 {
 130                         if (reader != null)
 131                                 reader.Close ();
 132
 133                         conn.Close ();
 134                 }
 135
 136                 [Test]
 137                 public void ReadEmptyNTextFieldTest ()
 138                 {
 139                         try {
 140                                 DBHelper.ExecuteNonQuery (conn, "create table #tmp_monotest (name ntext)");
 141                                 DBHelper.ExecuteNonQuery (conn, "insert into #tmp_monotest values ('')");
 142
 143                                 SqlCommand cmd = (SqlCommand) conn.CreateCommand ();
 144                                 cmd.CommandText = "select * from #tmp_monotest";
 145                                 SqlDataReader dr = cmd.ExecuteReader ();
 146                                 if (dr.Read()) {
 147                                         Assert.AreEqual("System.String",dr["NAME"].GetType().FullName);
 148                                 }
 149                                 Assert.AreEqual (false, dr.Read (), "#2");
 150                         } finally {
 151                                 ConnectionManager.Singleton.CloseConnection ();
 152                         }
 153                 }
 154
 155                 [Test]
 156                 public void ReadBigIntTest()
 157                 {
 158                         if (ClientVersion <= 7)
 159                                 Assert.Ignore ("BigInt data type is not supported.");
 160
 161                         try {
 162                                 string query = "SELECT CAST(548967465189498 AS bigint) AS Value";
 163                                 SqlCommand cmd = new SqlCommand();
 164                                 cmd.Connection = conn;
 165                                 cmd.CommandText = query;
 166                                 SqlDataReader r = cmd.ExecuteReader();
 167                                 using (r) {
 168                                         Assert.AreEqual (true, r.Read(), "#1");
 169                                         long id = r.GetInt64(0);
 170                                         Assert.AreEqual(548967465189498, id, "#2");
 171                                         id = r.GetSqlInt64(0).Value;
 172                                         Assert.AreEqual(548967465189498, id, "#3");
 173                                 }
 174                         } finally {
 175                                 ConnectionManager.Singleton.CloseConnection ();
 176                         }
 177                 }
 178
 179                 // This method just helps in Calling common tests among all the Get* Methods
 180                 // without replicating code
 181
 182                 void CallGetMethod (string s, int i)
 183                 {
 184                         switch (s) {
 185                         case "Boolean" : reader.GetBoolean (i) ; break;
 186                         case "SqlBoolean": reader.GetSqlBoolean (i); break;
 187                         case "Int16" : reader.GetInt16 (i); break;
 188                         case "SqlInt16" : reader.GetSqlInt16 (i); break;
 189                         case "Int32" : reader.GetInt32 (i);break;
 190                         case "SqlInt32" : reader.GetSqlInt32(i);break;
 191                         case "Int64" : reader.GetInt64 (i);break;
 192                         case "SqlInt64" : reader.GetSqlInt64(i); break;
 193                         case "Decimal" : reader.GetDecimal(i);break;
 194                         case "SqlDecimal" : reader.GetSqlDecimal (i);break;
 195                         case "SqlMoney" : reader.GetSqlMoney (i);break;
 196                         case "Float" : reader.GetFloat (i);break;
 197                         case "SqlSingle" : reader.GetSqlSingle(i);break;
 198                         case "Double" : reader.GetDouble (i);break;
 199                         case "SqlDouble" : reader.GetSqlDouble(i);break;
 200                         case "Guid" : reader.GetGuid(i);break;
 201                         case "SqlGuid" : reader.GetSqlGuid(i);break;
 202                         case "String" : reader.GetString(i);break;
 203                         case "SqlString" : reader.GetSqlString(i);break;
 204                         case "Char" : reader.GetChar(i);break;
 205                         case "Byte" : reader.GetByte (i);break;
 206                         case "SqlByte" : reader.GetSqlByte(i); break;
 207                         case "DateTime" : reader.GetDateTime(i); break;
 208                         case "SqlDateTime" : reader.GetSqlDateTime(i); break;
 209                         case "SqlBinary" : reader.GetSqlBinary(i); break;
 210                         default : Console.WriteLine ("OOOOPSSSSSS {0}",s);break;
 211                         }
 212                 }
 213
 214                 // This method just helps in Calling common tests among all the Get* Methods
 215                 // without replicating code
 216                 void GetMethodTests (string s)
 217                 {
 218
 219                         try {
 220                                 CallGetMethod (s, 1);
 221                                 Assert.Fail ("#1[Get"+s+"] InvalidCastException must be thrown");
 222                         } catch (InvalidCastException e) {
 223                                 Assert.AreEqual (typeof (InvalidCastException), e.GetType (),
 224                                         "#2[Get"+s+"] Incorrect Exception : " + e);
 225                         }
 226
 227                         // GetSql* Methods do not throw SqlNullValueException
 228                         // So, Testimg only for Get* Methods
 229                         if (!s.StartsWith("Sql")) {
 230                                 try {
 231                                         CallGetMethod (s, 2);
 232                                         Assert.Fail ("#3[Get"+s+"] Exception must be thrown");
 233                                 } catch (SqlNullValueException e) {
 234                                         Assert.AreEqual (typeof (SqlNullValueException), e.GetType (),
 235                                                 "#4[Get"+s+"] Incorrect Exception : " + e);
 236                                 }
 237                         }
 238
 239                         try {
 240                                 CallGetMethod (s, 3);
 241                                 Assert.Fail ("#5[Get"+s+"] IndexOutOfRangeException must be thrown");
 242                         } catch (IndexOutOfRangeException e) {
 243                                 Assert.AreEqual (typeof (IndexOutOfRangeException), e.GetType (),
 244                                         "#6[Get"+s+"] Incorrect Exception : " + e);
 245                         }
 246                 }
 247
 248                 [Test]
 249                 public void GetBooleanTest ()
 250                 {
 251                         cmd.CommandText = string.Format (query, "bit", "bit", "int");
 252                         reader = cmd.ExecuteReader ();
 253                         reader.Read ();
 254                         // Test for standard exceptions
 255                         GetMethodTests("Boolean");
 256
 257                         // Test if data is returned correctly
 258                         Assert.AreEqual (numericRow ["type_bit"], reader.GetBoolean (0),
 259                                                 "#2 DataValidation Failed");
 260
 261                         // Test for standard exceptions
 262                         GetMethodTests("SqlBoolean");
 263
 264                         // Test if data is returned correctly
 265                         Assert.AreEqual (numericRow["type_bit"], reader.GetSqlBoolean(0).Value,
 266                                 "#4 DataValidation Failed");
 267                         reader.Close ();
 268                 }
 269
 270                 [Test]
 271                 public void GetByteTest ()
 272                 {
 273                         cmd.CommandText = string.Format (query, "tinyint", "tinyint", "int");
 274                         reader = cmd.ExecuteReader ();
 275                         reader.Read ();
 276                         // Test for standard exceptions
 277                         GetMethodTests("Byte");
 278
 279                         // Test if data is returned correctly
 280                         Assert.AreEqual (numericRow["type_tinyint"], reader.GetByte(0),
 281                                                 "#2 DataValidation Failed");
 282
 283                         // Test for standard exceptions
 284                         GetMethodTests("SqlByte");
 285
 286                         // Test if data is returned correctly
 287                         Assert.AreEqual (numericRow["type_tinyint"], reader.GetSqlByte(0).Value,
 288                                                 "#4 DataValidation Failed");
 289                         reader.Close ();
 290                 }
 291
 292                 [Test]
 293                 public void GetInt16Test ()
 294                 {
 295                         cmd.CommandText = string.Format (query, "smallint", "smallint", "int");
 296                         reader = cmd.ExecuteReader();
 297                         reader.Read ();
 298                         // Test for standard exceptions
 299                         GetMethodTests("Int16");
 300
 301                         // Test if data is returned correctly
 302                         Assert.AreEqual (numericRow["type_smallint"], reader.GetInt16(0),
 303                                                 "#2 DataValidation Failed");
 304
 305                         // Test for standard exceptions
 306                         GetMethodTests("SqlInt16");
 307
 308                         // Test if data is returned correctly
 309                         Assert.AreEqual (numericRow["type_smallint"], reader.GetSqlInt16(0).Value,
 310                                                 "#4 DataValidation Failed");
 311                         reader.Close ();
 312                 }
 313
 314                 [Test]
 315                 public void GetInt32Test ()
 316                 {
 317                         if (ClientVersion == 7)
 318                                 cmd.CommandText = string.Format (query, "int", "int", "decimal1");
 319                         else
 320                                 cmd.CommandText = string.Format (query, "int", "int", "bigint");
 321
 322                         reader = cmd.ExecuteReader ();
 323                         reader.Read ();
 324                         // Test for standard exceptions
 325                         GetMethodTests("Int32");
 326
 327                         // Test if data is returned correctly
 328                         Assert.AreEqual (numericRow["type_int"], reader.GetInt32(0),
 329                                 "#2 DataValidation Failed");
 330
 331                         // Test for standard exceptions
 332                         GetMethodTests("SqlInt32");
 333
 334                         // Test if data is returned correctly
 335                         Assert.AreEqual (numericRow["type_int"], reader.GetSqlInt32(0).Value,
 336                                 "#4 DataValidation Failed");
 337                         reader.Close ();
 338                 }
 339
 340                 [Test]
 341                 public void GetInt64Test ()
 342                 {
 343                         if (ClientVersion == 7)
 344                                 Assert.Ignore ("BigInt data type is not supported.");
 345
 346                         cmd.CommandText = string.Format (query, "bigint", "bigint", "int");
 347                         reader = cmd.ExecuteReader ();
 348                         reader.Read ();
 349
 350                         object value;
 351
 352                         // Test for standard exceptions
 353                         GetMethodTests("Int64");
 354
 355                         // Test if data is returned correctly
 356                         value = reader.GetInt64 (0);
 357                         Assert.AreEqual (numericRow ["type_bigint"], value, "#A");
 358
 359                         // Test for standard exceptions
 360                         GetMethodTests("SqlInt64");
 361
 362                         // Test if data is returned correctly
 363                         value = reader.GetSqlInt64 (0);
 364                         Assert.IsNotNull (value, "#B1");
 365                         Assert.AreEqual (typeof (SqlInt64), value.GetType (), "#B2");
 366                         SqlInt64 sqlValue = (SqlInt64) value;
 367                         Assert.IsFalse (sqlValue.IsNull, "#B3");
 368                         Assert.AreEqual (numericRow ["type_bigint"], sqlValue.Value, "#B4");
 369
 370                         value = reader.GetValue (0);
 371                         Assert.IsNotNull (value, "#C1");
 372                         Assert.AreEqual (typeof (long), value.GetType (), "#C2");
 373                         Assert.AreEqual (numericRow ["type_bigint"], value, "#C3");
 374
 375                         reader.Close ();
 376                 }
 377
 378                 [Test]
 379                 public void GetDecimalTest ()
 380                 {
 381                         cmd.CommandText = string.Format (query, "decimal1", "decimal", "int");
 382                         reader = cmd.ExecuteReader ();
 383                         reader.Read ();
 384                         // Test for standard exceptions
 385                         GetMethodTests("Decimal");
 386
 387                         // Test if data is returned correctly
 388                         Assert.AreEqual (numericRow["type_decimal1"], reader.GetDecimal(0),
 389                                 "#2 DataValidation Failed");
 390
 391                         // Test for standard exceptions
 392                         GetMethodTests("SqlDecimal");
 393
 394                         // Test if data is returned correctly
 395                         Assert.AreEqual (numericRow["type_decimal1"], reader.GetSqlDecimal(0).Value,
 396                                 "#4 DataValidation Failed");
 397                         reader.Close ();
 398                 }
 399
 400                 //#613087, #620860 Test
 401                 [Test]
 402                 public void GetDecimalOfInt64Test_Max ()
 403                 {
 404                         string crTable = "CREATE TABLE #613087 (decimalint64 decimal(20,0))";
 405                         //string drTable = "drop table #613087";
 406
 407                         cmd.CommandText = crTable;
 408                         cmd.CommandType = CommandType.Text;
 409                         cmd.ExecuteNonQuery ();
 410
 411                         cmd.CommandText = "INSERT INTO #613087 VALUES (@decimalint64)";
 412                         SqlParameter param = new SqlParameter ();
 413                         param.ParameterName = "@decimalint64";
 414                         param.Value = new SqlDecimal ((long)Int64.MaxValue);
 415                         cmd.Parameters.Add (param);
 416                         cmd.ExecuteNonQuery ();
 417
 418                         cmd.Parameters.Clear ();
 419                         cmd.CommandText = "Select * from #613087";
 420                         reader = cmd.ExecuteReader();
 421                         reader.Read ();
 422                         Assert.AreEqual (param.Value, reader.GetSqlDecimal (0), "SqlDecimalFromInt64_Max Test failed");
 423                 }
 424
 425                 //#613087, #620860 Test
 426                 [Test]
 427                 public void GetDecimalOfInt64Test_Min ()
 428                 {
 429                         string crTable = "CREATE TABLE #613087 (decimalint64 decimal(20,0))";
 430                         //string drTable = "drop table #613087";
 431
 432                         cmd.CommandText = crTable;
 433                         cmd.CommandType = CommandType.Text;
 434                         cmd.ExecuteNonQuery ();
 435
 436                         cmd.CommandText = "INSERT INTO #613087 VALUES (@decimalint64)";
 437                         SqlParameter param = new SqlParameter ();
 438                         param.ParameterName = "@decimalint64";
 439                         param.Value = new SqlDecimal ((long)Int64.MinValue);
 440                         cmd.Parameters.Add (param);
 441                         cmd.ExecuteNonQuery ();
 442
 443                         cmd.Parameters.Clear ();
 444                         cmd.CommandText = "Select * from #613087";
 445                         reader = cmd.ExecuteReader();
 446                         reader.Read ();
 447                         Assert.AreEqual (param.Value, reader.GetSqlDecimal (0), "SqlDecimalFromInt64_Min Test failed");
 448                 }
 449
 450                 //#613087, #620860 Test
 451                 [Test]
 452                 public void GetDecimalOfInt64Test_Any ()
 453                 {
 454                         string crTable = "CREATE TABLE #613087 (decimalint64 decimal(20,0))";
 455                         //string drTable = "drop table #613087";
 456
 457                         cmd.CommandText = crTable;
 458                         cmd.CommandType = CommandType.Text;
 459                         cmd.ExecuteNonQuery ();
 460
 461                         cmd.CommandText = "INSERT INTO #613087 VALUES (@decimalint64)";
 462                         SqlParameter param = new SqlParameter ();
 463                         param.ParameterName = "@decimalint64";
 464                         param.DbType = DbType.Decimal;
 465                         param.Value = ulong.MaxValue;
 466                         cmd.Parameters.Add (param);
 467                         cmd.ExecuteNonQuery ();
 468
 469                         cmd.Parameters.Clear ();
 470                         cmd.CommandText = "Select * from #613087";
 471                         reader = cmd.ExecuteReader();
 472                         reader.Read ();
 473                         Assert.AreEqual (param.Value, (ulong)reader.GetSqlDecimal (0).Value, "SqlDecimalFromInt64_Any Test failed");
 474                 }
 475
 476                 [Test]
 477                 public void GetSqlMoneyTest ()
 478                 {
 479                         cmd.CommandText = string.Format (query, "money", "money", "int");
 480                         reader = cmd.ExecuteReader ();
 481                         reader.Read ();
 482                         // Test for standard exceptions
 483                         GetMethodTests("SqlMoney");
 484
 485                         // Test if data is returned correctly
 486                         Assert.AreEqual (numericRow["type_money"], reader.GetSqlMoney(0).Value,
 487                                 "#2 DataValidation Failed");
 488                         reader.Close ();
 489                 }
 490
 491                 [Test]
 492                 public void GetFloatTest ()
 493                 {
 494                         cmd.CommandText = "select type_float,type_double,convert(real,null)";
 495                         cmd.CommandText += "from numeric_family where id=1";
 496                         reader = cmd.ExecuteReader ();
 497                         reader.Read ();
 498                         // Test for standard exceptions
 499                         GetMethodTests("Float");
 500
 501                         // Test if data is returned correctly
 502                         Assert.AreEqual (numericRow["type_float"], reader.GetFloat(0),
 503                                 "#2 DataValidation Failed");
 504
 505                         // Test for standard exceptions
 506                         GetMethodTests("SqlSingle");
 507
 508                         // Test if data is returned correctly
 509                         Assert.AreEqual (numericRow["type_float"], reader.GetSqlSingle(0).Value,
 510                                 "#2 DataValidation Failed");
 511                         reader.Close ();
 512                 }
 513
 514                 [Test]
 515                 public void GetDoubleTest ()
 516                 {
 517                         cmd.CommandText = "select type_double,type_float,convert(float,null)";
 518                         cmd.CommandText += " from numeric_family where id=1";
 519                         reader = cmd.ExecuteReader ();
 520                         reader.Read ();
 521                         // Test for standard exceptions
 522                         GetMethodTests("Double");
 523
 524                         // Test if data is returned correctly
 525                         Assert.AreEqual (numericRow["type_double"], reader.GetDouble(0),
 526                                 "#2 DataValidation Failed");
 527
 528                         // Test for standard exceptions
 529                         GetMethodTests("SqlDouble");
 530
 531                         // Test if data is returned correctly
 532                         Assert.AreEqual (numericRow["type_double"], reader.GetSqlDouble(0).Value,
 533                                 "#4 DataValidation Failed");
 534                         reader.Close ();
 535                 }
 536
 537                 [Test]
 538                 public void GetBytesTest ()
 539                 {
 540                         cmd.CommandText = "Select type_text,type_ntext,convert(text,null) ";
 541                         cmd.CommandText += "from string_family where id=1";
 542                         reader = cmd.ExecuteReader ();
 543                         reader.Read ();
 544                         try {
 545                                 long totalsize = reader.GetBytes (0, 0, null, 0, 0);
 546                                 Assert.AreEqual (4, totalsize, "#1");
 547                         } finally {
 548                                 reader.Close ();
 549                         }
 550
 551                         byte[] asciiArray = (new ASCIIEncoding ()).GetBytes ("text");
 552                         byte[] unicodeArray = (new UnicodeEncoding ()).GetBytes ("nt\u092d\u093ext");
 553                         byte[] buffer = null ;
 554                         long size = 0;
 555
 556                         reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess);
 557                         reader.Read ();
 558                         size = reader.GetBytes (0,0,null,0,0);
 559                         Assert.AreEqual (asciiArray.Length, size, "#3 Data Incorrect");
 560
 561                         buffer = new byte[size];
 562                         size = reader.GetBytes (0,0,buffer,0,(int)size);
 563                         for (int i=0;i<size; i++)
 564                                 Assert.AreEqual (asciiArray[i], buffer[i], "#4 Data Incorrect");
 565
 566                         size = reader.GetBytes (1, 0, null, 0, 0);
 567                         Assert.AreEqual (unicodeArray.Length, size, "#5 Data Incorrect");
 568                         buffer = new byte[size];
 569                         size = reader.GetBytes (1,0,buffer,0,(int)size);
 570                         for (int i=0;i<size; i++)
 571                                 Assert.AreEqual (unicodeArray[i], buffer[i], "#6 Data Incorrect");
 572
 573                         // Test if msdotnet behavior s followed when null value
 574                         // is read using GetBytes
 575                         try {
 576                                 reader.GetBytes (2, 0, null, 0, 0);
 577                                 Assert.Fail ("#7");
 578                         } catch (SqlNullValueException) {
 579                         }
 580
 581                         try {
 582                                 reader.GetBytes (2, 0, buffer, 0, 10);
 583                                 Assert.Fail ("#8");
 584                         } catch (SqlNullValueException) {
 585                         }
 586                         reader.Close ();
 587                         // do i need to test for image/binary values also ???
 588                 }
 589
 590                 [Test]
 591                 public void GetBytes_BufferIndex_Negative ()
 592                 {
 593                         IDbConnection conn = ConnectionManager.Singleton.Connection;
 594                         conn.Open ();
 595
 596                         try {
 597                                 IDbCommand cmd = conn.CreateCommand ();
 598                                 cmd.CommandText = "SELECT type_blob FROM binary_family where id = 1";
 599
 600                                 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
 601                                         Assert.IsTrue (reader.Read (), "#1");
 602
 603                                         long size = reader.GetBytes (0, 0, null, -1, 0);
 604                                         Assert.AreEqual (5, size);
 605                                 }
 606                         } finally {
 607                                 ConnectionManager.Singleton.CloseConnection ();
 608                         }
 609                 }
 610
 611                 [Test]
 612                 public void GetBytes_DataIndex_Negative ()
 613                 {
 614                         IDbConnection conn = ConnectionManager.Singleton.Connection;
 615                         conn.Open ();
 616
 617                         try {
 618                                 IDbCommand cmd = conn.CreateCommand ();
 619                                 cmd.CommandText = "SELECT type_blob FROM binary_family where id = 1";
 620
 621                                 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
 622                                         Assert.IsTrue (reader.Read ());
 623
 624                                         long totalsize = reader.GetBytes (0, -1L, null, 0, 0);
 625                                         Assert.AreEqual (5, totalsize, "#A");
 626                                 }
 627
 628                                 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
 629                                         Assert.IsTrue (reader.Read ());
 630
 631                                         byte [] val = new byte [5];
 632                                         try {
 633                                                 reader.GetBytes (0, -1L, val, 0, 3);
 634                                                 Assert.Fail ("#B1");
 635                                         } catch (InvalidOperationException ex) {
 636                                                 // Invalid GetBytes attempt at dataIndex '-1'
 637                                                 // With CommandBehavior.SequentialAccess,
 638                                                 // you may only read from dataIndex '0'
 639                                                 // or greater.
 640                                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
 641                                                 Assert.IsNull (ex.InnerException, "#B3");
 642                                                 Assert.IsNotNull (ex.Message, "#B4");
 643                                                 Assert.IsTrue (ex.Message.IndexOf ("dataIndex") != -1, "#B5:" + ex.Message);
 644                                         }
 645                                 }
 646
 647                                 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SingleResult)) {
 648                                         Assert.IsTrue (reader.Read ());
 649
 650                                         try {
 651                                                 reader.GetBytes (0, -1L, null, 0, 0);
 652                                                 Assert.Fail ("#C1");
 653                                         } catch (InvalidOperationException ex) {
 654                                                 // Invalid value for argument 'dataIndex'.
 655                                                 // The value must be greater than or equal to 0
 656                                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
 657                                                 Assert.IsNull (ex.InnerException, "#C3");
 658                                                 Assert.IsNotNull (ex.Message, "#C4");
 659                                                 Assert.IsTrue (ex.Message.IndexOf ("'dataIndex'") != -1, "#C5:" + ex.Message);
 660                                         }
 661
 662                                         byte [] val = new byte [3];
 663                                         try {
 664                                                 reader.GetBytes (0, -1L, val, 0, 3);
 665                                                 Assert.Fail ("#D1");
 666                                         } catch (InvalidOperationException ex) {
 667                                                 // Invalid value for argument 'dataIndex'.
 668                                                 // The value must be greater than or equal to 0
 669                                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
 670                                                 Assert.IsNull (ex.InnerException, "#D3");
 671                                                 Assert.IsNotNull (ex.Message, "#D4");
 672                                                 Assert.IsTrue (ex.Message.IndexOf ("'dataIndex'") != -1, "#D5:" + ex.Message);
 673                                         }
 674                                 }
 675
 676                                 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SingleResult)) {
 677                                         Assert.IsTrue (reader.Read ());
 678
 679                                         byte [] val = new byte [5];
 680                                         try {
 681                                                 reader.GetBytes (0, -1L, val, 0, 3);
 682                                                 Assert.Fail ("#E1");
 683                                         } catch (InvalidOperationException ex) {
 684                                                 // Invalid value for argument 'dataIndex'.
 685                                                 // The value must be greater than or equal to 0
 686                                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");
 687                                                 Assert.IsNull (ex.InnerException, "#E3");
 688                                                 Assert.IsNotNull (ex.Message, "#E4");
 689                                                 Assert.IsTrue (ex.Message.IndexOf ("'dataIndex'") != -1, "#E5:" + ex.Message);
 690                                         }
 691                                 }
 692
 693                                 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
 694                                         Assert.IsTrue (reader.Read ());
 695
 696                                         long totalsize = reader.GetBytes (0, -1L, null, 5, 8);
 697                                         Assert.AreEqual (5, totalsize, "#F");
 698                                 }
 699
 700                                 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SingleResult)) {
 701                                         Assert.IsTrue (reader.Read ());
 702
 703                                         try {
 704                                                 reader.GetBytes (0, -1L, null, 4, 8);
 705                                                 Assert.Fail ("#G1");
 706                                         } catch (InvalidOperationException ex) {
 707                                                 // Invalid value for argument 'dataIndex'.
 708                                                 // The value must be greater than or equal to 0
 709                                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#G2");
 710                                                 Assert.IsNull (ex.InnerException, "#G3");
 711                                                 Assert.IsNotNull (ex.Message, "#G4");
 712                                                 Assert.IsTrue (ex.Message.IndexOf ("'dataIndex'") != -1, "#G5:" + ex.Message);
 713                                         }
 714                                 }
 715                         } finally {
 716                                 ConnectionManager.Singleton.CloseConnection ();
 717                         }
 718                 }
 719
 720                 [Test]
 721                 public void GetBytes_Length_Negative ()
 722                 {
 723                         IDbConnection conn = ConnectionManager.Singleton.Connection;
 724                         conn.Open ();
 725
 726                         try {
 727                                 IDbCommand cmd = conn.CreateCommand ();
 728                                 cmd.CommandText = "SELECT type_blob FROM binary_family where id = 1";
 729
 730                                 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
 731                                         Assert.IsTrue (reader.Read (), "#A1");
 732
 733                                         long size = reader.GetBytes (0, 0, null, 0, -1);
 734                                         Assert.AreEqual (5, size, "#A2");
 735                                 }
 736
 737                                 using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SingleResult)) {
 738                                         Assert.IsTrue (reader.Read (), "#B1");
 739
 740                                         long size = reader.GetBytes (0, 0, null, 0, -1);
 741                                         Assert.AreEqual (5, size, "#B2");
 742                                 }
 743                         } finally {
 744                                 ConnectionManager.Singleton.CloseConnection ();
 745                         }
 746                 }
 747
 748                 [Test]
 749                 public void GetBytes_Buffer_TooSmall ()
 750                 {
 751                         cmd = conn.CreateCommand ();
 752                         cmd.CommandText = "SELECT type_blob FROM binary_family where id = 2";
 753
 754                         using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SingleResult | CommandBehavior.SequentialAccess)) {
 755                                 Assert.IsTrue (reader.Read ());
 756
 757                                 long totalsize = reader.GetBytes (0, 0, null, 0, 0);
 758                                 byte [] val = new byte [totalsize -1];
 759
 760                                 try {
 761                                         reader.GetBytes (0, 0, val, 0, (int) totalsize);
 762                                         Assert.Fail ("#A1");
 763                                 } catch (IndexOutOfRangeException ex) {
 764                                         // Buffer offset '0' plus the bytes available
 765                                         // '275' is greater than the length of the
 766                                         // passed in buffer
 767                                         Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2");
 768                                         Assert.IsNull (ex.InnerException, "#A3");
 769                                         Assert.IsNotNull (ex.Message, "#A4");
 770                                         Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#A5:" + ex.Message);
 771                                         Assert.IsTrue (ex.Message.IndexOf ("'" + totalsize + "'") != -1, "#A6:" + ex.Message);
 772                                 }
 773                         }
 774
 775                         using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SingleResult | CommandBehavior.SequentialAccess)) {
 776                                 Assert.IsTrue (reader.Read ());
 777
 778                                 long totalsize = reader.GetBytes (0, 0, null, 0, 0);
 779                                 byte [] val = new byte [totalsize];
 780
 781                                 try {
 782                                         reader.GetBytes (0, 0, val, 1, (int) totalsize);
 783                                         Assert.Fail ("#B1");
 784                                 } catch (IndexOutOfRangeException ex) {
 785                                         // Buffer offset '1' plus the bytes available
 786                                         // '275' is greater than the length of the
 787                                         // passed in buffer
 788                                         Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2");
 789                                         Assert.IsNull (ex.InnerException, "#B3");
 790                                         Assert.IsNotNull (ex.Message, "#B4");
 791                                         Assert.IsTrue (ex.Message.IndexOf ("'1'") != -1, "#B5:" + ex.Message);
 792                                         Assert.IsTrue (ex.Message.IndexOf ("'" + totalsize + "'") != -1, "#B6:" + ex.Message);
 793                                 }
 794                         }
 795
 796                         using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SingleResult | CommandBehavior.SequentialAccess)) {
 797                                 Assert.IsTrue (reader.Read ());
 798
 799                                 long totalsize = reader.GetBytes (0, 0, null, 0, 0);
 800                                 byte [] val = new byte [totalsize];
 801
 802                                 try {
 803                                         reader.GetBytes (0, 0, val, 0, (int) (totalsize + 1));
 804                                         Assert.Fail ("#C1");
 805                                 } catch (IndexOutOfRangeException ex) {
 806                                         // Buffer offset '0' plus the bytes available
 807                                         // '277' is greater than the length of the
 808                                         // passed in buffer
 809                                         Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#C2");
 810                                         Assert.IsNull (ex.InnerException, "#C3");
 811                                         Assert.IsNotNull (ex.Message, "#C4");
 812                                         Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#C5:" + ex.Message);
 813                                         Assert.IsTrue (ex.Message.IndexOf ("'" + (totalsize + 1) + "'") != -1, "#C6:" + ex.Message);
 814                                 }
 815                         }
 816                 }
 817
 818                 [Test]
 819                 public void GetBytes ()
 820                 {
 821                         cmd = conn.CreateCommand ();
 822                         cmd.CommandText = "SELECT type_blob FROM binary_family where id = 2";
 823
 824                         using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SingleResult)) {
 825                                 Assert.IsTrue (reader.Read (), "#H1");
 826
 827                                 long totalsize = reader.GetBytes (0, 0, null, 0, 0);
 828
 829                                 byte [] val = new byte [totalsize];
 830                                 int offset = 0;
 831                                 long ret = 0;
 832                                 long count = 0;
 833
 834                                 do {
 835                                         ret = reader.GetBytes (0, offset, val, offset, 50);
 836                                         offset += (int) ret;
 837                                         count += ret;
 838                                 } while (count < totalsize);
 839
 840                                 Assert.AreEqual (long_bytes.Length, count, "#H2");
 841                                 Assert.AreEqual (long_bytes, val, "#H3");
 842                         }
 843                 }
 844
 845                 [Test]
 846                 public void GetBytes_Type_Binary ()
 847                 {
 848                         cmd.CommandText = "Select type_binary, type_varbinary, " +
 849                                 "type_blob from binary_family where id = 1";
 850                         reader = cmd.ExecuteReader ();
 851                         reader.Read ();
 852                         byte[] binary = (byte[])reader.GetValue (0);
 853                         byte[] varbinary = (byte[])reader.GetValue (1);
 854                         byte[] image = (byte[])reader.GetValue (2);
 855                         reader.Close ();
 856
 857                         reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess);
 858                         reader.Read ();
 859                         int len = 0;
 860                         byte[] arr ;
 861                         len = (int)reader.GetBytes (0,0,null,0,0);
 862                         Assert.AreEqual (binary.Length, len, "#1");
 863                         arr = new byte [len];
 864                         reader.GetBytes (0,0,arr,0,len);
 865                         for (int i=0; i<len; ++i)
 866                                 Assert.AreEqual (binary[i], arr[i], "#2");
 867
 868
 869                         len = (int)reader.GetBytes (1,0,null,0,0);
 870                         Assert.AreEqual (varbinary.Length, len, "#1");
 871                         arr = new byte [len];
 872                         reader.GetBytes (1,0,arr,0,len);
 873                         for (int i=0; i<len; ++i)
 874                                 Assert.AreEqual (varbinary[i], arr[i], "#2");
 875
 876                         len = (int)reader.GetBytes (2,0,null,0,0);
 877                         Assert.AreEqual (image.Length, len, "#1");
 878                         arr = new byte [len];
 879                         reader.GetBytes (2,0,arr,0,len);
 880                         for (int i=0; i<len; ++i)
 881                                 Assert.AreEqual (image[i], arr[i], "#2");
 882
 883                         reader.Close ();
 884
 885                         cmd.CommandText = "Select type_binary,type_varbinary,type_blob ";
 886                         cmd.CommandText += "from binary_family where id=1";
 887
 888                         reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess);
 889                         reader.Read ();
 890
 891                         len  = (int)reader.GetBytes (0,0,null,0,0);
 892                         arr = new byte [100];
 893                         for (int i=0; i<len; ++i) {
 894                                 Assert.AreEqual (len-i, reader.GetBytes (0, i, null, 0, 0), "#1_"+i);
 895                                 Assert.AreEqual (1, reader.GetBytes (0, i, arr, 0, 1), "#2_"+i);
 896                                 Assert.AreEqual (binary [i], arr [0], "#3_"+i);
 897                         }
 898                         Assert.AreEqual (0, reader.GetBytes (0, len+10, null, 0, 0));
 899                         reader.Close ();
 900                 }
 901
 902                 [Test]
 903                 public void GetBytes_Type_DateTime ()
 904                 {
 905                         cmd.CommandText = "SELECT type_datetime FROM datetime_family where id = 1";
 906
 907                         using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
 908                                 Assert.IsTrue (reader.Read ());
 909
 910                                 try {
 911                                         reader.GetBytes (0, 0, null, 0, 0);
 912                                         Assert.Fail ("#A1");
 913                                 } catch (InvalidCastException ex) {
 914                                         // Invalid attempt to GetBytes on column
 915                                         // 'type_datetime'.
 916                                         // The GetBytes function can only be used
 917                                         // on columns of type Text, NText, or Image
 918                                         Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#A2");
 919                                         Assert.IsNull (ex.InnerException, "#A3");
 920                                         Assert.IsNotNull (ex.Message, "#A4");
 921                                         Assert.IsTrue (ex.Message.IndexOf ("'type_datetime'") != -1, "#A5:" + ex.Message);
 922                                         Assert.IsTrue (ex.Message.IndexOf ("GetBytes") != -1, "#A6:" + ex.Message);
 923                                         Assert.IsTrue (ex.Message.IndexOf ("Text") != -1, "#A7:" + ex.Message);
 924                                         Assert.IsTrue (ex.Message.IndexOf ("NText") != -1, "#A8:" + ex.Message);
 925                                         Assert.IsTrue (ex.Message.IndexOf ("Image") != -1, "#A9:" + ex.Message);
 926                                 }
 927                         }
 928
 929                         using (IDataReader reader = cmd.ExecuteReader ()) {
 930                                 Assert.IsTrue (reader.Read ());
 931
 932                                 try {
 933                                         reader.GetBytes (0, 0, null, 0, 0);
 934                                         Assert.Fail ("#B1");
 935                                 } catch (InvalidCastException ex) {
 936                                         // Invalid attempt to GetBytes on column
 937                                         // 'type_datetime'.
 938                                         // The GetBytes function can only be used
 939                                         // on columns of type Text, NText, or Image
 940                                         Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#B2");
 941                                         Assert.IsNull (ex.InnerException, "#B3");
 942                                         Assert.IsNotNull (ex.Message, "#B4");
 943                                         Assert.IsTrue (ex.Message.IndexOf ("'type_datetime'") != -1, "#B5:" + ex.Message);
 944                                         Assert.IsTrue (ex.Message.IndexOf ("GetBytes") != -1, "#B6:" + ex.Message);
 945                                         Assert.IsTrue (ex.Message.IndexOf ("Text") != -1, "#B7:" + ex.Message);
 946                                         Assert.IsTrue (ex.Message.IndexOf ("NText") != -1, "#B8:" + ex.Message);
 947                                         Assert.IsTrue (ex.Message.IndexOf ("Image") != -1, "#B9:" + ex.Message);
 948                                 }
 949                         }
 950
 951                         cmd.CommandText = "SELECT type_datetime FROM datetime_family where id = 4";
 952
 953                         using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
 954                                 Assert.IsTrue (reader.Read ());
 955
 956                                 try {
 957                                         reader.GetBytes (0, 0, null, 0, 0);
 958                                         Assert.Fail ("#C1");
 959                                 } catch (InvalidCastException ex) {
 960                                         // Invalid attempt to GetBytes on column
 961                                         // 'type_datetime'.
 962                                         // The GetBytes function can only be used
 963                                         // on columns of type Text, NText, or Image
 964                                         Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#C2");
 965                                         Assert.IsNull (ex.InnerException, "#C3");
 966                                         Assert.IsNotNull (ex.Message, "#C4");
 967                                         Assert.IsTrue (ex.Message.IndexOf ("'type_datetime'") != -1, "#C5:" + ex.Message);
 968                                         Assert.IsTrue (ex.Message.IndexOf ("GetBytes") != -1, "#C6:" + ex.Message);
 969                                         Assert.IsTrue (ex.Message.IndexOf ("Text") != -1, "#C7:" + ex.Message);
 970                                         Assert.IsTrue (ex.Message.IndexOf ("NText") != -1, "#C8:" + ex.Message);
 971                                         Assert.IsTrue (ex.Message.IndexOf ("Image") != -1, "#C9:" + ex.Message);
 972                                 }
 973                         }
 974
 975                         using (IDataReader reader = cmd.ExecuteReader ()) {
 976                                 Assert.IsTrue (reader.Read ());
 977
 978                                 try {
 979                                         reader.GetBytes (0, 0, null, 0, 0);
 980                                         Assert.Fail ("#D1");
 981                                 } catch (InvalidCastException ex) {
 982                                         // Invalid attempt to GetBytes on column
 983                                         // 'type_datetime'.
 984                                         // The GetBytes function can only be used
 985                                         // on columns of type Text, NText, or Image
 986                                         Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#D2");
 987                                         Assert.IsNull (ex.InnerException, "#D3");
 988                                         Assert.IsNotNull (ex.Message, "#D4");
 989                                         Assert.IsTrue (ex.Message.IndexOf ("'type_datetime'") != -1, "#D5:" + ex.Message);
 990                                         Assert.IsTrue (ex.Message.IndexOf ("GetBytes") != -1, "#D6:" + ex.Message);
 991                                         Assert.IsTrue (ex.Message.IndexOf ("Text") != -1, "#D7:" + ex.Message);
 992                                         Assert.IsTrue (ex.Message.IndexOf ("NText") != -1, "#D8:" + ex.Message);
 993                                         Assert.IsTrue (ex.Message.IndexOf ("Image") != -1, "#D9:" + ex.Message);
 994                                 }
 995                         }
 996                 }
 997
 998                 [Test]
 999                 public void GetBytes_Type_Text ()
1000                 {
1001                         long len;
1002                         byte [] buffer;
1003                         byte [] expected;
1004
1005                         cmd.CommandText = "SELECT type_text FROM string_family order by id asc";
1006
1007                         using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
1008                                 expected = new byte [] { 0x74, 0x65, 0x78,
1009                                         0x74 };
1010
1011                                 Assert.IsTrue (reader.Read (), "#A1");
1012                                 len = reader.GetBytes (0, 0, null, 0, 0);
1013                                 Assert.AreEqual (4, len, "#A2");
1014                                 buffer = new byte [len];
1015                                 len = reader.GetBytes (0, 0, buffer, 0, (int) len);
1016                                 Assert.AreEqual (4, len, "#A3");
1017                                 Assert.AreEqual (expected, buffer, "#A4");
1018
1019                                 expected = new byte [] { 0x00, 0x00, 0x6f, 0x6e,
1020                                         0x67, 0x00 };
1021
1022                                 Assert.IsTrue (reader.Read (), "#B1");
1023                                 len = reader.GetBytes (0, 0, null, 0, 0);
1024                                 Assert.AreEqual (270, len, "#B2");
1025                                 buffer = new byte [6];
1026                                 len = reader.GetBytes (0, 1, buffer, 2, 3);
1027                                 Assert.AreEqual (3, len, "#B3");
1028                                 Assert.AreEqual (expected, buffer, "#B4");
1029
1030                                 expected = new byte [0];
1031
1032                                 Assert.IsTrue (reader.Read (), "#C1");
1033                                 len = reader.GetBytes (0, 0, null, 0, 0);
1034                                 Assert.AreEqual (0, len, "#C2");
1035                                 buffer = new byte [len];
1036                                 len = reader.GetBytes (0, 0, buffer, 0, 0);
1037                                 Assert.AreEqual (0, len, "#C3");
1038                                 Assert.AreEqual (expected, buffer, "#C4");
1039
1040                                 Assert.IsTrue (reader.Read (), "#D1");
1041                                 try {
1042                                         reader.GetBytes (0, 0, null, 0, 0);
1043                                         Assert.Fail ("#D2");
1044                                 } catch (SqlNullValueException) {
1045                                 }
1046                         }
1047
1048                         using (IDataReader reader = cmd.ExecuteReader ()) {
1049                                 expected = new byte [] { 0x74, 0x65, 0x78,
1050                                         0x74 };
1051
1052                                 Assert.IsTrue (reader.Read (), "#E1");
1053                                 len = reader.GetBytes (0, 0, null, 0, 0);
1054                                 Assert.AreEqual (4, len, "#E2");
1055                                 buffer = new byte [len];
1056                                 len = reader.GetBytes (0, 0, buffer, 0, (int) len);
1057                                 Assert.AreEqual (4, len, "#E3");
1058                                 Assert.AreEqual (expected, buffer, "#E4");
1059
1060                                 expected = new byte [] { 0x00, 0x00, 0x6f, 0x6e,
1061                                         0x67, 0x00 };
1062
1063                                 Assert.IsTrue (reader.Read (), "#F1");
1064                                 len = reader.GetBytes (0, 0, null, 0, 0);
1065                                 Assert.AreEqual (270, len, "#F2");
1066                                 buffer = new byte [6];
1067                                 len = reader.GetBytes (0, 1, buffer, 2, 3);
1068                                 Assert.AreEqual (3, len, "#F3");
1069                                 Assert.AreEqual (expected, buffer, "#F4");
1070
1071                                 expected = new byte [0];
1072
1073                                 Assert.IsTrue (reader.Read (), "#G1");
1074                                 len = reader.GetBytes (0, 0, null, 0, 0);
1075                                 Assert.AreEqual (0, len, "#G2");
1076                                 buffer = new byte [len];
1077                                 len = reader.GetBytes (0, 0, buffer, 0, 0);
1078                                 Assert.AreEqual (0, len, "#G3");
1079                                 Assert.AreEqual (expected, buffer, "#G4");
1080
1081                                 Assert.IsTrue (reader.Read (), "#H1");
1082                                 try {
1083                                         reader.GetBytes (0, 0, new byte [0], 0, 0);
1084                                         Assert.Fail ("#H2");
1085                                 } catch (NullReferenceException) {
1086                                 }
1087                                 try {
1088                                         reader.GetBytes (0, 0, null, 0, 0);
1089                                         Assert.Fail ("#H3");
1090                                 } catch (NullReferenceException) {
1091                                 }
1092                         }
1093                 }
1094
1095                 [Test]
1096                 public void GetChar ()
1097                 {
1098                         cmd.CommandText = "SELECT type_char FROM string_family where id = 1";
1099
1100                         using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
1101                                 Assert.IsTrue (reader.Read ());
1102
1103                                 try {
1104                                         reader.GetChar (0);
1105                                         Assert.Fail ("#A1");
1106                                 } catch (NotSupportedException ex) {
1107                                         Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#A2");
1108                                         Assert.IsNull (ex.InnerException, "#A3");
1109                                         Assert.IsNotNull (ex.Message, "#A4");
1110                                         Assert.AreEqual ((new NotSupportedException ()).Message, ex.Message, "#A5");
1111                                 }
1112                         }
1113
1114                         using (IDataReader reader = cmd.ExecuteReader ()) {
1115                                 Assert.IsTrue (reader.Read ());
1116
1117                                 try {
1118                                         reader.GetChar (0);
1119                                         Assert.Fail ("#B1");
1120                                 } catch (NotSupportedException ex) {
1121                                         Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#B2");
1122                                         Assert.IsNull (ex.InnerException, "#B3");
1123                                         Assert.IsNotNull (ex.Message, "#B4");
1124                                         Assert.AreEqual ((new NotSupportedException ()).Message, ex.Message, "#B5");
1125                                 }
1126                         }
1127                 }
1128
1129                 [Test]
1130                 public void GetChars ()
1131                 {
1132                         cmd.CommandText = "Select type_char, type_varchar,type_text, type_ntext ";
1133                         cmd.CommandText += "from string_family where id=1";
1134                         reader = cmd.ExecuteReader ();
1135                         reader.Read ();
1136                         string charstring = reader.GetString (0);
1137                         //string ncharstring = reader.GetString (1);
1138                         string varcharstring = reader.GetString (1);
1139                         //string nvarcharstring = reader.GetString (2);
1140                         string textstring = reader.GetString (2);
1141                         string ntextstring = reader.GetString (3);
1142                         reader.Close ();
1143
1144                         reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess);
1145                         reader.Read ();
1146                         int len = 0;
1147                         char[] arr;
1148
1149                         len = (int) reader.GetChars (0, 0, null, 0, 0);
1150                         Assert.AreEqual (charstring.Length, len, "#1");
1151                         arr = new char [len];
1152                         reader.GetChars (0, 0, arr, 0, len);
1153                         Assert.AreEqual (0, charstring.CompareTo (new String (arr)), "#2");
1154
1155                         len = (int)reader.GetChars (1,0,null,0,0);
1156                         Assert.AreEqual (varcharstring.Length, len, "#3");
1157                         arr = new char [len];
1158                         reader.GetChars (1, 0,arr,0,len);
1159                         Assert.AreEqual (0, varcharstring.CompareTo (new String (arr)), "#4");
1160
1161                         len = (int)reader.GetChars (2,0,null,0,0);
1162                         Assert.AreEqual (textstring.Length, len, "#5");
1163                         arr = new char [len];
1164                         reader.GetChars (2,0,arr,0,len);
1165                         Assert.AreEqual (0, textstring.CompareTo (new String (arr)), "#6");
1166
1167                         len = (int)reader.GetChars (3,0,null,0,0);
1168                         Assert.AreEqual (ntextstring.Length, len, "#7");
1169                         arr = new char [len];
1170                         reader.GetChars (3,0,arr,0,len);
1171                         Assert.AreEqual (0, ntextstring.CompareTo (new String (arr)), "#8");
1172
1173                         reader.Close ();
1174
1175                         reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess);
1176                         reader.Read ();
1177
1178                         len  = (int)reader.GetChars (0,0,null,0,0);
1179                         arr = new char [10];
1180                         for (int i = 0; i < len; ++i) {
1181                                 Assert.AreEqual (len - i, reader.GetChars (0, i, null, 0, 0), "#9_" + i);
1182                                 Assert.AreEqual (1, reader.GetChars (0, i, arr, 0, 1), "#10_" + i);
1183                                 Assert.AreEqual (charstring [i], arr [0], "#11_" + i);
1184                         }
1185                         Assert.AreEqual (0, reader.GetChars (0, len + 10, null, 0, 0));
1186
1187                         reader.Close ();
1188                 }
1189
1190                 [Test]
1191                 public void GetStringTest ()
1192                 {
1193                         cmd.CommandText = "Select type_varchar,10,convert(varchar,null)";
1194                         cmd.CommandText += "from string_family where id=1";
1195                         reader = cmd.ExecuteReader ();
1196                         reader.Read ();
1197                         // Test for standard exceptions
1198                         GetMethodTests("String");
1199
1200                         // Test if data is returned correctly
1201                         Assert.AreEqual (stringRow["type_varchar"], reader.GetString(0),
1202                                 "#2 DataValidation Failed");
1203
1204                         // Test for standard exceptions
1205                         GetMethodTests("SqlString");
1206
1207                         // Test if data is returned correctly
1208                         Assert.AreEqual (stringRow["type_varchar"], reader.GetSqlString(0).Value,
1209                                 "#4 DataValidation Failed");
1210                         reader.Close();
1211                 }
1212
1213                 [Test]
1214                 public void GetSqlBinaryTest ()
1215                 {
1216                         cmd.CommandText = "Select type_binary ,10 ,convert(binary,null)";
1217                         cmd.CommandText += "from binary_family where id=1";
1218                         reader = cmd.ExecuteReader ();
1219                         reader.Read ();
1220                         // Test for standard exceptions
1221                         GetMethodTests ("SqlBinary");
1222
1223                         // Test if data is returned correctly
1224                         Assert.AreEqual (binaryRow["type_binary"], reader.GetSqlBinary(0).Value,
1225                                 "#2 DataValidation Failed");
1226                         reader.Close ();
1227                 }
1228
1229                 [Test]
1230                 public void GetGuidTest ()
1231                 {
1232                         cmd.CommandText = "Select type_guid,id,convert(uniqueidentifier,null)";
1233                         cmd.CommandText += "from string_family where id=1";
1234                         reader = cmd.ExecuteReader ();
1235                         reader.Read ();
1236
1237                         // Test for standard exceptions
1238                         GetMethodTests("Guid");
1239
1240                         // Test if data is returned correctly
1241                         Assert.AreEqual (stringRow["type_guid"], reader.GetGuid(0),
1242                                 "#2 DataValidation Failed");
1243
1244                         // Test for standard exceptions
1245                         GetMethodTests("SqlGuid");
1246
1247                         // Test if data is returned correctly
1248                         Assert.AreEqual (stringRow["type_guid"], reader.GetSqlGuid(0).Value,
1249                                 "#4 DataValidation Failed");
1250                         reader.Close ();
1251                 }
1252
1253                 [Test]
1254                 public void GetDateTimeTest ()
1255                 {
1256                         cmd.CommandText = "Select type_datetime,10,convert(datetime,null)";
1257                         cmd.CommandText += "from datetime_family where id=1";
1258                         reader = cmd.ExecuteReader ();
1259                         reader.Read ();
1260
1261                         // Test for standard exceptions
1262                         GetMethodTests("DateTime");
1263
1264                         // Test if data is returned correctly
1265                         Assert.AreEqual (datetimeRow["type_datetime"], reader.GetDateTime(0),
1266                                 "#2 DataValidation Failed");
1267
1268                         // Test for standard exceptions
1269                         GetMethodTests("SqlDateTime");
1270
1271                         // Test if data is returned correctly
1272                         Assert.AreEqual (datetimeRow["type_datetime"], reader.GetSqlDateTime(0).Value,
1273                                 "#2 DataValidation Failed");
1274                         reader.Close ();
1275                 }
1276
1277                 [Test]
1278                 [Ignore ("Not Supported by msdotnet")]
1279                 public void GetCharTest ()
1280                 {
1281                         cmd.CommandText = "Select type_char,type_guid,convert(char,null)";
1282                         cmd.CommandText += "from string_family where id=1";
1283                         reader = cmd.ExecuteReader ();
1284                         reader.Read ();
1285                         // Test for standard exceptions
1286                         GetMethodTests ("Char");
1287                         reader.Close ();
1288                 }
1289
1290                 [Test]
1291                 public void GetValueTest ()
1292                 {
1293                         cmd.CommandText = "Select id, null from numeric_family where id=1";
1294                         reader = cmd.ExecuteReader ();
1295                         reader.Read ();
1296
1297                         object obj = null;
1298                         obj = reader.GetValue (0);
1299                         Assert.AreEqual ((byte)1, obj, "#1 Shud return the value of id");
1300                         obj = reader.GetValue (1);
1301                         Assert.AreEqual (DBNull.Value, obj, "#2 shud return DBNull");
1302                         reader.Close ();
1303                 }
1304
1305                 [Test]
1306                 public void GetValuesTest ()
1307                 {
1308                         cmd.CommandText = "Select 10,20,30 from numeric_family where id=1";
1309                         reader = cmd.ExecuteReader ();
1310                         reader.Read ();
1311                         object[] arr = null;
1312                         int count = 0;
1313
1314                         arr = new object[1];
1315                         count = reader.GetValues (arr);
1316                         Assert.AreEqual (10, (int)arr[0], "#1 Only first object shud be copied");
1317                         Assert.AreEqual (1, count, "#1 return value shud equal objects copied");
1318
1319                         arr = new object[3];
1320                         count = reader.GetValues (arr);
1321                         Assert.AreEqual (3, count, "#2 return value shud equal objects copied");
1322
1323                         arr = new object [5];
1324                         count = reader.GetValues (arr);
1325                         Assert.AreEqual (3, count, "#3 return value shud equal objects copied");
1326                         Assert.IsNull (arr[3], "#4 Only 3 objects shud be copied");
1327
1328                         reader.Close ();
1329                 }
1330
1331                 [Test]
1332                 public void GetValues_Values_Null ()
1333                 {
1334                         cmd.CommandText = "SELECT type_blob FROM binary_family where id = 1";
1335
1336                         using (IDataReader rdr = cmd.ExecuteReader ()) {
1337                                 Assert.IsTrue (rdr.Read ());
1338
1339                                 try {
1340                                         rdr.GetValues ((object []) null);
1341                                         Assert.Fail ("#1");
1342                                 } catch (ArgumentNullException ex) {
1343                                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1344                                         Assert.IsNull (ex.InnerException, "#3");
1345                                         Assert.IsNotNull (ex.Message, "#4");
1346                                         Assert.AreEqual ("values", ex.ParamName, "#5");
1347                                 }
1348                         }
1349                 }
1350
1351                 [Test]
1352                 public void GetSqlValue ()
1353                 {
1354                         cmd.CommandText = "Select id, type_tinyint, null from numeric_family where id=1";
1355                         reader = cmd.ExecuteReader ();
1356                         reader.Read ();
1357
1358                         Assert.AreEqual ((byte) 255, ((SqlByte) reader.GetSqlValue (1)).Value, "#1");
1359                         //Assert.AreEqual (DBNull.Value, reader.GetSqlValue(2), "#2");
1360
1361                         reader.Close ();
1362                 }
1363
1364                 [Test]
1365                 public void GetSqlValue_Index_Invalid ()
1366                 {
1367                         cmd.CommandText = "Select id, type_tinyint, null from numeric_family where id=1";
1368                         reader = cmd.ExecuteReader ();
1369                         reader.Read ();
1370
1371                         try {
1372                                 reader.GetSqlValue (-1);
1373                                 Assert.Fail ("#A1");
1374                         } catch (IndexOutOfRangeException ex) {
1375                                 // Index was outside the bounds of the array
1376                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2");
1377                                 Assert.IsNull (ex.InnerException, "#A3");
1378                                 Assert.IsNotNull (ex.Message, "#A4");
1379                         }
1380
1381                         try {
1382                                 reader.GetSqlValue (3);
1383                                 Assert.Fail ("#B1");
1384                         } catch (IndexOutOfRangeException ex) {
1385                                 // Index was outside the bounds of the array
1386                                 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2");
1387                                 Assert.IsNull (ex.InnerException, "#B3");
1388                                 Assert.IsNotNull (ex.Message, "#B4");
1389                         }
1390                 }
1391
1392                 [Test]
1393                 public void GetSqlValue_Reader_Closed ()
1394                 {
1395                         SqlCommand cmd = conn.CreateCommand ();
1396                         cmd.CommandText = "SELECT * FROM employee";
1397                         using (SqlDataReader rdr = cmd.ExecuteReader ()) {
1398                                 rdr.Read ();
1399                                 rdr.Close ();
1400                                 try {
1401                                         rdr.GetSqlValue (-1);
1402                                         Assert.Fail ("#1");
1403                                 } catch (InvalidOperationException ex) {
1404                                         // Invalid attempt to call MetaData
1405                                         // when reader is closed
1406                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
1407                                         Assert.IsNull (ex.InnerException, "#3");
1408                                         Assert.IsNotNull (ex.Message, "#4");
1409                                 }
1410                         }
1411                 }
1412
1413                 [Test]
1414                 public void GetSqlValue_Reader_NoData ()
1415                 {
1416                         SqlCommand cmd = conn.CreateCommand ();
1417                         cmd.CommandText = "SELECT * FROM employee where id = 6666";
1418                         using (SqlDataReader rdr = cmd.ExecuteReader ()) {
1419                                 try {
1420                                         rdr.GetSqlValue (-1);
1421                                         Assert.Fail ("#A1");
1422                                 } catch (InvalidOperationException ex) {
1423                                         // Invalid attempt to read when no data
1424                                         // is present
1425                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
1426                                         Assert.IsNull (ex.InnerException, "#A3");
1427                                         Assert.IsNotNull (ex.Message, "#A4");
1428                                 }
1429
1430                                 Assert.IsFalse (rdr.Read (), "#B");
1431
1432                                 try {
1433                                         rdr.GetSqlValue (-1);
1434                                         Assert.Fail ("#C1");
1435                                 } catch (InvalidOperationException ex) {
1436                                         // Invalid attempt to read when no data
1437                                         // is present
1438                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
1439                                         Assert.IsNull (ex.InnerException, "#C3");
1440                                         Assert.IsNotNull (ex.Message, "#C4");
1441                                 }
1442                         }
1443                 }
1444
1445                 [Test]
1446                 public void GetSqlValues ()
1447                 {
1448                         cmd.CommandText = "Select 10,20,30 from numeric_family where id=1";
1449                         reader = cmd.ExecuteReader ();
1450                         reader.Read ();
1451                         object[] arr = null;
1452                         int count = 0;
1453
1454                         arr = new object[1];
1455                         count = reader.GetSqlValues (arr);
1456                         // Something is wrong with types ... gotta figure it out
1457                         //Assert.AreEqual (10, arr[0], "#1 Only first object shud be copied");
1458                         Assert.AreEqual (1, count, "#1 return value shud equal objects copied");
1459
1460                         arr = new object[3];
1461                         count = reader.GetSqlValues (arr);
1462                         Assert.AreEqual (3, count, "#2 return value shud equal objects copied");
1463
1464                         arr = new object[5];
1465                         count = reader.GetSqlValues (arr);
1466                         Assert.AreEqual (3, count, "#3 return value shud equal objects copied");
1467                         Assert.IsNull (arr[3], "#4 Only 3 objects shud be copied");
1468
1469                         reader.Close ();
1470                 }
1471
1472                 [Test]
1473                 public void GetSqlValues_Reader_Closed ()
1474                 {
1475                         SqlCommand cmd = conn.CreateCommand ();
1476                         cmd.CommandText = "SELECT * FROM employee";
1477                         using (SqlDataReader rdr = cmd.ExecuteReader ()) {
1478                                 rdr.Read ();
1479                                 rdr.Close ();
1480                                 try {
1481                                         rdr.GetSqlValues (null);
1482                                         Assert.Fail ("#1");
1483                                 } catch (InvalidOperationException ex) {
1484                                         // Invalid attempt to call MetaData
1485                                         // when reader is closed
1486                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
1487                                         Assert.IsNull (ex.InnerException, "#3");
1488                                         Assert.IsNotNull (ex.Message, "#4");
1489                                 }
1490                         }
1491                 }
1492
1493                 [Test]
1494                 public void GetSqlValues_Reader_NoData ()
1495                 {
1496                         SqlCommand cmd = conn.CreateCommand ();
1497                         cmd.CommandText = "SELECT * FROM employee where id = 6666";
1498                         using (SqlDataReader rdr = cmd.ExecuteReader ()) {
1499                                 try {
1500                                         rdr.GetSqlValues (null);
1501                                         Assert.Fail ("#A1");
1502                                 } catch (InvalidOperationException ex) {
1503                                         // Invalid attempt to read when no data
1504                                         // is present
1505                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
1506                                         Assert.IsNull (ex.InnerException, "#A3");
1507                                         Assert.IsNotNull (ex.Message, "#A4");
1508                                 }
1509
1510                                 Assert.IsFalse (rdr.Read (), "#B");
1511
1512                                 try {
1513                                         rdr.GetSqlValues (null);
1514                                         Assert.Fail ("#C1");
1515                                 } catch (InvalidOperationException ex) {
1516                                         // Invalid attempt to read when no data
1517                                         // is present
1518                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
1519                                         Assert.IsNull (ex.InnerException, "#C3");
1520                                         Assert.IsNotNull (ex.Message, "#C4");
1521                                 }
1522                         }
1523                 }
1524
1525                 [Test]
1526                 public void GetSqlValues_Values_Null ()
1527                 {
1528                         SqlCommand cmd = conn.CreateCommand ();
1529                         cmd.CommandText = "SELECT * FROM employee";
1530                         using (SqlDataReader rdr = cmd.ExecuteReader ()) {
1531                                 rdr.Read ();
1532                                 try {
1533                                         rdr.GetSqlValues (null);
1534                                         Assert.Fail ("#1");
1535                                 } catch (ArgumentNullException ex) {
1536                                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1537                                         Assert.IsNull (ex.InnerException, "#3");
1538                                         Assert.IsNotNull (ex.Message, "#4");
1539                                         Assert.AreEqual ("values", ex.ParamName, "#5");
1540                                 }
1541                         }
1542                 }
1543
1544                 [Test]
1545                 public void HasRows ()
1546                 {
1547                         SqlCommand cmd = conn.CreateCommand ();
1548                         cmd.CommandText = "SELECT id FROM employee WHERE id in (1, 2) ORDER BY id ASC";
1549                         using (SqlDataReader rdr = cmd.ExecuteReader ()) {
1550                                 Assert.IsTrue (rdr.HasRows, "#A1");
1551                                 try {
1552                                         rdr.GetValue (0);
1553                                         Assert.Fail ("#A2");
1554                                 } catch (InvalidOperationException) {
1555                                 }
1556                                 Assert.IsTrue (rdr.HasRows, "#A3");
1557                                 Assert.IsTrue (rdr.Read (), "#A4");
1558                                 Assert.AreEqual (1, rdr.GetValue (0), "#A5");
1559                                 Assert.IsTrue (rdr.HasRows, "#A6");
1560                                 Assert.AreEqual (1, rdr.GetValue (0), "#A7");
1561                                 Assert.IsTrue (rdr.Read (), "#A8");
1562                                 Assert.AreEqual (2, rdr.GetValue (0), "#A9");
1563                                 Assert.IsTrue (rdr.HasRows, "#A10");
1564                                 Assert.IsFalse (rdr.Read (), "#A11");
1565                                 Assert.IsTrue (rdr.HasRows, "#A12");
1566                                 Assert.IsFalse (rdr.NextResult (), "#A13");
1567                                 Assert.IsFalse (rdr.HasRows, "#A14");
1568                         }
1569
1570                         cmd.CommandText = "SELECT id FROM employee WHERE id = 666";
1571                         using (SqlDataReader rdr = cmd.ExecuteReader ()) {
1572                                 Assert.IsFalse (rdr.HasRows, "#B1");
1573                                 Assert.IsFalse (rdr.Read (), "#B2");
1574                         }
1575
1576                         cmd.CommandText = "SELECT id FROM employee WHERE id = 666; SELECT 3";
1577                         using (SqlDataReader rdr = cmd.ExecuteReader ()) {
1578                                 Assert.IsFalse (rdr.HasRows, "#C1");
1579                                 Assert.IsFalse (rdr.Read (), "#C2");
1580                                 Assert.IsFalse (rdr.HasRows, "#C3");
1581                                 Assert.IsTrue (rdr.NextResult (), "#C4");
1582                                 Assert.IsTrue (rdr.HasRows, "#C5");
1583                                 try {
1584                                         rdr.GetValue (0);
1585                                         Assert.Fail ("#C6");
1586                                 } catch (InvalidOperationException) {
1587                                 }
1588                                 Assert.IsTrue (rdr.Read (), "#C7");
1589                                 Assert.AreEqual (3, rdr.GetValue (0), "#C8");
1590                                 Assert.IsTrue (rdr.HasRows, "#C9");
1591                                 Assert.AreEqual (3, rdr.GetValue (0), "#C10");
1592                                 Assert.IsFalse (rdr.Read (), "#C11");
1593                                 Assert.IsTrue (rdr.HasRows, "#C12");
1594                                 try {
1595                                         rdr.GetValue (0);
1596                                         Assert.Fail ("#C13");
1597                                 } catch (InvalidOperationException) {
1598                                 }
1599                                 Assert.IsFalse (rdr.NextResult (), "#C14");
1600                                 Assert.IsFalse (rdr.HasRows, "#C15");
1601                                 Assert.IsFalse (rdr.Read (), "#C16");
1602                                 Assert.IsFalse (rdr.HasRows, "#C17");
1603                         }
1604
1605                         cmd.CommandText = "SELECT id FROM employee WHERE id = 1; SELECT 3";
1606                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.SingleResult)) {
1607                                 Assert.IsTrue (rdr.HasRows, "#D1");
1608                                 Assert.IsTrue (rdr.Read (), "#D2");
1609                                 Assert.IsTrue (rdr.HasRows, "#D3");
1610                                 Assert.IsFalse (rdr.NextResult (), "#D4");
1611                                 Assert.IsFalse (rdr.HasRows, "#D5");
1612                                 Assert.IsFalse (rdr.Read (), "#D6");
1613                                 Assert.IsFalse (rdr.HasRows, "#D7");
1614                         }
1615
1616                         cmd.CommandText = "SELECT id FROM employee WHERE id = 666; SELECT 3";
1617                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.SingleResult)) {
1618                                 Assert.IsFalse (rdr.HasRows, "#E1");
1619                                 Assert.IsFalse (rdr.Read (), "#E2");
1620                                 Assert.IsFalse (rdr.HasRows, "#E3");
1621                                 Assert.IsFalse (rdr.NextResult (), "#E4");
1622                                 Assert.IsFalse (rdr.HasRows, "#E5");
1623                                 Assert.IsFalse (rdr.Read (), "#E6");
1624                                 Assert.IsFalse (rdr.HasRows, "#E7");
1625                         }
1626
1627                         cmd.CommandText = "SELECT id FROM employee WHERE id = 1; SELECT 3";
1628                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.SchemaOnly)) {
1629                                 Assert.IsFalse (rdr.HasRows, "#F1");
1630                                 try {
1631                                         rdr.GetValue (0);
1632                                         Assert.Fail ("#F2");
1633                                 } catch (InvalidOperationException) {
1634                                 }
1635                                 Assert.IsFalse (rdr.Read (), "#F3");
1636                                 try {
1637                                         rdr.GetValue (0);
1638                                         Assert.Fail ("#F4");
1639                                 } catch (InvalidOperationException) {
1640                                 }
1641                                 Assert.IsFalse (rdr.HasRows, "#F5");
1642                                 try {
1643                                         rdr.GetValue (0);
1644                                         Assert.Fail ("#F6");
1645                                 } catch (InvalidOperationException) {
1646                                 }
1647                                 Assert.IsTrue (rdr.NextResult (), "#F7");
1648                                 try {
1649                                         rdr.GetValue (0);
1650                                         Assert.Fail ("#F8");
1651                                 } catch (InvalidOperationException) {
1652                                 }
1653                                 Assert.IsFalse (rdr.HasRows, "#F9");
1654                                 Assert.IsFalse (rdr.Read (), "#F10");
1655                                 Assert.IsFalse (rdr.HasRows, "#F11");
1656                                 Assert.IsFalse (rdr.NextResult (), "#F12");
1657                                 Assert.IsFalse (rdr.HasRows, "#F13");
1658                                 Assert.IsFalse (rdr.Read (), "#F14");
1659                                 Assert.IsFalse (rdr.HasRows, "#F15");
1660                         }
1661
1662                         cmd.CommandText = "SELECT id FROM employee WHERE id = 666; SELECT 3";
1663                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.SchemaOnly)) {
1664                                 Assert.IsFalse (rdr.HasRows, "#G1");
1665                                 Assert.IsFalse (rdr.Read (), "#G2");
1666                                 Assert.IsFalse (rdr.HasRows, "#G3");
1667                                 Assert.IsTrue (rdr.NextResult (), "#G4");
1668                                 Assert.IsFalse (rdr.HasRows, "#G5");
1669                                 Assert.IsFalse (rdr.Read (), "#G6");
1670                                 Assert.IsFalse (rdr.HasRows, "#G7");
1671                                 Assert.IsFalse (rdr.NextResult (), "#G8");
1672                                 Assert.IsFalse (rdr.HasRows, "#G9");
1673                                 Assert.IsFalse (rdr.Read (), "#G10");
1674                                 Assert.IsFalse (rdr.HasRows, "#G11");
1675                         }
1676                 }
1677
1678                 [Test]
1679                 public void HasRows_Reader_Closed ()
1680                 {
1681                         SqlCommand cmd = conn.CreateCommand ();
1682                         cmd.CommandText = "SELECT id FROM employee WHERE id in (1, 2) ORDER BY id ASC";
1683                         using (SqlDataReader rdr = cmd.ExecuteReader ()) {
1684                                 rdr.Close ();
1685                                 try {
1686                                         bool hasRows = rdr.HasRows;
1687                                         Assert.Fail ("#A1:" + hasRows);
1688                                 } catch (InvalidOperationException ex) {
1689                                         // Invalid attempt to call MetaData
1690                                         // when reader is closed
1691                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
1692                                         Assert.IsNull (ex.InnerException, "#A3");
1693                                         Assert.IsNotNull (ex.Message, "#A4");
1694                                 }
1695                         }
1696
1697                         using (SqlDataReader rdr = cmd.ExecuteReader ()) {
1698                                 Assert.IsTrue (rdr.Read (), "#B1");
1699                                 rdr.Close ();
1700                                 try {
1701                                         bool hasRows = rdr.HasRows;
1702                                         Assert.Fail ("#B2:" + hasRows);
1703                                 } catch (InvalidOperationException ex) {
1704                                         // Invalid attempt to call MetaData
1705                                         // when reader is closed
1706                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B3");
1707                                         Assert.IsNull (ex.InnerException, "#B4");
1708                                         Assert.IsNotNull (ex.Message, "#B5");
1709                                 }
1710                         }
1711                 }
1712
1713                 [Test]
1714                 public void isDBNullTest ()
1715                 {
1716                         cmd.CommandText = "select id , null from numeric_family where id=1";
1717                         reader = cmd.ExecuteReader ();
1718                         reader.Read ();
1719
1720                         Assert.IsFalse (reader.IsDBNull (0), "#1");
1721                         Assert.IsTrue (reader.IsDBNull (1) , "#2");
1722
1723                         try {
1724                                 reader.IsDBNull (10);
1725                                 Assert.Fail ("#1 Invalid Argument");
1726                         } catch (IndexOutOfRangeException e) {
1727                                 Assert.AreEqual (typeof(IndexOutOfRangeException), e.GetType(),
1728                                         "#1 Incorrect Exception : " + e);
1729                         }
1730                 }
1731
1732                 [Test]
1733                 public void ReadTest ()
1734                 {
1735                         cmd.CommandText = "select id, type_bit from numeric_family where id=1" ;
1736                         reader = cmd.ExecuteReader ();
1737                         Assert.IsTrue (reader.Read () , "#1");
1738                         Assert.IsFalse (reader.Read (), "#2");
1739                         reader.Close ();
1740
1741                         try {
1742                                 reader.Read ();
1743                                 Assert.Fail ("#3 Exception shud be thrown : Reader is closed");
1744                         } catch (InvalidOperationException e) {
1745                                 Assert.AreEqual (typeof(InvalidOperationException), e.GetType (),
1746                                         "#4 Incorrect Exception : " + e);
1747                         }
1748                 }
1749
1750                 [Test]
1751                 public void NextResult ()
1752                 {
1753                         cmd.CommandText = "Select id from numeric_family where id=1";
1754                         reader = cmd.ExecuteReader ();
1755                         Assert.IsFalse (reader.NextResult (), "#1");
1756                         reader.Close ();
1757
1758                         cmd.CommandText = "select id from numeric_family where id=1;";
1759                         cmd.CommandText += "select type_bit from numeric_family where id=2;";
1760                         reader = cmd.ExecuteReader ();
1761                         Assert.IsTrue (reader.NextResult (), "#B1");
1762                         Assert.IsTrue (reader.Read (), "#B2");
1763                         Assert.IsFalse (reader.NextResult (), "#B3");
1764                         try {
1765                                 reader.GetValue (0);
1766                                 Assert.Fail ("#B3");
1767                         } catch (InvalidOperationException) {
1768                         }
1769                         Assert.IsFalse (reader.Read (), "#B4");
1770                         try {
1771                                 reader.GetValue (0);
1772                                 Assert.Fail ("#B5");
1773                         } catch (InvalidOperationException) {
1774                         }
1775                 }
1776
1777                 [Test]
1778                 public void NextResult_Reader_Close ()
1779                 {
1780                         SqlCommand cmd = conn.CreateCommand ();
1781                         cmd.CommandText = "SELECT * FROM employee";
1782                         using (SqlDataReader rdr = cmd.ExecuteReader ()) {
1783                                 rdr.Read ();
1784                                 rdr.Close ();
1785                                 try {
1786                                         rdr.NextResult ();
1787                                         Assert.Fail ("#1");
1788                                 } catch (InvalidOperationException ex) {
1789                                         // Invalid attempt to NextResult when
1790                                         // reader is closed
1791                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
1792                                         Assert.IsNull (ex.InnerException, "#3");
1793                                         Assert.IsNotNull (ex.Message, "#4");
1794                                 }
1795                         }
1796                 }
1797
1798                 [Test]
1799                 public void GetNameTest ()
1800                 {
1801                         cmd.CommandText = "Select id,10 as gen,20 from numeric_family where id=1";
1802                         reader = cmd.ExecuteReader ();
1803
1804                         Assert.AreEqual ("id" , reader.GetName(0) , "#1");
1805                         Assert.AreEqual ("gen" , reader.GetName(1) , "#2");
1806
1807                         try {
1808                                 reader.GetName (3);
1809                                 Assert.Fail ("#4 Exception shud be thrown");
1810                         } catch (IndexOutOfRangeException e) {
1811                                 Assert.AreEqual (typeof(IndexOutOfRangeException), e.GetType(),
1812                                         "#5 Incorrect Exception : " + e);
1813                         }
1814                 }
1815
1816                 [Test]
1817                 public void GetOrdinalTest ()
1818                 {
1819                         //what is kana-width insensitive ?????
1820                         cmd.CommandText = "Select id,10 as gen,20 from numeric_family where id=1";
1821                         reader = cmd.ExecuteReader ();
1822
1823                         Assert.AreEqual (0, reader.GetOrdinal ("id"), "#1");
1824                         Assert.AreEqual (0, reader.GetOrdinal ("ID"), "#2");
1825                         Assert.AreEqual (1, reader.GetOrdinal ("gen"), "#3");
1826                         // Would expect column1,columnn2 etc for unnamed columns,
1827                         // but msdotnet return empty string for unnamed columns
1828                         Assert.AreEqual (2, reader.GetOrdinal (""), "#4");
1829
1830                         try {
1831                                 reader.GetOrdinal ("invalidname");
1832                         } catch (IndexOutOfRangeException e) {
1833                                 Assert.AreEqual (typeof (IndexOutOfRangeException),
1834                                         e.GetType(), "#4 Incorrect Exception : " + e);
1835                         }
1836                 }
1837
1838                 [Test]
1839                 public void GetSchemaTable ()
1840                 {
1841                         IDbConnection conn = ConnectionManager.Singleton.Connection;
1842                         ConnectionManager.Singleton.OpenConnection ();
1843
1844                         IDbCommand cmd = null;
1845                         IDataReader reader = null;
1846                         DataTable schema;
1847                         DataRow pkRow;
1848
1849                         try {
1850                                 cmd = conn.CreateCommand ();
1851                                 cmd.CommandText = "select id, fname, id + 20 as plustwenty from employee";
1852                                 reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo);
1853                                 schema = reader.GetSchemaTable ();
1854                                 reader.Close ();
1855
1856                                 AssertSchemaTableStructure (schema, "#A:");
1857                                 Assert.AreEqual (3, schema.Rows.Count, "#A:RowCount");
1858                                 pkRow = schema.Select ("ColumnName = 'id'") [0];
1859                                 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#A:ColumnName_IsNull");
1860                                 Assert.AreEqual ("id", pkRow ["ColumnName"], "#A:ColumnName_Value");
1861                                 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#A:ColumnOrdinal_IsNull");
1862                                 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#A:ColumnOrdinal_Value");
1863                                 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#A:ColumnSize_IsNull");
1864                                 Assert.AreEqual (4, pkRow ["ColumnSize"], "#A:ColumnSize_Value");
1865                                 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#A:NumericPrecision_IsNull");
1866                                 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#A:NumericPrecision_Value");
1867                                 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#A:NumericScale_IsNull");
1868                                 Assert.AreEqual (255, pkRow ["NumericScale"], "#A:NumericScale_Value");
1869                                 Assert.IsFalse (pkRow.IsNull ("DataType"), "#A:DataType_IsNull");
1870                                 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#A:DataType_Value");
1871                                 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#A:ProviderType_IsNull");
1872                                 Assert.AreEqual (8, pkRow ["ProviderType"], "#A:ProviderType_Value");
1873                                 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#A:IsLong_IsNull");
1874                                 Assert.AreEqual (false, pkRow ["IsLong"], "#A:IsLong_Value");
1875                                 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#A:AllowDBNull_IsNull");
1876                                 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#A:AllowDBNull_Value");
1877                                 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#A:IsReadOnly_IsNull");
1878                                 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#A:IsReadOnly_Value");
1879                                 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#A:IsRowVersion_IsNull");
1880                                 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#A:IsRowVersion_Value");
1881                                 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#A:IsUnique_IsNull");
1882                                 Assert.AreEqual (false, pkRow ["IsUnique"], "#A:IsUnique_Value");
1883                                 Assert.IsFalse (pkRow.IsNull ("IsKey"), "#A:IsKey_IsNull");
1884                                 Assert.AreEqual (true, pkRow ["IsKey"], "#A:IsKey_Value");
1885                                 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#A:IsAutoIncrement_IsNull");
1886                                 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#A:IsAutoIncrement_Value");
1887                                 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#A:BaseSchemaName_IsNull");
1888                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#A:BaseSchemaName_Value");
1889                                 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#A:BaseCatalogName_IsNull");
1890                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#A:BaseCatalogName_Value");
1891                                 Assert.IsFalse (pkRow.IsNull ("BaseTableName"), "#A:BaseTableName_IsNull");
1892                                 Assert.AreEqual ("employee", pkRow ["BaseTableName"], "#A:BaseTableName_Value");
1893                                 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#A:BaseColumnName_IsNull");
1894                                 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#A:BaseColumnName_Value");
1895
1896                                 reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly);
1897                                 schema = reader.GetSchemaTable ();
1898                                 reader.Close ();
1899
1900                                 AssertSchemaTableStructure (schema, "#B:");
1901                                 Assert.AreEqual (3, schema.Rows.Count, "#B:RowCount");
1902                                 pkRow = schema.Select ("ColumnName = 'id'") [0];
1903                                 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#B:ColumnName_IsNull");
1904                                 Assert.AreEqual ("id", pkRow ["ColumnName"], "#B:ColumnName_Value");
1905                                 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#B:ColumnOrdinal_IsNull");
1906                                 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#B:ColumnOrdinal_Value");
1907                                 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#B:ColumnSize_IsNull");
1908                                 Assert.AreEqual (4, pkRow ["ColumnSize"], "#B:ColumnSize_Value");
1909                                 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#B:NumericPrecision_IsNull");
1910                                 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#B:NumericPrecision_Value");
1911                                 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#B:NumericScale_IsNull");
1912                                 Assert.AreEqual (255, pkRow ["NumericScale"], "#B:NumericScale_Value");
1913                                 Assert.IsFalse (pkRow.IsNull ("DataType"), "#B:DataType_IsNull");
1914                                 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#B:DataType_Value");
1915                                 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#B:ProviderType_IsNull");
1916                                 Assert.AreEqual (8, pkRow ["ProviderType"], "#B:ProviderType_Value");
1917                                 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#B:IsLong_IsNull");
1918                                 Assert.AreEqual (false, pkRow ["IsLong"], "#B:IsLong_Value");
1919                                 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#B:AllowDBNull_IsNull");
1920                                 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#B:AllowDBNull_Value");
1921                                 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#B:IsReadOnly_IsNull");
1922                                 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#B:IsReadOnly_Value");
1923                                 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#B:IsRowVersion_IsNull");
1924                                 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#B:IsRowVersion_Value");
1925                                 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#B:IsUnique_IsNull");
1926                                 Assert.AreEqual (false, pkRow ["IsUnique"], "#B:IsUnique_Value");
1927                                 Assert.IsTrue (pkRow.IsNull ("IsKey"), "#B:IsKey_IsNull");
1928                                 Assert.AreEqual (DBNull.Value, pkRow ["IsKey"], "#B:IsKey_Value");
1929                                 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#B:IsAutoIncrement_IsNull");
1930                                 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#B:IsAutoIncrement_Value");
1931                                 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#B:BaseSchemaName_IsNull");
1932                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#B:BaseSchemaName_Value");
1933                                 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#B:BaseCatalogName_IsNull");
1934                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#B:BaseCatalogName_Value");
1935                                 Assert.IsTrue (pkRow.IsNull ("BaseTableName"), "#B:BaseTableName_IsNull");
1936                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseTableName"], "#B:BaseTableName_Value");
1937                                 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#B:BaseColumnName_IsNull");
1938                                 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#B:BaseColumnName_Value");
1939
1940                                 reader = cmd.ExecuteReader (CommandBehavior.KeyInfo);
1941                                 schema = reader.GetSchemaTable ();
1942                                 reader.Close ();
1943
1944                                 AssertSchemaTableStructure (schema, "#C:");
1945                                 Assert.AreEqual (3, schema.Rows.Count, "#C:RowCount");
1946                                 pkRow = schema.Select ("ColumnName = 'id'") [0];
1947                                 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#C:ColumnName_IsNull");
1948                                 Assert.AreEqual ("id", pkRow ["ColumnName"], "#C:ColumnName_Value");
1949                                 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#C:ColumnOrdinal_IsNull");
1950                                 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#C:ColumnOrdinal_Value");
1951                                 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#C:ColumnSize_IsNull");
1952                                 Assert.AreEqual (4, pkRow ["ColumnSize"], "#C:ColumnSize_Value");
1953                                 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#C:NumericPrecision_IsNull");
1954                                 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#C:NumericPrecision_Value");
1955                                 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#C:NumericScale_IsNull");
1956                                 Assert.AreEqual (255, pkRow ["NumericScale"], "#C:NumericScale_Value");
1957                                 Assert.IsFalse (pkRow.IsNull ("DataType"), "#C:DataType_IsNull");
1958                                 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#C:DataType_Value");
1959                                 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#C:ProviderType_IsNull");
1960                                 Assert.AreEqual (8, pkRow ["ProviderType"], "#C:ProviderType_Value");
1961                                 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#C:IsLong_IsNull");
1962                                 Assert.AreEqual (false, pkRow ["IsLong"], "#C:IsLong_Value");
1963                                 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#C:AllowDBNull_IsNull");
1964                                 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#C:AllowDBNull_Value");
1965                                 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#C:IsReadOnly_IsNull");
1966                                 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#C:IsReadOnly_Value");
1967                                 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#C:IsRowVersion_IsNull");
1968                                 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#C:IsRowVersion_Value");
1969                                 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#C:IsUnique_IsNull");
1970                                 Assert.AreEqual (false, pkRow ["IsUnique"], "#C:IsUnique_Value");
1971                                 Assert.IsFalse (pkRow.IsNull ("IsKey"), "#C:IsKey_IsNull");
1972                                 Assert.AreEqual (true, pkRow ["IsKey"], "#C:IsKey_Value");
1973                                 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#C:IsAutoIncrement_IsNull");
1974                                 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#C:IsAutoIncrement_Value");
1975                                 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#C:BaseSchemaName_IsNull");
1976                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#C:BaseSchemaName_Value");
1977                                 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#C:BaseCatalogName_IsNull");
1978                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#C:BaseCatalogName_Value");
1979                                 Assert.IsFalse (pkRow.IsNull ("BaseTableName"), "#C:BaseTableName_IsNull");
1980                                 Assert.AreEqual ("employee", pkRow ["BaseTableName"], "#C:BaseTableName_Value");
1981                                 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#C:BaseColumnName_IsNull");
1982                                 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#C:BaseColumnName_Value");
1983
1984                                 reader = cmd.ExecuteReader ();
1985                                 schema = reader.GetSchemaTable ();
1986                                 reader.Close ();
1987
1988                                 AssertSchemaTableStructure (schema, "#D:");
1989                                 Assert.AreEqual (3, schema.Rows.Count, "#D:RowCount");
1990                                 pkRow = schema.Select ("ColumnName = 'id'") [0];
1991                                 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#D:ColumnName_IsNull");
1992                                 Assert.AreEqual ("id", pkRow ["ColumnName"], "#D:ColumnName_Value");
1993                                 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#D:ColumnOrdinal_IsNull");
1994                                 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#D:ColumnOrdinal_Value");
1995                                 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#D:ColumnSize_IsNull");
1996                                 Assert.AreEqual (4, pkRow ["ColumnSize"], "#D:ColumnSize_Value");
1997                                 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#D:NumericPrecision_IsNull");
1998                                 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#D:NumericPrecision_Value");
1999                                 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#D:NumericScale_IsNull");
2000                                 Assert.AreEqual (255, pkRow ["NumericScale"], "#D:NumericScale_Value");
2001                                 Assert.IsFalse (pkRow.IsNull ("DataType"), "#D:DataType_IsNull");
2002                                 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#D:DataType_Value");
2003                                 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#D:ProviderType_IsNull");
2004                                 Assert.AreEqual (8, pkRow ["ProviderType"], "#D:ProviderType_Value");
2005                                 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#D:IsLong_IsNull");
2006                                 Assert.AreEqual (false, pkRow ["IsLong"], "#D:IsLong_Value");
2007                                 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#D:AllowDBNull_IsNull");
2008                                 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#D:AllowDBNull_Value");
2009                                 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#D:IsReadOnly_IsNull");
2010                                 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#D:IsReadOnly_Value");
2011                                 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#D:IsRowVersion_IsNull");
2012                                 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#D:IsRowVersion_Value");
2013                                 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#D:IsUnique_IsNull");
2014                                 Assert.AreEqual (false, pkRow ["IsUnique"], "#D:IsUnique_Value");
2015                                 Assert.IsTrue (pkRow.IsNull ("IsKey"), "#D:IsKey_IsNull");
2016                                 Assert.AreEqual (DBNull.Value, pkRow ["IsKey"], "#D:IsKey_Value");
2017                                 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#D:IsAutoIncrement_IsNull");
2018                                 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#D:IsAutoIncrement_Value");
2019                                 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#D:BaseSchemaName_IsNull");
2020                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#D:BaseSchemaName_Value");
2021                                 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#D:BaseCatalogName_IsNull");
2022                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#D:BaseCatalogName_Value");
2023                                 Assert.IsTrue (pkRow.IsNull ("BaseTableName"), "#D:BaseTableName_IsNull");
2024                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseTableName"], "#D:BaseTableName_Value");
2025                                 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#D:BaseColumnName_IsNull");
2026                                 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#D:BaseColumnName_Value");
2027
2028                                 cmd = conn.CreateCommand ();
2029                                 cmd.CommandText = "select id, fname, id + 20 as plustwenty from employee";
2030                                 cmd.Prepare ();
2031                                 reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo);
2032                                 schema = reader.GetSchemaTable ();
2033                                 reader.Close ();
2034
2035                                 AssertSchemaTableStructure (schema, "#E:");
2036                                 Assert.AreEqual (3, schema.Rows.Count, "#E:RowCount");
2037                                 pkRow = schema.Select ("ColumnName = 'id'") [0];
2038                                 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#E:ColumnName_IsNull");
2039                                 Assert.AreEqual ("id", pkRow ["ColumnName"], "#E:ColumnName_Value");
2040                                 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#E:ColumnOrdinal_IsNull");
2041                                 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#E:ColumnOrdinal_Value");
2042                                 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#E:ColumnSize_IsNull");
2043                                 Assert.AreEqual (4, pkRow ["ColumnSize"], "#E:ColumnSize_Value");
2044                                 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#E:NumericPrecision_IsNull");
2045                                 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#E:NumericPrecision_Value");
2046                                 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#E:NumericScale_IsNull");
2047                                 Assert.AreEqual (255, pkRow ["NumericScale"], "#E:NumericScale_Value");
2048                                 Assert.IsFalse (pkRow.IsNull ("DataType"), "#E:DataType_IsNull");
2049                                 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#E:DataType_Value");
2050                                 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#E:ProviderType_IsNull");
2051                                 Assert.AreEqual (8, pkRow ["ProviderType"], "#E:ProviderType_Value");
2052                                 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#E:IsLong_IsNull");
2053                                 Assert.AreEqual (false, pkRow ["IsLong"], "#E:IsLong_Value");
2054                                 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#E:AllowDBNull_IsNull");
2055                                 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#E:AllowDBNull_Value");
2056                                 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#E:IsReadOnly_IsNull");
2057                                 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#E:IsReadOnly_Value");
2058                                 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#E:IsRowVersion_IsNull");
2059                                 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#E:IsRowVersion_Value");
2060                                 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#E:IsUnique_IsNull");
2061                                 Assert.AreEqual (false, pkRow ["IsUnique"], "#E:IsUnique_Value");
2062                                 Assert.IsFalse (pkRow.IsNull ("IsKey"), "#E:IsKey_IsNull");
2063                                 Assert.AreEqual (true, pkRow ["IsKey"], "#E:IsKey_Value");
2064                                 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#E:IsAutoIncrement_IsNull");
2065                                 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#E:IsAutoIncrement_Value");
2066                                 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#E:BaseSchemaName_IsNull");
2067                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#E:BaseSchemaName_Value");
2068                                 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#E:BaseCatalogName_IsNull");
2069                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#E:BaseCatalogName_Value");
2070                                 Assert.IsFalse (pkRow.IsNull ("BaseTableName"), "#E:BaseTableName_IsNull");
2071                                 Assert.AreEqual ("employee", pkRow ["BaseTableName"], "#E:BaseTableName_Value");
2072                                 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#E:BaseColumnName_IsNull");
2073                                 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#E:BaseColumnName_Value");
2074
2075                                 reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly);
2076                                 schema = reader.GetSchemaTable ();
2077                                 reader.Close ();
2078
2079                                 AssertSchemaTableStructure (schema, "#F:");
2080                                 Assert.AreEqual (3, schema.Rows.Count, "#F:RowCount");
2081                                 pkRow = schema.Select ("ColumnName = 'id'") [0];
2082                                 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#F:ColumnName_IsNull");
2083                                 Assert.AreEqual ("id", pkRow ["ColumnName"], "#F:ColumnName_Value");
2084                                 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#F:ColumnOrdinal_IsNull");
2085                                 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#F:ColumnOrdinal_Value");
2086                                 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#F:ColumnSize_IsNull");
2087                                 Assert.AreEqual (4, pkRow ["ColumnSize"], "#F:ColumnSize_Value");
2088                                 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#F:NumericPrecision_IsNull");
2089                                 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#F:NumericPrecision_Value");
2090                                 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#F:NumericScale_IsNull");
2091                                 Assert.AreEqual (255, pkRow ["NumericScale"], "#F:NumericScale_Value");
2092                                 Assert.IsFalse (pkRow.IsNull ("DataType"), "#F:DataType_IsNull");
2093                                 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#F:DataType_Value");
2094                                 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#F:ProviderType_IsNull");
2095                                 Assert.AreEqual (8, pkRow ["ProviderType"], "#F:ProviderType_Value");
2096                                 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#F:IsLong_IsNull");
2097                                 Assert.AreEqual (false, pkRow ["IsLong"], "#F:IsLong_Value");
2098                                 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#F:AllowDBNull_IsNull");
2099                                 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#F:AllowDBNull_Value");
2100                                 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#F:IsReadOnly_IsNull");
2101                                 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#F:IsReadOnly_Value");
2102                                 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#F:IsRowVersion_IsNull");
2103                                 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#F:IsRowVersion_Value");
2104                                 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#F:IsUnique_IsNull");
2105                                 Assert.AreEqual (false, pkRow ["IsUnique"], "#F:IsUnique_Value");
2106                                 Assert.IsTrue (pkRow.IsNull ("IsKey"), "#F:IsKey_IsNull");
2107                                 Assert.AreEqual (DBNull.Value, pkRow ["IsKey"], "#F:IsKey_Value");
2108                                 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#F:IsAutoIncrement_IsNull");
2109                                 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#F:IsAutoIncrement_Value");
2110                                 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#F:BaseSchemaName_IsNull");
2111                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#F:BaseSchemaName_Value");
2112                                 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#F:BaseCatalogName_IsNull");
2113                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#F:BaseCatalogName_Value");
2114                                 Assert.IsTrue (pkRow.IsNull ("BaseTableName"), "#F:BaseTableName_IsNull");
2115                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseTableName"], "#F:BaseTableName_Value");
2116                                 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#F:BaseColumnName_IsNull");
2117                                 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#F:BaseColumnName_Value");
2118
2119                                 reader = cmd.ExecuteReader (CommandBehavior.KeyInfo);
2120                                 schema = reader.GetSchemaTable ();
2121                                 reader.Close ();
2122
2123                                 AssertSchemaTableStructure (schema, "#G:");
2124                                 Assert.AreEqual (3, schema.Rows.Count, "#G:RowCount");
2125                                 pkRow = schema.Select ("ColumnName = 'id'") [0];
2126                                 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#G:ColumnName_IsNull");
2127                                 Assert.AreEqual ("id", pkRow ["ColumnName"], "#G:ColumnName_Value");
2128                                 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#G:ColumnOrdinal_IsNull");
2129                                 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#G:ColumnOrdinal_Value");
2130                                 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#G:ColumnSize_IsNull");
2131                                 Assert.AreEqual (4, pkRow ["ColumnSize"], "#G:ColumnSize_Value");
2132                                 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#G:NumericPrecision_IsNull");
2133                                 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#G:NumericPrecision_Value");
2134                                 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#G:NumericScale_IsNull");
2135                                 Assert.AreEqual (255, pkRow ["NumericScale"], "#G:NumericScale_Value");
2136                                 Assert.IsFalse (pkRow.IsNull ("DataType"), "#G:DataType_IsNull");
2137                                 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#G:DataType_Value");
2138                                 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#G:ProviderType_IsNull");
2139                                 Assert.AreEqual (8, pkRow ["ProviderType"], "#G:ProviderType_Value");
2140                                 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#G:IsLong_IsNull");
2141                                 Assert.AreEqual (false, pkRow ["IsLong"], "#G:IsLong_Value");
2142                                 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#G:AllowDBNull_IsNull");
2143                                 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#G:AllowDBNull_Value");
2144                                 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#G:IsReadOnly_IsNull");
2145                                 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#G:IsReadOnly_Value");
2146                                 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#G:IsRowVersion_IsNull");
2147                                 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#G:IsRowVersion_Value");
2148                                 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#G:IsUnique_IsNull");
2149                                 Assert.AreEqual (false, pkRow ["IsUnique"], "#G:IsUnique_Value");
2150                                 Assert.IsFalse (pkRow.IsNull ("IsKey"), "#G:IsKey_IsNull");
2151                                 Assert.AreEqual (true, pkRow ["IsKey"], "#G:IsKey_Value");
2152                                 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#G:IsAutoIncrement_IsNull");
2153                                 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#G:IsAutoIncrement_Value");
2154                                 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#G:BaseSchemaName_IsNull");
2155                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#G:BaseSchemaName_Value");
2156                                 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#G:BaseCatalogName_IsNull");
2157                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#G:BaseCatalogName_Value");
2158                                 Assert.IsFalse (pkRow.IsNull ("BaseTableName"), "#G:BaseTableName_IsNull");
2159                                 Assert.AreEqual ("employee", pkRow ["BaseTableName"], "#G:BaseTableName_Value");
2160                                 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#G:BaseColumnName_IsNull");
2161                                 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#G:BaseColumnName_Value");
2162
2163                                 reader = cmd.ExecuteReader ();
2164                                 schema = reader.GetSchemaTable ();
2165                                 reader.Close ();
2166
2167                                 AssertSchemaTableStructure (schema, "#H:");
2168                                 Assert.AreEqual (3, schema.Rows.Count, "#H:RowCount");
2169                                 pkRow = schema.Select ("ColumnName = 'id'") [0];
2170                                 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#H:ColumnName_IsNull");
2171                                 Assert.AreEqual ("id", pkRow ["ColumnName"], "#H:ColumnName_Value");
2172                                 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#H:ColumnOrdinal_IsNull");
2173                                 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#H:ColumnOrdinal_Value");
2174                                 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#H:ColumnSize_IsNull");
2175                                 Assert.AreEqual (4, pkRow ["ColumnSize"], "#H:ColumnSize_Value");
2176                                 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#H:NumericPrecision_IsNull");
2177                                 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#H:NumericPrecision_Value");
2178                                 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#H:NumericScale_IsNull");
2179                                 Assert.AreEqual (255, pkRow ["NumericScale"], "#H:NumericScale_Value");
2180                                 Assert.IsFalse (pkRow.IsNull ("DataType"), "#H:DataType_IsNull");
2181                                 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#H:DataType_Value");
2182                                 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#H:ProviderType_IsNull");
2183                                 Assert.AreEqual (8, pkRow ["ProviderType"], "#H:ProviderType_Value");
2184                                 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#H:IsLong_IsNull");
2185                                 Assert.AreEqual (false, pkRow ["IsLong"], "#H:IsLong_Value");
2186                                 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#H:AllowDBNull_IsNull");
2187                                 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#H:AllowDBNull_Value");
2188                                 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#H:IsReadOnly_IsNull");
2189                                 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#H:IsReadOnly_Value");
2190                                 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#H:IsRowVersion_IsNull");
2191                                 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#H:IsRowVersion_Value");
2192                                 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#H:IsUnique_IsNull");
2193                                 Assert.AreEqual (false, pkRow ["IsUnique"], "#H:IsUnique_Value");
2194                                 Assert.IsTrue (pkRow.IsNull ("IsKey"), "#H:IsKey_IsNull");
2195                                 Assert.AreEqual (DBNull.Value, pkRow ["IsKey"], "#H:IsKey_Value");
2196                                 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#H:IsAutoIncrement_IsNull");
2197                                 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#H:IsAutoIncrement_Value");
2198                                 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#H:BaseSchemaName_IsNull");
2199                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#H:BaseSchemaName_Value");
2200                                 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#H:BaseCatalogName_IsNull");
2201                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#H:BaseCatalogName_Value");
2202                                 Assert.IsTrue (pkRow.IsNull ("BaseTableName"), "#H:BaseTableName_IsNull");
2203                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseTableName"], "#H:BaseTableName_Value");
2204                                 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#H:BaseColumnName_IsNull");
2205                                 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#H:BaseColumnName_Value");
2206
2207                                 cmd.CommandText = "select id, fname, id + 20 as plustwenty from employee where id = @id";
2208                                 IDbDataParameter param = cmd.CreateParameter ();
2209                                 param.ParameterName = "@id";
2210                                 cmd.Parameters.Add (param);
2211                                 param.DbType = DbType.Int32;
2212                                 param.Value = 2;
2213                                 reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo);
2214                                 schema = reader.GetSchemaTable ();
2215                                 reader.Close ();
2216
2217                                 AssertSchemaTableStructure (schema, "#I:");
2218                                 Assert.AreEqual (3, schema.Rows.Count, "#I:RowCount");
2219                                 pkRow = schema.Select ("ColumnName = 'id'") [0];
2220                                 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#I:ColumnName_IsNull");
2221                                 Assert.AreEqual ("id", pkRow ["ColumnName"], "#I:ColumnName_Value");
2222                                 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#I:ColumnOrdinal_IsNull");
2223                                 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#I:ColumnOrdinal_Value");
2224                                 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#I:ColumnSize_IsNull");
2225                                 Assert.AreEqual (4, pkRow ["ColumnSize"], "#I:ColumnSize_Value");
2226                                 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#I:NumericPrecision_IsNull");
2227                                 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#I:NumericPrecision_Value");
2228                                 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#I:NumericScale_IsNull");
2229                                 Assert.AreEqual (255, pkRow ["NumericScale"], "#I:NumericScale_Value");
2230                                 Assert.IsFalse (pkRow.IsNull ("DataType"), "#I:DataType_IsNull");
2231                                 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#I:DataType_Value");
2232                                 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#I:ProviderType_IsNull");
2233                                 Assert.AreEqual (8, pkRow ["ProviderType"], "#I:ProviderType_Value");
2234                                 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#I:IsLong_IsNull");
2235                                 Assert.AreEqual (false, pkRow ["IsLong"], "#I:IsLong_Value");
2236                                 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#I:AllowDBNull_IsNull");
2237                                 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#I:AllowDBNull_Value");
2238                                 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#I:IsReadOnly_IsNull");
2239                                 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#I:IsReadOnly_Value");
2240                                 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#I:IsRowVersion_IsNull");
2241                                 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#I:IsRowVersion_Value");
2242                                 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#I:IsUnique_IsNull");
2243                                 Assert.AreEqual (false, pkRow ["IsUnique"], "#I:IsUnique_Value");
2244                                 Assert.IsFalse (pkRow.IsNull ("IsKey"), "#I:IsKey_IsNull");
2245                                 Assert.AreEqual (true, pkRow ["IsKey"], "#I:IsKey_Value");
2246                                 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#I:IsAutoIncrement_IsNull");
2247                                 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#I:IsAutoIncrement_Value");
2248                                 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#I:BaseSchemaName_IsNull");
2249                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#I:BaseSchemaName_Value");
2250                                 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#I:BaseCatalogName_IsNull");
2251                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#I:BaseCatalogName_Value");
2252                                 Assert.IsFalse (pkRow.IsNull ("BaseTableName"), "#I:BaseTableName_IsNull");
2253                                 Assert.AreEqual ("employee", pkRow ["BaseTableName"], "#I:BaseTableName_Value");
2254                                 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#I:BaseColumnName_IsNull");
2255                                 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#I:BaseColumnName_Value");
2256
2257                                 reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly);
2258                                 schema = reader.GetSchemaTable ();
2259                                 reader.Close ();
2260
2261                                 AssertSchemaTableStructure (schema, "#J:");
2262                                 Assert.AreEqual (3, schema.Rows.Count, "#J:RowCount");
2263                                 pkRow = schema.Select ("ColumnName = 'id'") [0];
2264                                 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#J:ColumnName_IsNull");
2265                                 Assert.AreEqual ("id", pkRow ["ColumnName"], "#J:ColumnName_Value");
2266                                 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#J:ColumnOrdinal_IsNull");
2267                                 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#J:ColumnOrdinal_Value");
2268                                 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#J:ColumnSize_IsNull");
2269                                 Assert.AreEqual (4, pkRow ["ColumnSize"], "#J:ColumnSize_Value");
2270                                 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#J:NumericPrecision_IsNull");
2271                                 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#J:NumericPrecision_Value");
2272                                 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#J:NumericScale_IsNull");
2273                                 Assert.AreEqual (255, pkRow ["NumericScale"], "#J:NumericScale_Value");
2274                                 Assert.IsFalse (pkRow.IsNull ("DataType"), "#J:DataType_IsNull");
2275                                 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#J:DataType_Value");
2276                                 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#J:ProviderType_IsNull");
2277                                 Assert.AreEqual (8, pkRow ["ProviderType"], "#J:ProviderType_Value");
2278                                 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#J:IsLong_IsNull");
2279                                 Assert.AreEqual (false, pkRow ["IsLong"], "#J:IsLong_Value");
2280                                 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#J:AllowDBNull_IsNull");
2281                                 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#J:AllowDBNull_Value");
2282                                 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#J:IsReadOnly_IsNull");
2283                                 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#J:IsReadOnly_Value");
2284                                 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#J:IsRowVersion_IsNull");
2285                                 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#J:IsRowVersion_Value");
2286                                 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#J:IsUnique_IsNull");
2287                                 Assert.AreEqual (false, pkRow ["IsUnique"], "#J:IsUnique_Value");
2288                                 Assert.IsTrue (pkRow.IsNull ("IsKey"), "#J:IsKey_IsNull");
2289                                 Assert.AreEqual (DBNull.Value, pkRow ["IsKey"], "#J:IsKey_Value");
2290                                 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#J:IsAutoIncrement_IsNull");
2291                                 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#J:IsAutoIncrement_Value");
2292                                 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#J:BaseSchemaName_IsNull");
2293                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#J:BaseSchemaName_Value");
2294                                 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#J:BaseCatalogName_IsNull");
2295                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#J:BaseCatalogName_Value");
2296                                 Assert.IsTrue (pkRow.IsNull ("BaseTableName"), "#J:BaseTableName_IsNull");
2297                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseTableName"], "#J:BaseTableName_Value");
2298                                 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#J:BaseColumnName_IsNull");
2299                                 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#J:BaseColumnName_Value");
2300
2301                                 reader = cmd.ExecuteReader (CommandBehavior.KeyInfo);
2302                                 schema = reader.GetSchemaTable ();
2303                                 reader.Close ();
2304
2305                                 AssertSchemaTableStructure (schema, "#K:");
2306                                 Assert.AreEqual (3, schema.Rows.Count, "#K:RowCount");
2307                                 pkRow = schema.Select ("ColumnName = 'id'") [0];
2308                                 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#K:ColumnName_IsNull");
2309                                 Assert.AreEqual ("id", pkRow ["ColumnName"], "#K:ColumnName_Value");
2310                                 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#K:ColumnOrdinal_IsNull");
2311                                 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#K:ColumnOrdinal_Value");
2312                                 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#K:ColumnSize_IsNull");
2313                                 Assert.AreEqual (4, pkRow ["ColumnSize"], "#K:ColumnSize_Value");
2314                                 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#K:NumericPrecision_IsNull");
2315                                 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#K:NumericPrecision_Value");
2316                                 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#K:NumericScale_IsNull");
2317                                 Assert.AreEqual (255, pkRow ["NumericScale"], "#K:NumericScale_Value");
2318                                 Assert.IsFalse (pkRow.IsNull ("DataType"), "#K:DataType_IsNull");
2319                                 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#K:DataType_Value");
2320                                 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#K:ProviderType_IsNull");
2321                                 Assert.AreEqual (8, pkRow ["ProviderType"], "#K:ProviderType_Value");
2322                                 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#K:IsLong_IsNull");
2323                                 Assert.AreEqual (false, pkRow ["IsLong"], "#K:IsLong_Value");
2324                                 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#K:AllowDBNull_IsNull");
2325                                 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#K:AllowDBNull_Value");
2326                                 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#K:IsReadOnly_IsNull");
2327                                 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#K:IsReadOnly_Value");
2328                                 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#K:IsRowVersion_IsNull");
2329                                 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#K:IsRowVersion_Value");
2330                                 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#K:IsUnique_IsNull");
2331                                 Assert.AreEqual (false, pkRow ["IsUnique"], "#K:IsUnique_Value");
2332                                 Assert.IsFalse (pkRow.IsNull ("IsKey"), "#K:IsKey_IsNull");
2333                                 Assert.AreEqual (true, pkRow ["IsKey"], "#K:IsKey_Value");
2334                                 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#K:IsAutoIncrement_IsNull");
2335                                 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#K:IsAutoIncrement_Value");
2336                                 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#K:BaseSchemaName_IsNull");
2337                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#K:BaseSchemaName_Value");
2338                                 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#K:BaseCatalogName_IsNull");
2339                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#K:BaseCatalogName_Value");
2340                                 Assert.IsFalse (pkRow.IsNull ("BaseTableName"), "#K:BaseTableName_IsNull");
2341                                 Assert.AreEqual ("employee", pkRow ["BaseTableName"], "#K:BaseTableName_Value");
2342                                 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#K:BaseColumnName_IsNull");
2343                                 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#K:BaseColumnName_Value");
2344
2345                                 reader = cmd.ExecuteReader ();
2346                                 schema = reader.GetSchemaTable ();
2347                                 reader.Close ();
2348
2349                                 AssertSchemaTableStructure (schema, "#L:");
2350                                 Assert.AreEqual (3, schema.Rows.Count, "#L:RowCount");
2351                                 pkRow = schema.Select ("ColumnName = 'id'") [0];
2352                                 Assert.IsFalse (pkRow.IsNull ("ColumnName"), "#L:ColumnName_IsNull");
2353                                 Assert.AreEqual ("id", pkRow ["ColumnName"], "#L:ColumnName_Value");
2354                                 Assert.IsFalse (pkRow.IsNull ("ColumnOrdinal"), "#L:ColumnOrdinal_IsNull");
2355                                 Assert.AreEqual (0, pkRow ["ColumnOrdinal"], "#L:ColumnOrdinal_Value");
2356                                 Assert.IsFalse (pkRow.IsNull ("ColumnSize"), "#L:ColumnSize_IsNull");
2357                                 Assert.AreEqual (4, pkRow ["ColumnSize"], "#L:ColumnSize_Value");
2358                                 Assert.IsFalse (pkRow.IsNull ("NumericPrecision"), "#L:NumericPrecision_IsNull");
2359                                 Assert.AreEqual (10, pkRow ["NumericPrecision"], "#L:NumericPrecision_Value");
2360                                 Assert.IsFalse (pkRow.IsNull ("NumericScale"), "#L:NumericScale_IsNull");
2361                                 Assert.AreEqual (255, pkRow ["NumericScale"], "#L:NumericScale_Value");
2362                                 Assert.IsFalse (pkRow.IsNull ("DataType"), "#L:DataType_IsNull");
2363                                 Assert.AreEqual (typeof (int), pkRow ["DataType"], "#L:DataType_Value");
2364                                 Assert.IsFalse (pkRow.IsNull ("ProviderType"), "#L:ProviderType_IsNull");
2365                                 Assert.AreEqual (8, pkRow ["ProviderType"], "#L:ProviderType_Value");
2366                                 Assert.IsFalse (pkRow.IsNull ("IsLong"), "#L:IsLong_IsNull");
2367                                 Assert.AreEqual (false, pkRow ["IsLong"], "#L:IsLong_Value");
2368                                 Assert.IsFalse (pkRow.IsNull ("AllowDBNull"), "#L:AllowDBNull_IsNull");
2369                                 Assert.AreEqual (false, pkRow ["AllowDBNull"], "#L:AllowDBNull_Value");
2370                                 Assert.IsFalse (pkRow.IsNull ("IsReadOnly"), "#L:IsReadOnly_IsNull");
2371                                 Assert.AreEqual (false, pkRow ["IsReadOnly"], "#L:IsReadOnly_Value");
2372                                 Assert.IsFalse (pkRow.IsNull ("IsRowVersion"), "#L:IsRowVersion_IsNull");
2373                                 Assert.AreEqual (false, pkRow ["IsRowVersion"], "#L:IsRowVersion_Value");
2374                                 Assert.IsFalse (pkRow.IsNull ("IsUnique"), "#L:IsUnique_IsNull");
2375                                 Assert.AreEqual (false, pkRow ["IsUnique"], "#L:IsUnique_Value");
2376                                 Assert.IsTrue (pkRow.IsNull ("IsKey"), "#L:IsKey_IsNull");
2377                                 Assert.AreEqual (DBNull.Value, pkRow ["IsKey"], "#L:IsKey_Value");
2378                                 Assert.IsFalse (pkRow.IsNull ("IsAutoIncrement"), "#L:IsAutoIncrement_IsNull");
2379                                 Assert.AreEqual (false, pkRow ["IsAutoIncrement"], "#L:IsAutoIncrement_Value");
2380                                 Assert.IsTrue (pkRow.IsNull ("BaseSchemaName"), "#L:BaseSchemaName_IsNull");
2381                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseSchemaName"], "#L:BaseSchemaName_Value");
2382                                 Assert.IsTrue (pkRow.IsNull ("BaseCatalogName"), "#L:BaseCatalogName_IsNull");
2383                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseCatalogName"], "#L:BaseCatalogName_Value");
2384                                 Assert.IsTrue (pkRow.IsNull ("BaseTableName"), "#L:BaseTableName_IsNull");
2385                                 Assert.AreEqual (DBNull.Value, pkRow ["BaseTableName"], "#L:BaseTableName_Value");
2386                                 Assert.IsFalse (pkRow.IsNull ("BaseColumnName"), "#L:BaseColumnName_IsNull");
2387                                 Assert.AreEqual ("id", pkRow ["BaseColumnName"], "#L:BaseColumnName_Value");
2388                         } finally {
2389                                 if (cmd != null)
2390                                         cmd.Dispose ();
2391                                 if (reader != null)
2392                                         reader.Close ();
2393                                 ConnectionManager.Singleton.CloseConnection ();
2394                         }
2395                 }
2396
2397                 [Test]
2398                 public void GetSchemaTableTest ()
2399                 {
2400                         cmd.CommandText = "Select type_decimal1 as decimal,id,10 ";
2401                         cmd.CommandText += "from numeric_family where id=1";
2402                         reader = cmd.ExecuteReader (CommandBehavior.KeyInfo);
2403                         DataTable schemaTable  = reader.GetSchemaTable ();
2404                         DataRow row0 = schemaTable.Rows[0];
2405                         DataRow row1 = schemaTable.Rows[1];
2406
2407                         Assert.AreEqual ("decimal", row0["ColumnName"], "#1");
2408                         Assert.AreEqual ("", schemaTable.Rows[2]["ColumnName"], "#2");
2409
2410                         Assert.AreEqual (0, row0["ColumnOrdinal"], "#2");
2411                         Assert.AreEqual (17, row0["ColumnSize"], "#3");
2412                         if (ClientVersion == 7)
2413                                 Assert.AreEqual (28, row0["NumericPrecision"], "#4");
2414                         else
2415                                 Assert.AreEqual (38, row0 ["NumericPrecision"], "#4");
2416                         Assert.AreEqual (0, row0["NumericScale"], "#5");
2417
2418                         Assert.AreEqual (false, row0["IsUnique"], "#6");
2419                         // msdotnet returns IsUnique as false for Primary key
2420                         // even though table consists of a single Primary Key
2421                         //Assert.AreEqual (true, row1["IsUnique"], "#7");
2422                         Assert.AreEqual (false, row0["IsKey"], "#8");
2423                         Assert.AreEqual (true, row1["IsKey"], "#9");
2424
2425                         //Assert.AreEqual ("servername", row0["BaseServerName"], "#10");
2426                         //Assert.AreEqual ("monotest", row0["BaseCatalogName"], "#11");
2427                         Assert.AreEqual ("type_decimal1", row0["BaseColumnName"], "#12");
2428                         //Assert.IsNull(row0["BaseSchemaName"], "#13");
2429                         Assert.AreEqual ("numeric_family", row0["BaseTableName"], "#14");
2430                         Assert.AreEqual (typeof (Decimal), row0["DataType"], "#15");
2431                         Assert.AreEqual (true, row0["AllowDBNull"], "#16");
2432                         Assert.AreEqual (false, row1["AllowDBNull"], "#17");
2433                         //Assert.IsNull(row0["ProviderType"], "#18");
2434                         Assert.AreEqual (true, row0["IsAliased"], "#19");
2435                         Assert.AreEqual (false, row1["IsAliased"], "#20");
2436
2437                         Assert.AreEqual (false, row0["IsExpression"], "#21");
2438                         Assert.AreEqual (false, row0["IsIdentity"], "#22");
2439                         Assert.AreEqual (false, row0["IsAutoIncrement"], "#23");
2440                         Assert.AreEqual (false, row0["IsRowVersion"], "#24");
2441                         Assert.AreEqual (false, row0["IsHidden"], "#25");
2442                         Assert.AreEqual (false, row0["IsLong"], "#26");
2443                         Assert.AreEqual (false, row0["IsReadOnly"], "#27");
2444                         Assert.AreEqual (true, schemaTable.Rows[2]["IsReadOnly"], "#27");
2445
2446                         // Test Exception is thrown when reader is closed
2447                         reader.Close ();
2448                         try {
2449                                 reader.GetSchemaTable ();
2450                                 Assert.Fail ("#28 Exception shud be thrown" );
2451                         } catch (InvalidOperationException e) {
2452                                 Assert.AreEqual (typeof (InvalidOperationException), e.GetType(),
2453                                         "#29 Incorrect Exception");
2454                         }
2455                 }
2456
2457                 [Test]
2458                 public void GetDataTypeNameTest ()
2459                 {
2460                         cmd.CommandText = "Select id, type_tinyint, 10,null from numeric_family where id=1";
2461                         reader = cmd.ExecuteReader ();
2462
2463                         Assert.AreEqual ("tinyint", reader.GetDataTypeName(1), "#1");
2464                         Assert.AreEqual ("int", reader.GetDataTypeName(2), "#2");
2465                         //need check on windows
2466                         Assert.AreEqual ("int", reader.GetDataTypeName(3), "#3");
2467                         try {
2468                                 reader.GetDataTypeName (10);
2469                                 Assert.Fail ("#4 Exception shud be thrown");
2470                         } catch (IndexOutOfRangeException e) {
2471                                 Assert.AreEqual (typeof (IndexOutOfRangeException), e.GetType (),
2472                                         "#5 Incorrect Exception : " + e);
2473                         }
2474                 }
2475
2476                 [Test]
2477                 public void GetFieldType_BigInt ()
2478                 {
2479                         if (ClientVersion <= 7)
2480                                 Assert.Ignore ("BigInt data type is not supported.");
2481
2482                         cmd.CommandText = "SELECT type_bigint FROM numeric_family WHERE id = 1";
2483
2484                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2485                                 Assert.AreEqual (typeof (long), rdr.GetFieldType (0));
2486                         }
2487                 }
2488
2489                 [Test]
2490                 public void GetFieldType_Binary ()
2491                 {
2492                         cmd.CommandText = "SELECT type_binary FROM binary_family WHERE id = 1";
2493
2494                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2495                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0));
2496                         }
2497                 }
2498
2499                 [Test]
2500                 public void GetFieldType_Bit ()
2501                 {
2502                         cmd.CommandText = "SELECT type_bit FROM numeric_family WHERE id = 1";
2503
2504                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2505                                 Assert.AreEqual (typeof (bool), rdr.GetFieldType (0));
2506                         }
2507                 }
2508
2509                 [Test]
2510                 public void GetFieldType_Char ()
2511                 {
2512                         cmd.CommandText = "SELECT type_char FROM string_family WHERE id = 1";
2513
2514                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2515                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0));
2516                         }
2517                 }
2518
2519                 [Test]
2520                 public void GetFieldType_Date ()
2521                 {
2522                         // TODO
2523                 }
2524
2525                 [Test]
2526                 public void GetFieldType_DateTime ()
2527                 {
2528                         cmd.CommandText = "SELECT type_datetime FROM datetime_family WHERE id = 1";
2529
2530                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2531                                 Assert.AreEqual (typeof (DateTime), rdr.GetFieldType (0));
2532                         }
2533                 }
2534
2535                 [Test]
2536                 public void GetFieldType_Decimal ()
2537                 {
2538                         cmd.CommandText = "SELECT type_decimal1 FROM numeric_family WHERE id = 1";
2539
2540                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2541                                 Assert.AreEqual (typeof (decimal), rdr.GetFieldType (0));
2542                         }
2543
2544                         cmd.CommandText = "SELECT type_decimal2 FROM numeric_family WHERE id = 1";
2545
2546                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2547                                 Assert.AreEqual (typeof (decimal), rdr.GetFieldType (0));
2548                         }
2549
2550                         cmd.CommandText = "SELECT type_numeric1 FROM numeric_family WHERE id = 1";
2551
2552                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2553                                 Assert.AreEqual (typeof (decimal), rdr.GetFieldType (0));
2554                         }
2555
2556                         cmd.CommandText = "SELECT type_numeric2 FROM numeric_family WHERE id = 1";
2557
2558                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2559                                 Assert.AreEqual (typeof (decimal), rdr.GetFieldType (0));
2560                         }
2561                 }
2562
2563                 [Test]
2564                 public void GetFieldType_Float ()
2565                 {
2566                         cmd.CommandText = "SELECT type_double FROM numeric_family WHERE id = 1";
2567
2568                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2569                                 Assert.AreEqual (typeof (double), rdr.GetFieldType (0));
2570                         }
2571                 }
2572
2573                 [Test]
2574                 public void GetFieldType_Image ()
2575                 {
2576                         cmd.CommandText = "SELECT type_tinyblob FROM binary_family WHERE id = 1";
2577
2578                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2579                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0));
2580                         }
2581                 }
2582
2583                 [Test]
2584                 public void GetFieldType_Int ()
2585                 {
2586                         cmd.CommandText = "SELECT type_int FROM numeric_family WHERE id = 1";
2587
2588                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2589                                 Assert.AreEqual (typeof (int), rdr.GetFieldType (0));
2590                         }
2591                 }
2592
2593                 [Test]
2594                 public void GetFieldType_Money ()
2595                 {
2596                         cmd.CommandText = "SELECT type_money FROM numeric_family WHERE id = 1";
2597
2598                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2599                                 Assert.AreEqual (typeof (decimal), rdr.GetFieldType (0));
2600                         }
2601                 }
2602
2603                 [Test]
2604                 public void GetFieldType_NChar ()
2605                 {
2606                         cmd.CommandText = "SELECT type_nchar FROM string_family WHERE id = 1";
2607
2608                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2609                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0));
2610                         }
2611                 }
2612
2613                 [Test]
2614                 public void GetFieldType_NText ()
2615                 {
2616                         cmd.CommandText = "SELECT type_ntext FROM string_family WHERE id = 1";
2617
2618                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2619                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0));
2620                         }
2621                 }
2622
2623                 [Test]
2624                 public void GetFieldType_NVarChar ()
2625                 {
2626                         cmd.CommandText = "SELECT type_nvarchar FROM string_family WHERE id = 1";
2627
2628                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2629                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0));
2630                         }
2631                 }
2632
2633                 [Test]
2634                 public void GetFieldType_Real ()
2635                 {
2636                         cmd.CommandText = "SELECT type_float FROM numeric_family WHERE id = 1";
2637
2638                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2639                                 Assert.AreEqual (typeof (float), rdr.GetFieldType (0));
2640                         }
2641
2642                 }
2643
2644                 [Test]
2645                 public void GetFieldType_SmallDateTime ()
2646                 {
2647                         cmd.CommandText = "SELECT type_smalldatetime FROM datetime_family WHERE id = 1";
2648
2649                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2650                                 Assert.AreEqual (typeof (DateTime), rdr.GetFieldType (0));
2651                         }
2652                 }
2653
2654                 [Test]
2655                 public void GetFieldType_SmallInt ()
2656                 {
2657                         cmd.CommandText = "SELECT type_smallint FROM numeric_family WHERE id = 1";
2658
2659                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2660                                 Assert.AreEqual (typeof (short), rdr.GetFieldType (0));
2661                         }
2662                 }
2663
2664                 [Test]
2665                 public void GetFieldType_SmallMoney ()
2666                 {
2667                         cmd.CommandText = "SELECT type_smallmoney FROM numeric_family WHERE id = 1";
2668
2669                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2670                                 Assert.AreEqual (typeof (decimal), rdr.GetFieldType (0));
2671                         }
2672                 }
2673
2674                 [Test]
2675                 public void GetFieldType_Text ()
2676                 {
2677                         cmd.CommandText = "SELECT type_text FROM string_family WHERE id = 1";
2678
2679                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2680                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0));
2681                         }
2682                 }
2683
2684                 [Test]
2685                 public void GetFieldType_Time ()
2686                 {
2687                         // TODO
2688                 }
2689
2690                 [Test]
2691                 public void GetFieldType_Timestamp ()
2692                 {
2693                         cmd.CommandText = "SELECT type_timestamp FROM binary_family WHERE id = 1";
2694
2695                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2696                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0));
2697                         }
2698                 }
2699
2700                 [Test]
2701                 public void GetFieldType_TinyInt ()
2702                 {
2703                         cmd.CommandText = "SELECT type_tinyint FROM numeric_family WHERE id = 1";
2704
2705                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2706                                 Assert.AreEqual (typeof (byte), rdr.GetFieldType (0));
2707                         }
2708                 }
2709
2710                 [Test]
2711                 public void GetFieldType_Udt ()
2712                 {
2713                         // TODO
2714                 }
2715
2716                 [Test]
2717                 public void GetFieldType_UniqueIdentifier ()
2718                 {
2719                         cmd.CommandText = "SELECT type_guid FROM string_family WHERE id = 1";
2720
2721                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2722                                 Assert.AreEqual (typeof (Guid), rdr.GetFieldType (0));
2723                         }
2724                 }
2725
2726                 [Test]
2727                 public void GetFieldType_VarBinary ()
2728                 {
2729                         cmd.CommandText = "SELECT type_varbinary FROM binary_family WHERE id = 1";
2730
2731                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2732                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0));
2733                         }
2734                 }
2735
2736                 [Test]
2737                 public void GetFieldType_VarChar ()
2738                 {
2739                         cmd.CommandText = "SELECT type_varchar FROM string_family WHERE id = 1";
2740
2741                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
2742                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0));
2743                         }
2744                 }
2745
2746                 // Need to populate the data from a config file
2747                 // Will be replaced later
2748                 void validateData(string sqlQuery, DataTable table)
2749                 {
2750                         string fmt = "#TAB[{0}] ROW[{1}] COL[{2}] Data Mismatch";
2751
2752                         int noOfColumns = table.Columns.Count ;
2753                         int i=0;
2754
2755                         cmd.CommandText = sqlQuery ;
2756                         reader = cmd.ExecuteReader ();
2757
2758                         while (reader.Read ()){
2759                                 for (int j=1; j< noOfColumns ; ++j) {
2760                                         Assert.AreEqual (table.Rows[i][j], reader[j],
2761                                                 String.Format (fmt, table.TableName, i+1, j));
2762                                 }
2763
2764                                 i++;
2765                         }
2766                         reader.Close ();
2767                 }
2768
2769                 [Test]
2770                 public void NumericDataValidation ()
2771                 {
2772                         validateData ("select * from numeric_family order by id ASC",
2773                                 numericDataTable);
2774                 }
2775
2776                 [Test]
2777                 public void StringDataValidation ()
2778                 {
2779                         validateData ("select * from string_family order by id ASC",
2780                                 stringDataTable);
2781                 }
2782
2783                 [Test]
2784                 public void BinaryDataValidation ()
2785                 {
2786                         validateData ("select * from binary_family order by id ASC",
2787                                 binaryDataTable);
2788                 }
2789
2790                 [Test]
2791                 public void DatetimeDataValidation ()
2792                 {
2793                         validateData ("select * from datetime_family order by id ASC",
2794                                 datetimeDataTable);
2795                 }
2796
2797                 string connectionString = ConnectionManager.Singleton.ConnectionString;
2798
2799                 //FIXME : Add more test cases
2800                 [Test]
2801                 public void GetProviderSpecificFieldTypeTest ()
2802                 {
2803                         using (SqlConnection conn = new SqlConnection (connectionString)) {
2804                                 conn.Open ();
2805                                 SqlCommand cmd = conn.CreateCommand ();
2806                                 cmd.CommandText = "SELECT * FROM employee";
2807                                 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
2808                                         rdr.Read();
2809                                         Assert.AreEqual (6, rdr.FieldCount, "#A1");
2810                                         Assert.AreEqual(typeof(SqlInt32), rdr.GetProviderSpecificFieldType (0), "#A2");
2811                                         Assert.AreEqual(typeof(SqlString), rdr.GetProviderSpecificFieldType (1), "#A3");
2812                                         Assert.AreEqual(typeof(SqlString), rdr.GetProviderSpecificFieldType (2), "#A4");
2813                                         Assert.AreEqual(typeof(SqlDateTime), rdr.GetProviderSpecificFieldType (3), "#A5");
2814                                         Assert.AreEqual(typeof(SqlDateTime), rdr.GetProviderSpecificFieldType (4), "#A6");
2815                                         Assert.AreEqual(typeof(SqlString), rdr.GetProviderSpecificFieldType (5), "#A7");
2816                                 }
2817                                 cmd.CommandText = "SELECT * FROM numeric_family";
2818                                 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
2819                                         rdr.Read();
2820                                         Assert.AreEqual (15, rdr.FieldCount, "#B1");
2821                                         Assert.AreEqual(typeof (SqlInt32), rdr.GetProviderSpecificFieldType(0), "#B2");
2822                                         Assert.AreEqual(typeof (SqlBoolean), rdr.GetProviderSpecificFieldType(1), "#B3");
2823                                         Assert.AreEqual(typeof (SqlByte), rdr.GetProviderSpecificFieldType(2), "#B4");
2824                                         Assert.AreEqual(typeof (SqlInt16), rdr.GetProviderSpecificFieldType(3), "#B5");
2825                                         Assert.AreEqual(typeof (SqlInt32), rdr.GetProviderSpecificFieldType(4), "#B6");
2826                                         Assert.AreEqual(typeof (SqlInt64), rdr.GetProviderSpecificFieldType(5), "#B7");
2827                                         Assert.AreEqual(typeof (SqlDecimal), rdr.GetProviderSpecificFieldType(6), "#B8");
2828                                         Assert.AreEqual(typeof (SqlDecimal), rdr.GetProviderSpecificFieldType(7), "#B9");
2829                                         Assert.AreEqual(typeof (SqlDecimal), rdr.GetProviderSpecificFieldType(8), "#B10");
2830                                         Assert.AreEqual(typeof (SqlDecimal), rdr.GetProviderSpecificFieldType(9), "#B11");
2831                                         Assert.AreEqual(typeof (SqlMoney), rdr.GetProviderSpecificFieldType(10), "#B12");
2832                                         Assert.AreEqual(typeof (SqlMoney), rdr.GetProviderSpecificFieldType(11), "#B13");
2833                                         Assert.AreEqual(typeof (SqlSingle), rdr.GetProviderSpecificFieldType(12), "#B14");
2834                                         Assert.AreEqual(typeof (SqlDouble), rdr.GetProviderSpecificFieldType(13), "#B15");
2835                                         Assert.AreEqual(typeof (SqlInt32), rdr.GetProviderSpecificFieldType(14), "#B16");
2836                                 }
2837                         }
2838                 }
2839
2840                 //FIXME : Add more test cases
2841                 [Test]
2842                 public void GetProviderSpecificValueTest ()
2843                 {
2844                         using (SqlConnection conn = new SqlConnection (connectionString)) {
2845                                 conn.Open ();
2846                                 SqlCommand cmd = conn.CreateCommand ();
2847                                 cmd.CommandText = "SELECT * FROM employee";
2848                                 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
2849                                         rdr.Read();
2850                                         Assert.AreEqual (6, rdr.FieldCount, "#1");
2851                                         Assert.AreEqual((SqlInt32)1,rdr.GetProviderSpecificValue(0), "#2");
2852                                         Assert.AreEqual((SqlString)"suresh",rdr.GetProviderSpecificValue(1), "#3");
2853                                         Assert.AreEqual((SqlDateTime) new DateTime (1978, 8, 22), rdr.GetProviderSpecificValue(3), "#4");
2854                                 }
2855                         }
2856                 }
2857
2858                 [Test]
2859                 public void GetProviderSpecificValueLowerBoundaryTest ()
2860                 {
2861                         using (SqlConnection conn = new SqlConnection (connectionString)) {
2862                                 conn.Open ();
2863                                 SqlCommand cmd = conn.CreateCommand ();
2864                                 cmd.CommandText = "SELECT * FROM employee";
2865                                 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
2866                                         rdr.Read();
2867                                         try {
2868                                                 object value = rdr.GetProviderSpecificValue (-1);
2869                                                 Assert.Fail ("#1:" + value);
2870                                         } catch (IndexOutOfRangeException) {
2871                                                 Assert.AreEqual((SqlInt32) 1, rdr.GetProviderSpecificValue (0), "#2");
2872                                                 Assert.AreEqual((SqlString) "suresh", rdr.GetProviderSpecificValue(1), "#3");
2873                                                 Assert.AreEqual((SqlDateTime) new DateTime (1978, 8, 22), rdr.GetProviderSpecificValue (3), "#4");
2874                                         }
2875                                 }
2876                         }
2877                 }
2878
2879                 [Test]
2880                 public void GetProviderSpecificValueUpperBoundaryTest ()
2881                 {
2882                         using (SqlConnection conn = new SqlConnection (connectionString)) {
2883                                 conn.Open ();
2884                                 SqlCommand cmd = conn.CreateCommand ();
2885                                 cmd.CommandText = "SELECT * FROM employee";
2886                                 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
2887                                         rdr.Read();
2888                                         try {
2889                                                 object value = rdr.GetProviderSpecificValue (rdr.FieldCount);
2890                                                 Assert.Fail ("#1:" + value);
2891                                         } catch (IndexOutOfRangeException) {
2892                                                 Assert.AreEqual((SqlInt32) 1, rdr.GetProviderSpecificValue (0), "#2");
2893                                                 Assert.AreEqual((SqlString) "suresh", rdr.GetProviderSpecificValue (1), "#3");
2894                                                 Assert.AreEqual((SqlDateTime) new DateTime (1978, 8, 22), rdr.GetProviderSpecificValue (3), "#4");
2895                                         }
2896                                 }
2897                         }
2898                 }
2899
2900                 //FIXME : Add more test cases
2901                 [Test]
2902                 public void GetProviderSpecificValuesTest ()
2903                 {
2904                         using (SqlConnection conn = new SqlConnection (connectionString)) {
2905                                 conn.Open ();
2906                                 SqlCommand cmd = conn.CreateCommand ();
2907                                 cmd.CommandText = "SELECT * FROM employee";
2908                                 Object [] psValues = new Object[6];
2909                                 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
2910                                         rdr.Read();
2911                                         int count = rdr.GetProviderSpecificValues (psValues);
2912                                         Assert.AreEqual (6, count, "#1");
2913                                         Assert.AreEqual ((SqlInt32) 1, psValues [0], "#2");
2914                                         Assert.AreEqual ((SqlString) "suresh", psValues [1], "#3");
2915                                         Assert.AreEqual ((SqlString) "kumar", psValues [2], "#4");
2916                                         Assert.AreEqual ((SqlDateTime) new DateTime (1978, 8, 22), psValues [3], "#5");
2917                                         Assert.AreEqual ((SqlDateTime) new DateTime (2001, 03, 12), psValues [4], "#6");
2918                                         Assert.AreEqual ((SqlString) "suresh@gmail.com", psValues [5], "#7");
2919                                 }
2920                         }
2921                 }
2922
2923                 [Test]
2924                 public void GetProviderSpecificValues_Values_Null ()
2925                 {
2926                         cmd.CommandText = "SELECT * FROM employee";
2927                         reader = cmd.ExecuteReader ();
2928                         reader.Read ();
2929
2930                         try {
2931                                 reader.GetProviderSpecificValues (null);
2932                                 Assert.Fail ("#1");
2933                         } catch (ArgumentNullException ex) {
2934                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
2935                                 Assert.IsNull (ex.InnerException, "#3");
2936                                 Assert.IsNotNull (ex.Message, "#4");
2937                                 Assert.AreEqual ("values", ex.ParamName, "#5");
2938                         }
2939                 }
2940
2941                 [Test]
2942                 public void GetProviderSpecificValuesSmallArrayTest ()
2943                 {
2944                         using (SqlConnection conn = new SqlConnection (connectionString)) {
2945                                 conn.Open ();
2946                                 SqlCommand cmd = conn.CreateCommand ();
2947                                 cmd.CommandText = "SELECT * FROM employee";
2948                                 Object [] psValues = new Object[2];
2949                                 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
2950                                         rdr.Read();
2951                                         int count = rdr.GetProviderSpecificValues (psValues);
2952                                         Assert.AreEqual (2, count, "#1");
2953                                         Assert.AreEqual ((SqlInt32) 1, psValues [0], "#2");
2954                                         Assert.AreEqual ((SqlString) "suresh", psValues [1], "#3");
2955                                 }
2956                         }
2957                 }
2958
2959                 [Test]
2960                 public void GetProviderSpecificValuesLargeArrayTest ()
2961                 {
2962                         using (SqlConnection conn = new SqlConnection (connectionString)) {
2963                                 conn.Open ();
2964                                 SqlCommand cmd = conn.CreateCommand ();
2965                                 cmd.CommandText = "SELECT * FROM employee";
2966                                 Object [] psValues = new Object[10];
2967                                 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
2968                                         rdr.Read();
2969                                         int count = rdr.GetProviderSpecificValues (psValues);
2970                                         Assert.AreEqual (6, count, "#1");
2971                                         Assert.AreEqual ((SqlInt32) 1, psValues [0], "#2");
2972                                         Assert.AreEqual ((SqlString) "suresh", psValues [1], "#3");
2973                                         Assert.AreEqual ((SqlString) "kumar", psValues [2], "#4");
2974                                         Assert.AreEqual ((SqlDateTime) new DateTime (1978, 8, 22), psValues [3], "#5");
2975                                         Assert.AreEqual ((SqlDateTime) new DateTime (2001, 03, 12), psValues [4], "#6");
2976                                         Assert.AreEqual ((SqlString) "suresh@gmail.com", psValues [5], "#7");
2977                                         Assert.IsNull (psValues [6], "#8");
2978                                         Assert.IsNull (psValues [7], "#9");
2979                                         Assert.IsNull (psValues [8], "#10");
2980                                         Assert.IsNull (psValues [9], "#11");
2981                                 }
2982                         }
2983                 }
2984
2985                 [Test]
2986                 public void GetSqlBytesTest ()
2987                 {
2988                         using (SqlConnection conn = new SqlConnection (connectionString)) {
2989                                 conn.Open ();
2990                                 SqlCommand cmd = conn.CreateCommand ();
2991                                 cmd.CommandText = "SELECT * FROM binary_family where id=1";
2992                                 using (SqlDataReader rdr = cmd.ExecuteReader ()) {
2993                                         rdr.Read();
2994                                         Assert.AreEqual (8, rdr.FieldCount);
2995
2996                                         SqlBytes sb = rdr.GetSqlBytes (1);
2997                                         Assert.AreEqual (8, sb.Length, "#A1");
2998                                         Assert.AreEqual (53, sb [0], "#A2");
2999                                         Assert.AreEqual (0, sb [1], "#A3");
3000                                         Assert.AreEqual (0, sb [2], "#A4");
3001                                         Assert.AreEqual (0, sb [3], "#A5");
3002                                         Assert.AreEqual (0, sb [4], "#A6");
3003                                         Assert.AreEqual (0, sb [5], "#A7");
3004                                         Assert.AreEqual (0, sb [6], "#A8");
3005                                         Assert.AreEqual (0, sb [7], "#A9");
3006
3007                                         sb = rdr.GetSqlBytes (2);
3008                                         Assert.AreEqual (typeof (SqlBinary), rdr.GetSqlValue (2).GetType (), "B1#");
3009                                         Assert.AreEqual (33, sb.Length, "#B2");
3010                                         Assert.AreEqual (48, sb [0], "#B3");
3011                                         Assert.AreEqual (49, sb [1], "#B4");
3012                                         Assert.AreEqual (50, sb [2], "#B5");
3013                                         Assert.AreEqual (53, sb [15], "#B6");
3014                                         Assert.AreEqual (57, sb [29], "#B7");
3015                                 }
3016                         }
3017
3018                 }
3019
3020
3021                 static void AssertSchemaTableStructure (DataTable schemaTable, string prefix)
3022                 {
3023                         object [] [] columns = {
3024                                 new object [] { "ColumnName", typeof (string) },
3025                                 new object [] { "ColumnOrdinal", typeof (int) },
3026                                 new object [] { "ColumnSize", typeof (int) },
3027                                 new object [] { "NumericPrecision", typeof (short) },
3028                                 new object [] { "NumericScale", typeof (short) },
3029                                 new object [] { "IsUnique", typeof (bool) },
3030                                 new object [] { "IsKey", typeof (bool) },
3031                                 new object [] { "BaseServerName", typeof (string) },
3032                                 new object [] { "BaseCatalogName", typeof (string) },
3033                                 new object [] { "BaseColumnName", typeof (string) },
3034                                 new object [] { "BaseSchemaName", typeof (string) },
3035                                 new object [] { "BaseTableName", typeof (string) },
3036                                 new object [] { "DataType", typeof (Type) },
3037                                 new object [] { "AllowDBNull", typeof (bool) },
3038                                 new object [] { "ProviderType", typeof (int) },
3039                                 new object [] { "IsAliased", typeof (bool) },
3040                                 new object [] { "IsExpression", typeof (bool) },
3041                                 new object [] { "IsIdentity", typeof (bool) },
3042                                 new object [] { "IsAutoIncrement", typeof (bool) },
3043                                 new object [] { "IsRowVersion", typeof (bool) },
3044                                 new object [] { "IsHidden", typeof (bool) },
3045                                 new object [] { "IsLong", typeof (bool) },
3046                                 new object [] { "IsReadOnly", typeof (bool) },
3047                                 new object [] { "ProviderSpecificDataType", typeof (Type) },
3048                                 new object [] { "DataTypeName", typeof (string) },
3049                                 new object [] { "XmlSchemaCollectionDatabase", typeof (string) },
3050                                 new object [] { "XmlSchemaCollectionOwningSchema", typeof (string) },
3051                                 new object [] { "XmlSchemaCollectionName", typeof (string) },
3052                                 new object [] { "UdtAssemblyQualifiedName", typeof (string) },
3053                                 new object [] { "NonVersionedProviderType", typeof (int) },
3054                                 new object [] { "IsColumnSet", typeof (bool) }
3055                                 };
3056
3057                         Assert.AreEqual (columns.Length, schemaTable.Columns.Count, prefix);
3058
3059                         for (int i = 0; i < columns.Length; i++) {
3060                                 DataColumn col = schemaTable.Columns [i];
3061                                 Assert.IsTrue (col.AllowDBNull, prefix + "AllowDBNull (" + i + ")");
3062                                 Assert.AreEqual (columns [i] [0], col.ColumnName, prefix + "ColumnName (" + i + ")");
3063                                 Assert.AreEqual (columns [i] [1], col.DataType, prefix + "DataType (" + i + ")");
3064                         }
3065                 }
3066
3067                 int ClientVersion {
3068                         get {
3069                                 return (engine.ClientVersion);
3070                         }
3071                 }
3072         }
3073
3074         [TestFixture]
3075         [Category ("sqlserver")]
3076         public class SqlDataReaderSchemaTest
3077         {
3078                 SqlConnection conn;
3079                 SqlCommand cmd;
3080                 EngineConfig engine;
3081
3082                 [SetUp]
3083                 public void SetUp ()
3084                 {
3085                         conn = (SqlConnection) ConnectionManager.Singleton.Connection;
3086                         ConnectionManager.Singleton.OpenConnection ();
3087                         cmd = conn.CreateCommand ();
3088                         engine = ConnectionManager.Singleton.Engine;
3089                 }
3090
3091                 [TearDown]
3092                 public void TearDown ()
3093                 {
3094                         if (cmd != null)
3095                                 cmd.Dispose ();
3096                         ConnectionManager.Singleton.CloseConnection ();
3097                 }
3098
3099                 [Test]
3100                 public void ColumnSize_BigInt ()
3101                 {
3102                         if (ClientVersion <= 7)
3103                                 Assert.Ignore ("BigInt data type is not supported.");
3104
3105                         cmd.CommandText = "SELECT type_bigint FROM numeric_family WHERE id = 1";
3106
3107                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3108                                 DataTable schemaTable = rdr.GetSchemaTable ();
3109                                 DataRow row = schemaTable.Rows [0];
3110                                 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3111                                 // we only support TDS 7.0, which returns bigint data values as decimal(19,0)
3112                                 if (ClientVersion > 7)
3113                                         Assert.AreEqual (8, row ["ColumnSize"], "Value");
3114                                 else
3115                                         Assert.AreEqual (17, row ["ColumnSize"], "Value");
3116                         }
3117                 }
3118
3119                 [Test]
3120                 public void ColumnSize_Binary ()
3121                 {
3122                         cmd.CommandText = "SELECT type_binary FROM binary_family WHERE id = 1";
3123
3124                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3125                                 DataTable schemaTable = rdr.GetSchemaTable ();
3126                                 DataRow row = schemaTable.Rows [0];
3127                                 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3128                                 Assert.AreEqual (8, row ["ColumnSize"], "Value");
3129                         }
3130                 }
3131
3132                 [Test]
3133                 public void ColumnSize_Bit ()
3134                 {
3135                         cmd.CommandText = "SELECT type_bit FROM numeric_family WHERE id = 1";
3136
3137                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3138                                 DataTable schemaTable = rdr.GetSchemaTable ();
3139                                 DataRow row = schemaTable.Rows [0];
3140                                 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3141                                 Assert.AreEqual (1, row ["ColumnSize"], "Value");
3142                         }
3143                 }
3144
3145                 [Test]
3146                 public void ColumnSize_Char ()
3147                 {
3148                         cmd.CommandText = "SELECT type_char FROM string_family WHERE id = 1";
3149
3150                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3151                                 DataTable schemaTable = rdr.GetSchemaTable ();
3152                                 DataRow row = schemaTable.Rows [0];
3153                                 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3154                                 Assert.AreEqual (10, row ["ColumnSize"], "Value");
3155                         }
3156                 }
3157
3158                 [Test]
3159                 public void ColumnSize_Date ()
3160                 {
3161                         // TODO
3162                 }
3163
3164                 [Test]
3165                 public void ColumnSize_DateTime ()
3166                 {
3167                         cmd.CommandText = "SELECT type_datetime FROM datetime_family WHERE id = 1";
3168
3169                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3170                                 DataTable schemaTable = rdr.GetSchemaTable ();
3171                                 DataRow row = schemaTable.Rows [0];
3172                                 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3173                                 Assert.AreEqual (8, row ["ColumnSize"], "Value");
3174                         }
3175                 }
3176
3177                 [Test]
3178                 public void ColumnSize_Decimal ()
3179                 {
3180                         cmd.CommandText = "SELECT type_decimal1 FROM numeric_family WHERE id = 1";
3181
3182                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3183                                 DataTable schemaTable = rdr.GetSchemaTable ();
3184                                 DataRow row = schemaTable.Rows [0];
3185                                 Assert.IsFalse (row.IsNull ("ColumnSize"), "#A:IsNull");
3186                                 Assert.AreEqual (17, row ["ColumnSize"], "#A:Value");
3187                         }
3188
3189                         cmd.CommandText = "SELECT type_decimal2 FROM numeric_family WHERE id = 1";
3190
3191                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3192                                 DataTable schemaTable = rdr.GetSchemaTable ();
3193                                 DataRow row = schemaTable.Rows [0];
3194                                 Assert.IsFalse (row.IsNull ("ColumnSize"), "#B:IsNull");
3195                                 Assert.AreEqual (17, row ["ColumnSize"], "#B:Value");
3196                         }
3197
3198                         cmd.CommandText = "SELECT type_numeric1 FROM numeric_family WHERE id = 1";
3199
3200                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3201                                 DataTable schemaTable = rdr.GetSchemaTable ();
3202                                 DataRow row = schemaTable.Rows [0];
3203                                 Assert.IsFalse (row.IsNull ("ColumnSize"), "#C:IsNull");
3204                                 Assert.AreEqual (17, row ["ColumnSize"], "#C:Value");
3205                         }
3206
3207                         cmd.CommandText = "SELECT type_numeric2 FROM numeric_family WHERE id = 1";
3208
3209                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3210                                 DataTable schemaTable = rdr.GetSchemaTable ();
3211                                 DataRow row = schemaTable.Rows [0];
3212                                 Assert.IsFalse (row.IsNull ("ColumnSize"), "#D:IsNull");
3213                                 Assert.AreEqual (17, row ["ColumnSize"], "#D:Value");
3214                         }
3215                 }
3216
3217                 [Test]
3218                 public void ColumnSize_Float ()
3219                 {
3220                         cmd.CommandText = "SELECT type_double FROM numeric_family WHERE id = 1";
3221
3222                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3223                                 DataTable schemaTable = rdr.GetSchemaTable ();
3224                                 DataRow row = schemaTable.Rows [0];
3225                                 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3226                                 Assert.AreEqual (8, row ["ColumnSize"], "Value");
3227                         }
3228                 }
3229
3230                 [Test]
3231                 public void ColumnSize_Image ()
3232                 {
3233                         cmd.CommandText = "SELECT type_tinyblob FROM binary_family WHERE id = 1";
3234
3235                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3236                                 DataTable schemaTable = rdr.GetSchemaTable ();
3237                                 DataRow row = schemaTable.Rows [0];
3238                                 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3239                                 Assert.AreEqual (int.MaxValue, row ["ColumnSize"], "Value");
3240                         }
3241                 }
3242
3243                 [Test]
3244                 public void ColumnSize_Int ()
3245                 {
3246                         cmd.CommandText = "SELECT type_int FROM numeric_family WHERE id = 1";
3247
3248                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3249                                 DataTable schemaTable = rdr.GetSchemaTable ();
3250                                 DataRow row = schemaTable.Rows [0];
3251                                 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3252                                 Assert.AreEqual (4, row ["ColumnSize"], "Value");
3253                         }
3254                 }
3255
3256                 [Test]
3257                 public void ColumnSize_Money ()
3258                 {
3259                         cmd.CommandText = "SELECT type_money FROM numeric_family WHERE id = 1";
3260
3261                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3262                                 DataTable schemaTable = rdr.GetSchemaTable ();
3263                                 DataRow row = schemaTable.Rows [0];
3264                                 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3265                                 Assert.AreEqual (8, row ["ColumnSize"], "Value");
3266                         }
3267                 }
3268
3269                 [Test]
3270                 public void ColumnSize_NChar ()
3271                 {
3272                         cmd.CommandText = "SELECT type_nchar FROM string_family WHERE id = 1";
3273
3274                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3275                                 DataTable schemaTable = rdr.GetSchemaTable ();
3276                                 DataRow row = schemaTable.Rows [0];
3277                                 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3278                                 Assert.AreEqual (10, row ["ColumnSize"], "Value");
3279                         }
3280                 }
3281
3282                 [Test]
3283                 public void ColumnSize_NText ()
3284                 {
3285                         cmd.CommandText = "SELECT type_ntext FROM string_family WHERE id = 1";
3286
3287                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3288                                 DataTable schemaTable = rdr.GetSchemaTable ();
3289                                 DataRow row = schemaTable.Rows [0];
3290                                 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3291                                 Assert.AreEqual (1073741823, row ["ColumnSize"], "Value");
3292                         }
3293                 }
3294
3295                 [Test]
3296                 public void ColumnSize_NVarChar ()
3297                 {
3298                         cmd.CommandText = "SELECT type_nvarchar FROM string_family WHERE id = 1";
3299
3300                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3301                                 DataTable schemaTable = rdr.GetSchemaTable ();
3302                                 DataRow row = schemaTable.Rows [0];
3303                                 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3304                                 Assert.AreEqual (10, row ["ColumnSize"], "Value");
3305                         }
3306                 }
3307
3308                 [Test]
3309                 public void ColumnSize_Real ()
3310                 {
3311                         cmd.CommandText = "SELECT type_float FROM numeric_family WHERE id = 1";
3312
3313                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3314                                 DataTable schemaTable = rdr.GetSchemaTable ();
3315                                 DataRow row = schemaTable.Rows [0];
3316                                 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3317                                 Assert.AreEqual (4, row ["ColumnSize"], "Value");
3318                         }
3319
3320                 }
3321
3322                 [Test]
3323                 public void ColumnSize_SmallDateTime ()
3324                 {
3325                         cmd.CommandText = "SELECT type_smalldatetime FROM datetime_family WHERE id = 1";
3326
3327                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3328                                 DataTable schemaTable = rdr.GetSchemaTable ();
3329                                 DataRow row = schemaTable.Rows [0];
3330                                 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3331                                 Assert.AreEqual (4, row ["ColumnSize"], "Value");
3332                         }
3333                 }
3334
3335                 [Test]
3336                 public void ColumnSize_SmallInt ()
3337                 {
3338                         cmd.CommandText = "SELECT type_smallint FROM numeric_family WHERE id = 1";
3339
3340                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3341                                 DataTable schemaTable = rdr.GetSchemaTable ();
3342                                 DataRow row = schemaTable.Rows [0];
3343                                 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3344                                 Assert.AreEqual (2, row ["ColumnSize"], "Value");
3345                         }
3346                 }
3347
3348                 [Test]
3349                 public void ColumnSize_SmallMoney ()
3350                 {
3351                         cmd.CommandText = "SELECT type_smallmoney FROM numeric_family WHERE id = 1";
3352
3353                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3354                                 DataTable schemaTable = rdr.GetSchemaTable ();
3355                                 DataRow row = schemaTable.Rows [0];
3356                                 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3357                                 Assert.AreEqual (4, row ["ColumnSize"], "Value");
3358                         }
3359                 }
3360
3361                 [Test]
3362                 public void ColumnSize_Text ()
3363                 {
3364                         cmd.CommandText = "SELECT type_text FROM string_family WHERE id = 1";
3365
3366                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3367                                 DataTable schemaTable = rdr.GetSchemaTable ();
3368                                 DataRow row = schemaTable.Rows [0];
3369                                 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3370                                 Assert.AreEqual (2147483647, row ["ColumnSize"], "Value");
3371                         }
3372                 }
3373
3374                 [Test]
3375                 public void ColumnSize_Time ()
3376                 {
3377                         // TODO
3378                 }
3379
3380                 [Test]
3381                 public void ColumnSize_Timestamp ()
3382                 {
3383                         cmd.CommandText = "SELECT type_timestamp FROM binary_family WHERE id = 1";
3384
3385                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3386                                 DataTable schemaTable = rdr.GetSchemaTable ();
3387                                 DataRow row = schemaTable.Rows [0];
3388                                 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3389                                 Assert.AreEqual (8, row ["ColumnSize"], "Value");
3390                         }
3391                 }
3392
3393                 [Test]
3394                 public void ColumnSize_TinyInt ()
3395                 {
3396                         cmd.CommandText = "SELECT type_tinyint FROM numeric_family WHERE id = 1";
3397
3398                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3399                                 DataTable schemaTable = rdr.GetSchemaTable ();
3400                                 DataRow row = schemaTable.Rows [0];
3401                                 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3402                                 Assert.AreEqual (1, row ["ColumnSize"], "Value");
3403                         }
3404                 }
3405
3406                 [Test]
3407                 public void ColumnSize_Udt ()
3408                 {
3409                         // TODO
3410                 }
3411
3412                 [Test]
3413                 public void ColumnSize_UniqueIdentifier ()
3414                 {
3415                         cmd.CommandText = "SELECT type_guid FROM string_family WHERE id = 1";
3416
3417                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3418                                 DataTable schemaTable = rdr.GetSchemaTable ();
3419                                 DataRow row = schemaTable.Rows [0];
3420                                 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3421                                 Assert.AreEqual (16, row ["ColumnSize"], "Value");
3422                         }
3423                 }
3424
3425                 [Test]
3426                 public void ColumnSize_VarBinary ()
3427                 {
3428                         cmd.CommandText = "SELECT type_varbinary FROM binary_family WHERE id = 1";
3429
3430                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3431                                 DataTable schemaTable = rdr.GetSchemaTable ();
3432                                 DataRow row = schemaTable.Rows [0];
3433                                 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3434                                 Assert.AreEqual (255, row ["ColumnSize"], "Value");
3435                         }
3436                 }
3437
3438                 [Test]
3439                 public void ColumnSize_VarChar ()
3440                 {
3441                         cmd.CommandText = "SELECT type_varchar FROM string_family WHERE id = 1";
3442
3443                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3444                                 DataTable schemaTable = rdr.GetSchemaTable ();
3445                                 DataRow row = schemaTable.Rows [0];
3446                                 Assert.IsFalse (row.IsNull ("ColumnSize"), "IsNull");
3447                                 Assert.AreEqual (10, row ["ColumnSize"], "Value");
3448                         }
3449                 }
3450
3451                 [Test]
3452                 public void DataType_BigInt ()
3453                 {
3454                         if (ClientVersion <= 7)
3455                                 Assert.Ignore ("BigInt data type is not supported.");
3456
3457                         cmd.CommandText = "SELECT type_bigint FROM numeric_family WHERE id = 1";
3458
3459                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3460                                 DataTable schemaTable = rdr.GetSchemaTable ();
3461                                 DataRow row = schemaTable.Rows [0];
3462                                 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3463                                 Assert.AreEqual (typeof (long), row ["DataType"], "Value");
3464                         }
3465                 }
3466
3467                 [Test]
3468                 public void DataType_Binary ()
3469                 {
3470                         cmd.CommandText = "SELECT type_binary FROM binary_family WHERE id = 1";
3471
3472                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3473                                 DataTable schemaTable = rdr.GetSchemaTable ();
3474                                 DataRow row = schemaTable.Rows [0];
3475                                 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3476                                 Assert.AreEqual (typeof (byte []), row ["DataType"], "Value");
3477                         }
3478                 }
3479
3480                 [Test]
3481                 public void DataType_Bit ()
3482                 {
3483                         cmd.CommandText = "SELECT type_bit FROM numeric_family WHERE id = 1";
3484
3485                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3486                                 DataTable schemaTable = rdr.GetSchemaTable ();
3487                                 DataRow row = schemaTable.Rows [0];
3488                                 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3489                                 Assert.AreEqual (typeof (bool), row ["DataType"], "Value");
3490                         }
3491                 }
3492
3493                 [Test]
3494                 public void DataType_Char ()
3495                 {
3496                         cmd.CommandText = "SELECT type_char FROM string_family WHERE id = 1";
3497
3498                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3499                                 DataTable schemaTable = rdr.GetSchemaTable ();
3500                                 DataRow row = schemaTable.Rows [0];
3501                                 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3502                                 Assert.AreEqual (typeof (string), row ["DataType"], "Value");
3503                         }
3504                 }
3505
3506                 [Test]
3507                 public void DataType_Date ()
3508                 {
3509                         // TODO
3510                 }
3511
3512                 [Test]
3513                 public void DataType_DateTime ()
3514                 {
3515                         cmd.CommandText = "SELECT type_datetime FROM datetime_family WHERE id = 1";
3516
3517                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3518                                 DataTable schemaTable = rdr.GetSchemaTable ();
3519                                 DataRow row = schemaTable.Rows [0];
3520                                 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3521                                 Assert.AreEqual (typeof (DateTime), row ["DataType"], "Value");
3522                         }
3523                 }
3524
3525                 [Test]
3526                 public void DataType_Decimal ()
3527                 {
3528                         cmd.CommandText = "SELECT type_decimal1 FROM numeric_family WHERE id = 1";
3529
3530                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3531                                 DataTable schemaTable = rdr.GetSchemaTable ();
3532                                 DataRow row = schemaTable.Rows [0];
3533                                 Assert.IsFalse (row.IsNull ("DataType"), "#A:IsNull");
3534                                 Assert.AreEqual (typeof (decimal), row ["DataType"], "#A:Value");
3535                         }
3536
3537                         cmd.CommandText = "SELECT type_decimal2 FROM numeric_family WHERE id = 1";
3538
3539                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3540                                 DataTable schemaTable = rdr.GetSchemaTable ();
3541                                 DataRow row = schemaTable.Rows [0];
3542                                 Assert.IsFalse (row.IsNull ("DataType"), "#B:IsNull");
3543                                 Assert.AreEqual (typeof (decimal), row ["DataType"], "#B:Value");
3544                         }
3545
3546                         cmd.CommandText = "SELECT type_numeric1 FROM numeric_family WHERE id = 1";
3547
3548                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3549                                 DataTable schemaTable = rdr.GetSchemaTable ();
3550                                 DataRow row = schemaTable.Rows [0];
3551                                 Assert.IsFalse (row.IsNull ("DataType"), "#C:IsNull");
3552                                 Assert.AreEqual (typeof (decimal), row ["DataType"], "#C:Value");
3553                         }
3554
3555                         cmd.CommandText = "SELECT type_numeric2 FROM numeric_family WHERE id = 1";
3556
3557                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3558                                 DataTable schemaTable = rdr.GetSchemaTable ();
3559                                 DataRow row = schemaTable.Rows [0];
3560                                 Assert.IsFalse (row.IsNull ("DataType"), "#D:IsNull");
3561                                 Assert.AreEqual (typeof (decimal), row ["DataType"], "#D:Value");
3562                         }
3563                 }
3564
3565                 [Test]
3566                 public void DataType_Float ()
3567                 {
3568                         cmd.CommandText = "SELECT type_double FROM numeric_family WHERE id = 1";
3569
3570                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3571                                 DataTable schemaTable = rdr.GetSchemaTable ();
3572                                 DataRow row = schemaTable.Rows [0];
3573                                 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3574                                 Assert.AreEqual (typeof (double), row ["DataType"], "Value");
3575                         }
3576                 }
3577
3578                 [Test]
3579                 public void DataType_Image ()
3580                 {
3581                         cmd.CommandText = "SELECT type_tinyblob FROM binary_family WHERE id = 1";
3582
3583                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3584                                 DataTable schemaTable = rdr.GetSchemaTable ();
3585                                 DataRow row = schemaTable.Rows [0];
3586                                 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3587                                 Assert.AreEqual (typeof (byte []), row ["DataType"], "Value");
3588                         }
3589                 }
3590
3591                 [Test]
3592                 public void DataType_Int ()
3593                 {
3594                         cmd.CommandText = "SELECT type_int FROM numeric_family WHERE id = 1";
3595
3596                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3597                                 DataTable schemaTable = rdr.GetSchemaTable ();
3598                                 DataRow row = schemaTable.Rows [0];
3599                                 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3600                                 Assert.AreEqual (typeof (int), row ["DataType"], "Value");
3601                         }
3602                 }
3603
3604                 [Test]
3605                 public void DataType_Money ()
3606                 {
3607                         cmd.CommandText = "SELECT type_money FROM numeric_family WHERE id = 1";
3608
3609                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3610                                 DataTable schemaTable = rdr.GetSchemaTable ();
3611                                 DataRow row = schemaTable.Rows [0];
3612                                 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3613                                 Assert.AreEqual (typeof (decimal), row ["DataType"], "Value");
3614                         }
3615                 }
3616
3617                 [Test]
3618                 public void DataType_NChar ()
3619                 {
3620                         cmd.CommandText = "SELECT type_nchar FROM string_family WHERE id = 1";
3621
3622                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3623                                 DataTable schemaTable = rdr.GetSchemaTable ();
3624                                 DataRow row = schemaTable.Rows [0];
3625                                 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3626                                 Assert.AreEqual (typeof (string), row ["DataType"], "Value");
3627                         }
3628                 }
3629
3630                 [Test]
3631                 public void DataType_NText ()
3632                 {
3633                         cmd.CommandText = "SELECT type_ntext FROM string_family WHERE id = 1";
3634
3635                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3636                                 DataTable schemaTable = rdr.GetSchemaTable ();
3637                                 DataRow row = schemaTable.Rows [0];
3638                                 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3639                                 Assert.AreEqual (typeof (string), row ["DataType"], "Value");
3640                         }
3641                 }
3642
3643                 [Test]
3644                 public void DataType_NVarChar ()
3645                 {
3646                         cmd.CommandText = "SELECT type_nvarchar FROM string_family WHERE id = 1";
3647
3648                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3649                                 DataTable schemaTable = rdr.GetSchemaTable ();
3650                                 DataRow row = schemaTable.Rows [0];
3651                                 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3652                                 Assert.AreEqual (typeof (string), row ["DataType"], "Value");
3653                         }
3654                 }
3655
3656                 [Test]
3657                 public void DataType_Real ()
3658                 {
3659                         cmd.CommandText = "SELECT type_float FROM numeric_family WHERE id = 1";
3660
3661                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3662                                 DataTable schemaTable = rdr.GetSchemaTable ();
3663                                 DataRow row = schemaTable.Rows [0];
3664                                 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3665                                 Assert.AreEqual (typeof (float), row ["DataType"], "Value");
3666                         }
3667
3668                 }
3669
3670                 [Test]
3671                 public void DataType_SmallDateTime ()
3672                 {
3673                         cmd.CommandText = "SELECT type_smalldatetime FROM datetime_family WHERE id = 1";
3674
3675                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3676                                 DataTable schemaTable = rdr.GetSchemaTable ();
3677                                 DataRow row = schemaTable.Rows [0];
3678                                 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3679                                 Assert.AreEqual (typeof (DateTime), row ["DataType"], "Value");
3680                         }
3681                 }
3682
3683                 [Test]
3684                 public void DataType_SmallInt ()
3685                 {
3686                         cmd.CommandText = "SELECT type_smallint FROM numeric_family WHERE id = 1";
3687
3688                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3689                                 DataTable schemaTable = rdr.GetSchemaTable ();
3690                                 DataRow row = schemaTable.Rows [0];
3691                                 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3692                                 Assert.AreEqual (typeof (short), row ["DataType"], "Value");
3693                         }
3694                 }
3695
3696                 [Test]
3697                 public void DataType_SmallMoney ()
3698                 {
3699                         cmd.CommandText = "SELECT type_smallmoney FROM numeric_family WHERE id = 1";
3700
3701                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3702                                 DataTable schemaTable = rdr.GetSchemaTable ();
3703                                 DataRow row = schemaTable.Rows [0];
3704                                 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3705                                 Assert.AreEqual (typeof (decimal), row ["DataType"], "Value");
3706                         }
3707                 }
3708
3709                 [Test]
3710                 public void DataType_Text ()
3711                 {
3712                         cmd.CommandText = "SELECT type_text FROM string_family WHERE id = 1";
3713
3714                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3715                                 DataTable schemaTable = rdr.GetSchemaTable ();
3716                                 DataRow row = schemaTable.Rows [0];
3717                                 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3718                                 Assert.AreEqual (typeof (string), row ["DataType"], "Value");
3719                         }
3720                 }
3721
3722                 [Test]
3723                 public void DataType_Time ()
3724                 {
3725                         // TODO
3726                 }
3727
3728                 [Test]
3729                 public void DataType_Timestamp ()
3730                 {
3731                         cmd.CommandText = "SELECT type_timestamp FROM binary_family WHERE id = 1";
3732
3733                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3734                                 DataTable schemaTable = rdr.GetSchemaTable ();
3735                                 DataRow row = schemaTable.Rows [0];
3736                                 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3737                                 Assert.AreEqual (typeof (byte []), row ["DataType"], "Value");
3738                         }
3739                 }
3740
3741                 [Test]
3742                 public void DataType_TinyInt ()
3743                 {
3744                         cmd.CommandText = "SELECT type_tinyint FROM numeric_family WHERE id = 1";
3745
3746                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3747                                 DataTable schemaTable = rdr.GetSchemaTable ();
3748                                 DataRow row = schemaTable.Rows [0];
3749                                 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3750                                 Assert.AreEqual (typeof (byte), row ["DataType"], "Value");
3751                         }
3752                 }
3753
3754                 [Test]
3755                 public void DataType_Udt ()
3756                 {
3757                         // TODO
3758                 }
3759
3760                 [Test]
3761                 public void DataType_UniqueIdentifier ()
3762                 {
3763                         cmd.CommandText = "SELECT type_guid FROM string_family WHERE id = 1";
3764
3765                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3766                                 DataTable schemaTable = rdr.GetSchemaTable ();
3767                                 DataRow row = schemaTable.Rows [0];
3768                                 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3769                                 Assert.AreEqual (typeof (Guid), row ["DataType"], "Value");
3770                         }
3771                 }
3772
3773                 [Test]
3774                 public void DataType_VarBinary ()
3775                 {
3776                         cmd.CommandText = "SELECT type_varbinary FROM binary_family WHERE id = 1";
3777
3778                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3779                                 DataTable schemaTable = rdr.GetSchemaTable ();
3780                                 DataRow row = schemaTable.Rows [0];
3781                                 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3782                                 Assert.AreEqual (typeof (byte []), row ["DataType"], "Value");
3783                         }
3784                 }
3785
3786                 [Test]
3787                 public void DataType_VarChar ()
3788                 {
3789                         cmd.CommandText = "SELECT type_varchar FROM string_family WHERE id = 1";
3790
3791                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3792                                 DataTable schemaTable = rdr.GetSchemaTable ();
3793                                 DataRow row = schemaTable.Rows [0];
3794                                 Assert.IsFalse (row.IsNull ("DataType"), "IsNull");
3795                                 Assert.AreEqual (typeof (string), row ["DataType"], "Value");
3796                         }
3797                 }
3798
3799                 [Test]
3800                 public void IsLong_BigInt ()
3801                 {
3802                         if (ClientVersion <= 7)
3803                                 Assert.Ignore ("BigInt data type is not supported.");
3804
3805                         cmd.CommandText = "SELECT type_bigint FROM numeric_family WHERE id = 1";
3806
3807                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3808                                 DataTable schemaTable = rdr.GetSchemaTable ();
3809                                 DataRow row = schemaTable.Rows [0];
3810                                 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
3811                                 Assert.AreEqual (false, row ["IsLong"], "Value");
3812                         }
3813                 }
3814
3815                 [Test]
3816                 public void IsLong_Binary ()
3817                 {
3818                         cmd.CommandText = "SELECT type_binary FROM binary_family WHERE id = 1";
3819
3820                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3821                                 DataTable schemaTable = rdr.GetSchemaTable ();
3822                                 DataRow row = schemaTable.Rows [0];
3823                                 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
3824                                 Assert.AreEqual (false, row ["IsLong"], "Value");
3825                         }
3826                 }
3827
3828                 [Test]
3829                 public void IsLong_Bit ()
3830                 {
3831                         cmd.CommandText = "SELECT type_bit FROM numeric_family WHERE id = 1";
3832
3833                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3834                                 DataTable schemaTable = rdr.GetSchemaTable ();
3835                                 DataRow row = schemaTable.Rows [0];
3836                                 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
3837                                 Assert.AreEqual (false, row ["IsLong"], "Value");
3838                         }
3839                 }
3840
3841                 [Test]
3842                 public void IsLong_Char ()
3843                 {
3844                         cmd.CommandText = "SELECT type_char FROM string_family WHERE id = 1";
3845
3846                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3847                                 DataTable schemaTable = rdr.GetSchemaTable ();
3848                                 DataRow row = schemaTable.Rows [0];
3849                                 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
3850                                 Assert.AreEqual (false, row ["IsLong"], "Value");
3851                         }
3852                 }
3853
3854                 [Test]
3855                 public void IsLong_Date ()
3856                 {
3857                         // TODO
3858                 }
3859
3860                 [Test]
3861                 public void IsLong_DateTime ()
3862                 {
3863                         cmd.CommandText = "SELECT type_datetime FROM datetime_family WHERE id = 1";
3864
3865                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3866                                 DataTable schemaTable = rdr.GetSchemaTable ();
3867                                 DataRow row = schemaTable.Rows [0];
3868                                 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
3869                                 Assert.AreEqual (false, row ["IsLong"], "Value");
3870                         }
3871                 }
3872
3873                 [Test]
3874                 public void IsLong_Decimal ()
3875                 {
3876                         cmd.CommandText = "SELECT type_decimal1 FROM numeric_family WHERE id = 1";
3877
3878                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3879                                 DataTable schemaTable = rdr.GetSchemaTable ();
3880                                 DataRow row = schemaTable.Rows [0];
3881                                 Assert.IsFalse (row.IsNull ("IsLong"), "#A:IsNull");
3882                                 Assert.AreEqual (false, row ["IsLong"], "#A:Value");
3883                         }
3884
3885                         cmd.CommandText = "SELECT type_decimal2 FROM numeric_family WHERE id = 1";
3886
3887                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3888                                 DataTable schemaTable = rdr.GetSchemaTable ();
3889                                 DataRow row = schemaTable.Rows [0];
3890                                 Assert.IsFalse (row.IsNull ("IsLong"), "#B:IsNull");
3891                                 Assert.AreEqual (false, row ["IsLong"], "#B:Value");
3892                         }
3893
3894                         cmd.CommandText = "SELECT type_numeric1 FROM numeric_family WHERE id = 1";
3895
3896                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3897                                 DataTable schemaTable = rdr.GetSchemaTable ();
3898                                 DataRow row = schemaTable.Rows [0];
3899                                 Assert.IsFalse (row.IsNull ("IsLong"), "#C:IsNull");
3900                                 Assert.AreEqual (false, row ["IsLong"], "#C:Value");
3901                         }
3902
3903                         cmd.CommandText = "SELECT type_numeric2 FROM numeric_family WHERE id = 1";
3904
3905                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3906                                 DataTable schemaTable = rdr.GetSchemaTable ();
3907                                 DataRow row = schemaTable.Rows [0];
3908                                 Assert.IsFalse (row.IsNull ("IsLong"), "#D:IsNull");
3909                                 Assert.AreEqual (false, row ["IsLong"], "#D:Value");
3910                         }
3911                 }
3912
3913                 [Test]
3914                 public void IsLong_Float ()
3915                 {
3916                         cmd.CommandText = "SELECT type_double FROM numeric_family WHERE id = 1";
3917
3918                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3919                                 DataTable schemaTable = rdr.GetSchemaTable ();
3920                                 DataRow row = schemaTable.Rows [0];
3921                                 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
3922                                 Assert.AreEqual (false, row ["IsLong"], "Value");
3923                         }
3924                 }
3925
3926                 [Test]
3927                 public void IsLong_Image ()
3928                 {
3929                         cmd.CommandText = "SELECT type_tinyblob FROM binary_family WHERE id = 1";
3930
3931                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3932                                 DataTable schemaTable = rdr.GetSchemaTable ();
3933                                 DataRow row = schemaTable.Rows [0];
3934                                 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
3935                                 Assert.AreEqual (true, row ["IsLong"], "Value");
3936                         }
3937                 }
3938
3939                 [Test]
3940                 public void IsLong_Int ()
3941                 {
3942                         cmd.CommandText = "SELECT type_int FROM numeric_family WHERE id = 1";
3943
3944                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3945                                 DataTable schemaTable = rdr.GetSchemaTable ();
3946                                 DataRow row = schemaTable.Rows [0];
3947                                 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
3948                                 Assert.AreEqual (false, row ["IsLong"], "Value");
3949                         }
3950                 }
3951
3952                 [Test]
3953                 public void IsLong_Money ()
3954                 {
3955                         cmd.CommandText = "SELECT type_money FROM numeric_family WHERE id = 1";
3956
3957                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3958                                 DataTable schemaTable = rdr.GetSchemaTable ();
3959                                 DataRow row = schemaTable.Rows [0];
3960                                 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
3961                                 Assert.AreEqual (false, row ["IsLong"], "Value");
3962                         }
3963                 }
3964
3965                 [Test]
3966                 public void IsLong_NChar ()
3967                 {
3968                         cmd.CommandText = "SELECT type_nchar FROM string_family WHERE id = 1";
3969
3970                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3971                                 DataTable schemaTable = rdr.GetSchemaTable ();
3972                                 DataRow row = schemaTable.Rows [0];
3973                                 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
3974                                 Assert.AreEqual (false, row ["IsLong"], "Value");
3975                         }
3976                 }
3977
3978                 [Test]
3979                 public void IsLong_NText ()
3980                 {
3981                         cmd.CommandText = "SELECT type_ntext FROM string_family WHERE id = 1";
3982
3983                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3984                                 DataTable schemaTable = rdr.GetSchemaTable ();
3985                                 DataRow row = schemaTable.Rows [0];
3986                                 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
3987                                 Assert.AreEqual (true, row ["IsLong"], "Value");
3988                         }
3989                 }
3990
3991                 [Test]
3992                 public void IsLong_NVarChar ()
3993                 {
3994                         cmd.CommandText = "SELECT type_nvarchar FROM string_family WHERE id = 1";
3995
3996                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
3997                                 DataTable schemaTable = rdr.GetSchemaTable ();
3998                                 DataRow row = schemaTable.Rows [0];
3999                                 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
4000                                 Assert.AreEqual (false, row ["IsLong"], "Value");
4001                         }
4002                 }
4003
4004                 [Test]
4005                 public void IsLong_Real ()
4006                 {
4007                         cmd.CommandText = "SELECT type_float FROM numeric_family WHERE id = 1";
4008
4009                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4010                                 DataTable schemaTable = rdr.GetSchemaTable ();
4011                                 DataRow row = schemaTable.Rows [0];
4012                                 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
4013                                 Assert.AreEqual (false, row ["IsLong"], "Value");
4014                         }
4015
4016                 }
4017
4018                 [Test]
4019                 public void IsLong_SmallDateTime ()
4020                 {
4021                         cmd.CommandText = "SELECT type_smalldatetime FROM datetime_family WHERE id = 1";
4022
4023                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4024                                 DataTable schemaTable = rdr.GetSchemaTable ();
4025                                 DataRow row = schemaTable.Rows [0];
4026                                 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
4027                                 Assert.AreEqual (false, row ["IsLong"], "Value");
4028                         }
4029                 }
4030
4031                 [Test]
4032                 public void IsLong_SmallInt ()
4033                 {
4034                         cmd.CommandText = "SELECT type_smallint FROM numeric_family WHERE id = 1";
4035
4036                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4037                                 DataTable schemaTable = rdr.GetSchemaTable ();
4038                                 DataRow row = schemaTable.Rows [0];
4039                                 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
4040                                 Assert.AreEqual (false, row ["IsLong"], "Value");
4041                         }
4042                 }
4043
4044                 [Test]
4045                 public void IsLong_SmallMoney ()
4046                 {
4047                         cmd.CommandText = "SELECT type_smallmoney FROM numeric_family WHERE id = 1";
4048
4049                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4050                                 DataTable schemaTable = rdr.GetSchemaTable ();
4051                                 DataRow row = schemaTable.Rows [0];
4052                                 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
4053                                 Assert.AreEqual (false, row ["IsLong"], "Value");
4054                         }
4055                 }
4056
4057                 [Test]
4058                 public void IsLong_Text ()
4059                 {
4060                         cmd.CommandText = "SELECT type_text FROM string_family WHERE id = 1";
4061
4062                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4063                                 DataTable schemaTable = rdr.GetSchemaTable ();
4064                                 DataRow row = schemaTable.Rows [0];
4065                                 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
4066                                 Assert.AreEqual (true, row ["IsLong"], "Value");
4067                         }
4068                 }
4069
4070                 [Test]
4071                 public void IsLong_Time ()
4072                 {
4073                         // TODO
4074                 }
4075
4076                 [Test]
4077                 public void IsLong_Timestamp ()
4078                 {
4079                         cmd.CommandText = "SELECT type_timestamp FROM binary_family WHERE id = 1";
4080
4081                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4082                                 DataTable schemaTable = rdr.GetSchemaTable ();
4083                                 DataRow row = schemaTable.Rows [0];
4084                                 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
4085                                 Assert.AreEqual (false, row ["IsLong"], "Value");
4086                         }
4087                 }
4088
4089                 [Test]
4090                 public void IsLong_TinyInt ()
4091                 {
4092                         cmd.CommandText = "SELECT type_tinyint FROM numeric_family WHERE id = 1";
4093
4094                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4095                                 DataTable schemaTable = rdr.GetSchemaTable ();
4096                                 DataRow row = schemaTable.Rows [0];
4097                                 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
4098                                 Assert.AreEqual (false, row ["IsLong"], "Value");
4099                         }
4100                 }
4101
4102                 [Test]
4103                 public void IsLong_Udt ()
4104                 {
4105                         // TODO
4106                 }
4107
4108                 [Test]
4109                 public void IsLong_UniqueIdentifier ()
4110                 {
4111                         cmd.CommandText = "SELECT type_guid FROM string_family WHERE id = 1";
4112
4113                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4114                                 DataTable schemaTable = rdr.GetSchemaTable ();
4115                                 DataRow row = schemaTable.Rows [0];
4116                                 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
4117                                 Assert.AreEqual (false, row ["IsLong"], "Value");
4118                         }
4119                 }
4120
4121                 [Test]
4122                 public void IsLong_VarBinary ()
4123                 {
4124                         cmd.CommandText = "SELECT type_varbinary FROM binary_family WHERE id = 1";
4125
4126                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4127                                 DataTable schemaTable = rdr.GetSchemaTable ();
4128                                 DataRow row = schemaTable.Rows [0];
4129                                 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
4130                                 Assert.AreEqual (false, row ["IsLong"], "Value");
4131                         }
4132                 }
4133
4134                 [Test]
4135                 public void IsLong_VarChar ()
4136                 {
4137                         cmd.CommandText = "SELECT type_varchar FROM string_family WHERE id = 1";
4138
4139                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4140                                 DataTable schemaTable = rdr.GetSchemaTable ();
4141                                 DataRow row = schemaTable.Rows [0];
4142                                 Assert.IsFalse (row.IsNull ("IsLong"), "IsNull");
4143                                 Assert.AreEqual (false, row ["IsLong"], "Value");
4144                         }
4145                 }
4146
4147                 [Test]
4148                 public void NumericPrecision_BigInt ()
4149                 {
4150                         if (ClientVersion <= 7)
4151                                 Assert.Ignore ("BigInt data type is not supported.");
4152
4153                         cmd.CommandText = "SELECT type_bigint FROM numeric_family WHERE id = 1";
4154
4155                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4156                                 DataTable schemaTable = rdr.GetSchemaTable ();
4157                                 DataRow row = schemaTable.Rows [0];
4158                                 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4159                                 if (ClientVersion > 7)
4160                                         Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4161                                 else
4162                                         Assert.AreEqual (19, row ["NumericPrecision"], "Value");
4163                         }
4164                 }
4165
4166                 [Test]
4167                 public void NumericPrecision_Binary ()
4168                 {
4169                         cmd.CommandText = "SELECT type_binary FROM binary_family WHERE id = 1";
4170
4171                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4172                                 DataTable schemaTable = rdr.GetSchemaTable ();
4173                                 DataRow row = schemaTable.Rows [0];
4174                                 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4175                                 if (ClientVersion > 7)
4176                                         Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4177                                 else
4178                                         Assert.AreEqual (255, row ["NumericPrecision"], "Value");
4179                         }
4180                 }
4181
4182                 [Test]
4183                 public void NumericPrecision_Bit ()
4184                 {
4185                         cmd.CommandText = "SELECT type_bit FROM numeric_family WHERE id = 1";
4186
4187                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4188                                 DataTable schemaTable = rdr.GetSchemaTable ();
4189                                 DataRow row = schemaTable.Rows [0];
4190                                 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4191                                 if (ClientVersion > 7)
4192                                         Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4193                                 else
4194                                         Assert.AreEqual (255, row ["NumericPrecision"], "Value");
4195                         }
4196                 }
4197
4198                 [Test]
4199                 public void NumericPrecision_Char ()
4200                 {
4201                         cmd.CommandText = "SELECT type_char FROM string_family WHERE id = 1";
4202
4203                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4204                                 DataTable schemaTable = rdr.GetSchemaTable ();
4205                                 DataRow row = schemaTable.Rows [0];
4206                                 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4207                                 if (ClientVersion > 7)
4208                                         Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4209                                 else
4210                                         Assert.AreEqual (255, row ["NumericPrecision"], "Value");
4211                         }
4212                 }
4213
4214                 [Test]
4215                 public void NumericPrecision_Date ()
4216                 {
4217                         // TODO
4218                 }
4219
4220                 [Test]
4221                 public void NumericPrecision_DateTime ()
4222                 {
4223                         cmd.CommandText = "SELECT type_datetime FROM datetime_family WHERE id = 1";
4224
4225                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4226                                 DataTable schemaTable = rdr.GetSchemaTable ();
4227                                 DataRow row = schemaTable.Rows [0];
4228                                 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4229                                 if (ClientVersion > 7)
4230                                         Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4231                                 else
4232                                         Assert.AreEqual (23, row ["NumericPrecision"], "Value");
4233                         }
4234                 }
4235
4236                 [Test]
4237                 public void NumericPrecision_Decimal ()
4238                 {
4239                         cmd.CommandText = "SELECT type_decimal1 FROM numeric_family WHERE id = 1";
4240
4241                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4242                                 DataTable schemaTable = rdr.GetSchemaTable ();
4243                                 DataRow row = schemaTable.Rows [0];
4244                                 Assert.IsFalse (row.IsNull ("NumericPrecision"), "#A:IsNull");
4245                                 if (ClientVersion == 7)
4246                                         Assert.AreEqual (28, row ["NumericPrecision"], "#A:Value");
4247                                 else
4248                                         Assert.AreEqual (38, row ["NumericPrecision"], "#A:Value");
4249                         }
4250
4251                         cmd.CommandText = "SELECT type_decimal2 FROM numeric_family WHERE id = 1";
4252
4253                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4254                                 DataTable schemaTable = rdr.GetSchemaTable ();
4255                                 DataRow row = schemaTable.Rows [0];
4256                                 Assert.IsFalse (row.IsNull ("NumericPrecision"), "#B:IsNull");
4257                                 Assert.AreEqual (10, row ["NumericPrecision"], "#B:Value");
4258                         }
4259
4260                         cmd.CommandText = "SELECT type_numeric1 FROM numeric_family WHERE id = 1";
4261
4262                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4263                                 DataTable schemaTable = rdr.GetSchemaTable ();
4264                                 DataRow row = schemaTable.Rows [0];
4265                                 Assert.IsFalse (row.IsNull ("NumericPrecision"), "#C:IsNull");
4266                                 if (ClientVersion == 7)
4267                                         Assert.AreEqual (28, row ["NumericPrecision"], "#C:Value");
4268                                 else
4269                                         Assert.AreEqual (38, row ["NumericPrecision"], "#C:Value");
4270                         }
4271
4272                         cmd.CommandText = "SELECT type_numeric2 FROM numeric_family WHERE id = 1";
4273
4274                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4275                                 DataTable schemaTable = rdr.GetSchemaTable ();
4276                                 DataRow row = schemaTable.Rows [0];
4277                                 Assert.IsFalse (row.IsNull ("NumericPrecision"), "#D:IsNull");
4278                                 Assert.AreEqual (10, row ["NumericPrecision"], "#D:Value");
4279                         }
4280                 }
4281
4282                 [Test]
4283                 public void NumericPrecision_Float ()
4284                 {
4285                         cmd.CommandText = "SELECT type_double FROM numeric_family WHERE id = 1";
4286
4287                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4288                                 DataTable schemaTable = rdr.GetSchemaTable ();
4289                                 DataRow row = schemaTable.Rows [0];
4290                                 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4291                                 if (ClientVersion > 7)
4292                                         Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4293                                 else
4294                                         Assert.AreEqual (15, row ["NumericPrecision"], "Value");
4295                         }
4296                 }
4297
4298                 [Test]
4299                 public void NumericPrecision_Image ()
4300                 {
4301                         cmd.CommandText = "SELECT type_tinyblob FROM binary_family WHERE id = 1";
4302
4303                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4304                                 DataTable schemaTable = rdr.GetSchemaTable ();
4305                                 DataRow row = schemaTable.Rows [0];
4306                                 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4307                                 if (ClientVersion > 7)
4308                                         Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4309                                 else
4310                                         Assert.AreEqual (255, row ["NumericPrecision"], "Value");
4311                         }
4312                 }
4313
4314                 [Test]
4315                 public void NumericPrecision_Int ()
4316                 {
4317                         cmd.CommandText = "SELECT type_int FROM numeric_family WHERE id = 1";
4318
4319                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4320                                 DataTable schemaTable = rdr.GetSchemaTable ();
4321                                 DataRow row = schemaTable.Rows [0];
4322                                 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4323                                 if (ClientVersion > 7)
4324                                         Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4325                                 else
4326                                         Assert.AreEqual (10, row ["NumericPrecision"], "Value");
4327                         }
4328                 }
4329
4330                 [Test]
4331                 public void NumericPrecision_Money ()
4332                 {
4333                         cmd.CommandText = "SELECT type_money FROM numeric_family WHERE id = 1";
4334
4335                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4336                                 DataTable schemaTable = rdr.GetSchemaTable ();
4337                                 DataRow row = schemaTable.Rows [0];
4338                                 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4339                                 if (ClientVersion > 7)
4340                                         Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4341                                 else
4342                                         Assert.AreEqual (19, row ["NumericPrecision"], "Value");
4343                         }
4344                 }
4345
4346                 [Test]
4347                 public void NumericPrecision_NChar ()
4348                 {
4349                         cmd.CommandText = "SELECT type_nchar FROM string_family WHERE id = 1";
4350
4351                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4352                                 DataTable schemaTable = rdr.GetSchemaTable ();
4353                                 DataRow row = schemaTable.Rows [0];
4354                                 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4355                                 if (ClientVersion > 7)
4356                                         Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4357                                 else
4358                                         Assert.AreEqual (255, row ["NumericPrecision"], "Value");
4359                         }
4360                 }
4361
4362                 [Test]
4363                 public void NumericPrecision_NText ()
4364                 {
4365                         cmd.CommandText = "SELECT type_ntext FROM string_family WHERE id = 1";
4366
4367                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4368                                 DataTable schemaTable = rdr.GetSchemaTable ();
4369                                 DataRow row = schemaTable.Rows [0];
4370                                 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4371                                 if (ClientVersion > 7)
4372                                         Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4373                                 else
4374                                         Assert.AreEqual (255, row ["NumericPrecision"], "Value");
4375                         }
4376                 }
4377
4378                 [Test]
4379                 public void NumericPrecision_NVarChar ()
4380                 {
4381                         cmd.CommandText = "SELECT type_nvarchar FROM string_family WHERE id = 1";
4382
4383                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4384                                 DataTable schemaTable = rdr.GetSchemaTable ();
4385                                 DataRow row = schemaTable.Rows [0];
4386                                 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4387                                 if (ClientVersion > 7)
4388                                         Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4389                                 else
4390                                         Assert.AreEqual (255, row ["NumericPrecision"], "Value");
4391                         }
4392                 }
4393
4394                 [Test]
4395                 public void NumericPrecision_Real ()
4396                 {
4397                         cmd.CommandText = "SELECT type_float FROM numeric_family WHERE id = 1";
4398
4399                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4400                                 DataTable schemaTable = rdr.GetSchemaTable ();
4401                                 DataRow row = schemaTable.Rows [0];
4402                                 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4403                                 if (ClientVersion > 7)
4404                                         Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4405                                 else
4406                                         Assert.AreEqual (7, row ["NumericPrecision"], "Value");
4407                         }
4408
4409                 }
4410
4411                 [Test]
4412                 public void NumericPrecision_SmallDateTime ()
4413                 {
4414                         cmd.CommandText = "SELECT type_smalldatetime FROM datetime_family WHERE id = 1";
4415
4416                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4417                                 DataTable schemaTable = rdr.GetSchemaTable ();
4418                                 DataRow row = schemaTable.Rows [0];
4419                                 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4420                                 if (ClientVersion > 7)
4421                                         Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4422                                 else
4423                                         Assert.AreEqual (16, row ["NumericPrecision"], "Value");
4424                         }
4425                 }
4426
4427                 [Test]
4428                 public void NumericPrecision_SmallInt ()
4429                 {
4430                         cmd.CommandText = "SELECT type_smallint FROM numeric_family WHERE id = 1";
4431
4432                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4433                                 DataTable schemaTable = rdr.GetSchemaTable ();
4434                                 DataRow row = schemaTable.Rows [0];
4435                                 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4436                                 if (ClientVersion > 7)
4437                                         Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4438                                 else
4439                                         Assert.AreEqual (5, row ["NumericPrecision"], "Value");
4440                         }
4441                 }
4442
4443                 [Test]
4444                 public void NumericPrecision_SmallMoney ()
4445                 {
4446                         cmd.CommandText = "SELECT type_smallmoney FROM numeric_family WHERE id = 1";
4447
4448                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4449                                 DataTable schemaTable = rdr.GetSchemaTable ();
4450                                 DataRow row = schemaTable.Rows [0];
4451                                 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4452                                 if (ClientVersion > 7)
4453                                         Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4454                                 else
4455                                         Assert.AreEqual (10, row ["NumericPrecision"], "Value");
4456                         }
4457                 }
4458
4459                 [Test]
4460                 public void NumericPrecision_Text ()
4461                 {
4462                         cmd.CommandText = "SELECT type_text FROM string_family WHERE id = 1";
4463
4464                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4465                                 DataTable schemaTable = rdr.GetSchemaTable ();
4466                                 DataRow row = schemaTable.Rows [0];
4467                                 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4468                                 if (ClientVersion > 7)
4469                                         Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4470                                 else
4471                                         Assert.AreEqual (255, row ["NumericPrecision"], "Value");
4472                         }
4473                 }
4474
4475                 [Test]
4476                 public void NumericPrecision_Time ()
4477                 {
4478                         // TODO
4479                 }
4480
4481                 [Test]
4482                 public void NumericPrecision_Timestamp ()
4483                 {
4484                         cmd.CommandText = "SELECT type_timestamp FROM binary_family WHERE id = 1";
4485
4486                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4487                                 DataTable schemaTable = rdr.GetSchemaTable ();
4488                                 DataRow row = schemaTable.Rows [0];
4489                                 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4490                                 if (ClientVersion > 7)
4491                                         Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4492                                 else
4493                                         Assert.AreEqual (255, row ["NumericPrecision"], "Value");
4494                         }
4495                 }
4496
4497                 [Test]
4498                 public void NumericPrecision_TinyInt ()
4499                 {
4500                         cmd.CommandText = "SELECT type_tinyint FROM numeric_family WHERE id = 1";
4501
4502                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4503                                 DataTable schemaTable = rdr.GetSchemaTable ();
4504                                 DataRow row = schemaTable.Rows [0];
4505                                 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4506                                 if (ClientVersion > 7)
4507                                         Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4508                                 else
4509                                         Assert.AreEqual (3, row ["NumericPrecision"], "Value");
4510                         }
4511                 }
4512
4513                 [Test]
4514                 public void NumericPrecision_Udt ()
4515                 {
4516                         // TODO
4517                 }
4518
4519                 [Test]
4520                 public void NumericPrecision_UniqueIdentifier ()
4521                 {
4522                         cmd.CommandText = "SELECT type_guid FROM string_family WHERE id = 1";
4523
4524                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4525                                 DataTable schemaTable = rdr.GetSchemaTable ();
4526                                 DataRow row = schemaTable.Rows [0];
4527                                 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4528                                 if (ClientVersion > 7)
4529                                         Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4530                                 else
4531                                         Assert.AreEqual (255, row ["NumericPrecision"], "Value");
4532                         }
4533                 }
4534
4535                 [Test]
4536                 public void NumericPrecision_VarBinary ()
4537                 {
4538                         cmd.CommandText = "SELECT type_varbinary FROM binary_family WHERE id = 1";
4539
4540                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4541                                 DataTable schemaTable = rdr.GetSchemaTable ();
4542                                 DataRow row = schemaTable.Rows [0];
4543                                 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4544                                 if (ClientVersion > 7)
4545                                         Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4546                                 else
4547                                         Assert.AreEqual (255, row ["NumericPrecision"], "Value");
4548                         }
4549                 }
4550
4551                 [Test]
4552                 public void NumericPrecision_VarChar ()
4553                 {
4554                         cmd.CommandText = "SELECT type_varchar FROM string_family WHERE id = 1";
4555
4556                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4557                                 DataTable schemaTable = rdr.GetSchemaTable ();
4558                                 DataRow row = schemaTable.Rows [0];
4559                                 Assert.IsFalse (row.IsNull ("NumericPrecision"), "IsNull");
4560                                 if (ClientVersion > 7)
4561                                         Assert.AreEqual (0, row ["NumericPrecision"], "Value");
4562                                 else
4563                                         Assert.AreEqual (255, row ["NumericPrecision"], "Value");
4564                         }
4565                 }
4566
4567                 [Test]
4568                 public void NumericPrecision_Variant ()
4569                 {
4570                         // TODO
4571                 }
4572
4573                 [Test]
4574                 public void NumericPrecision_Xml ()
4575                 {
4576                         // TODO
4577                 }
4578
4579                 [Test]
4580                 public void NumericScale_BigInt ()
4581                 {
4582                         if (ClientVersion <= 7)
4583                                 Assert.Ignore ("BigInt data type is not supported.");
4584
4585                         cmd.CommandText = "SELECT type_bigint FROM numeric_family WHERE id = 1";
4586
4587                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4588                                 DataTable schemaTable = rdr.GetSchemaTable ();
4589                                 DataRow row = schemaTable.Rows [0];
4590                                 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4591                                 if (ClientVersion > 7)
4592                                         Assert.AreEqual (0, row ["NumericScale"], "Value");
4593                                 else
4594                                         Assert.AreEqual (255, row ["NumericScale"], "Value");
4595                         }
4596                 }
4597
4598                 [Test]
4599                 public void NumericScale_Binary ()
4600                 {
4601                         cmd.CommandText = "SELECT type_binary FROM binary_family WHERE id = 1";
4602
4603                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4604                                 DataTable schemaTable = rdr.GetSchemaTable ();
4605                                 DataRow row = schemaTable.Rows [0];
4606                                 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4607                                 if (ClientVersion > 7)
4608                                         Assert.AreEqual (0, row ["NumericScale"], "Value");
4609                                 else
4610                                         Assert.AreEqual (255, row ["NumericScale"], "Value");
4611                         }
4612                 }
4613
4614                 [Test]
4615                 public void NumericScale_Bit ()
4616                 {
4617                         cmd.CommandText = "SELECT type_bit FROM numeric_family WHERE id = 1";
4618
4619                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4620                                 DataTable schemaTable = rdr.GetSchemaTable ();
4621                                 DataRow row = schemaTable.Rows [0];
4622                                 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4623                                 if (ClientVersion > 7)
4624                                         Assert.AreEqual (0, row ["NumericScale"], "Value");
4625                                 else
4626                                         Assert.AreEqual (255, row ["NumericScale"], "Value");
4627                         }
4628                 }
4629
4630                 [Test]
4631                 public void NumericScale_Char ()
4632                 {
4633                         cmd.CommandText = "SELECT type_char FROM string_family WHERE id = 1";
4634
4635                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4636                                 DataTable schemaTable = rdr.GetSchemaTable ();
4637                                 DataRow row = schemaTable.Rows [0];
4638                                 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4639                                 if (ClientVersion > 7)
4640                                         Assert.AreEqual (0, row ["NumericScale"], "Value");
4641                                 else
4642                                         Assert.AreEqual (255, row ["NumericScale"], "Value");
4643                         }
4644                 }
4645
4646                 [Test]
4647                 public void NumericScale_Date ()
4648                 {
4649                         // TODO
4650                 }
4651
4652                 [Test]
4653                 public void NumericScale_DateTime ()
4654                 {
4655                         cmd.CommandText = "SELECT type_datetime FROM datetime_family WHERE id = 1";
4656
4657                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4658                                 DataTable schemaTable = rdr.GetSchemaTable ();
4659                                 DataRow row = schemaTable.Rows [0];
4660                                 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4661                                 if (ClientVersion > 7)
4662                                         Assert.AreEqual (0, row ["NumericScale"], "Value");
4663                                 else
4664                                         Assert.AreEqual (3, row ["NumericScale"], "Value");
4665                         }
4666                 }
4667
4668                 [Test]
4669                 public void NumericScale_Decimal ()
4670                 {
4671                         cmd.CommandText = "SELECT type_decimal1 FROM numeric_family WHERE id = 1";
4672
4673                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4674                                 DataTable schemaTable = rdr.GetSchemaTable ();
4675                                 DataRow row = schemaTable.Rows [0];
4676                                 Assert.IsFalse (row.IsNull ("NumericScale"), "#A:IsNull");
4677                                 Assert.AreEqual (0, row ["NumericScale"], "#A:Value");
4678                         }
4679
4680                         cmd.CommandText = "SELECT type_decimal2 FROM numeric_family WHERE id = 1";
4681
4682                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4683                                 DataTable schemaTable = rdr.GetSchemaTable ();
4684                                 DataRow row = schemaTable.Rows [0];
4685                                 Assert.IsFalse (row.IsNull ("NumericScale"), "#B:IsNull");
4686                                 Assert.AreEqual (3, row ["NumericScale"], "#B:Value");
4687                         }
4688
4689                         cmd.CommandText = "SELECT type_numeric1 FROM numeric_family WHERE id = 1";
4690
4691                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4692                                 DataTable schemaTable = rdr.GetSchemaTable ();
4693                                 DataRow row = schemaTable.Rows [0];
4694                                 Assert.IsFalse (row.IsNull ("NumericScale"), "#C:IsNull");
4695                                 Assert.AreEqual (0, row ["NumericScale"], "#C:Value");
4696                         }
4697
4698                         cmd.CommandText = "SELECT type_numeric2 FROM numeric_family WHERE id = 1";
4699
4700                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4701                                 DataTable schemaTable = rdr.GetSchemaTable ();
4702                                 DataRow row = schemaTable.Rows [0];
4703                                 Assert.IsFalse (row.IsNull ("NumericScale"), "#D:IsNull");
4704                                 Assert.AreEqual (3, row ["NumericScale"], "#D:Value");
4705                         }
4706                 }
4707
4708                 [Test]
4709                 public void NumericScale_Float ()
4710                 {
4711                         cmd.CommandText = "SELECT type_double FROM numeric_family WHERE id = 1";
4712
4713                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4714                                 DataTable schemaTable = rdr.GetSchemaTable ();
4715                                 DataRow row = schemaTable.Rows [0];
4716                                 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4717                                 if (ClientVersion > 7)
4718                                         Assert.AreEqual (0, row ["NumericScale"], "Value");
4719                                 else
4720                                         Assert.AreEqual (255, row ["NumericScale"], "Value");
4721                         }
4722                 }
4723
4724                 [Test]
4725                 public void NumericScale_Image ()
4726                 {
4727                         cmd.CommandText = "SELECT type_tinyblob FROM binary_family WHERE id = 1";
4728
4729                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4730                                 DataTable schemaTable = rdr.GetSchemaTable ();
4731                                 DataRow row = schemaTable.Rows [0];
4732                                 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4733                                 if (ClientVersion > 7)
4734                                         Assert.AreEqual (0, row ["NumericScale"], "Value");
4735                                 else
4736                                         Assert.AreEqual (255, row ["NumericScale"], "Value");
4737                         }
4738                 }
4739
4740                 [Test]
4741                 public void NumericScale_Int ()
4742                 {
4743                         cmd.CommandText = "SELECT type_int FROM numeric_family WHERE id = 1";
4744
4745                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4746                                 DataTable schemaTable = rdr.GetSchemaTable ();
4747                                 DataRow row = schemaTable.Rows [0];
4748                                 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4749                                 if (ClientVersion > 7)
4750                                         Assert.AreEqual (0, row ["NumericScale"], "Value");
4751                                 else
4752                                         Assert.AreEqual (255, row ["NumericScale"], "Value");
4753                         }
4754                 }
4755
4756                 [Test]
4757                 public void NumericScale_Money ()
4758                 {
4759                         cmd.CommandText = "SELECT type_money FROM numeric_family WHERE id = 1";
4760
4761                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4762                                 DataTable schemaTable = rdr.GetSchemaTable ();
4763                                 DataRow row = schemaTable.Rows [0];
4764                                 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4765                                 if (ClientVersion > 7)
4766                                         Assert.AreEqual (0, row ["NumericScale"], "Value");
4767                                 else
4768                                         Assert.AreEqual (255, row ["NumericScale"], "Value");
4769                         }
4770                 }
4771
4772                 [Test]
4773                 public void NumericScale_NChar ()
4774                 {
4775                         cmd.CommandText = "SELECT type_nchar FROM string_family WHERE id = 1";
4776
4777                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4778                                 DataTable schemaTable = rdr.GetSchemaTable ();
4779                                 DataRow row = schemaTable.Rows [0];
4780                                 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4781                                 if (ClientVersion > 7)
4782                                         Assert.AreEqual (0, row ["NumericScale"], "Value");
4783                                 else
4784                                         Assert.AreEqual (255, row ["NumericScale"], "Value");
4785                         }
4786                 }
4787
4788                 [Test]
4789                 public void NumericScale_NText ()
4790                 {
4791                         cmd.CommandText = "SELECT type_ntext FROM string_family WHERE id = 1";
4792
4793                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4794                                 DataTable schemaTable = rdr.GetSchemaTable ();
4795                                 DataRow row = schemaTable.Rows [0];
4796                                 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4797                                 if (ClientVersion > 7)
4798                                         Assert.AreEqual (0, row ["NumericScale"], "Value");
4799                                 else
4800                                         Assert.AreEqual (255, row ["NumericScale"], "Value");
4801                         }
4802                 }
4803
4804                 [Test]
4805                 public void NumericScale_NVarChar ()
4806                 {
4807                         cmd.CommandText = "SELECT type_nvarchar FROM string_family WHERE id = 1";
4808
4809                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4810                                 DataTable schemaTable = rdr.GetSchemaTable ();
4811                                 DataRow row = schemaTable.Rows [0];
4812                                 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4813                                 if (ClientVersion > 7)
4814                                         Assert.AreEqual (0, row ["NumericScale"], "Value");
4815                                 else
4816                                         Assert.AreEqual (255, row ["NumericScale"], "Value");
4817                         }
4818                 }
4819
4820                 [Test]
4821                 public void NumericScale_Real ()
4822                 {
4823                         cmd.CommandText = "SELECT type_float FROM numeric_family WHERE id = 1";
4824
4825                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4826                                 DataTable schemaTable = rdr.GetSchemaTable ();
4827                                 DataRow row = schemaTable.Rows [0];
4828                                 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4829                                 if (ClientVersion > 7)
4830                                         Assert.AreEqual (0, row ["NumericScale"], "Value");
4831                                 else
4832                                         Assert.AreEqual (255, row ["NumericScale"], "Value");
4833                         }
4834
4835                 }
4836
4837                 [Test]
4838                 public void NumericScale_SmallDateTime ()
4839                 {
4840                         cmd.CommandText = "SELECT type_smalldatetime FROM datetime_family WHERE id = 1";
4841
4842                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4843                                 DataTable schemaTable = rdr.GetSchemaTable ();
4844                                 DataRow row = schemaTable.Rows [0];
4845                                 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4846                                 Assert.AreEqual (0, row ["NumericScale"], "Value");
4847                         }
4848                 }
4849
4850                 [Test]
4851                 public void NumericScale_SmallInt ()
4852                 {
4853                         cmd.CommandText = "SELECT type_smallint FROM numeric_family WHERE id = 1";
4854
4855                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4856                                 DataTable schemaTable = rdr.GetSchemaTable ();
4857                                 DataRow row = schemaTable.Rows [0];
4858                                 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4859                                 if (ClientVersion > 7)
4860                                         Assert.AreEqual (0, row ["NumericScale"], "Value");
4861                                 else
4862                                         Assert.AreEqual (255, row ["NumericScale"], "Value");
4863                         }
4864                 }
4865
4866                 [Test]
4867                 public void NumericScale_SmallMoney ()
4868                 {
4869                         cmd.CommandText = "SELECT type_smallmoney FROM numeric_family WHERE id = 1";
4870
4871                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4872                                 DataTable schemaTable = rdr.GetSchemaTable ();
4873                                 DataRow row = schemaTable.Rows [0];
4874                                 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4875                                 if (ClientVersion > 7)
4876                                         Assert.AreEqual (0, row ["NumericScale"], "Value");
4877                                 else
4878                                         Assert.AreEqual (255, row ["NumericScale"], "Value");
4879                         }
4880                 }
4881
4882                 [Test]
4883                 public void NumericScale_Text ()
4884                 {
4885                         cmd.CommandText = "SELECT type_text FROM string_family WHERE id = 1";
4886
4887                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4888                                 DataTable schemaTable = rdr.GetSchemaTable ();
4889                                 DataRow row = schemaTable.Rows [0];
4890                                 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4891                                 if (ClientVersion > 7)
4892                                         Assert.AreEqual (0, row ["NumericScale"], "Value");
4893                                 else
4894                                         Assert.AreEqual (255, row ["NumericScale"], "Value");
4895                         }
4896                 }
4897
4898                 [Test]
4899                 public void NumericScale_Time ()
4900                 {
4901                         // TODO
4902                 }
4903
4904                 [Test]
4905                 public void NumericScale_Timestamp ()
4906                 {
4907                         cmd.CommandText = "SELECT type_timestamp FROM binary_family WHERE id = 1";
4908
4909                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4910                                 DataTable schemaTable = rdr.GetSchemaTable ();
4911                                 DataRow row = schemaTable.Rows [0];
4912                                 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4913                                 if (ClientVersion > 7)
4914                                         Assert.AreEqual (0, row ["NumericScale"], "Value");
4915                                 else
4916                                         Assert.AreEqual (255, row ["NumericScale"], "Value");
4917                         }
4918                 }
4919
4920                 [Test]
4921                 public void NumericScale_TinyInt ()
4922                 {
4923                         cmd.CommandText = "SELECT type_tinyint FROM numeric_family WHERE id = 1";
4924
4925                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4926                                 DataTable schemaTable = rdr.GetSchemaTable ();
4927                                 DataRow row = schemaTable.Rows [0];
4928                                 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4929                                 if (ClientVersion > 7)
4930                                         Assert.AreEqual (0, row ["NumericScale"], "Value");
4931                                 else
4932                                         Assert.AreEqual (255, row ["NumericScale"], "Value");
4933                         }
4934                 }
4935
4936                 [Test]
4937                 public void NumericScale_Udt ()
4938                 {
4939                         // TODO
4940                 }
4941
4942                 [Test]
4943                 public void NumericScale_UniqueIdentifier ()
4944                 {
4945                         cmd.CommandText = "SELECT type_guid FROM string_family WHERE id = 1";
4946
4947                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4948                                 DataTable schemaTable = rdr.GetSchemaTable ();
4949                                 DataRow row = schemaTable.Rows [0];
4950                                 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4951                                 if (ClientVersion > 7)
4952                                         Assert.AreEqual (0, row ["NumericScale"], "Value");
4953                                 else
4954                                         Assert.AreEqual (255, row ["NumericScale"], "Value");
4955                         }
4956                 }
4957
4958                 [Test]
4959                 public void NumericScale_VarBinary ()
4960                 {
4961                         cmd.CommandText = "SELECT type_varbinary FROM binary_family WHERE id = 1";
4962
4963                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4964                                 DataTable schemaTable = rdr.GetSchemaTable ();
4965                                 DataRow row = schemaTable.Rows [0];
4966                                 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4967                                 if (ClientVersion > 7)
4968                                         Assert.AreEqual (0, row ["NumericScale"], "Value");
4969                                 else
4970                                         Assert.AreEqual (255, row ["NumericScale"], "Value");
4971                         }
4972                 }
4973
4974                 [Test]
4975                 public void NumericScale_VarChar ()
4976                 {
4977                         cmd.CommandText = "SELECT type_varchar FROM string_family WHERE id = 1";
4978
4979                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
4980                                 DataTable schemaTable = rdr.GetSchemaTable ();
4981                                 DataRow row = schemaTable.Rows [0];
4982                                 Assert.IsFalse (row.IsNull ("NumericScale"), "IsNull");
4983                                 if (ClientVersion > 7)
4984                                         Assert.AreEqual (0, row ["NumericScale"], "Value");
4985                                 else
4986                                         Assert.AreEqual (255, row ["NumericScale"], "Value");
4987                         }
4988                 }
4989
4990                 [Test]
4991                 public void NumericScale_Variant ()
4992                 {
4993                         // TODO
4994                 }
4995
4996                 [Test]
4997                 public void NumericScale_Xml ()
4998                 {
4999                         // TODO
5000                 }
5001
5002                 [Test]
5003                 public void ProviderType_BigInt ()
5004                 {
5005                         if (ClientVersion <= 7)
5006                                 Assert.Ignore ("BigInt data type is not supported.");
5007
5008                         cmd.CommandText = "SELECT type_bigint FROM numeric_family WHERE id = 1";
5009
5010                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5011                                 DataTable schemaTable = rdr.GetSchemaTable ();
5012                                 DataRow row = schemaTable.Rows [0];
5013                                 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5014                                 Assert.AreEqual (0, row ["ProviderType"], "Value");
5015                         }
5016                 }
5017
5018                 [Test]
5019                 public void ProviderType_Binary ()
5020                 {
5021                         cmd.CommandText = "SELECT type_binary FROM binary_family WHERE id = 1";
5022
5023                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5024                                 DataTable schemaTable = rdr.GetSchemaTable ();
5025                                 DataRow row = schemaTable.Rows [0];
5026                                 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5027                                 Assert.AreEqual (1, row ["ProviderType"], "Value");
5028                         }
5029                 }
5030
5031                 [Test]
5032                 public void ProviderType_Bit ()
5033                 {
5034                         cmd.CommandText = "SELECT type_bit FROM numeric_family WHERE id = 1";
5035
5036                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5037                                 DataTable schemaTable = rdr.GetSchemaTable ();
5038                                 DataRow row = schemaTable.Rows [0];
5039                                 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5040                                 Assert.AreEqual (2, row ["ProviderType"], "Value");
5041                         }
5042                 }
5043
5044                 [Test]
5045                 public void ProviderType_Char ()
5046                 {
5047                         cmd.CommandText = "SELECT type_char FROM string_family WHERE id = 1";
5048
5049                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5050                                 DataTable schemaTable = rdr.GetSchemaTable ();
5051                                 DataRow row = schemaTable.Rows [0];
5052                                 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5053                                 Assert.AreEqual (3, row ["ProviderType"], "Value");
5054                         }
5055                 }
5056
5057                 [Test]
5058                 public void ProviderType_Date ()
5059                 {
5060                         // TODO
5061                 }
5062
5063                 [Test]
5064                 public void ProviderType_DateTime ()
5065                 {
5066                         cmd.CommandText = "SELECT type_datetime FROM datetime_family WHERE id = 1";
5067
5068                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5069                                 DataTable schemaTable = rdr.GetSchemaTable ();
5070                                 DataRow row = schemaTable.Rows [0];
5071                                 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5072                                 Assert.AreEqual (4, row ["ProviderType"], "Value");
5073                         }
5074                 }
5075
5076                 [Test]
5077                 public void ProviderType_Decimal ()
5078                 {
5079                         cmd.CommandText = "SELECT type_decimal1 FROM numeric_family WHERE id = 1";
5080
5081                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5082                                 DataTable schemaTable = rdr.GetSchemaTable ();
5083                                 DataRow row = schemaTable.Rows [0];
5084                                 Assert.IsFalse (row.IsNull ("ProviderType"), "#A:IsNull");
5085                                 Assert.AreEqual (5, row ["ProviderType"], "#A:Value");
5086                         }
5087
5088                         cmd.CommandText = "SELECT type_decimal2 FROM numeric_family WHERE id = 1";
5089
5090                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5091                                 DataTable schemaTable = rdr.GetSchemaTable ();
5092                                 DataRow row = schemaTable.Rows [0];
5093                                 Assert.IsFalse (row.IsNull ("ProviderType"), "#B:IsNull");
5094                                 Assert.AreEqual (5, row ["ProviderType"], "#B:Value");
5095                         }
5096
5097                         cmd.CommandText = "SELECT type_numeric1 FROM numeric_family WHERE id = 1";
5098
5099                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5100                                 DataTable schemaTable = rdr.GetSchemaTable ();
5101                                 DataRow row = schemaTable.Rows [0];
5102                                 Assert.IsFalse (row.IsNull ("ProviderType"), "#C:IsNull");
5103                                 Assert.AreEqual (5, row ["ProviderType"], "#C:Value");
5104                         }
5105
5106                         cmd.CommandText = "SELECT type_numeric2 FROM numeric_family WHERE id = 1";
5107
5108                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5109                                 DataTable schemaTable = rdr.GetSchemaTable ();
5110                                 DataRow row = schemaTable.Rows [0];
5111                                 Assert.IsFalse (row.IsNull ("ProviderType"), "#D:IsNull");
5112                                 Assert.AreEqual (5, row ["ProviderType"], "#D:Value");
5113                         }
5114                 }
5115
5116                 [Test]
5117                 public void ProviderType_Float ()
5118                 {
5119                         cmd.CommandText = "SELECT type_double FROM numeric_family WHERE id = 1";
5120
5121                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5122                                 DataTable schemaTable = rdr.GetSchemaTable ();
5123                                 DataRow row = schemaTable.Rows [0];
5124                                 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5125                                 Assert.AreEqual (6, row ["ProviderType"], "Value");
5126                         }
5127                 }
5128
5129                 [Test]
5130                 public void ProviderType_Image ()
5131                 {
5132                         cmd.CommandText = "SELECT type_tinyblob FROM binary_family WHERE id = 1";
5133
5134                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5135                                 DataTable schemaTable = rdr.GetSchemaTable ();
5136                                 DataRow row = schemaTable.Rows [0];
5137                                 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5138                                 Assert.AreEqual (7, row ["ProviderType"], "Value");
5139                         }
5140                 }
5141
5142                 [Test]
5143                 public void ProviderType_Int ()
5144                 {
5145                         cmd.CommandText = "SELECT type_int FROM numeric_family WHERE id = 1";
5146
5147                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5148                                 DataTable schemaTable = rdr.GetSchemaTable ();
5149                                 DataRow row = schemaTable.Rows [0];
5150                                 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5151                                 Assert.AreEqual (8, row ["ProviderType"], "Value");
5152                         }
5153                 }
5154
5155                 [Test]
5156                 public void ProviderType_Money ()
5157                 {
5158                         cmd.CommandText = "SELECT type_money FROM numeric_family WHERE id = 1";
5159
5160                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5161                                 DataTable schemaTable = rdr.GetSchemaTable ();
5162                                 DataRow row = schemaTable.Rows [0];
5163                                 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5164                                 Assert.AreEqual (9, row ["ProviderType"], "Value");
5165                         }
5166                 }
5167
5168                 [Test]
5169                 public void ProviderType_NChar ()
5170                 {
5171                         cmd.CommandText = "SELECT type_nchar FROM string_family WHERE id = 1";
5172
5173                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5174                                 DataTable schemaTable = rdr.GetSchemaTable ();
5175                                 DataRow row = schemaTable.Rows [0];
5176                                 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5177                                 Assert.AreEqual (10, row ["ProviderType"], "Value");
5178                         }
5179                 }
5180
5181                 [Test]
5182                 public void ProviderType_NText ()
5183                 {
5184                         cmd.CommandText = "SELECT type_ntext FROM string_family WHERE id = 1";
5185
5186                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5187                                 DataTable schemaTable = rdr.GetSchemaTable ();
5188                                 DataRow row = schemaTable.Rows [0];
5189                                 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5190                                 Assert.AreEqual (11, row ["ProviderType"], "Value");
5191                         }
5192                 }
5193
5194                 [Test]
5195                 public void ProviderType_NVarChar ()
5196                 {
5197                         cmd.CommandText = "SELECT type_nvarchar FROM string_family WHERE id = 1";
5198
5199                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5200                                 DataTable schemaTable = rdr.GetSchemaTable ();
5201                                 DataRow row = schemaTable.Rows [0];
5202                                 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5203                                 Assert.AreEqual (12, row ["ProviderType"], "Value");
5204                         }
5205                 }
5206
5207                 [Test]
5208                 public void ProviderType_Real ()
5209                 {
5210                         cmd.CommandText = "SELECT type_float FROM numeric_family WHERE id = 1";
5211
5212                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5213                                 DataTable schemaTable = rdr.GetSchemaTable ();
5214                                 DataRow row = schemaTable.Rows [0];
5215                                 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5216                                 Assert.AreEqual (13, row ["ProviderType"], "Value");
5217                         }
5218
5219                 }
5220
5221                 [Test]
5222                 public void ProviderType_SmallDateTime ()
5223                 {
5224                         cmd.CommandText = "SELECT type_smalldatetime FROM datetime_family WHERE id = 1";
5225
5226                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5227                                 DataTable schemaTable = rdr.GetSchemaTable ();
5228                                 DataRow row = schemaTable.Rows [0];
5229                                 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5230                                 Assert.AreEqual (15, row ["ProviderType"], "Value");
5231                         }
5232                 }
5233
5234                 [Test]
5235                 public void ProviderType_SmallInt ()
5236                 {
5237                         cmd.CommandText = "SELECT type_smallint FROM numeric_family WHERE id = 1";
5238
5239                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5240                                 DataTable schemaTable = rdr.GetSchemaTable ();
5241                                 DataRow row = schemaTable.Rows [0];
5242                                 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5243                                 Assert.AreEqual (16, row ["ProviderType"], "Value");
5244                         }
5245                 }
5246
5247                 [Test]
5248                 public void ProviderType_SmallMoney ()
5249                 {
5250                         cmd.CommandText = "SELECT type_smallmoney FROM numeric_family WHERE id = 1";
5251
5252                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5253                                 DataTable schemaTable = rdr.GetSchemaTable ();
5254                                 DataRow row = schemaTable.Rows [0];
5255                                 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5256                                 Assert.AreEqual (17, row ["ProviderType"], "Value");
5257                         }
5258                 }
5259
5260                 [Test]
5261                 public void ProviderType_Text ()
5262                 {
5263                         cmd.CommandText = "SELECT type_text FROM string_family WHERE id = 1";
5264
5265                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5266                                 DataTable schemaTable = rdr.GetSchemaTable ();
5267                                 DataRow row = schemaTable.Rows [0];
5268                                 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5269                                 Assert.AreEqual (18, row ["ProviderType"], "Value");
5270                         }
5271                 }
5272
5273                 [Test]
5274                 public void ProviderType_Time ()
5275                 {
5276                         // TODO
5277                 }
5278
5279                 [Test]
5280                 public void ProviderType_Timestamp ()
5281                 {
5282                         cmd.CommandText = "SELECT type_timestamp FROM binary_family WHERE id = 1";
5283
5284                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5285                                 DataTable schemaTable = rdr.GetSchemaTable ();
5286                                 DataRow row = schemaTable.Rows [0];
5287                                 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5288                                 // we currently consider timestamp as binary (due to TDS 7.0?)
5289                                 if (ClientVersion > 7)
5290                                         Assert.AreEqual (1, row ["ProviderType"], "Value");
5291                                 else
5292                                         Assert.AreEqual (19, row ["ProviderType"], "Value");
5293                         }
5294                 }
5295
5296                 [Test]
5297                 public void ProviderType_TinyInt ()
5298                 {
5299                         cmd.CommandText = "SELECT type_tinyint FROM numeric_family WHERE id = 1";
5300
5301                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5302                                 DataTable schemaTable = rdr.GetSchemaTable ();
5303                                 DataRow row = schemaTable.Rows [0];
5304                                 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5305                                 Assert.AreEqual (20, row ["ProviderType"], "Value");
5306                         }
5307                 }
5308
5309                 [Test]
5310                 public void ProviderType_Udt ()
5311                 {
5312                         // TODO
5313                 }
5314
5315                 [Test]
5316                 public void ProviderType_UniqueIdentifier ()
5317                 {
5318                         cmd.CommandText = "SELECT type_guid FROM string_family WHERE id = 1";
5319
5320                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5321                                 DataTable schemaTable = rdr.GetSchemaTable ();
5322                                 DataRow row = schemaTable.Rows [0];
5323                                 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5324                                 Assert.AreEqual (14, row ["ProviderType"], "Value");
5325                         }
5326                 }
5327
5328                 [Test]
5329                 public void ProviderType_VarBinary ()
5330                 {
5331                         cmd.CommandText = "SELECT type_varbinary FROM binary_family WHERE id = 1";
5332
5333                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5334                                 DataTable schemaTable = rdr.GetSchemaTable ();
5335                                 DataRow row = schemaTable.Rows [0];
5336                                 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5337                                 Assert.AreEqual (21, row ["ProviderType"], "Value");
5338                         }
5339                 }
5340
5341                 [Test]
5342                 public void ProviderType_VarChar ()
5343                 {
5344                         cmd.CommandText = "SELECT type_varchar FROM string_family WHERE id = 1";
5345
5346                         using (SqlDataReader rdr = cmd.ExecuteReader (CommandBehavior.KeyInfo)) {
5347                                 DataTable schemaTable = rdr.GetSchemaTable ();
5348                                 DataRow row = schemaTable.Rows [0];
5349                                 Assert.IsFalse (row.IsNull ("ProviderType"), "IsNull");
5350                                 Assert.AreEqual (22, row ["ProviderType"], "Value");
5351                         }
5352                 }
5353
5354                 [Test]
5355                 public void ProviderType_Variant ()
5356                 {
5357                         // TODO
5358                 }
5359
5360                 [Test]
5361                 public void ProviderType_Xml ()
5362                 {
5363                         // TODO
5364                 }
5365
5366                 private int ClientVersion {
5367                         get {
5368                                 return (engine.ClientVersion);
5369                         }
5370                 }
5371         }
5372 }