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