mcs/class/System.Data/Test/ProviderTests/ProviderIndependant/DataReaderTest.cs

   1 // DataReaderTest.cs - NUnit Test Cases for testing the
   2 // DataReader family of classes
   3 //
   4 // Authors:
   5 //      Sureshkumar T (tsureshkumar@novell.com)
   6 //      Gert Driesen (drieseng@users.sourceforge.net)
   7 //      Veerapuram Varadhan  (vvaradhan@novell.com)
   8 //
   9 // Copyright (c) 2004 Novell Inc., and the individuals listed on the
  10 // ChangeLog entries.
  11 //
  12 // Permission is hereby granted, free of charge, to any person
  13 // obtaining a copy of this software and associated documentation
  14 // files (the "Software"), to deal in the Software without
  15 // restriction, including without limitation the rights to use, copy,
  16 // modify, merge, publish, distribute, sublicense, and/or sell copies
  17 // of the Software, and to permit persons to whom the Software is
  18 // furnished to do so, subject to the following conditions:
  19 //
  20 // The above copyright notice and this permission notice shall be
  21 // included in all copies or substantial portions of the Software.
  22 //
  23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  27 // BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  28 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  29 // CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  30 // SOFTWARE.
  31
  32 using System;
  33 using System.Data;
  34 using System.Data.Common;
  35 using System.Data.Odbc;
  36 using System.Data.SqlClient;
  37 using System.Data.SqlTypes;
  38 using System.Globalization;
  39 using System.Text;
  40
  41 using Mono.Data;
  42
  43 using NUnit.Framework;
  44
  45 namespace MonoTests.System.Data
  46 {
  47         [TestFixture]
  48         [Category ("odbc")]
  49         [Category ("sqlserver")]
  50         public class DataReaderTest
  51         {
  52                 static byte [] long_bytes = new byte [] {
  53                         0x00, 0x66, 0x06, 0x66, 0x97, 0x00, 0x66, 0x06, 0x66,
  54                         0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
  55                         0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
  56                         0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
  57                         0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
  58                         0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
  59                         0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
  60                         0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
  61                         0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
  62                         0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
  63                         0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
  64                         0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
  65                         0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
  66                         0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
  67                         0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
  68                         0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
  69                         0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
  70                         0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
  71                         0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
  72                         0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
  73                         0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
  74                         0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
  75                         0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
  76                         0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
  77                         0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
  78                         0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
  79                         0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
  80                         0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
  81                         0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
  82                         0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
  83                         0x06, 0x66, 0x06, 0x66, 0x98};
  84
  85                 IDbConnection conn;
  86                 IDbCommand cmd;
  87
  88                 [SetUp]
  89                 public void SetUp ()
  90                 {
  91                         conn = ConnectionManager.Singleton.Connection;
  92                         ConnectionManager.Singleton.OpenConnection ();
  93                         cmd = conn.CreateCommand ();
  94                 }
  95
  96                 [TearDown]
  97                 public void TearDown ()
  98                 {
  99                         if (cmd != null)
 100                                 cmd.Dispose ();
 101                         ConnectionManager.Singleton.CloseConnection ();
 102                 }
 103
 104                 [Test]
 105                 public void FieldCount ()
 106                 {
 107                         IDataReader reader = null;
 108
 109                         try {
 110                                 cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'";
 111                                 reader = cmd.ExecuteReader ();
 112                                 Assert.AreEqual (6, reader.FieldCount);
 113                         } finally {
 114                                 if (reader != null)
 115                                         reader.Close ();
 116                         }
 117                 }
 118
 119                 [Test]
 120                 public void FieldCount_Command_Disposed ()
 121                 {
 122                         IDataReader reader = null;
 123
 124                         try {
 125                                 cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'";
 126                                 reader = cmd.ExecuteReader ();
 127                                 cmd.Dispose ();
 128                                 Assert.AreEqual (6, reader.FieldCount);
 129                         } finally {
 130                                 if (reader != null)
 131                                         reader.Close ();
 132                         }
 133                 }
 134
 135                 [Test]
 136                 public void FieldCount_Reader_Closed ()
 137                 {
 138                         IDataReader reader = null;
 139
 140                         try {
 141                                 cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'";
 142                                 reader = cmd.ExecuteReader ();
 143                                 reader.Close ();
 144                                 try {
 145                                         int fieldcount = reader.FieldCount;
 146                                         Assert.Fail ("#1:" + fieldcount);
 147                                 } catch (InvalidOperationException ex) {
 148                                         // Invalid attempt to FieldCount when
 149                                         // reader is closed
 150                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 151                                         Assert.IsNull (ex.InnerException, "#3");
 152                                         Assert.IsNotNull (ex.Message, "#4");
 153                                 }
 154                         } finally {
 155                                 if (reader != null)
 156                                         reader.Close ();
 157                         }
 158                 }
 159
 160                 [Test]
 161                 public void GetChars_Index_Invalid ()
 162                 {
 163                         //Console.WriteLine ("In GetChars_Index_Invalid - first_executereader");
 164                         cmd.CommandText = "SELECT type_blob FROM binary_family where id = 1";
 165
 166                         using (IDataReader rdr = cmd.ExecuteReader ()) {
 167                                 Assert.IsTrue (rdr.Read ());
 168
 169                                 try {
 170                                         rdr.GetChars (-1, 0, (char []) null, 0, 0);
 171                                         Assert.Fail ("#A1");
 172                                 } catch (IndexOutOfRangeException ex) {
 173                                         // Index was outside the bounds of the array
 174                                         Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2");
 175                                         Assert.IsNull (ex.InnerException, "#A3");
 176                                         Assert.IsNotNull (ex.Message, "#A4");
 177                                 }
 178
 179                                 try {
 180                                         rdr.GetChars (1, 0, (char []) null, 0, 0);
 181                                         Assert.Fail ("#B1");
 182                                 } catch (IndexOutOfRangeException ex) {
 183                                         // Index was outside the bounds of the array
 184                                         Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2");
 185                                         Assert.IsNull (ex.InnerException, "#B3");
 186                                         Assert.IsNotNull (ex.Message, "#B4");
 187                                 }
 188                         }
 189
 190                         //Console.WriteLine ("In GetChars_Index_Invalid - second_executereader");
 191                         using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
 192                                 Assert.IsTrue (rdr.Read ());
 193
 194                                 try {
 195                                         rdr.GetChars (-1, 0, (char []) null, 0, 0);
 196                                         Assert.Fail ("#C1");
 197                                 } catch (IndexOutOfRangeException ex) {
 198                                         // Index was outside the bounds of the array
 199                                         Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#C2");
 200                                         Assert.IsNull (ex.InnerException, "#C3");
 201                                         Assert.IsNotNull (ex.Message, "#C4");
 202                                 }
 203
 204                                 try {
 205                                         rdr.GetChars (1, 0, (char []) null, 0, 0);
 206                                         Assert.Fail ("#D1");
 207                                 } catch (IndexOutOfRangeException ex) {
 208                                         // Index was outside the bounds of the array
 209                                         Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#D2");
 210                                         Assert.IsNull (ex.InnerException, "#D3");
 211                                         Assert.IsNotNull (ex.Message, "#D4");
 212                                 }
 213                         }
 214                 }
 215
 216                 [Test]
 217                 public void GetChars_Reader_Closed ()
 218                 {
 219                         //Console.WriteLine ("GetChars_Reader_Closed - first_executereader");
 220                         cmd.CommandText = "SELECT type_blob FROM binary_family where id = 1";
 221
 222                         using (IDataReader rdr = cmd.ExecuteReader ()) {
 223                                 Assert.IsTrue (rdr.Read ());
 224                                 rdr.Close ();
 225
 226                                 try {
 227                                         rdr.GetChars (-1, 0, (char []) null, 0, 0);
 228                                         Assert.Fail ("#A1");
 229                                 } catch (InvalidOperationException ex) {
 230                                         // No data exists for the row/column
 231                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
 232                                         Assert.IsNull (ex.InnerException, "#A3");
 233                                         Assert.IsNotNull (ex.Message, "#A4");
 234                                 }
 235                         }
 236
 237                         //Console.WriteLine ("GetChars_Reader_Closed - second_executereader");
 238                         using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
 239                                 Assert.IsTrue (rdr.Read ());
 240                                 rdr.Close ();
 241
 242                                 try {
 243                                         rdr.GetChars (-1, 0, (char []) null, 0, 0);
 244                                         Assert.Fail ("#B1");
 245                                 } catch (InvalidOperationException ex) {
 246                                         // No data exists for the row/column
 247                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
 248                                         Assert.IsNull (ex.InnerException, "#B3");
 249                                         Assert.IsNotNull (ex.Message, "#B4");
 250                                 }
 251                         }
 252                 }
 253
 254                 [Test]
 255                 public void GetChars_Reader_NoData ()
 256                 {
 257                         //Console.WriteLine ("GetChars_Reader_NoData - first_executereader");
 258                         cmd.CommandText = "SELECT type_blob FROM binary_family where id = 666";
 259
 260                         using (IDataReader rdr = cmd.ExecuteReader ()) {
 261                                 try {
 262                                         rdr.GetChars (-1, 0, (char []) null, 0, 0);
 263                                         Assert.Fail ("#A1");
 264                                 } catch (InvalidOperationException ex) {
 265                                         // No data exists for the row/column
 266                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
 267                                         Assert.IsNull (ex.InnerException, "#A3");
 268                                         Assert.IsNotNull (ex.Message, "#A4");
 269                                 }
 270
 271                                 Assert.IsFalse (rdr.Read (), "#B");
 272
 273                                 try {
 274                                         rdr.GetChars (-1, 0, (char []) null, 0, 0);
 275                                         Assert.Fail ("#C1");
 276                                 } catch (InvalidOperationException ex) {
 277                                         // No data exists for the row/column
 278                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
 279                                         Assert.IsNull (ex.InnerException, "#C3");
 280                                         Assert.IsNotNull (ex.Message, "#C4");
 281                                 }
 282                         }
 283                 }
 284
 285                 [Test]
 286                 public void GetDataTypeName ()
 287                 {
 288                         IDataReader reader = null;
 289
 290                         try {
 291                                 cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'";
 292                                 reader = cmd.ExecuteReader ();
 293
 294                                 switch (ConnectionManager.Singleton.Engine.Type) {
 295                                 case EngineType.SQLServer:
 296                                         Assert.AreEqual ("int", reader.GetDataTypeName (0), "#1");
 297                                         break;
 298                                 case EngineType.MySQL:
 299                                         Assert.AreEqual ("integer", reader.GetDataTypeName (0), "#1");
 300                                         break;
 301                                 default:
 302                                         Assert.Fail ("Engine type not supported.");
 303                                         break;
 304                                 }
 305                                 Assert.AreEqual ("varchar", reader.GetDataTypeName (1), "#2");
 306                                 Assert.AreEqual ("varchar", reader.GetDataTypeName (2), "#3");
 307                                 Assert.AreEqual ("datetime", reader.GetDataTypeName (3), "#4");
 308                                 Assert.AreEqual ("datetime", reader.GetDataTypeName (4), "#5");
 309                                 Assert.AreEqual ("varchar", reader.GetDataTypeName (5), "#6");
 310                         } finally {
 311                                 if (reader != null)
 312                                         reader.Close ();
 313                         }
 314                 }
 315
 316                 [Test]
 317                 public void GetDataTypeName_Index_Invalid ()
 318                 {
 319                         IDataReader reader = null;
 320
 321                         try {
 322                                 cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'";
 323                                 reader = cmd.ExecuteReader ();
 324
 325                                 try {
 326                                         reader.GetDataTypeName (-1);
 327                                         Assert.Fail ("#A1");
 328                                 } catch (IndexOutOfRangeException ex) {
 329                                         // Index was outside the bounds of the array
 330                                         Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2");
 331                                         Assert.IsNull (ex.InnerException, "#A3");
 332                                         Assert.IsNotNull (ex.Message, "#A4");
 333                                 }
 334
 335                                 try {
 336                                         reader.GetDataTypeName (6);
 337                                         Assert.Fail ("#B1");
 338                                 } catch (IndexOutOfRangeException ex) {
 339                                         // Index was outside the bounds of the array
 340                                         Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2");
 341                                         Assert.IsNull (ex.InnerException, "#B3");
 342                                         Assert.IsNotNull (ex.Message, "#B4");
 343                                 }
 344                         } finally {
 345                                 if (reader != null)
 346                                         reader.Close ();
 347                         }
 348                 }
 349
 350                 [Test]
 351                 public void GetDataTypeName_Reader_Closed ()
 352                 {
 353                         IDataReader reader = null;
 354
 355                         try {
 356                                 cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'";
 357                                 reader = cmd.ExecuteReader ();
 358                                 reader.Close ();
 359
 360                                 try {
 361                                         reader.GetDataTypeName (0);
 362                                         Assert.Fail ("#1");
 363                                 } catch (InvalidOperationException ex) {
 364                                         // No data exists for the row/column
 365                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 366                                         Assert.IsNull (ex.InnerException, "#3");
 367                                         Assert.IsNotNull (ex.Message, "#4");
 368                                 }
 369                         } finally {
 370                                 if (reader != null)
 371                                         reader.Close ();
 372                         }
 373                 }
 374
 375                 [Test]
 376                 public void GetFieldType ()
 377                 {
 378                         IDataReader reader = null;
 379
 380                         try {
 381                                 cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'";
 382                                 reader = cmd.ExecuteReader ();
 383                                 Assert.AreEqual (typeof (int), reader.GetFieldType (0), "#1");
 384                                 Assert.AreEqual (typeof (string), reader.GetFieldType (2), "#2");
 385                                 Assert.AreEqual (typeof (DateTime), reader.GetFieldType (4), "#3");
 386                         } finally {
 387                                 if (reader != null)
 388                                         reader.Close ();
 389                         }
 390                 }
 391
 392                 [Test]
 393                 public void GetFieldType_Index_Invalid ()
 394                 {
 395                         IDataReader reader = null;
 396
 397                         try {
 398                                 cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'";
 399                                 reader = cmd.ExecuteReader ();
 400                                 try {
 401                                         reader.GetFieldType (-1);
 402                                         Assert.Fail ("#A1");
 403                                 } catch (IndexOutOfRangeException ex) {
 404                                         // Index was outside the bounds of the array
 405                                         Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2");
 406                                         Assert.IsNull (ex.InnerException, "#A3");
 407                                         Assert.IsNotNull (ex.Message, "#A4");
 408                                 }
 409
 410                                 try {
 411                                         reader.GetFieldType (6);
 412                                         Assert.Fail ("#B1");
 413                                 } catch (IndexOutOfRangeException ex) {
 414                                         // Index was outside the bounds of the array
 415                                         Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2");
 416                                         Assert.IsNull (ex.InnerException, "#B3");
 417                                         Assert.IsNotNull (ex.Message, "#B4");
 418                                 }
 419                         } finally {
 420                                 if (reader != null)
 421                                         reader.Close ();
 422                         }
 423                 }
 424
 425                 [Test]
 426                 public void GetFieldType_Reader_Closed ()
 427                 {
 428                         IDataReader reader = null;
 429
 430                         try {
 431                                 cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'";
 432                                 reader = cmd.ExecuteReader ();
 433                                 reader.Close ();
 434                                 try {
 435                                         reader.GetFieldType (0);
 436                                         Assert.Fail ("#1");
 437                                 } catch (InvalidOperationException ex) {
 438                                         // No data exists for the row/column
 439                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 440                                         Assert.IsNull (ex.InnerException, "#3");
 441                                         Assert.IsNotNull (ex.Message, "#4");
 442                                 }
 443                         } finally {
 444                                 if (reader != null)
 445                                         reader.Close ();
 446                         }
 447                 }
 448
 449                 [Test]
 450                 public void GetName ()
 451                 {
 452                         IDataReader reader = null;
 453
 454                         try {
 455                                 cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'";
 456                                 reader = cmd.ExecuteReader ();
 457                                 Assert.AreEqual ("id", reader.GetName (0), "#1");
 458                                 Assert.AreEqual ("fname", reader.GetName (1), "#2");
 459                                 Assert.AreEqual ("lname", reader.GetName (2), "#3");
 460                                 Assert.AreEqual ("dob", reader.GetName (3), "#4");
 461                                 Assert.AreEqual ("doj", reader.GetName (4), "#5");
 462                                 Assert.AreEqual ("email", reader.GetName (5), "#6");
 463                         } finally {
 464                                 if (reader != null)
 465                                         reader.Close ();
 466                         }
 467                 }
 468
 469                 [Test]
 470                 public void GetName_Index_Invalid ()
 471                 {
 472                         IDataReader reader = null;
 473
 474                         try {
 475                                 cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'";
 476                                 reader = cmd.ExecuteReader ();
 477                                 try {
 478                                         reader.GetName (-1);
 479                                         Assert.Fail ("#A1");
 480                                 } catch (IndexOutOfRangeException ex) {
 481                                         // Index was outside the bounds of the array
 482                                         Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2");
 483                                         Assert.IsNull (ex.InnerException, "#A3");
 484                                         Assert.IsNotNull (ex.Message, "#A4");
 485                                 }
 486
 487                                 try {
 488                                         reader.GetName (6);
 489                                         Assert.Fail ("#B1");
 490                                 } catch (IndexOutOfRangeException ex) {
 491                                         // Index was outside the bounds of the array
 492                                         Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2");
 493                                         Assert.IsNull (ex.InnerException, "#B3");
 494                                         Assert.IsNotNull (ex.Message, "#B4");
 495                                 }
 496                         } finally {
 497                                 if (reader != null)
 498                                         reader.Close ();
 499                         }
 500                 }
 501
 502                 [Test]
 503                 public void GetName_Reader_Closed ()
 504                 {
 505                         IDataReader reader = null;
 506
 507                         try {
 508                                 cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'";
 509                                 reader = cmd.ExecuteReader ();
 510                                 reader.Close ();
 511                                 try {
 512                                         reader.GetName (0);
 513                                         Assert.Fail ("#1");
 514                                 } catch (InvalidOperationException ex) {
 515                                         // No data exists for the row/column
 516                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 517                                         Assert.IsNull (ex.InnerException, "#3");
 518                                         Assert.IsNotNull (ex.Message, "#4");
 519                                 }
 520                         } finally {
 521                                 if (reader != null)
 522                                         reader.Close ();
 523                         }
 524                 }
 525
 526                 [Test]
 527                 public void GetOrdinal ()
 528                 {
 529                         IDataReader reader = null;
 530
 531                         try {
 532                                 cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'";
 533                                 reader = cmd.ExecuteReader ();
 534                                 Assert.AreEqual (0, reader.GetOrdinal ("id"), "#1");
 535                                 Assert.AreEqual (1, reader.GetOrdinal ("fname"), "#2");
 536                                 Assert.AreEqual (2, reader.GetOrdinal ("lname"), "#3");
 537                                 Assert.AreEqual (3, reader.GetOrdinal ("doB"), "#4");
 538                                 Assert.AreEqual (4, reader.GetOrdinal ("doj"), "#5");
 539                                 Assert.AreEqual (5, reader.GetOrdinal ("EmaiL"), "#6");
 540                                 Assert.AreEqual (0, reader.GetOrdinal ("iD"), "#7");
 541                                 Assert.AreEqual (5, reader.GetOrdinal ("eMail"), "#8");
 542                         } finally {
 543                                 if (reader != null)
 544                                         reader.Close ();
 545                         }
 546                 }
 547
 548                 [Test]
 549                 public void GetOrdinal_Name_NotFound ()
 550                 {
 551                         IDataReader reader = null;
 552
 553                         try {
 554                                 cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'";
 555                                 reader = cmd.ExecuteReader ();
 556                                 try {
 557                                         reader.GetOrdinal ("non_existing_column");
 558                                         Assert.Fail ("#A1");
 559                                 } catch (IndexOutOfRangeException ex) {
 560                                         // Index was outside the bounds of the array
 561                                         Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2");
 562                                         Assert.IsNull (ex.InnerException, "#A3");
 563                                         Assert.IsNotNull (ex.Message, "#A4");
 564                                 }
 565
 566                                 try {
 567                                         reader.GetOrdinal (string.Empty);
 568                                         Assert.Fail ("#B1");
 569                                 } catch (IndexOutOfRangeException ex) {
 570                                         // Index was outside the bounds of the array
 571                                         Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2");
 572                                         Assert.IsNull (ex.InnerException, "#B3");
 573                                         Assert.IsNotNull (ex.Message, "#B4");
 574                                 }
 575                         } finally {
 576                                 if (reader != null)
 577                                         reader.Close ();
 578                         }
 579                 }
 580
 581                 [Test]
 582                 public void GetOrdinal_Name_Null ()
 583                 {
 584                         IDataReader reader = null;
 585
 586                         try {
 587                                 cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'";
 588                                 reader = cmd.ExecuteReader ();
 589                                 try {
 590                                         reader.GetOrdinal (null);
 591                                         Assert.Fail ("#1");
 592                                 } catch (ArgumentNullException ex) {
 593                                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 594                                         Assert.IsNull (ex.InnerException, "#3");
 595                                         Assert.IsNotNull (ex.Message, "#4");
 596                                         Assert.AreEqual ("fieldName", ex.ParamName, "#5");
 597                                 }
 598                         } finally {
 599                                 if (reader != null)
 600                                         reader.Close ();
 601                         }
 602                 }
 603
 604                 [Test]
 605                 public void GetOrdinal_Reader_Closed ()
 606                 {
 607                         cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'";
 608
 609                         using (IDataReader rdr = cmd.ExecuteReader ()) {
 610                                 rdr.Close ();
 611
 612                                 try {
 613                                         rdr.GetOrdinal (null);
 614                                         Assert.Fail ("#A1");
 615                                 } catch (InvalidOperationException ex) {
 616                                         // No data exists for the row/column
 617                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
 618                                         Assert.IsNull (ex.InnerException, "#A3");
 619                                         Assert.IsNotNull (ex.Message, "#A4");
 620                                 }
 621                         }
 622                 }
 623
 624                 [Test]
 625                 public void GetOrdinal_Reader_NoData ()
 626                 {
 627                         cmd.CommandText = "SELECT * FROM employee WHERE id = 666";
 628
 629                         using (IDataReader rdr = cmd.ExecuteReader ()) {
 630                                 Assert.AreEqual (0, rdr.GetOrdinal ("id"), "#A1");
 631                                 Assert.AreEqual (5, rdr.GetOrdinal ("eMail"), "#A2");
 632
 633                                 Assert.IsFalse (rdr.Read (), "#B");
 634
 635                                 Assert.AreEqual (2, rdr.GetOrdinal ("lname"), "#C1");
 636                                 Assert.AreEqual (3, rdr.GetOrdinal ("dob"), "#C2");
 637                         }
 638                 }
 639
 640                 [Test]
 641                 public void GetSchemaTable_Command_Disposed ()
 642                 {
 643                         if (RunningOnMono && (conn is OdbcConnection))
 644                                 Assert.Ignore ("Our statement handle is closed when we dispose the (Odbc)Command");
 645
 646                         IDataReader reader = null;
 647
 648                         try {
 649                                 cmd.CommandText = "select id, fname, id + 20 as plustwenty from employee";
 650                                 reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly);
 651                                 cmd.Dispose ();
 652                                 DataTable schema = reader.GetSchemaTable ();
 653                                 Assert.AreEqual (3, schema.Rows.Count, "RowCount");
 654                         } finally {
 655                                 if (reader != null)
 656                                         reader.Close ();
 657                         }
 658                 }
 659
 660                 [Test]
 661                 public void GetSchemaTable_Reader_Closed ()
 662                 {
 663                         IDataReader reader = null;
 664
 665                         try {
 666                                 cmd.CommandText = "select id, fname, id + 20 as plustwenty from employee";
 667                                 reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo);
 668                                 reader.Close ();
 669
 670                                 try {
 671                                         reader.GetSchemaTable ();
 672                                         Assert.Fail ("#1");
 673                                 } catch (InvalidOperationException ex) {
 674                                         // Invalid attempt to call GetSchemaTable
 675                                         // when reader is closed
 676                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 677                                         Assert.IsNull (ex.InnerException, "#3");
 678                                         Assert.IsNotNull (ex.Message, "#4");
 679                                 }
 680                         } finally {
 681                                 if (reader != null)
 682                                         reader.Close ();
 683                         }
 684                 }
 685
 686                 [Test]
 687                 public void GetNameTest ()
 688                 {
 689                         cmd.CommandText = "SELECT type_tinyint from numeric_family"; ;
 690                         using (IDataReader reader = cmd.ExecuteReader ()) {
 691                                 Assert.AreEqual ("type_tinyint", reader.GetName (0), "#1");
 692                         }
 693                 }
 694
 695                 [Test] // this [Int32]
 696                 public void Indexer1 ()
 697                 {
 698                         IDataReader reader = null;
 699
 700                         try {
 701                                 cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'";
 702                                 reader = cmd.ExecuteReader ();
 703                                 Assert.IsTrue (reader.Read ());
 704                                 Assert.AreEqual (1, reader [0], "#0");
 705                                 Assert.AreEqual ("suresh", reader [1], "#1");
 706                                 Assert.AreEqual ("kumar", reader [2], "#2");
 707                                 Assert.AreEqual (new DateTime (1978, 8, 22), reader [3], "#3");
 708                                 Assert.AreEqual (new DateTime (2001, 3, 12), reader [4], "#4");
 709                                 Assert.AreEqual ("suresh@gmail.com", reader [5], "#5");
 710                         } finally {
 711                                 if (reader != null)
 712                                         reader.Close ();
 713                         }
 714                 }
 715
 716                 [Test] // this [Int32]
 717                 public void Indexer1_Reader_Closed ()
 718                 {
 719                         IDataReader reader = null;
 720
 721                         try {
 722                                 cmd.CommandText = "select fname from employee";
 723                                 reader = cmd.ExecuteReader ();
 724                                 reader.Read ();
 725                                 reader.Close ();
 726
 727                                 try {
 728                                         object value = reader [0];
 729                                         Assert.Fail ("#A1:" + value);
 730                                 } catch (InvalidOperationException ex) {
 731                                         // No data exists for the row/column
 732                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
 733                                         Assert.IsNull (ex.InnerException, "#A3");
 734                                         Assert.IsNotNull (ex.Message, "#A4");
 735                                 }
 736
 737                                 reader = cmd.ExecuteReader ();
 738                                 reader.Close ();
 739
 740                                 try {
 741                                         object value = reader [0];
 742                                         Assert.Fail ("#B1:" + value);
 743                                 } catch (InvalidOperationException ex) {
 744                                         // No data exists for the row/column
 745                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
 746                                         Assert.IsNull (ex.InnerException, "#B3");
 747                                         Assert.IsNotNull (ex.Message, "#B4");
 748                                 }
 749                         } finally {
 750                                 if (reader != null)
 751                                         reader.Close ();
 752                         }
 753                 }
 754
 755                 [Test] // this [Int32]
 756                 public void Indexer1_Reader_NoData ()
 757                 {
 758                         IDataReader reader = null;
 759
 760                         try {
 761                                 cmd.CommandText = "select fname from employee WHERE lname='kumar'";
 762                                 reader = cmd.ExecuteReader ();
 763                                 try {
 764                                         object value = reader [0];
 765                                         Assert.Fail ("#A1:" + value);
 766                                 } catch (InvalidOperationException ex) {
 767                                         // No data exists for the row/column
 768                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
 769                                         Assert.IsNull (ex.InnerException, "#A3");
 770                                         Assert.IsNotNull (ex.Message, "#A4");
 771                                 }
 772
 773                                 Assert.IsTrue (reader.Read ());
 774                                 Assert.IsFalse (reader.Read ());
 775
 776                                 try {
 777                                         object value = reader [0];
 778                                         Assert.Fail ("#B1:" + value);
 779                                 } catch (InvalidOperationException ex) {
 780                                         // No data exists for the row/column
 781                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
 782                                         Assert.IsNull (ex.InnerException, "#B3");
 783                                         Assert.IsNotNull (ex.Message, "#B4");
 784                                 }
 785                         } finally {
 786                                 if (reader != null)
 787                                         reader.Close ();
 788                         }
 789                 }
 790
 791                 [Test] // this [Int32]
 792                 public void Indexer1_Value_Invalid ()
 793                 {
 794                         IDataReader reader = null;
 795
 796                         try {
 797                                 cmd.CommandText = "select fname from employee";
 798                                 reader = cmd.ExecuteReader ();
 799                                 Assert.IsTrue (reader.Read ());
 800                                 try {
 801                                         object value = reader [-1];
 802                                         Assert.Fail ("#A1:" + value);
 803                                 } catch (IndexOutOfRangeException ex) {
 804                                         // Index was outside the bounds of the array
 805                                         Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2");
 806                                         Assert.IsNull (ex.InnerException, "#A3");
 807                                         Assert.IsNotNull (ex.Message, "#A4");
 808                                 }
 809
 810                                 try {
 811                                         object value = reader [1];
 812                                         Assert.Fail ("#B1:" + value);
 813                                 } catch (IndexOutOfRangeException ex) {
 814                                         // Index was outside the bounds of the array
 815                                         Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2");
 816                                         Assert.IsNull (ex.InnerException, "#B3");
 817                                         Assert.IsNotNull (ex.Message, "#B4");
 818                                 }
 819                         } finally {
 820                                 if (reader != null)
 821                                         reader.Close ();
 822                         }
 823                 }
 824
 825                 [Test] // this [String]
 826                 public void Indexer2 ()
 827                 {
 828                         IDataReader reader = null;
 829
 830                         try {
 831                                 cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'";
 832                                 reader = cmd.ExecuteReader ();
 833                                 Assert.IsTrue (reader.Read ());
 834                                 Assert.AreEqual (1, reader ["id"], "id");
 835                                 Assert.AreEqual ("suresh", reader ["fname"], "fname");
 836                                 Assert.AreEqual ("kumar", reader ["lname"], "lname");
 837                                 Assert.AreEqual (new DateTime (1978, 8, 22), reader ["doB"], "doB");
 838                                 Assert.AreEqual (new DateTime (2001, 3, 12), reader ["doj"], "doj");
 839                                 Assert.AreEqual ("suresh@gmail.com", reader ["EmaiL"], "EmaiL");
 840                                 Assert.AreEqual (1, reader ["iD"], "iD");
 841                                 Assert.AreEqual ("suresh@gmail.com", reader ["eMail"], "eMail");
 842                         } finally {
 843                                 if (reader != null)
 844                                         reader.Close ();
 845                         }
 846                 }
 847
 848                 [Test] // this [String]
 849                 public void Indexer2_Reader_Closed ()
 850                 {
 851                         IDataReader reader = null;
 852
 853                         try {
 854                                 cmd.CommandText = "select fname from employee";
 855                                 reader = cmd.ExecuteReader ();
 856                                 reader.Read ();
 857                                 reader.Close ();
 858
 859                                 try {
 860                                         object value = reader ["fname"];
 861                                         Assert.Fail ("#A1:" + value);
 862                                 } catch (InvalidOperationException ex) {
 863                                         // No data exists for the row/column
 864                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
 865                                         Assert.IsNull (ex.InnerException, "#A3");
 866                                         Assert.IsNotNull (ex.Message, "#A4");
 867                                 }
 868
 869                                 reader = cmd.ExecuteReader ();
 870                                 reader.Close ();
 871
 872                                 try {
 873                                         object value = reader ["fname"];
 874                                         Assert.Fail ("#B1:" + value);
 875                                 } catch (InvalidOperationException ex) {
 876                                         // No data exists for the row/column
 877                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
 878                                         Assert.IsNull (ex.InnerException, "#B3");
 879                                         Assert.IsNotNull (ex.Message, "#B4");
 880                                 }
 881                         } finally {
 882                                 if (reader != null)
 883                                         reader.Close ();
 884                         }
 885                 }
 886
 887                 [Test] // this [String]
 888                 public void Indexer2_Reader_NoData ()
 889                 {
 890                         IDataReader reader = null;
 891
 892                         try {
 893                                 cmd.CommandText = "select fname from employee WHERE lname='kumar'";
 894                                 reader = cmd.ExecuteReader ();
 895
 896                                 try {
 897                                         object value = reader ["fname"];
 898                                         Assert.Fail ("#A1:" + value);
 899                                 } catch (InvalidOperationException ex) {
 900                                         // No data exists for the row/column
 901                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
 902                                         Assert.IsNull (ex.InnerException, "#A3");
 903                                         Assert.IsNotNull (ex.Message, "#A4");
 904                                 }
 905
 906                                 Assert.IsTrue (reader.Read ());
 907                                 Assert.IsFalse (reader.Read ());
 908
 909                                 try {
 910                                         object value = reader ["fname"];
 911                                         Assert.Fail ("#B1:" + value);
 912                                 } catch (InvalidOperationException ex) {
 913                                         // No data exists for the row/column
 914                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
 915                                         Assert.IsNull (ex.InnerException, "#B3");
 916                                         Assert.IsNotNull (ex.Message, "#B4");
 917                                 }
 918                         } finally {
 919                                 if (reader != null)
 920                                         reader.Close ();
 921                         }
 922                 }
 923
 924                 [Test] // this [String]
 925                 public void Indexer2_Value_NotFound ()
 926                 {
 927                         IDataReader reader = null;
 928
 929                         try {
 930                                 cmd.CommandText = "select fname from employee";
 931                                 reader = cmd.ExecuteReader ();
 932                                 Assert.IsTrue (reader.Read ());
 933                                 try {
 934                                         object value = reader ["address"];
 935                                         Assert.Fail ("#A1:" + value);
 936                                 } catch (IndexOutOfRangeException ex) {
 937                                         // Index was outside the bounds of the array
 938                                         Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2");
 939                                         Assert.IsNull (ex.InnerException, "#A3");
 940                                         Assert.IsNotNull (ex.Message, "#A4");
 941                                 }
 942
 943                                 try {
 944                                         object value = reader [string.Empty];
 945                                         Assert.Fail ("#B1:" + value);
 946                                 } catch (IndexOutOfRangeException ex) {
 947                                         // Index was outside the bounds of the array
 948                                         Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2");
 949                                         Assert.IsNull (ex.InnerException, "#B3");
 950                                         Assert.IsNotNull (ex.Message, "#B4");
 951                                 }
 952                         } finally {
 953                                 if (reader != null)
 954                                         reader.Close ();
 955                         }
 956                 }
 957
 958                 [Test] // this [String]
 959                 public void Indexer2_Value_Null ()
 960                 {
 961                         IDataReader reader = null;
 962
 963                         try {
 964                                 cmd.CommandText = "select fname from employee";
 965                                 reader = cmd.ExecuteReader ();
 966                                 try {
 967                                         object value = reader [(string) null];
 968                                         Assert.Fail ("#1:" + value);
 969                                 } catch (ArgumentNullException ex) {
 970                                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 971                                         Assert.IsNull (ex.InnerException, "#3");
 972                                         Assert.IsNotNull (ex.Message, "#4");
 973                                         Assert.AreEqual ("fieldName", ex.ParamName, "#5");
 974                                 }
 975                         } finally {
 976                                 if (reader != null)
 977                                         reader.Close ();
 978                         }
 979                 }
 980
 981                 [Test]
 982                 public void IsClosed_Command_Disposed ()
 983                 {
 984                         IDataReader reader = null;
 985
 986                         try {
 987                                 cmd.CommandText = "select id, fname, id + 20 as plustwenty from employee";
 988                                 reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo);
 989                                 Assert.IsFalse (reader.IsClosed, "#1");
 990                                 cmd.Dispose ();
 991                                 Assert.IsFalse (reader.IsClosed, "#2");
 992                         } finally {
 993                                 if (reader != null)
 994                                         reader.Close ();
 995                         }
 996                 }
 997
 998                 [Test]
 999                 public void IsClosed_Connection_Closed ()
