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