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