1000                 {
1001                         if (RunningOnMono)
1002                                 Assert.Ignore ("We do not mark the corresponding Reader closed when we close a Connection.");
1003
1004                         IDataReader reader = null;
1005
1006                         try {
1007                                 cmd.CommandText = "select id, fname, id + 20 as plustwenty from employee";
1008                                 reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo);
1009                                 Assert.IsFalse (reader.IsClosed, "#1");
1010                                 ConnectionManager.Singleton.CloseConnection ();
1011                                 Assert.IsTrue (reader.IsClosed, "#2");
1012                         } finally {
1013                                 if (reader != null)
1014                                         reader.Close ();
1015                         }
1016                 }
1017
1018                 [Test]
1019                 public void IsClosed_Reader_Closed ()
1020                 {
1021                         IDataReader reader = null;
1022
1023                         try {
1024                                 cmd.CommandText = "select id, fname, id + 20 as plustwenty from employee";
1025                                 reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo);
1026                                 Assert.IsFalse (reader.IsClosed, "#1");
1027                                 reader.Close ();
1028                                 Assert.IsTrue (reader.IsClosed, "#2");
1029                         } finally {
1030                                 if (reader != null)
1031                                         reader.Close ();
1032                         }
1033                 }
1034
1035                 [Test]
1036                 public void NumericTest()
1037                 {
1038                         cmd.CommandText = "select type_numeric1 from numeric_family where id = 1;";
1039
1040                         using (IDataReader reader = cmd.ExecuteReader ()) {
1041                                 Assert.IsTrue (reader.Read(), "#1");
1042                                 object value = reader.GetValue (0);
1043                                 Assert.AreEqual (typeof (decimal), value.GetType (), "#2");
1044                                 Assert.AreEqual (1000m, value, "#3");
1045                         }
1046                 }
1047
1048                 [Test]
1049                 public void TinyIntTest ()
1050                 {
1051                         cmd.CommandText = "select type_tinyint from numeric_family where id = 1;";
1052                         using (IDataReader reader = cmd.ExecuteReader ()) {
1053                                 Assert.IsTrue (reader.Read (), "#1");
1054                                 object value = reader.GetValue (0);
1055                                 Assert.AreEqual (typeof (byte), value.GetType (), "#2");
1056                                 Assert.AreEqual (255, value, "#3");
1057                         }
1058                 }
1059
1060                 [Test]
1061                 public void GetByteTest ()
1062                 {
1063                         cmd.CommandText = "select type_tinyint from numeric_family where id = 1";
1064                         using (IDataReader reader = cmd.ExecuteReader ()) {
1065                                 Assert.IsTrue (reader.Read (), "#1");
1066                                 byte b = reader.GetByte (0);
1067                                 Assert.AreEqual (255, b, "#2");
1068                         }
1069                 }
1070
1071                 [Test]
1072                 public void GetValue_Reader_Closed ()
1073                 {
1074                         //Console.WriteLine ("GetValue_Reader_Closed - first_executereader");
1075                         cmd.CommandText = "SELECT type_blob FROM binary_family where id = 1";
1076
1077                         using (IDataReader reader = cmd.ExecuteReader ()) {
1078                                 Assert.IsTrue (reader.Read ());
1079                                 reader.Close ();
1080
1081                                 try {
1082                                         reader.GetValue (-1);
1083                                         Assert.Fail ("#1");
1084                                 } catch (InvalidOperationException ex) {
1085                                         // No data exists for the row/column
1086                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
1087                                         Assert.IsNull (ex.InnerException, "#3");
1088                                         Assert.IsNotNull (ex.Message, "#4");
1089                                 }
1090                         }
1091                 }
1092
1093                 [Test]
1094                 public void GetValue_Reader_NoData ()
1095                 {
1096                         //Console.WriteLine ("GetValue_Reader_NoData - first_executereader");
1097                         cmd.CommandText = "SELECT type_blob FROM binary_family where id = 666";
1098
1099                         using (IDataReader rdr = cmd.ExecuteReader ()) {
1100                                 try {
1101                                         rdr.GetValue (-1);
1102                                         Assert.Fail ("#A1");
1103                                 } catch (InvalidOperationException ex) {
1104                                         // No data exists for the row/column
1105                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
1106                                         Assert.IsNull (ex.InnerException, "#A3");
1107                                         Assert.IsNotNull (ex.Message, "#A4");
1108                                 }
1109
1110                                 Assert.IsFalse (rdr.Read (), "#B");
1111
1112                                 try {
1113                                         rdr.GetValue (-1);
1114                                         Assert.Fail ("#C1");
1115                                 } catch (InvalidOperationException ex) {
1116                                         // No data exists for the row/column
1117                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
1118                                         Assert.IsNull (ex.InnerException, "#C3");
1119                                         Assert.IsNotNull (ex.Message, "#C4");
1120                                 }
1121                         }
1122                 }
1123
1124                 [Test]
1125                 public void GetValue_Type_Binary ()
1126                 {
1127                         object value;
1128                         object expected;
1129
1130                         cmd.CommandText = "select type_binary from binary_family order by id asc";
1131                         using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
1132                                 expected = new byte [] { 0x35, 0x00, 0x00, 0x00,
1133                                         0x00, 0x00, 0x00, 0x00 };
1134
1135                                 Assert.IsTrue (rdr.Read (), "#A1");
1136                                 value = rdr.GetValue (0);
1137                                 Assert.IsNotNull (value, "#A2");
1138                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#A3");
1139                                 Assert.AreEqual (expected, value, "#A4");
1140                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#A5");
1141
1142                                 expected = new byte [] { 0x00, 0x33, 0x34, 0x00,
1143                                         0x33, 0x30, 0x35, 0x31 };
1144
1145                                 Assert.IsTrue (rdr.Read (), "#B1");
1146                                 value = rdr.GetValue (0);
1147                                 Assert.IsNotNull (value, "#B2");
1148                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#B3");
1149                                 Assert.AreEqual (expected, value, "#B4");
1150                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#B5");
1151
1152                                 expected = new byte [8];
1153
1154                                 Assert.IsTrue (rdr.Read (), "#C1");
1155                                 value = rdr.GetValue (0);
1156                                 Assert.IsNotNull (value, "#C2");
1157                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#C3");
1158                                 Assert.AreEqual (expected, value, "#C4");
1159                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#C5");
1160
1161                                 expected = DBNull.Value;
1162
1163                                 Assert.IsTrue (rdr.Read (), "#D1");
1164                                 value = rdr.GetValue (0);
1165                                 Assert.IsNotNull (value, "#D2");
1166                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#D3");
1167                                 Assert.AreEqual (DBNull.Value, value, "#D4");
1168                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#D5");
1169                         }
1170
1171                         using (IDataReader rdr = cmd.ExecuteReader ()) {
1172                                 expected = new byte [] { 0x35, 0x00, 0x00, 0x00,
1173                                         0x00, 0x00, 0x00, 0x00 };
1174
1175                                 Assert.IsTrue (rdr.Read (), "#E1");
1176                                 value = rdr.GetValue (0);
1177                                 Assert.IsNotNull (value, "#E2");
1178                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#E3");
1179                                 Assert.AreEqual (expected, value, "#E4");
1180                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#E5");
1181
1182                                 expected = new byte [] { 0x00, 0x33, 0x34, 0x00,
1183                                         0x33, 0x30, 0x35, 0x31 };
1184
1185                                 Assert.IsTrue (rdr.Read (), "#F1");
1186                                 value = rdr.GetValue (0);
1187                                 Assert.IsNotNull (value, "#F2");
1188                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#F3");
1189                                 Assert.AreEqual (expected, value, "#F4");
1190                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#F5");
1191
1192                                 expected = new byte [8];
1193
1194                                 Assert.IsTrue (rdr.Read (), "#G1");
1195                                 value = rdr.GetValue (0);
1196                                 Assert.IsNotNull (value, "#G2");
1197                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#G3");
1198                                 Assert.AreEqual (expected, value, "#G4");
1199                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#G5");
1200
1201                                 expected = DBNull.Value;
1202
1203                                 Assert.IsTrue (rdr.Read (), "#H1");
1204                                 value = rdr.GetValue (0);
1205                                 Assert.IsNotNull (value, "#H2");
1206                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#H3");
1207                                 Assert.AreEqual (expected, value, "#H4");
1208                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#H5");
1209                         }
1210                 }
1211
1212                 [Test]
1213                 public void GetValue_Type_Image ()
1214                 {
1215                         object value;
1216                         object expected;
1217
1218                         //Console.WriteLine ("GetValue_Type_Image - first_executereader");
1219                         cmd.CommandText = "select type_blob from binary_family order by id asc";
1220                         using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
1221                                 expected = new byte [] { 0x32, 0x56, 0x00,
1222                                         0x44, 0x22 };
1223
1224                                 Assert.IsTrue (rdr.Read (), "#A1");
1225                                 value = rdr.GetValue (0);
1226                                 Assert.IsNotNull (value, "#A2");
1227                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#A3");
1228                                 Assert.AreEqual (expected, value, "#A4");
1229                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#A5");
1230
1231                                 expected = long_bytes;
1232
1233                                 Assert.IsTrue (rdr.Read (), "#B1");
1234                                 value = rdr.GetValue (0);
1235                                 Assert.IsNotNull (value, "#B2");
1236                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#B3");
1237                                 Assert.AreEqual (expected, value, "#B4");
1238                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#B5");
1239
1240                                 expected = new byte [0];
1241
1242                                 Assert.IsTrue (rdr.Read (), "#C1");
1243                                 value = rdr.GetValue (0);
1244                                 Assert.IsNotNull (value, "#C2");
1245                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#C3");
1246                                 Assert.AreEqual (expected, value, "#C4");
1247                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#C5");
1248
1249                                 expected = DBNull.Value;
1250
1251                                 Assert.IsTrue (rdr.Read (), "#D1");
1252                                 value = rdr.GetValue (0);
1253                                 Assert.IsNotNull (value, "#D2");
1254                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#D3");
1255                                 Assert.AreEqual (DBNull.Value, value, "#D4");
1256                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#D5");
1257                         }
1258
1259                         //Console.WriteLine ("GetChars_Reader_Closed - second_executereader");
1260                         using (IDataReader rdr = cmd.ExecuteReader ()) {
1261                                 expected = new byte [] { 0x32, 0x56, 0x00,
1262                                         0x44, 0x22 };
1263
1264                                 Assert.IsTrue (rdr.Read (), "#E1");
1265                                 value = rdr.GetValue (0);
1266                                 Assert.IsNotNull (value, "#E2");
1267                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#E3");
1268                                 Assert.AreEqual (expected, value, "#E4");
1269                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#E5");
1270
1271                                 expected = long_bytes;
1272
1273                                 Assert.IsTrue (rdr.Read (), "#F1");
1274                                 value = rdr.GetValue (0);
1275                                 Assert.IsNotNull (value, "#F2");
1276                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#F3");
1277                                 Assert.AreEqual (expected, value, "#F4");
1278                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#F5");
1279
1280                                 expected = new byte [0];
1281
1282                                 Assert.IsTrue (rdr.Read (), "#G1");
1283                                 value = rdr.GetValue (0);
1284                                 Assert.IsNotNull (value, "#G2");
1285                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#G3");
1286                                 Assert.AreEqual (expected, value, "#G4");
1287                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#G5");
1288
1289                                 expected = DBNull.Value;
1290
1291                                 Assert.IsTrue (rdr.Read (), "#H1");
1292                                 value = rdr.GetValue (0);
1293                                 Assert.IsNotNull (value, "#H2");
1294                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#H3");
1295                                 Assert.AreEqual (expected, value, "#H4");
1296                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#H5");
1297                         }
1298                 }
1299
1300                 [Test]
1301                 public void GetValue_Type_Integer ()
1302                 {
1303                         object value;
1304                         object expected;
1305
1306                         cmd.CommandText = "select type_int from numeric_family order by id asc";
1307                         using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
1308                                 expected = int.MaxValue;
1309
1310                                 Assert.IsTrue (rdr.Read (), "#A1");
1311                                 value = rdr.GetValue (0);
1312                                 Assert.IsNotNull (value, "#A2");
1313                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#A3");
1314                                 Assert.AreEqual (expected, value, "#A4");
1315                                 Assert.AreEqual (typeof (int), rdr.GetFieldType (0), "#A5");
1316
1317                                 expected = int.MinValue;
1318
1319                                 Assert.IsTrue (rdr.Read (), "#B1");
1320                                 value = rdr.GetValue (0);
1321                                 Assert.IsNotNull (value, "#B2");
1322                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#B3");
1323                                 Assert.AreEqual (expected, value, "#B4");
1324                                 Assert.AreEqual (typeof (int), rdr.GetFieldType (0), "#B5");
1325
1326                                 expected = 0;
1327
1328                                 Assert.IsTrue (rdr.Read (), "#C1");
1329                                 value = rdr.GetValue (0);
1330                                 Assert.IsNotNull (value, "#C2");
1331                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#C3");
1332                                 Assert.AreEqual (expected, value, "#C4");
1333                                 Assert.AreEqual (typeof (int), rdr.GetFieldType (0), "#C5");
1334
1335                                 expected = DBNull.Value;
1336
1337                                 Assert.IsTrue (rdr.Read (), "#D1");
1338                                 value = rdr.GetValue (0);
1339                                 Assert.IsNotNull (value, "#D2");
1340                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#D3");
1341                                 Assert.AreEqual (DBNull.Value, value, "#D4");
1342                                 Assert.AreEqual (typeof (int), rdr.GetFieldType (0), "#D5");
1343                         }
1344
1345                         using (IDataReader rdr = cmd.ExecuteReader ()) {
1346                                 expected = int.MaxValue;
1347
1348                                 Assert.IsTrue (rdr.Read (), "#E1");
1349                                 value = rdr.GetValue (0);
1350                                 Assert.IsNotNull (value, "#E2");
1351                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#E3");
1352                                 Assert.AreEqual (expected, value, "#E4");
1353                                 Assert.AreEqual (typeof (int), rdr.GetFieldType (0), "#E5");
1354
1355                                 expected = int.MinValue;
1356
1357                                 Assert.IsTrue (rdr.Read (), "#F1");
1358                                 value = rdr.GetValue (0);
1359                                 Assert.IsNotNull (value, "#F2");
1360                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#F3");
1361                                 Assert.AreEqual (expected, value, "#F4");
1362                                 Assert.AreEqual (typeof (int), rdr.GetFieldType (0), "#F5");
1363
1364                                 expected = 0;
1365
1366                                 Assert.IsTrue (rdr.Read (), "#G1");
1367                                 value = rdr.GetValue (0);
1368                                 Assert.IsNotNull (value, "#G2");
1369                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#G3");
1370                                 Assert.AreEqual (expected, value, "#G4");
1371                                 Assert.AreEqual (typeof (int), rdr.GetFieldType (0), "#G5");
1372
1373                                 expected = DBNull.Value;
1374
1375                                 Assert.IsTrue (rdr.Read (), "#H1");
1376                                 value = rdr.GetValue (0);
1377                                 Assert.IsNotNull (value, "#H2");
1378                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#H3");
1379                                 Assert.AreEqual (expected, value, "#H4");
1380                                 Assert.AreEqual (typeof (int), rdr.GetFieldType (0), "#H5");
1381                         }
1382                 }
1383
1384                 [Test]
1385                 public void GetValue_Type_NText ()
1386                 {
1387                         object value;
1388                         object expected;
1389
1390                         cmd.CommandText = "select type_ntext from string_family order by id asc";
1391                         using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
1392                                 expected = "nt\u092d\u093ext";
1393
1394                                 Assert.IsTrue (rdr.Read (), "#A1");
1395                                 value = rdr.GetValue (0);
1396                                 Assert.IsNotNull (value, "#A2");
1397                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#A3");
1398                                 Assert.AreEqual (expected, value, "#A4");
1399                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#A5");
1400
1401                                 expected = "nt\u092d\u093ext ";
1402
1403                                 Assert.IsTrue (rdr.Read (), "#B1");
1404                                 value = rdr.GetValue (0);
1405                                 Assert.IsNotNull (value, "#B2");
1406                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#B3");
1407                                 Assert.AreEqual (expected, value, "#B4");
1408                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#B5");
1409
1410                                 expected = string.Empty;
1411
1412                                 Assert.IsTrue (rdr.Read (), "#C1");
1413                                 value = rdr.GetValue (0);
1414                                 Assert.IsNotNull (value, "#C2");
1415                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#C3");
1416                                 Assert.AreEqual (expected, value, "#C4");
1417                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#C5");
1418
1419                                 expected = DBNull.Value;
1420
1421                                 Assert.IsTrue (rdr.Read (), "#D1");
1422                                 value = rdr.GetValue (0);
1423                                 Assert.IsNotNull (value, "#D2");
1424                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#D3");
1425                                 Assert.AreEqual (expected, value, "#D4");
1426                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#D5");
1427                         }
1428
1429                         using (IDataReader rdr = cmd.ExecuteReader ()) {
1430                                 expected = "nt\u092d\u093ext";
1431
1432                                 Assert.IsTrue (rdr.Read (), "#E1");
1433                                 value = rdr.GetValue (0);
1434                                 Assert.IsNotNull (value, "#E2");
1435                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#E3");
1436                                 Assert.AreEqual (expected, value, "#E4");
1437                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#E5");
1438
1439                                 expected = "nt\u092d\u093ext ";
1440
1441                                 Assert.IsTrue (rdr.Read (), "#F1");
1442                                 value = rdr.GetValue (0);
1443                                 Assert.IsNotNull (value, "#F2");
1444                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#F3");
1445                                 Assert.AreEqual (expected, value, "#F4");
1446                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#F5");
1447
1448                                 expected = string.Empty;
1449
1450                                 Assert.IsTrue (rdr.Read (), "#G1");
1451                                 value = rdr.GetValue (0);
1452                                 Assert.IsNotNull (value, "#G2");
1453                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#G3");
1454                                 Assert.AreEqual (expected, value, "#G4");
1455                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#G5");
1456
1457                                 expected = DBNull.Value;
1458
1459                                 Assert.IsTrue (rdr.Read (), "#H1");
1460                                 value = rdr.GetValue (0);
1461                                 Assert.IsNotNull (value, "#H2");
1462                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#H3");
1463                                 Assert.AreEqual (expected, value, "#H4");
1464                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#H5");
1465                         }
1466                 }
1467
1468                 [Test]
1469                 public void GetValue_Type_NVarChar ()
1470                 {
1471                         object value;
1472                         object expected;
1473
1474                         cmd.CommandText = "select type_nvarchar from string_family order by id asc";
1475                         using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
1476                                 expected = "nv\u092d\u093e\u0930\u0924r";
1477
1478                                 Assert.IsTrue (rdr.Read (), "#A1");
1479                                 value = rdr.GetValue (0);
1480                                 Assert.IsNotNull (value, "#A2");
1481                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#A3");
1482                                 Assert.AreEqual (expected, value, "#A4");
1483                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#A5");
1484
1485                                 expected = "nv\u092d\u093e\u0930\u0924r ";
1486
1487                                 Assert.IsTrue (rdr.Read (), "#B1");
1488                                 value = rdr.GetValue (0);
1489                                 Assert.IsNotNull (value, "#B2");
1490                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#B3");
1491                                 Assert.AreEqual (expected, value, "#B4");
1492                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#B5");
1493
1494                                 expected = string.Empty;
1495
1496                                 Assert.IsTrue (rdr.Read (), "#C1");
1497                                 value = rdr.GetValue (0);
1498                                 Assert.IsNotNull (value, "#C2");
1499                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#C3");
1500                                 Assert.AreEqual (expected, value, "#C4");
1501                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#C5");
1502
1503                                 expected = DBNull.Value;
1504
1505                                 Assert.IsTrue (rdr.Read (), "#D1");
1506                                 value = rdr.GetValue (0);
1507                                 Assert.IsNotNull (value, "#D2");
1508                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#D3");
1509                                 Assert.AreEqual (expected, value, "#D4");
1510                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#D5");
1511                         }
1512
1513                         using (IDataReader rdr = cmd.ExecuteReader ()) {
1514                                 expected = "nv\u092d\u093e\u0930\u0924r";
1515
1516                                 Assert.IsTrue (rdr.Read (), "#E1");
1517                                 value = rdr.GetValue (0);
1518                                 Assert.IsNotNull (value, "#E2");
1519                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#E3");
1520                                 Assert.AreEqual (expected, value, "#E4");
1521                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#E5");
1522
1523                                 expected = "nv\u092d\u093e\u0930\u0924r ";
1524
1525                                 Assert.IsTrue (rdr.Read (), "#F1");
1526                                 value = rdr.GetValue (0);
1527                                 Assert.IsNotNull (value, "#F2");
1528                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#F3");
1529                                 Assert.AreEqual (expected, value, "#F4");
1530                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#F5");
1531
1532                                 expected = string.Empty;
1533
1534                                 Assert.IsTrue (rdr.Read (), "#G1");
1535                                 value = rdr.GetValue (0);
1536                                 Assert.IsNotNull (value, "#G2");
1537                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#G3");
1538                                 Assert.AreEqual (expected, value, "#G4");
1539                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#G5");
1540
1541                                 expected = DBNull.Value;
1542
1543                                 Assert.IsTrue (rdr.Read (), "#H1");
1544                                 value = rdr.GetValue (0);
1545                                 Assert.IsNotNull (value, "#H2");
1546                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#H3");
1547                                 Assert.AreEqual (expected, value, "#H4");
1548                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#H5");
1549                         }
1550                 }
1551
1552                 [Test]
1553                 public void GetValue_Type_Real ()
1554                 {
1555                         object value;
1556                         object expected;
1557
1558                         cmd.CommandText = "select type_float from numeric_family order by id asc";
1559                         using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
1560                                 expected = 3.40E+38F;
1561
1562                                 Assert.IsTrue (rdr.Read (), "#A1");
1563                                 value = rdr.GetValue (0);
1564                                 Assert.IsNotNull (value, "#A2");
1565                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#A3");
1566                                 Assert.AreEqual (expected, value, "#A4");
1567                                 Assert.AreEqual (typeof (float), rdr.GetFieldType (0), "#A5");
1568
1569                                 expected = -3.40E+38F;
1570
1571                                 Assert.IsTrue (rdr.Read (), "#B1");
1572                                 value = rdr.GetValue (0);
1573                                 Assert.IsNotNull (value, "#B2");
1574                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#B3");
1575                                 Assert.AreEqual (expected, value, "#B4");
1576                                 Assert.AreEqual (typeof (float), rdr.GetFieldType (0), "#B5");
1577
1578                                 expected = 0F;
1579
1580                                 Assert.IsTrue (rdr.Read (), "#C1");
1581                                 value = rdr.GetValue (0);
1582                                 Assert.IsNotNull (value, "#C2");
1583                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#C3");
1584                                 Assert.AreEqual (expected, value, "#C4");
1585                                 Assert.AreEqual (typeof (float), rdr.GetFieldType (0), "#C5");
1586
1587                                 expected = DBNull.Value;
1588
1589                                 Assert.IsTrue (rdr.Read (), "#D1");
1590                                 value = rdr.GetValue (0);
1591                                 Assert.IsNotNull (value, "#D2");
1592                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#D3");
1593                                 Assert.AreEqual (expected, value, "#D4");
1594                                 Assert.AreEqual (typeof (float), rdr.GetFieldType (0), "#D5");
1595                         }
1596
1597                         using (IDataReader rdr = cmd.ExecuteReader ()) {
1598                                 expected = 3.40E+38F;
1599
1600                                 Assert.IsTrue (rdr.Read (), "#E1");
1601                                 value = rdr.GetValue (0);
1602                                 Assert.IsNotNull (value, "#E2");
1603                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#E3");
1604                                 Assert.AreEqual (expected, value, "#E4");
1605                                 Assert.AreEqual (typeof (float), rdr.GetFieldType (0), "#E5");
1606
1607                                 expected = -3.40E+38F;
1608
1609                                 Assert.IsTrue (rdr.Read (), "#F1");
1610                                 value = rdr.GetValue (0);
1611                                 Assert.IsNotNull (value, "#F2");
1612                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#F3");
1613                                 Assert.AreEqual (expected, value, "#F4");
1614                                 Assert.AreEqual (typeof (float), rdr.GetFieldType (0), "#F5");
1615
1616                                 expected = 0F;
1617
1618                                 Assert.IsTrue (rdr.Read (), "#G1");
1619                                 value = rdr.GetValue (0);
1620                                 Assert.IsNotNull (value, "#G2");
1621                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#G3");
1622                                 Assert.AreEqual (expected, value, "#G4");
1623                                 Assert.AreEqual (typeof (float), rdr.GetFieldType (0), "#G5");
1624
1625                                 expected = DBNull.Value;
1626
1627                                 Assert.IsTrue (rdr.Read (), "#H1");
1628                                 value = rdr.GetValue (0);
1629                                 Assert.IsNotNull (value, "#H2");
1630                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#H3");
1631                                 Assert.AreEqual (expected, value, "#H4");
1632                                 Assert.AreEqual (typeof (float), rdr.GetFieldType (0), "#H5");
1633                         }
1634                 }
1635
1636                 [Test]
1637                 public void GetValue_Type_SmallDateTime ()
1638                 {
1639                         object value;
1640                         object expected;
1641
1642                         cmd.CommandText = "select type_smalldatetime from datetime_family order by id asc";
1643                         using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
1644                                 expected = DateTime.Parse ("2037-12-31 23:59:00");
1645
1646                                 Assert.IsTrue (rdr.Read (), "#A1");
1647                                 value = rdr.GetValue (0);
1648                                 Assert.IsNotNull (value, "#A2");
1649                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#A3");
1650                                 Assert.AreEqual (expected, value, "#A4");
1651                                 Assert.AreEqual (typeof (DateTime), rdr.GetFieldType (0), "#A5");
1652
1653                                 expected = DBNull.Value;
1654
1655                                 Assert.IsTrue (rdr.Read (), "#B1");
1656                                 value = rdr.GetValue (0);
1657                                 Assert.IsNotNull (value, "#B2");
1658                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#B3");
1659                                 Assert.AreEqual (expected, value, "#B4");
1660                                 Assert.AreEqual (typeof (DateTime), rdr.GetFieldType (0), "#B5");
1661                         }
1662
1663                         using (IDataReader rdr = cmd.ExecuteReader ()) {
1664                                 expected = DateTime.Parse ("2037-12-31 23:59:00");
1665
1666                                 Assert.IsTrue (rdr.Read (), "#C1");
1667                                 value = rdr.GetValue (0);
1668                                 Assert.IsNotNull (value, "#C2");
1669                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#C3");
1670                                 Assert.AreEqual (expected, value, "#C4");
1671                                 Assert.AreEqual (typeof (DateTime), rdr.GetFieldType (0), "#C5");
1672
1673                                 expected = DBNull.Value;
1674
1675                                 Assert.IsTrue (rdr.Read (), "#D1");
1676                                 value = rdr.GetValue (0);
1677                                 Assert.IsNotNull (value, "#D2");
1678                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#D3");
1679                                 Assert.AreEqual (expected, value, "#D4");
1680                                 Assert.AreEqual (typeof (DateTime), rdr.GetFieldType (0), "#D5");
1681                         }
1682                 }
1683
1684                 [Test]
1685                 public void GetValue_Type_SmallInt ()
1686                 {
1687                         object value;
1688                         object expected;
1689
1690                         cmd.CommandText = "select type_smallint from numeric_family order by id asc";
1691                         using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
1692                                 expected = short.MaxValue;
1693
1694                                 Assert.IsTrue (rdr.Read (), "#A1");
1695                                 value = rdr.GetValue (0);
1696                                 Assert.IsNotNull (value, "#A2");
1697                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#A3");
1698                                 Assert.AreEqual (expected, value, "#A4");
1699                                 Assert.AreEqual (typeof (short), rdr.GetFieldType (0), "#A5");
1700
1701                                 expected = short.MinValue;
1702
1703                                 Assert.IsTrue (rdr.Read (), "#B1");
1704                                 value = rdr.GetValue (0);
1705                                 Assert.IsNotNull (value, "#B2");
1706                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#B3");
1707                                 Assert.AreEqual (expected, value, "#B4");
1708                                 Assert.AreEqual (typeof (short), rdr.GetFieldType (0), "#B5");
1709
1710                                 expected = (short) 0;
1711
1712                                 Assert.IsTrue (rdr.Read (), "#C1");
1713                                 value = rdr.GetValue (0);
1714                                 Assert.IsNotNull (value, "#C2");
1715                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#C3");
1716                                 Assert.AreEqual (expected, value, "#C4");
1717                                 Assert.AreEqual (typeof (short), rdr.GetFieldType (0), "#C5");
1718
1719                                 expected = DBNull.Value;
1720
1721                                 Assert.IsTrue (rdr.Read (), "#D1");
1722                                 value = rdr.GetValue (0);
1723                                 Assert.IsNotNull (value, "#D2");
1724                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#D3");
1725                                 Assert.AreEqual (expected, value, "#D4");
1726                                 Assert.AreEqual (typeof (short), rdr.GetFieldType (0), "#D5");
1727                         }
1728
1729                         using (IDataReader rdr = cmd.ExecuteReader ()) {
1730                                 expected = short.MaxValue;
1731
1732                                 Assert.IsTrue (rdr.Read (), "#E1");
1733                                 value = rdr.GetValue (0);
1734                                 Assert.IsNotNull (value, "#E2");
1735                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#E3");
1736                                 Assert.AreEqual (expected, value, "#E4");
1737                                 Assert.AreEqual (typeof (short), rdr.GetFieldType (0), "#E5");
1738
1739                                 expected = short.MinValue;
1740
1741                                 Assert.IsTrue (rdr.Read (), "#F1");
1742                                 value = rdr.GetValue (0);
1743                                 Assert.IsNotNull (value, "#F2");
1744                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#F3");
1745                                 Assert.AreEqual (expected, value, "#F4");
1746                                 Assert.AreEqual (typeof (short), rdr.GetFieldType (0), "#F5");
1747
1748                                 expected = (short) 0;
1749
1750                                 Assert.IsTrue (rdr.Read (), "#G1");
1751                                 value = rdr.GetValue (0);
1752                                 Assert.IsNotNull (value, "#G2");
1753                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#G3");
1754                                 Assert.AreEqual (expected, value, "#G4");
1755                                 Assert.AreEqual (typeof (short), rdr.GetFieldType (0), "#G5");
1756
1757                                 expected = DBNull.Value;
1758
1759                                 Assert.IsTrue (rdr.Read (), "#H1");
1760                                 value = rdr.GetValue (0);
1761                                 Assert.IsNotNull (value, "#H2");
1762                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#H3");
1763                                 Assert.AreEqual (expected, value, "#H4");
1764                                 Assert.AreEqual (typeof (short), rdr.GetFieldType (0), "#H5");
1765                         }
1766                 }
1767
1768                 [Test]
1769                 public void GetValue_Type_Text ()
1770                 {
1771                         object value;
1772                         object expected;
1773
1774                         cmd.CommandText = "select type_text from string_family order by id asc";
1775                         using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
1776                                 expected = "text";
1777
1778                                 Assert.IsTrue (rdr.Read (), "#A1");
1779                                 value = rdr.GetValue (0);
1780                                 Assert.IsNotNull (value, "#A2");
1781                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#A3");
1782                                 Assert.AreEqual (expected, value, "#A4");
1783                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#A5");
1784
1785                                 StringBuilder sb = new StringBuilder ();
1786                                 for (int i = 0; i < 30; i++)
1787                                         sb.Append ("longtext ");
1788                                 expected = sb.ToString ();
1789
1790                                 Assert.IsTrue (rdr.Read (), "#B1");
1791                                 value = rdr.GetValue (0);
1792                                 Assert.IsNotNull (value, "#B2");
1793                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#B3");
1794                                 Assert.AreEqual (expected, value, "#B4");
1795                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#B5");
1796
1797                                 expected = string.Empty;
1798
1799                                 Assert.IsTrue (rdr.Read (), "#C1");
1800                                 value = rdr.GetValue (0);
1801                                 Assert.IsNotNull (value, "#C2");
1802                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#C3");
1803                                 Assert.AreEqual (expected, value, "#C4");
1804                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#C5");
1805
1806                                 expected = DBNull.Value;
1807
1808                                 Assert.IsTrue (rdr.Read (), "#D1");
1809                                 value = rdr.GetValue (0);
1810                                 Assert.IsNotNull (value, "#D2");
1811                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#D3");
1812                                 Assert.AreEqual (expected, value, "#D4");
1813                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#D5");
1814                         }
1815
1816                         using (IDataReader rdr = cmd.ExecuteReader ()) {
1817                                 expected = "text";
1818
1819                                 Assert.IsTrue (rdr.Read (), "#E1");
1820                                 value = rdr.GetValue (0);
1821                                 Assert.IsNotNull (value, "#E2");
1822                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#E3");
1823                                 Assert.AreEqual (expected, value, "#E4");
1824                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#E5");
1825
1826                                 StringBuilder sb = new StringBuilder ();
1827                                 for (int i = 0; i < 30; i++)
1828                                         sb.Append ("longtext ");
1829                                 expected = sb.ToString ();
1830
1831                                 Assert.IsTrue (rdr.Read (), "#F1");
1832                                 value = rdr.GetValue (0);
1833                                 Assert.IsNotNull (value, "#F2");
1834                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#F3");
1835                                 Assert.AreEqual (expected, value, "#F4");
1836                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#F5");
1837
1838                                 expected = string.Empty;
1839
1840                                 Assert.IsTrue (rdr.Read (), "#G1");
1841                                 value = rdr.GetValue (0);
1842                                 Assert.IsNotNull (value, "#G2");
1843                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#G3");
1844                                 Assert.AreEqual (expected, value, "#G4");
1845                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#G5");
1846
1847                                 expected = DBNull.Value;
1848
1849                                 Assert.IsTrue (rdr.Read (), "#H1");
1850                                 value = rdr.GetValue (0);
1851                                 Assert.IsNotNull (value, "#H2");
1852                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#H3");
1853                                 Assert.AreEqual (expected, value, "#H4");
1854                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#H5");
1855                         }
1856                 }
1857
1858                 [Test]
1859                 public void GetValue_Type_TinyInt ()
1860                 {
1861                         object value;
1862                         object expected;
1863
1864                         cmd.CommandText = "select type_tinyint from numeric_family order by id asc";
1865                         using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
1866                                 expected = byte.MaxValue;
1867
1868                                 Assert.IsTrue (rdr.Read (), "#A1");
1869                                 value = rdr.GetValue (0);
1870                                 Assert.IsNotNull (value, "#A2");
1871                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#A3");
1872                                 Assert.AreEqual (expected, value, "#A4");
1873                                 Assert.AreEqual (typeof (byte), rdr.GetFieldType (0), "#A5");
1874
1875                                 expected = byte.MinValue;
1876
1877                                 Assert.IsTrue (rdr.Read (), "#B1");
1878                                 value = rdr.GetValue (0);
1879                                 Assert.IsNotNull (value, "#B2");
1880                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#B3");
1881                                 Assert.AreEqual (expected, value, "#B4");
1882                                 Assert.AreEqual (typeof (byte), rdr.GetFieldType (0), "#B5");
1883
1884                                 expected = (byte) 0x00;
1885
1886                                 Assert.IsTrue (rdr.Read (), "#C1");
1887                                 value = rdr.GetValue (0);
1888                                 Assert.IsNotNull (value, "#C2");
1889                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#C3");
1890                                 Assert.AreEqual (expected, value, "#C4");
1891                                 Assert.AreEqual (typeof (byte), rdr.GetFieldType (0), "#C5");
1892
1893                                 expected = DBNull.Value;
1894
1895                                 Assert.IsTrue (rdr.Read (), "#D1");
1896                                 value = rdr.GetValue (0);
1897                                 Assert.IsNotNull (value, "#D2");
1898                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#D3");
1899                                 Assert.AreEqual (expected, value, "#D4");
1900                                 Assert.AreEqual (typeof (byte), rdr.GetFieldType (0), "#D5");
1901                         }
1902
1903                         using (IDataReader rdr = cmd.ExecuteReader ()) {
1904                                 expected = byte.MaxValue;
1905
1906                                 Assert.IsTrue (rdr.Read (), "#E1");
1907                                 value = rdr.GetValue (0);
1908                                 Assert.IsNotNull (value, "#E2");
1909                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#E3");
1910                                 Assert.AreEqual (expected, value, "#E4");
1911                                 Assert.AreEqual (typeof (byte), rdr.GetFieldType (0), "#E5");
1912
1913                                 expected = byte.MinValue;
1914
1915                                 Assert.IsTrue (rdr.Read (), "#F1");
1916                                 value = rdr.GetValue (0);
1917                                 Assert.IsNotNull (value, "#F2");
1918                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#F3");
1919                                 Assert.AreEqual (expected, value, "#F4");
1920                                 Assert.AreEqual (typeof (byte), rdr.GetFieldType (0), "#F5");
1921
1922                                 expected = (byte) 0x00;
1923
1924                                 Assert.IsTrue (rdr.Read (), "#G1");
1925                                 value = rdr.GetValue (0);
1926                                 Assert.IsNotNull (value, "#G2");
1927                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#G3");
1928                                 Assert.AreEqual (expected, value, "#G4");
1929                                 Assert.AreEqual (typeof (byte), rdr.GetFieldType (0), "#G5");
1930
1931                                 expected = DBNull.Value;
1932
1933                                 Assert.IsTrue (rdr.Read (), "#H1");
1934                                 value = rdr.GetValue (0);
1935                                 Assert.IsNotNull (value, "#H2");
1936                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#H3");
1937                                 Assert.AreEqual (expected, value, "#H4");
1938                                 Assert.AreEqual (typeof (byte), rdr.GetFieldType (0), "#H5");
1939                         }
1940                 }
1941
1942                 [Test]
1943                 public void GetValue_Type_VarBinary ()
1944                 {
1945                         object value;
1946                         object expected;
1947
1948                         cmd.CommandText = "select type_varbinary from binary_family order by id asc";
1949                         using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
1950                                 expected = new byte [] { 0x30, 0x31, 0x32, 0x33,
1951                                         0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x30,
1952                                         0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
1953                                         0x38, 0x39, 0x30, 0x31, 0x32, 0x33, 0x34,
1954                                         0x35, 0x36, 0x37, 0x38, 0x39, 0x00, 0x44,
1955                                         0x53};
1956
1957                                 Assert.IsTrue (rdr.Read (), "#A1");
1958                                 value = rdr.GetValue (0);
1959                                 Assert.IsNotNull (value, "#A2");
1960                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#A3");
1961                                 Assert.AreEqual (expected, value, "#A4");
1962                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#A5");
1963
1964                                 expected = new byte [] { 0x00, 0x39, 0x38, 0x37,
1965                                         0x36, 0x35, 0x00, 0x33, 0x32, 0x31, 0x30,
1966                                         0x31, 0x32, 0x33, 0x34 };
1967
1968                                 Assert.IsTrue (rdr.Read (), "#B1");
1969                                 value = rdr.GetValue (0);
1970                                 Assert.IsNotNull (value, "#B2");
1971                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#B3");
1972                                 Assert.AreEqual (expected, value, "#B4");
1973                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#B5");
1974
1975                                 expected = new byte [0];
1976
1977                                 Assert.IsTrue (rdr.Read (), "#C1");
1978                                 value = rdr.GetValue (0);
1979                                 Assert.IsNotNull (value, "#C2");
1980                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#C3");
1981                                 Assert.AreEqual (expected, value, "#C4");
1982                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#C5");
1983
1984                                 expected = DBNull.Value;
1985
1986                                 Assert.IsTrue (rdr.Read (), "#D1");
1987                                 value = rdr.GetValue (0);
1988                                 Assert.IsNotNull (value, "#D2");
1989                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#D3");
1990                                 Assert.AreEqual (DBNull.Value, value, "#D4");
1991                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#D5");
1992                         }
1993
1994                         using (IDataReader rdr = cmd.ExecuteReader ()) {
1995                                 expected = new byte [] { 0x30, 0x31, 0x32, 0x33,
1996                                         0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x30,
1997                                         0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
1998                                         0x38, 0x39, 0x30, 0x31, 0x32, 0x33, 0x34,
1999                                         0x35, 0x36, 0x37, 0x38, 0x39, 0x00, 0x44,
2000                                         0x53};
2001
2002                                 Assert.IsTrue (rdr.Read (), "#E1");
2003                                 value = rdr.GetValue (0);
2004                                 Assert.IsNotNull (value, "#E2");
2005                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#E3");
2006                                 Assert.AreEqual (expected, value, "#E4");
2007                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#E5");
2008
2009                                 expected = new byte [] { 0x00, 0x39, 0x38, 0x37,
2010                                         0x36, 0x35, 0x00, 0x33, 0x32, 0x31, 0x30,
2011                                         0x31, 0x32, 0x33, 0x34 };
2012
2013                                 Assert.IsTrue (rdr.Read (), "#F1");
2014                                 value = rdr.GetValue (0);
2015                                 Assert.IsNotNull (value, "#F2");
2016                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#F3");
2017                                 Assert.AreEqual (expected, value, "#F4");
2018                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#F5");
2019
2020                                 expected = new byte [0];
2021
2022                                 Assert.IsTrue (rdr.Read (), "#G1");
2023                                 value = rdr.GetValue (0);
2024                                 Assert.IsNotNull (value, "#G2");
2025                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#G3");
2026                                 Assert.AreEqual (expected, value, "#G4");
2027                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#G5");
2028
2029                                 expected = DBNull.Value;
2030
2031                                 Assert.IsTrue (rdr.Read (), "#H1");
2032                                 value = rdr.GetValue (0);
2033                                 Assert.IsNotNull (value, "#H2");
2034                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#H3");
2035                                 Assert.AreEqual (expected, value, "#H4");
2036                                 Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#H5");
2037                         }
2038                 }
2039
2040                 [Test]
2041                 public void GetValue_Type_VarChar ()
2042                 {
2043                         object value;
2044                         object expected;
2045
2046                         cmd.CommandText = "select type_varchar from string_family order by id asc";
2047                         using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
2048                                 expected = "varchar";
2049
2050                                 Assert.IsTrue (rdr.Read (), "#A1");
2051                                 value = rdr.GetValue (0);
2052                                 Assert.IsNotNull (value, "#A2");
2053                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#A3");
2054                                 Assert.AreEqual (expected, value, "#A4");
2055                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#A5");
2056
2057                                 expected = "varchar ";
2058
2059                                 Assert.IsTrue (rdr.Read (), "#B1");
2060                                 value = rdr.GetValue (0);
2061                                 Assert.IsNotNull (value, "#B2");
2062                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#B3");
2063                                 Assert.AreEqual (expected, value, "#B4");
2064                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#B5");
2065
2066                                 expected = string.Empty;
2067
2068                                 Assert.IsTrue (rdr.Read (), "#C1");
2069                                 value = rdr.GetValue (0);
2070                                 Assert.IsNotNull (value, "#C2");
2071                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#C3");
2072                                 Assert.AreEqual (expected, value, "#C4");
2073                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#C5");
2074
2075                                 expected = DBNull.Value;
2076
2077                                 Assert.IsTrue (rdr.Read (), "#D1");
2078                                 value = rdr.GetValue (0);
2079                                 Assert.IsNotNull (value, "#D2");
2080                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#D3");
2081                                 Assert.AreEqual (expected, value, "#D4");
2082                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#D5");
2083                         }
2084
2085                         using (IDataReader rdr = cmd.ExecuteReader ()) {
2086                                 expected = "varchar";
2087
2088                                 Assert.IsTrue (rdr.Read (), "#E1");
2089                                 value = rdr.GetValue (0);
2090                                 Assert.IsNotNull (value, "#E2");
2091                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#E3");
2092                                 Assert.AreEqual (expected, value, "#E4");
2093                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#E5");
2094
2095                                 expected = "varchar ";
2096
2097                                 Assert.IsTrue (rdr.Read (), "#F1");
2098                                 value = rdr.GetValue (0);
2099                                 Assert.IsNotNull (value, "#F2");
2100                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#F3");
2101                                 Assert.AreEqual (expected, value, "#F4");
2102                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#F5");
2103
2104                                 expected = string.Empty;
2105
2106                                 Assert.IsTrue (rdr.Read (), "#G1");
2107                                 value = rdr.GetValue (0);
2108                                 Assert.IsNotNull (value, "#G2");
2109                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#G3");
2110                                 Assert.AreEqual (expected, value, "#G4");
2111                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#G5");
2112
2113                                 expected = DBNull.Value;
2114
2115                                 Assert.IsTrue (rdr.Read (), "#H1");
2116                                 value = rdr.GetValue (0);
2117                                 Assert.IsNotNull (value, "#H2");
2118                                 Assert.AreEqual (expected.GetType (), value.GetType (), "#H3");
2119                                 Assert.AreEqual (expected, value, "#H4");
2120                                 Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#H5");
2121                         }
2122                 }
2123
2124                 [Test]
2125                 public void GetBytes ()
2126                 {
2127                         //Console.WriteLine ("GetBytes - first_executereader");
2128                         byte [] expected = new byte [] { 0x32, 0x56, 0x00, 0x44, 0x22 };
2129                         cmd.CommandText = "SELECT type_blob FROM binary_family where id = 1";
2130
2131                         using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
2132                                 Assert.IsTrue (reader.Read (), "#A1");
2133
2134                                 // Get By Parts for the column blob
2135                                 long totalsize = reader.GetBytes (0, 0, null, 0, 0);
2136                                 int buffsize = 3;
2137                                 int offset = 0;
2138                                 long ret = 0;
2139                                 long count = 0;
2140                                 byte [] val = new byte [totalsize];
2141                                 //Console.WriteLine ("GetBytes:: totalsize={0}", totalsize);
2142                                 do {
2143                                         ret = reader.GetBytes (0, offset, val, offset,
2144                                                 (int) Math.Min (buffsize, totalsize - count));
2145                                         offset += (int) ret;
2146                                         count += ret;
2147                                 } while (count < totalsize);
2148
2149                                 Assert.AreEqual (expected.Length, count, "#A2");
2150                                 Assert.AreEqual (expected, val, "#A3");
2151                         }
2152
2153                         //Console.WriteLine ("GetBytes - second_executereader");
2154                         using (IDataReader reader = cmd.ExecuteReader ()) {
2155                                 Assert.IsTrue (reader.Read (), "#B1");
2156
2157                                 // Get By Parts for the column blob
2158                                 long totalsize = reader.GetBytes (0, 0, null, 0, 0);
2159                                 int buffsize = 3;
2160                                 int offset = 0;
2161                                 long ret = 0;
2162                                 long count = 0;
2163                                 byte [] val = new byte [totalsize];
2164
2165                                 do {
2166                                         ret = reader.GetBytes (0, offset, val, offset,
2167                                                 (int) Math.Min (buffsize, totalsize - count));
2168                                         offset += (int) ret;
2169                                         count += ret;
2170                                 } while (count < totalsize);
2171
2172                                 Assert.AreEqual (expected.Length, count, "#B2");
2173                                 Assert.AreEqual (expected, val, "#B3");
2174                         }
2175
2176                         //Console.WriteLine ("GetBytes - third_executereader");
2177                         // buffer size > (buffer offset + length) > remaining data
2178                         using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
2179                                 Assert.IsTrue (reader.Read ());
2180
2181                                 long totalsize = reader.GetBytes (0, 0, null, 0, 0);
2182                                 byte [] val = new byte [totalsize + 5];
2183                                 int buffer_offset = 3;
2184
2185                                 long ret = reader.GetBytes (0, 0, val, buffer_offset, (int) totalsize);
2186                                 Assert.AreEqual (expected.Length, ret, "#C1");
2187                                 for (int i = 0; i < buffer_offset; i++)
2188                                         Assert.AreEqual (0x00, val [i], "#C2:" + i);
2189                                 for (int i = 0; i < totalsize; i++)
2190                                         Assert.AreEqual (expected [i], val [buffer_offset + i], "#C3:" + i);
2191                         }
2192
2193                         //Console.WriteLine ("GetBytes - fourth_executereader");
2194                         // buffer size > (buffer offset + length) > remaining data
2195                         using (IDataReader reader = cmd.ExecuteReader ()) {
2196                                 Assert.IsTrue (reader.Read ());
2197
2198                                 long totalsize = reader.GetBytes (0, 0, null, 0, 0);
2199                                 byte [] val = new byte [totalsize + 5];
2200                                 int buffer_offset = 3;
2201
2202                                 long ret = reader.GetBytes (0, 0, val, buffer_offset, (int) totalsize);
2203                                 Assert.AreEqual (expected.Length, ret, "#D1");
2204                                 for (int i = 0; i < buffer_offset; i++)
2205                                         Assert.AreEqual (0x00, val [i], "#D2:" + i);
2206                                 for (int i = 0; i < totalsize; i++)
2207                                         Assert.AreEqual (expected [i], val [buffer_offset + i], "#D3:" + i);
2208                         }
2209
2210                         /* FIXME: dataIndex is currently ignored */
2211                         /*
2212                         behavior = CommandBehavior.SingleResult | CommandBehavior.SequentialAccess;
2213                         using (IDataReader reader = cmd.ExecuteReader (behavior)) {
2214                                 Assert.IsTrue (reader.Read (), "#E1");
2215
2216                                 long totalsize = reader.GetBytes (0, 0, null, 0, 0);
2217
2218                                 int bufferIndex = 3;
2219                                 long ret = 0L;
2220                                 byte [] val = new byte [totalsize + bufferIndex];
2221                                 for (int i = 0; i < val.Length; i++)
2222                                         val [i] = 0x0a;
2223                                 ret = reader.GetBytes (0, 1L, val, bufferIndex, (int) (totalsize - 2));
2224                                 Assert.AreEqual (3, ret, "#E2");
2225                                 Assert.AreEqual (new byte [] { 0x0a, 0x0a, 0x0a, 0x56, 0x00, 0x44, 0x0a, 0x0a }, val, "#E3");
2226                                 try {
2227                                         reader.GetBytes (0, 3L, val, 1, 2);
2228                                         Assert.Fail ("#E4");
2229                                 } catch (InvalidOperationException ex) {
2230                                         // Invalid GetBytes attempt at dataIndex '3'.
2231                                         // With CommandBehavior.SequentialAccess, you
2232                                         // may only read from dataIndex '4' or greater
2233                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E5");
2234                                         Assert.IsNull (ex.InnerException, "#E6");
2235                                         Assert.IsNotNull (ex.Message, "#E7");
2236                                         Assert.IsTrue (ex.Message.IndexOf ("CommandBehavior.SequentialAccess") != -1, "#E8:" + ex.Message);
2237                                         Assert.IsTrue (ex.Message.IndexOf ("'" + 3L.ToString (CultureInfo.InvariantCulture) + "'") != -1, "#E9:" + ex.Message);
2238                                         Assert.IsTrue (ex.Message.IndexOf ("'" + 4L.ToString (CultureInfo.InvariantCulture) + "'") != -1, "#E10:" + ex.Message);
2239                                 }
2240
2241                                 ret = reader.GetBytes (0, 4L, val, bufferIndex + 4, 2);
2242                                 Assert.AreEqual (1, ret, "#E11");
2243                                 Assert.AreEqual (new byte [] { 0x0a, 0x0a, 0x0a, 0x56, 0x00, 0x44, 0x0a, 0x22 }, val, "#E12");
2244                         }
2245
2246                         //Console.WriteLine ("GetBytes - fifth_executereader");
2247                         behavior = CommandBehavior.SingleResult;
2248                         using (IDataReader reader = cmd.ExecuteReader (behavior)) {
2249                                 Assert.IsTrue (reader.Read (), "#F1");
2250
2251                                 long totalsize = reader.GetBytes (0, 0, null, 0, 0);
2252
2253                                 int bufferIndex = 3;
2254                                 long ret = 0L;
2255                                 byte [] val = new byte [totalsize + bufferIndex];
2256                                 for (int i = 0; i < val.Length; i++)
2257                                         val [i] = 0x0a;
2258                                 ret = reader.GetBytes (0, 1L, val, bufferIndex, (int) (totalsize - 2));
2259                                 Assert.AreEqual (3, ret, "#F2");
2260                                 Assert.AreEqual (new byte [] { 0x0a, 0x0a, 0x0a, 0x56, 0x00, 0x44, 0x0a, 0x0a }, val, "#F3");
2261                                 ret = reader.GetBytes (0, 3L, val, 1, 2);
2262                                 Assert.AreEqual (2, ret, "#F4");
2263                                 Assert.AreEqual (new byte [] { 0x0a, 0x44, 0x22, 0x56, 0x00, 0x44, 0x0a, 0x0a }, val, "#F5");
2264                         }
2265                         */
2266                 }
2267
2268                 [Test]
2269                 public void GetBytes_Buffer_Null ()
2270                 {
2271                         //Console.WriteLine ("GetBytes_Buffer_Null- first_executereader");
2272                         cmd.CommandText = "SELECT type_blob FROM binary_family where id in (1,2,3,4) order by id";
2273
2274                         using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
2275                                 Assert.IsTrue (reader.Read (), "#A1");
2276                                 Assert.AreEqual (5, reader.GetBytes (0, 0, null, 0, 0), "#A2");
2277
2278                                 Assert.IsTrue (reader.Read (), "#B1");
2279                                 Assert.AreEqual (275, reader.GetBytes (0, 0, null, 0, 0), "#B2");
2280
2281                                 Assert.IsTrue (reader.Read (), "#C1");
2282                                 Assert.AreEqual (0, reader.GetBytes (0, 0, null, 0, 0), "#C2");
2283
2284                                 Assert.IsTrue (reader.Read (), "#D1");
2285                                 if (conn is SqlConnection) {
2286                                         try {
2287                                                 reader.GetBytes (0, 0, null, 0, 0);
2288                                                 Assert.Fail ("#D2");
2289                                         } catch (SqlNullValueException ex) {
2290                                                 // Data is Null. This method or
2291                                                 // property cannot be called on
2292                                                 // Null values
2293                                                 Assert.AreEqual (typeof (SqlNullValueException), ex.GetType (), "#D3");
2294                                                 Assert.IsNull (ex.InnerException, "#D4");
2295                                                 Assert.IsNotNull (ex.Message, "#D5");
2296                                         }
2297                                 } else {
2298                                         Assert.AreEqual (-1, reader.GetBytes (0, 0, null, 0, 0), "#D2");
2299                                 }
2300                         }
2301
2302                         using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
2303                                 Assert.IsTrue (reader.Read (), "#E1");
2304                                 Assert.AreEqual (5, reader.GetBytes (0, 5, null, 3, 8), "#E2");
2305
2306                                 Assert.IsTrue (reader.Read (), "#F1");
2307                                 Assert.AreEqual (275, reader.GetBytes (0, 5, null, 3, 4), "#F2");
2308
2309                                 Assert.IsTrue (reader.Read (), "#G1");
2310                                 Assert.AreEqual (0, reader.GetBytes (0, 5, null, 3, 4), "#G2");
2311
2312                                 Assert.IsTrue (reader.Read (), "#H1");
2313                                 if (conn is SqlConnection) {
2314                                         try {
2315                                                 reader.GetBytes (0, 5, null, 3, 4);
2316                                                 Assert.Fail ("#H2");
2317                                         } catch (SqlNullValueException ex) {
2318                                                 // Data is Null. This method or
2319                                                 // property cannot be called on
2320                                                 // Null values
2321                                                 Assert.AreEqual (typeof (SqlNullValueException), ex.GetType (), "#H3");
2322                                                 Assert.IsNull (ex.InnerException, "#H4");
2323                                                 Assert.IsNotNull (ex.Message, "#H5");
2324                                         }
2325                                 } else {
2326                                         Assert.AreEqual (-1, reader.GetBytes (0, 5, null, 3, 4), "#H2");
2327                                 }
2328                         }
2329
2330                         using (IDataReader reader = cmd.ExecuteReader ()) {
2331                                 Assert.IsTrue (reader.Read (), "#I1");
2332                                 Assert.AreEqual (5, reader.GetBytes (0, 0, null, 0, 0), "#I2");
2333
2334                                 Assert.IsTrue (reader.Read (), "#J1");
2335                                 Assert.AreEqual (275, reader.GetBytes (0, 0, null, 0, 0), "#J2");
2336
2337                                 Assert.IsTrue (reader.Read (), "#K1");
2338                                 Assert.AreEqual (0, reader.GetBytes (0, 0, null, 0, 0), "#K2");
2339
2340                                 Assert.IsTrue (reader.Read (), "#L1");
2341                                 if (conn is SqlConnection) {
2342                                         try {
2343                                                 reader.GetBytes (0, 0, null, 0, 0);
2344                                                 Assert.Fail ("#L2");
2345                                         } catch (SqlNullValueException ex) {
2346                                                 // Data is Null. This method or
2347                                                 // property cannot be called on
2348                                                 // Null values
2349                                                 Assert.AreEqual (typeof (SqlNullValueException), ex.GetType (), "#L3");
2350                                                 Assert.IsNull (ex.InnerException, "#L4");
2351                                                 Assert.IsNotNull (ex.Message, "#L5");
2352                                         }
2353                                 } else {
2354                                         if (RunningOnMono)
2355                                                 Assert.AreEqual (-1, reader.GetBytes (0, 0, null, 0, 0), "#L2");
2356                                         else {
2357                                                 try {
2358                                                         reader.GetBytes (0, 0, null, 0, 0);
2359                                                         Assert.Fail ("#L2");
2360                                                 } catch (InvalidCastException) {
2361                                                         // Unable to cast object of type
2362                                                         // 'System.DBNull' to type 'System.Byte[]'
2363                                                 }
2364                                         }
2365                                 }
2366                         }
2367
2368                         using (IDataReader reader = cmd.ExecuteReader ()) {
2369                                 Assert.IsTrue (reader.Read (), "#M1");
2370                                 Assert.AreEqual (5, reader.GetBytes (0, 5, null, 3, 8), "#M2");
2371
2372                                 Assert.IsTrue (reader.Read (), "#N1");
2373                                 Assert.AreEqual (275, reader.GetBytes (0, 5, null, 3, 4), "#N2");
2374
2375                                 Assert.IsTrue (reader.Read (), "#O1");
2376                                 Assert.AreEqual (0, reader.GetBytes (0, 5, null, 3, 4), "#O2");
2377
2378                                 Assert.IsTrue (reader.Read (), "#P1");
2379                                 if (conn is SqlConnection) {
2380                                         try {
2381                                                 reader.GetBytes (0, 5, null, 3, 4);
2382                                                 Assert.Fail ("#P2");
2383                                         } catch (SqlNullValueException ex) {
2384                                                 // Data is Null. This method or
2385                                                 // property cannot be called on
2386                                                 // Null values
2387                                                 Assert.AreEqual (typeof (SqlNullValueException), ex.GetType (), "#P3");
2388                                                 Assert.IsNull (ex.InnerException, "#P4");
2389                                                 Assert.IsNotNull (ex.Message, "#P5");
2390                                         }
2391                                 } else {
2392                                         if (RunningOnMono)
2393                                                 Assert.AreEqual (-1, reader.GetBytes (0, 0, null, 0, 0), "#L2");
2394                                         else {
2395                                                 try {
2396                                                         reader.GetBytes (0, 0, null, 0, 0);
2397                                                         Assert.Fail ("#L2");
2398                                                 } catch (InvalidCastException) {
2399                                                         // Unable to cast object of type
2400                                                         // 'System.DBNull' to type 'System.Byte[]'
2401                                                 }
2402                                         }
2403                                 }
2404                         }
2405                 }
2406
2407                 [Test]
2408                 public void GetBytes_DataIndex_Overflow ()
2409                 {
2410                         cmd.CommandText = "SELECT type_blob FROM binary_family where id = 2";
2411
2412                         //Console.WriteLine ("GetBytes_DataIndex_Overflow - first_executereader");
2413                         using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
2414                                 Assert.IsTrue (reader.Read ());
2415
2416                                 long totalsize = reader.GetBytes (0, 0, null, 0, 0);
2417                                 byte [] val = new byte [totalsize * 2];
2418                                 long ret;
2419
2420                                 // dataIndex > total size, length = 0
2421                                 ret = reader.GetBytes (0, totalsize + 5, val, 0, 0);
2422                                 Assert.AreEqual (0, ret, "#C1");
2423                                 // dataIndex > total size, length < total size
2424                                 ret = reader.GetBytes (0, totalsize + 5, val, 0, 5);
2425                                 Assert.AreEqual (0, ret, "#C2");
2426                                 // dataIndex > total size, length > total size
2427                                 ret = reader.GetBytes (0, totalsize + 5, val, 0, (int) (totalsize + 5));
2428                                 Assert.AreEqual (0, ret, "#C3");
2429                         }
2430
2431                         //Console.WriteLine ("GetBytes_DataIndex_Overflow - second_executereader");
2432                         using (IDataReader reader = cmd.ExecuteReader ()) {
2433                                 Assert.IsTrue (reader.Read ());
2434
2435                                 long totalsize = reader.GetBytes (0, 0, null, 0, 0);
2436                                 byte [] val = new byte [totalsize * 2];
2437                                 long ret;
2438
2439                                 // dataIndex > total size, length = 0
2440                                 ret = reader.GetBytes (0, totalsize + 5, val, 0, 0);
2441                                 Assert.AreEqual (0, ret, "#B1");
2442                                 // dataIndex > total size, length < total size
2443                                 ret = reader.GetBytes (0, totalsize + 5, val, 0, 5);
2444                                 Assert.AreEqual (0, ret, "#B2");
2445                                 // dataIndex > total size, length > total size
2446                                 ret = reader.GetBytes (0, totalsize + 5, val, 0, (int) (totalsize + 5));
2447                                 Assert.AreEqual (0, ret, "#B3");
2448                         }
2449                 }
2450
2451                 [Test]
2452                 public void GetBytes_DataIndex_OffSet ()
2453                 {
2454                         //Console.WriteLine ("GetBytes_DataIndex_Offset - first_executereader");
2455                         cmd.CommandText = "SELECT type_blob FROM binary_family where id = 2";
2456
2457                         using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SingleResult | CommandBehavior.SequentialAccess)) {
2458                                 Assert.IsTrue (reader.Read ());
2459
2460                                 long totalsize = reader.GetBytes (0, 0, null, 0, 0);
2461                                 byte [] val = new byte [totalsize];
2462                                 long ret;
2463
2464                                 // start reading at index 0
2465                                 ret = reader.GetBytes (0, 0, val, 0, 5);
2466                                 Assert.AreEqual (5, ret, "#A1");
2467                                 for (int i = 0; i < ret; i++)
2468                                         Assert.AreEqual (long_bytes [i], val [i], "#A2:" + i);
2469                                 Assert.AreEqual (0x00, val [5], "#A3");
2470
2471                                 // attempt to read data prior to current pointer
2472                                 try {
2473                                         reader.GetBytes (0, 4, val, 0, 5);
2474                                         Assert.Fail ("#B1");
2475                                 } catch (InvalidOperationException ex) {
2476                                         // Invalid GetBytes attempt at dataIndex '4'
2477                                         // With CommandBehavior.SequentialAccess,
2478                                         // you may only read from dataIndex '5'
2479                                         // or greater.
2480                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
2481                                         Assert.IsNull (ex.InnerException, "#B3");
2482                                         Assert.IsNotNull (ex.Message, "#B4");
2483                                         Assert.IsTrue (ex.Message.IndexOf ("'4'") != -1, "#B5:" + ex.Message);
2484                                         Assert.IsTrue (ex.Message.IndexOf ("'5'") != -1, "#B6:" + ex.Message);
2485                                 }
2486
2487                                 // continue reading at current pointer
2488                                 ret = reader.GetBytes (0, 5, val, 5, 6);
2489                                 Assert.AreEqual (6, ret, "#C1");
2490                                 for (int i = 0; i < 11; i++)
2491                                         Assert.AreEqual (long_bytes [i], val [i], "#C2:" + i);
2492                                 Assert.AreEqual (0x00, val [11], "#C3");
2493
2494                                 // skip 4 characters
2495                                 ret = reader.GetBytes (0, 15, val, 13, (val.Length - 13));
2496                                 Assert.AreEqual (260, ret, "#D1");
2497                                 for (int i = 0; i < 11; i++)
2498                                         Assert.AreEqual (long_bytes [i], val [i], "#D2:" + i);
2499                                 for (int i = 11; i < 13; i++)
2500                                         Assert.AreEqual (0x00, val [i], "#D3:" + i);
2501                                 for (int i = 13; i < (totalsize - 4); i++)
2502                                         Assert.AreEqual (long_bytes [i + 2], val [i], "#D4:" + i);
2503                         }
2504
2505                         //Console.WriteLine ("GetBytes_DataIndex_Offset - second_executereader");
2506                         using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SingleResult | CommandBehavior.SequentialAccess)) {
2507                                 Assert.IsTrue (reader.Read ());
2508
2509                                 long totalsize = reader.GetBytes (0, 0, null, 0, 0);
2510                                 byte [] val = new byte [totalsize];
2511                                 long ret;
2512
2513                                 int offset = (int) totalsize - 5;
2514                                 int buffer_offset = 7;
2515
2516                                 // start reading at a specific position
2517                                 ret = reader.GetBytes (0, offset, val, buffer_offset,
2518                                         val.Length - buffer_offset);
2519                                 Assert.AreEqual (5, ret, "#E1");
2520                                 for (int i = 0; i < buffer_offset; i++)
2521                                         Assert.AreEqual (0x00, val [i], "#E2:" + i);
2522                                 for (int i = 0; i < ret; i++)
2523                                         Assert.AreEqual (long_bytes [offset + i], val [buffer_offset + i], "#E3:" + i);
2524                                 for (int i = (buffer_offset + (int) ret); i < val.Length; i++)
2525                                         Assert.AreEqual (0x00, val [i], "#E4:" + i);
2526                         }
2527                 }
2528
2529                 [Test]
2530                 public void GetBytes_Reader_Closed ()
2531                 {
2532                         //Console.WriteLine ("GetBytes_Reader_Closed - first_executereader");
2533                         cmd.CommandText = "SELECT type_blob FROM binary_family where id = 1";
2534
2535                         using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
2536                                 Assert.IsTrue (reader.Read (), "#1");
2537                                 reader.Close ();
2538
2539                                 try {
2540                                         reader.GetBytes (0, 0, null, -1, 0);
2541                                         Assert.Fail ("#2");
2542                                 } catch (InvalidOperationException ex) {
2543                                         // No data exists for the row/column
2544                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#3");
2545                                         Assert.IsNull (ex.InnerException, "#4");
2546                                         Assert.IsNotNull (ex.Message, "#5");
2547                                 }
2548                         }
2549                 }
2550
2551 #if DONT_RUN
2552                 [Test]
2553                 public void GetBytes_Reader_NoData ()
2554                 {
2555                         //Console.WriteLine ("GetBytes_Reader_NoData - first_executereader");
2556                         cmd.CommandText = "SELECT type_blob FROM binary_family where id = 1";
2557
2558                         using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) {
2559                                 try {
2560                                         reader.GetBytes (0, 0, null, -1, 0);
2561                                         Assert.Fail ("#2");
2562                                 } catch (InvalidOperationException ex) {
2563                                         // No data exists for the row/column
2564                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#3");
2565                                         Assert.IsNull (ex.InnerException, "#4");
2566                                         Assert.IsNotNull (ex.Message, "#5");
2567                                 }
2568                         }
2569                 }
2570 #endif
2571                 [Test]
2572                 public void GetSchemaTableTest_AutoIncrement ()
2573                 {
2574                         cmd.CommandText = "select type_autoincrement from numeric_family";
2575                         cmd.ExecuteNonQuery ();
2576                         using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly)) {
2577                                 DataTable schemaTable = reader.GetSchemaTable ();
2578                                 Assert.IsTrue ((bool) schemaTable.Rows [0]["IsAutoIncrement"], "#1");
2579
2580                                 if (!RunningOnMono) {
2581                                         /* FIXME: we always set it to false */
2582                                         if (schemaTable.Columns.Contains ("IsIdentity"))
2583                                                 Assert.IsTrue ((bool) schemaTable.Rows [0] ["IsIdentity"], "#2");
2584                                 }
2585                         }
2586                 }
2587
2588                 [Test]
2589                 public void GetValues_Reader_Closed ()
2590                 {
2591                         //Console.WriteLine ("GetValues_Reader_Closed - first_executereader");
2592                         cmd.CommandText = "SELECT type_blob FROM binary_family where id = 1";
2593
2594                         using (IDataReader rdr = cmd.ExecuteReader ()) {
2595                                 Assert.IsTrue (rdr.Read ());
2596                                 rdr.Close ();
2597
2598                                 try {
2599                                         rdr.GetValues ((object []) null);
2600                                         Assert.Fail ("#1");
2601                                 } catch (InvalidOperationException ex) {
2602                                         // No data exists for the row/column
2603                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
2604                                         Assert.IsNull (ex.InnerException, "#3");
2605                                         Assert.IsNotNull (ex.Message, "#4");
2606                                 }
2607                         }
2608                 }
2609
2610                 [Test]
2611                 public void GetValues_Reader_NoData ()
2612                 {
2613                         //Console.WriteLine ("GetValues_Reader_NoData - first_executereader");
2614                         cmd.CommandText = "SELECT type_blob FROM binary_family where id = 666";
2615
2616                         using (IDataReader rdr = cmd.ExecuteReader ()) {
2617                                 try {
2618                                         rdr.GetValues ((object []) null);
2619                                         Assert.Fail ("#A1");
2620                                 } catch (InvalidOperationException ex) {
2621                                         // No data exists for the row/column
2622                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
2623                                         Assert.IsNull (ex.InnerException, "#A3");
2624                                         Assert.IsNotNull (ex.Message, "#A4");
2625                                 }
2626
2627                                 Assert.IsFalse (rdr.Read (), "#B");
2628
2629                                 try {
2630                                         rdr.GetValues ((object []) null);
2631                                         Assert.Fail ("#C1");
2632                                 } catch (InvalidOperationException ex) {
2633                                         // No data exists for the row/column
2634                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
2635                                         Assert.IsNull (ex.InnerException, "#C3");
2636                                         Assert.IsNotNull (ex.Message, "#C4");
2637                                 }
2638                         }
2639                 }
2640
2641                 static bool RunningOnMono {
2642                         get {
2643                                 return (Type.GetType ("System.MonoType", false) != null);
2644                         }
2645                 }
2646         }
2647 }