X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fclass%2FSystem.Data%2FTest%2FProviderTests%2FProviderIndependant%2FDataReaderTest.cs;h=e6e4578a8e2902ec824c24e23f2c7dd8c8814297;hb=2115cd7394c0212e246ac44df0a360ed8ae036d5;hp=9ae60988067247df9a36c13887bb67f48282b95b;hpb=d4d1e6f922168123eda0bcc62cf255ba6e292de2;p=mono.git diff --git a/mcs/class/System.Data/Test/ProviderTests/ProviderIndependant/DataReaderTest.cs b/mcs/class/System.Data/Test/ProviderTests/ProviderIndependant/DataReaderTest.cs index 9ae60988067..e6e4578a8e2 100644 --- a/mcs/class/System.Data/Test/ProviderTests/ProviderIndependant/DataReaderTest.cs +++ b/mcs/class/System.Data/Test/ProviderTests/ProviderIndependant/DataReaderTest.cs @@ -3,11 +3,12 @@ // // Authors: // Sureshkumar T (tsureshkumar@novell.com) +// Gert Driesen (drieseng@users.sourceforge.net) +// Veerapuram Varadhan (vvaradhan@novell.com) // // Copyright (c) 2004 Novell Inc., and the individuals listed on the // ChangeLog entries. // -// // Permission is hereby granted, free of charge, to any person // obtaining a copy of this software and associated documentation // files (the "Software"), to deal in the Software without @@ -31,220 +32,2609 @@ using System; using System.Data; using System.Data.Common; -using Mono.Data; - +using System.Data.Odbc; +using System.Data.SqlClient; +using System.Data.SqlTypes; +using System.Globalization; +using System.Text; using NUnit.Framework; -namespace MonoTests.System.Data +namespace MonoTests.System.Data.Connected { [TestFixture] - [Category ("odbc"), Category ("sqlserver")] + [Category ("odbc")] + [Category ("sqlserver")] public class DataReaderTest { + static byte [] long_bytes = new byte [] { + 0x00, 0x66, 0x06, 0x66, 0x97, 0x00, 0x66, 0x06, 0x66, + 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, + 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, + 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, + 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, + 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, + 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, + 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, + 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, + 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, + 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, + 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, + 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, + 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, + 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, + 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, + 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, + 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, + 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, + 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, + 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, + 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, + 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, + 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, + 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, + 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, + 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, + 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, + 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06, + 0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97, + 0x06, 0x66, 0x06, 0x66, 0x98}; + + IDbConnection conn; + IDbCommand cmd; + + [SetUp] + public void SetUp () + { + conn = ConnectionManager.Instance.Sql.Connection; + cmd = conn.CreateCommand (); + } + + [TearDown] + public void TearDown () + { + cmd?.Dispose (); + ConnectionManager.Instance.Close(); + } + [Test] - public void GetSchemaTableTest () + public void FieldCount () { - IDbConnection conn = ConnectionManager.Singleton.Connection; + IDataReader reader = null; + try { - ConnectionManager.Singleton.OpenConnection (); - IDbCommand cmd = conn.CreateCommand (); - cmd.CommandText = "select id, fname, id + 20 as plustwenty from employee"; - IDataReader reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo); - DataTable schema = reader.GetSchemaTable (); + cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'"; + reader = cmd.ExecuteReader (); + Assert.AreEqual (6, reader.FieldCount); + } finally { + if (reader != null) + reader.Close (); + } + } + + [Test] + public void FieldCount_Command_Disposed () + { + IDataReader reader = null; + + try { + cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'"; + reader = cmd.ExecuteReader (); + cmd.Dispose (); + Assert.AreEqual (6, reader.FieldCount); + } finally { + if (reader != null) + reader.Close (); + } + } + + [Test] + public void FieldCount_Reader_Closed () + { + IDataReader reader = null; + + try { + cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'"; + reader = cmd.ExecuteReader (); reader.Close (); - Assert.AreEqual (3, schema.Rows.Count, "#1"); + try { + int fieldcount = reader.FieldCount; + Assert.Fail ("#1:" + fieldcount); + } catch (InvalidOperationException ex) { + // Invalid attempt to FieldCount when + // reader is closed + Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + } + } finally { + if (reader != null) + reader.Close (); + } + } + + [Test] + public void GetChars_Index_Invalid () + { + //Console.WriteLine ("In GetChars_Index_Invalid - first_executereader"); + cmd.CommandText = "SELECT type_blob FROM binary_family where id = 1"; + + using (IDataReader rdr = cmd.ExecuteReader ()) { + Assert.IsTrue (rdr.Read ()); + + try { + rdr.GetChars (-1, 0, (char []) null, 0, 0); + Assert.Fail ("#A1"); + } catch (IndexOutOfRangeException ex) { + // Index was outside the bounds of the array + Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + } + + try { + rdr.GetChars (1, 0, (char []) null, 0, 0); + Assert.Fail ("#B1"); + } catch (IndexOutOfRangeException ex) { + // Index was outside the bounds of the array + Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + } + } + + //Console.WriteLine ("In GetChars_Index_Invalid - second_executereader"); + using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) { + Assert.IsTrue (rdr.Read ()); + + try { + rdr.GetChars (-1, 0, (char []) null, 0, 0); + Assert.Fail ("#C1"); + } catch (IndexOutOfRangeException ex) { + // Index was outside the bounds of the array + Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#C2"); + Assert.IsNull (ex.InnerException, "#C3"); + Assert.IsNotNull (ex.Message, "#C4"); + } + + try { + rdr.GetChars (1, 0, (char []) null, 0, 0); + Assert.Fail ("#D1"); + } catch (IndexOutOfRangeException ex) { + // Index was outside the bounds of the array + Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#D2"); + Assert.IsNull (ex.InnerException, "#D3"); + Assert.IsNotNull (ex.Message, "#D4"); + } + } + } + + [Test] + public void GetChars_Reader_Closed () + { + //Console.WriteLine ("GetChars_Reader_Closed - first_executereader"); + cmd.CommandText = "SELECT type_blob FROM binary_family where id = 1"; + + using (IDataReader rdr = cmd.ExecuteReader ()) { + Assert.IsTrue (rdr.Read ()); + rdr.Close (); + + try { + rdr.GetChars (-1, 0, (char []) null, 0, 0); + Assert.Fail ("#A1"); + } catch (InvalidOperationException ex) { + // No data exists for the row/column + Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + } + } + + //Console.WriteLine ("GetChars_Reader_Closed - second_executereader"); + using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) { + Assert.IsTrue (rdr.Read ()); + rdr.Close (); + + try { + rdr.GetChars (-1, 0, (char []) null, 0, 0); + Assert.Fail ("#B1"); + } catch (InvalidOperationException ex) { + // No data exists for the row/column + Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + } + } + } + + [Test] + [Category("NotWorking")] + public void GetChars_Reader_NoData () + { + //Console.WriteLine ("GetChars_Reader_NoData - first_executereader"); + cmd.CommandText = "SELECT type_blob FROM binary_family where id = 666"; - // Primary Key Test - DataRow pkRow = schema.Select ("ColumnName = 'id'") [0]; - Assert.AreEqual (false, pkRow.IsNull ("IsKey"), "#2"); - Assert.AreEqual (true, (bool) pkRow ["IsKey"], "#3"); + using (IDataReader rdr = cmd.ExecuteReader ()) { + try { + rdr.GetChars (-1, 0, (char []) null, 0, 0); + Assert.Fail ("#A1"); + } catch (IndexOutOfRangeException ex) { + // No data exists for the row/column + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + } + + Assert.IsFalse (rdr.Read (), "#B"); + + try { + rdr.GetChars (-1, 0, (char []) null, 0, 0); + Assert.Fail ("#C1"); + } catch (IndexOutOfRangeException ex) { + // No data exists for the row/column + Assert.IsNull (ex.InnerException, "#C3"); + Assert.IsNotNull (ex.Message, "#C4"); + } + } + } + + [Test] + public void GetDataTypeName () + { + IDataReader reader = null; + + try { + cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'"; + reader = cmd.ExecuteReader (); + + switch (ConnectionManager.Instance.Sql.EngineConfig.Type) { + case EngineType.SQLServer: + Assert.AreEqual ("int", reader.GetDataTypeName (0), "#1"); + break; + case EngineType.MySQL: + Assert.AreEqual ("integer", reader.GetDataTypeName (0), "#1"); + break; + default: + Assert.Fail ("Engine type not supported."); + break; + } + Assert.AreEqual ("varchar", reader.GetDataTypeName (1), "#2"); + Assert.AreEqual ("varchar", reader.GetDataTypeName (2), "#3"); + Assert.AreEqual ("datetime", reader.GetDataTypeName (3), "#4"); + Assert.AreEqual ("datetime", reader.GetDataTypeName (4), "#5"); + Assert.AreEqual ("varchar", reader.GetDataTypeName (5), "#6"); } finally { - ConnectionManager.Singleton.CloseConnection (); + if (reader != null) + reader.Close (); } } - [Test] - public void GetNameTest () + public void GetDataTypeName_Index_Invalid () { - IDbConnection conn = ConnectionManager.Singleton.Connection; + IDataReader reader = null; + try { - ConnectionManager.Singleton.OpenConnection (); - IDbCommand dbcmd = conn.CreateCommand (); - string sql = "SELECT type_tinyint from numeric_family"; - dbcmd.CommandText = sql; - using (IDataReader reader = dbcmd.ExecuteReader ()) { - Assert.AreEqual ("type_tinyint", reader.GetName (0), "#1 GetName failes"); + cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'"; + reader = cmd.ExecuteReader (); + + try { + reader.GetDataTypeName (-1); + Assert.Fail ("#A1"); + } catch (IndexOutOfRangeException ex) { + // Index was outside the bounds of the array + Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + } + + try { + reader.GetDataTypeName (6); + Assert.Fail ("#B1"); + } catch (IndexOutOfRangeException ex) { + // Index was outside the bounds of the array + Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); } } finally { - ConnectionManager.Singleton.CloseConnection (); + if (reader != null) + reader.Close (); } } [Test] - public void NumericTest() + public void GetDataTypeName_Reader_Closed () { - IDbConnection conn = ConnectionManager.Singleton.Connection; + IDataReader reader = null; + try { - ConnectionManager.Singleton.OpenConnection (); - IDbCommand dbCommand = conn.CreateCommand (); - dbCommand.CommandText = "select type_numeric from numeric_family where id = 1;"; - using(IDataReader reader = dbCommand.ExecuteReader ()) { - if (reader.Read()) { - object value = reader.GetValue(0); - Assert.AreEqual (typeof (decimal), value.GetType(), "#1 wrong type"); - Assert.AreEqual ( (decimal) 1000, value, "#2 value is wrong"); - } else - Assert.Fail ("#3 does not have test data"); + cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'"; + reader = cmd.ExecuteReader (); + reader.Close (); + + try { + reader.GetDataTypeName (0); + Assert.Fail ("#1"); + } catch (InvalidOperationException ex) { + // No data exists for the row/column + Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); } } finally { - ConnectionManager.Singleton.CloseConnection (); + if (reader != null) + reader.Close (); } } [Test] - public void TinyIntTest () + public void GetFieldType () + { + IDataReader reader = null; + + try { + cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'"; + reader = cmd.ExecuteReader (); + Assert.AreEqual (typeof (int), reader.GetFieldType (0), "#1"); + Assert.AreEqual (typeof (string), reader.GetFieldType (2), "#2"); + Assert.AreEqual (typeof (DateTime), reader.GetFieldType (4), "#3"); + } finally { + if (reader != null) + reader.Close (); + } + } + + [Test] + public void GetFieldType_Index_Invalid () + { + IDataReader reader = null; + + try { + cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'"; + reader = cmd.ExecuteReader (); + try { + reader.GetFieldType (-1); + Assert.Fail ("#A1"); + } catch (IndexOutOfRangeException ex) { + // Index was outside the bounds of the array + Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + } + + try { + reader.GetFieldType (6); + Assert.Fail ("#B1"); + } catch (IndexOutOfRangeException ex) { + // Index was outside the bounds of the array + Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + } + } finally { + if (reader != null) + reader.Close (); + } + } + + [Test] + public void GetFieldType_Reader_Closed () { - IDbConnection conn = ConnectionManager.Singleton.Connection; + IDataReader reader = null; + try { - ConnectionManager.Singleton.OpenConnection (); - IDbCommand dbCommand = conn.CreateCommand (); - dbCommand.CommandText = "select type_tinyint from numeric_family where id = 1;"; - using(IDataReader reader = dbCommand.ExecuteReader ()) { - if (reader.Read()) { - object value = reader.GetValue (0); - Assert.AreEqual (typeof (byte), value.GetType(), "#1 wrong type"); - Assert.AreEqual (255, value, "#2 value is wrong"); - } else - Assert.Fail ("#3 does not have test data"); + cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'"; + reader = cmd.ExecuteReader (); + reader.Close (); + try { + reader.GetFieldType (0); + Assert.Fail ("#1"); + } catch (InvalidOperationException ex) { + // No data exists for the row/column + Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); } } finally { - ConnectionManager.Singleton.CloseConnection (); + if (reader != null) + reader.Close (); } } - + [Test] - public void GetByteTest () + public void GetName () + { + IDataReader reader = null; + + try { + cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'"; + reader = cmd.ExecuteReader (); + Assert.AreEqual ("id", reader.GetName (0), "#1"); + Assert.AreEqual ("fname", reader.GetName (1), "#2"); + Assert.AreEqual ("lname", reader.GetName (2), "#3"); + Assert.AreEqual ("dob", reader.GetName (3), "#4"); + Assert.AreEqual ("doj", reader.GetName (4), "#5"); + Assert.AreEqual ("email", reader.GetName (5), "#6"); + } finally { + if (reader != null) + reader.Close (); + } + } + + [Test] + public void GetName_Index_Invalid () { - IDbConnection conn = ConnectionManager.Singleton.Connection; + IDataReader reader = null; + try { - ConnectionManager.Singleton.OpenConnection (); - IDbCommand cmd = conn.CreateCommand (); - string query = "select type_tinyint from numeric_family where id = 1"; - cmd.CommandText = query; - using (IDataReader reader = cmd.ExecuteReader ()) { - if (reader.Read ()) { - byte b = reader.GetByte (0); - Assert.AreEqual (255, b, "GetByte returns wrong result"); - } else // This should not happen while testing - Assert.Fail ("test table does not have a test data!"); + cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'"; + reader = cmd.ExecuteReader (); + try { + reader.GetName (-1); + Assert.Fail ("#A1"); + } catch (IndexOutOfRangeException ex) { + // Index was outside the bounds of the array + Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + } + + try { + reader.GetName (6); + Assert.Fail ("#B1"); + } catch (IndexOutOfRangeException ex) { + // Index was outside the bounds of the array + Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); } } finally { - ConnectionManager.Singleton.CloseConnection (); - } + if (reader != null) + reader.Close (); + } } [Test] - public void GetValueBinaryTest () + public void GetName_Reader_Closed () { - IDbConnection conn = ConnectionManager.Singleton.Connection; + IDataReader reader = null; + try { - ConnectionManager.Singleton.OpenConnection (); - IDbCommand cmd = conn.CreateCommand (); - string sql = "select type_binary from binary_family where id = 1"; - cmd.CommandText = sql; - using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) { - if (reader.Read ()) { - object ob = reader.GetValue (0); - Assert.AreEqual (typeof (byte []), ob.GetType (), "#1 Type of binary column is wrong!"); - } else - Assert.Fail ("#2 test data not available"); + cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'"; + reader = cmd.ExecuteReader (); + reader.Close (); + try { + reader.GetName (0); + Assert.Fail ("#1"); + } catch (InvalidOperationException ex) { + // No data exists for the row/column + Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); } } finally { - ConnectionManager.Singleton.CloseConnection (); - } + if (reader != null) + reader.Close (); + } } - + [Test] - public void GetBytesNullBufferTest () + public void GetOrdinal () { - IDbConnection conn = ConnectionManager.Singleton.Connection; + IDataReader reader = null; + + try { + cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'"; + reader = cmd.ExecuteReader (); + Assert.AreEqual (0, reader.GetOrdinal ("id"), "#1"); + Assert.AreEqual (1, reader.GetOrdinal ("fname"), "#2"); + Assert.AreEqual (2, reader.GetOrdinal ("lname"), "#3"); + Assert.AreEqual (3, reader.GetOrdinal ("doB"), "#4"); + Assert.AreEqual (4, reader.GetOrdinal ("doj"), "#5"); + Assert.AreEqual (5, reader.GetOrdinal ("EmaiL"), "#6"); + Assert.AreEqual (0, reader.GetOrdinal ("iD"), "#7"); + Assert.AreEqual (5, reader.GetOrdinal ("eMail"), "#8"); + } finally { + if (reader != null) + reader.Close (); + } + } + + [Test] + public void GetOrdinal_Name_NotFound () + { + IDataReader reader = null; + try { - ConnectionManager.Singleton.OpenConnection (); - IDbCommand cmd = conn.CreateCommand (); - // 4th row is null - string sql = "SELECT type_blob FROM binary_family where id = 1 or id = 4 order by id"; - cmd.CommandText = sql; - using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) { - if (reader.Read ()) { - Assert.AreEqual (8, reader.GetBytes (0, 0, null, 0, 0), - "#1 getbytes should return length of column"); - } else - Assert.Fail ("#2 No test data"); - // for null value, length in bytes should return 0 - if (reader.Read ()) - Assert.AreEqual (0, reader.GetBytes (0, 0, null, 0, 0), - "#3 on null value, it should return -1"); - else - Assert.Fail ("#4 No test data"); + cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'"; + reader = cmd.ExecuteReader (); + try { + reader.GetOrdinal ("non_existing_column"); + Assert.Fail ("#A1"); + } catch (IndexOutOfRangeException ex) { + // Index was outside the bounds of the array + Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + } + + try { + reader.GetOrdinal (string.Empty); + Assert.Fail ("#B1"); + } catch (IndexOutOfRangeException ex) { + // Index was outside the bounds of the array + Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); } } finally { - ConnectionManager.Singleton.CloseConnection (); + if (reader != null) + reader.Close (); } } [Test] - public void GetBytesTest () + public void GetOrdinal_Name_Null () { - IDbConnection conn = ConnectionManager.Singleton.Connection; + IDataReader reader = null; + try { - ConnectionManager.Singleton.OpenConnection (); - IDbCommand cmd = conn.CreateCommand (); - string sql = "SELECT type_blob FROM binary_family where id = 1"; - cmd.CommandText = sql; - using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) { - if (reader.Read ()) { - // Get By Parts for the column blob - long totalsize = reader.GetBytes (0, 0, null, 0, 0); - int buffsize = 5; - int start = 0; - int offset = 0; - long ret = 0; - long count = 0; - byte [] val = new byte [totalsize]; - do { - ret = reader.GetBytes (0, offset, val, offset, buffsize); - offset += (int) ret; - count += ret; - } while (count < totalsize); - Assert.AreEqual (8, count, - "#1 The assembled value length does not match"); - } else - Assert.Fail ("#2 no test data"); + cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'"; + reader = cmd.ExecuteReader (); + try { + reader.GetOrdinal (null); + Assert.Fail ("#1"); + } catch (ArgumentNullException ex) { + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("fieldName", ex.ParamName, "#5"); } } finally { - ConnectionManager.Singleton.CloseConnection (); + if (reader != null) + reader.Close (); } } [Test] - public void GetSchemaTableTest_AutoIncrement () + public void GetOrdinal_Reader_Closed () + { + cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'"; + + using (IDataReader rdr = cmd.ExecuteReader ()) { + rdr.Close (); + + try { + rdr.GetOrdinal (null); + Assert.Fail ("#A1"); + } catch (InvalidOperationException ex) { + // No data exists for the row/column + Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + } + } + } + + [Test] + public void GetOrdinal_Reader_NoData () + { + cmd.CommandText = "SELECT * FROM employee WHERE id = 666"; + + using (IDataReader rdr = cmd.ExecuteReader ()) { + Assert.AreEqual (0, rdr.GetOrdinal ("id"), "#A1"); + Assert.AreEqual (5, rdr.GetOrdinal ("eMail"), "#A2"); + + Assert.IsFalse (rdr.Read (), "#B"); + + Assert.AreEqual (2, rdr.GetOrdinal ("lname"), "#C1"); + Assert.AreEqual (3, rdr.GetOrdinal ("dob"), "#C2"); + } + } + + [Test] + public void GetSchemaTable_Command_Disposed () { - IDbConnection conn = ConnectionManager.Singleton.Connection; + if (RunningOnMono && (conn is OdbcConnection)) + Assert.Ignore ("Our statement handle is closed when we dispose the (Odbc)Command"); + + IDataReader reader = null; + try { - ConnectionManager.Singleton.OpenConnection (); - IDbCommand cmd = conn.CreateCommand (); - cmd.CommandText = "create table #tmp_table (id int identity(1,1))"; - cmd.ExecuteNonQuery (); - cmd.CommandText = "select * from #tmp_table"; - using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly)) { - DataTable schemaTable = reader.GetSchemaTable (); - Assert.IsTrue ((bool)schemaTable.Rows [0]["IsAutoIncrement"], "#1"); - if (schemaTable.Columns.Contains ("IsIdentity")) - Assert.IsTrue ((bool)schemaTable.Rows [0]["IsIdentity"], "#2"); + cmd.CommandText = "select id, fname, id + 20 as plustwenty from employee"; + reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly); + cmd.Dispose (); + DataTable schema = reader.GetSchemaTable (); + Assert.AreEqual (3, schema.Rows.Count, "RowCount"); + } finally { + if (reader != null) + reader.Close (); + } + } + + [Test] + public void GetSchemaTable_Reader_Closed () + { + IDataReader reader = null; + + try { + cmd.CommandText = "select id, fname, id + 20 as plustwenty from employee"; + reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo); + reader.Close (); + + try { + reader.GetSchemaTable (); + Assert.Fail ("#1"); + } catch (InvalidOperationException ex) { + // Invalid attempt to call GetSchemaTable + // when reader is closed + Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + } + } finally { + if (reader != null) + reader.Close (); + } + } + + [Test] + public void GetNameTest () + { + cmd.CommandText = "SELECT type_tinyint from numeric_family"; ; + using (IDataReader reader = cmd.ExecuteReader ()) { + Assert.AreEqual ("type_tinyint", reader.GetName (0), "#1"); + } + } + + [Test] // this [Int32] + public void Indexer1 () + { + IDataReader reader = null; + + try { + cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'"; + reader = cmd.ExecuteReader (); + Assert.IsTrue (reader.Read ()); + Assert.AreEqual (1, reader [0], "#0"); + Assert.AreEqual ("suresh", reader [1], "#1"); + Assert.AreEqual ("kumar", reader [2], "#2"); + Assert.AreEqual (new DateTime (1978, 8, 22), reader [3], "#3"); + Assert.AreEqual (new DateTime (2001, 3, 12), reader [4], "#4"); + Assert.AreEqual ("suresh@gmail.com", reader [5], "#5"); + } finally { + if (reader != null) + reader.Close (); + } + } + + [Test] // this [Int32] + public void Indexer1_Reader_Closed () + { + IDataReader reader = null; + + try { + cmd.CommandText = "select fname from employee"; + reader = cmd.ExecuteReader (); + reader.Read (); + reader.Close (); + + try { + object value = reader [0]; + Assert.Fail ("#A1:" + value); + } catch (InvalidOperationException ex) { + // No data exists for the row/column + Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + } + + reader = cmd.ExecuteReader (); + reader.Close (); + + try { + object value = reader [0]; + Assert.Fail ("#B1:" + value); + } catch (InvalidOperationException ex) { + // No data exists for the row/column + Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + } + } finally { + if (reader != null) + reader.Close (); + } + } + + [Test] // this [Int32] + public void Indexer1_Reader_NoData () + { + IDataReader reader = null; + + try { + cmd.CommandText = "select fname from employee WHERE lname='kumar'"; + reader = cmd.ExecuteReader (); + try { + object value = reader [0]; + Assert.Fail ("#A1:" + value); + } catch (InvalidOperationException ex) { + // No data exists for the row/column + Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + } + + Assert.IsTrue (reader.Read ()); + Assert.IsFalse (reader.Read ()); + + try { + object value = reader [0]; + Assert.Fail ("#B1:" + value); + } catch (InvalidOperationException ex) { + // No data exists for the row/column + Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + } + } finally { + if (reader != null) + reader.Close (); + } + } + + [Test] // this [Int32] + public void Indexer1_Value_Invalid () + { + IDataReader reader = null; + + try { + cmd.CommandText = "select fname from employee"; + reader = cmd.ExecuteReader (); + Assert.IsTrue (reader.Read ()); + try { + object value = reader [-1]; + Assert.Fail ("#A1:" + value); + } catch (IndexOutOfRangeException ex) { + // Index was outside the bounds of the array + Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + } + + try { + object value = reader [1]; + Assert.Fail ("#B1:" + value); + } catch (IndexOutOfRangeException ex) { + // Index was outside the bounds of the array + Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + } + } finally { + if (reader != null) + reader.Close (); + } + } + + [Test] // this [String] + public void Indexer2 () + { + IDataReader reader = null; + + try { + cmd.CommandText = "SELECT * FROM employee WHERE lname='kumar'"; + reader = cmd.ExecuteReader (); + Assert.IsTrue (reader.Read ()); + Assert.AreEqual (1, reader ["id"], "id"); + Assert.AreEqual ("suresh", reader ["fname"], "fname"); + Assert.AreEqual ("kumar", reader ["lname"], "lname"); + Assert.AreEqual (new DateTime (1978, 8, 22), reader ["doB"], "doB"); + Assert.AreEqual (new DateTime (2001, 3, 12), reader ["doj"], "doj"); + Assert.AreEqual ("suresh@gmail.com", reader ["EmaiL"], "EmaiL"); + Assert.AreEqual (1, reader ["iD"], "iD"); + Assert.AreEqual ("suresh@gmail.com", reader ["eMail"], "eMail"); + } finally { + if (reader != null) + reader.Close (); + } + } + + [Test] // this [String] + public void Indexer2_Reader_Closed () + { + IDataReader reader = null; + + try { + cmd.CommandText = "select fname from employee"; + reader = cmd.ExecuteReader (); + reader.Read (); + reader.Close (); + + try { + object value = reader ["fname"]; + Assert.Fail ("#A1:" + value); + } catch (InvalidOperationException ex) { + // No data exists for the row/column + Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + } + + reader = cmd.ExecuteReader (); + reader.Close (); + + try { + object value = reader ["fname"]; + Assert.Fail ("#B1:" + value); + } catch (InvalidOperationException ex) { + // No data exists for the row/column + Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + } + } finally { + if (reader != null) + reader.Close (); + } + } + + [Test] // this [String] + public void Indexer2_Reader_NoData () + { + IDataReader reader = null; + + try { + cmd.CommandText = "select fname from employee WHERE lname='kumar'"; + reader = cmd.ExecuteReader (); + + try { + object value = reader ["fname"]; + Assert.Fail ("#A1:" + value); + } catch (InvalidOperationException ex) { + // No data exists for the row/column + Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + } + + Assert.IsTrue (reader.Read ()); + Assert.IsFalse (reader.Read ()); + + try { + object value = reader ["fname"]; + Assert.Fail ("#B1:" + value); + } catch (InvalidOperationException ex) { + // No data exists for the row/column + Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); } } finally { - ConnectionManager.Singleton.CloseConnection (); + if (reader != null) + reader.Close (); + } + } + + [Test] // this [String] + public void Indexer2_Value_NotFound () + { + IDataReader reader = null; + + try { + cmd.CommandText = "select fname from employee"; + reader = cmd.ExecuteReader (); + Assert.IsTrue (reader.Read ()); + try { + object value = reader ["address"]; + Assert.Fail ("#A1:" + value); + } catch (IndexOutOfRangeException ex) { + // Index was outside the bounds of the array + Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + } + + try { + object value = reader [string.Empty]; + Assert.Fail ("#B1:" + value); + } catch (IndexOutOfRangeException ex) { + // Index was outside the bounds of the array + Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + } + } finally { + if (reader != null) + reader.Close (); + } + } + + [Test] // this [String] + public void Indexer2_Value_Null () + { + IDataReader reader = null; + + try { + cmd.CommandText = "select fname from employee"; + reader = cmd.ExecuteReader (); + try { + object value = reader [(string) null]; + Assert.Fail ("#1:" + value); + } catch (ArgumentNullException ex) { + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("fieldName", ex.ParamName, "#5"); + } + } finally { + if (reader != null) + reader.Close (); + } + } + + [Test] + public void IsClosed_Command_Disposed () + { + IDataReader reader = null; + + try { + cmd.CommandText = "select id, fname, id + 20 as plustwenty from employee"; + reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo); + Assert.IsFalse (reader.IsClosed, "#1"); + cmd.Dispose (); + Assert.IsFalse (reader.IsClosed, "#2"); + } finally { + if (reader != null) + reader.Close (); + } + } + + [Test] + public void IsClosed_Connection_Closed () + { + if (RunningOnMono) + Assert.Ignore ("We do not mark the corresponding Reader closed when we close a Connection."); + + IDataReader reader = null; + + try { + cmd.CommandText = "select id, fname, id + 20 as plustwenty from employee"; + reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo); + Assert.IsFalse (reader.IsClosed, "#1"); + ConnectionManager.Instance.Sql.CloseConnection (); + Assert.IsTrue (reader.IsClosed, "#2"); + } finally { + if (reader != null) + reader.Close (); + } + } + + [Test] + public void IsClosed_Reader_Closed () + { + IDataReader reader = null; + + try { + cmd.CommandText = "select id, fname, id + 20 as plustwenty from employee"; + reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo); + Assert.IsFalse (reader.IsClosed, "#1"); + reader.Close (); + Assert.IsTrue (reader.IsClosed, "#2"); + } finally { + if (reader != null) + reader.Close (); + } + } + + [Test] + public void NumericTest() + { + cmd.CommandText = "select type_numeric1 from numeric_family where id = 1;"; + + using (IDataReader reader = cmd.ExecuteReader ()) { + Assert.IsTrue (reader.Read(), "#1"); + object value = reader.GetValue (0); + Assert.AreEqual (typeof (decimal), value.GetType (), "#2"); + Assert.AreEqual (1000m, value, "#3"); + } + } + + [Test] + public void TinyIntTest () + { + cmd.CommandText = "select type_tinyint from numeric_family where id = 1;"; + using (IDataReader reader = cmd.ExecuteReader ()) { + Assert.IsTrue (reader.Read (), "#1"); + object value = reader.GetValue (0); + Assert.AreEqual (typeof (byte), value.GetType (), "#2"); + Assert.AreEqual (255, value, "#3"); + } + } + + [Test] + public void GetByteTest () + { + cmd.CommandText = "select type_tinyint from numeric_family where id = 1"; + using (IDataReader reader = cmd.ExecuteReader ()) { + Assert.IsTrue (reader.Read (), "#1"); + byte b = reader.GetByte (0); + Assert.AreEqual (255, b, "#2"); + } + } + + [Test] + public void GetValue_Reader_Closed () + { + //Console.WriteLine ("GetValue_Reader_Closed - first_executereader"); + cmd.CommandText = "SELECT type_blob FROM binary_family where id = 1"; + + using (IDataReader reader = cmd.ExecuteReader ()) { + Assert.IsTrue (reader.Read ()); + reader.Close (); + + try { + reader.GetValue (-1); + Assert.Fail ("#1"); + } catch (InvalidOperationException ex) { + // No data exists for the row/column + Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + } + } + } + + [Test] + public void GetValue_Reader_NoData () + { + //Console.WriteLine ("GetValue_Reader_NoData - first_executereader"); + cmd.CommandText = "SELECT type_blob FROM binary_family where id = 666"; + + using (IDataReader rdr = cmd.ExecuteReader ()) { + try { + rdr.GetValue (-1); + Assert.Fail ("#A1"); + } catch (InvalidOperationException ex) { + // No data exists for the row/column + Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + } + + Assert.IsFalse (rdr.Read (), "#B"); + + try { + rdr.GetValue (-1); + Assert.Fail ("#C1"); + } catch (InvalidOperationException ex) { + // No data exists for the row/column + Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2"); + Assert.IsNull (ex.InnerException, "#C3"); + Assert.IsNotNull (ex.Message, "#C4"); + } + } + } + + [Test] + public void GetValue_Type_Binary () + { + object value; + object expected; + + cmd.CommandText = "select type_binary from binary_family order by id asc"; + using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) { + expected = new byte [] { 0x35, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00 }; + + Assert.IsTrue (rdr.Read (), "#A1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#A2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#A3"); + Assert.AreEqual (expected, value, "#A4"); + Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#A5"); + + expected = new byte [] { 0x00, 0x33, 0x34, 0x00, + 0x33, 0x30, 0x35, 0x31 }; + + Assert.IsTrue (rdr.Read (), "#B1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#B2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#B3"); + Assert.AreEqual (expected, value, "#B4"); + Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#B5"); + + expected = new byte [8]; + + Assert.IsTrue (rdr.Read (), "#C1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#C2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#C3"); + Assert.AreEqual (expected, value, "#C4"); + Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#C5"); + + expected = DBNull.Value; + + Assert.IsTrue (rdr.Read (), "#D1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#D2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#D3"); + Assert.AreEqual (DBNull.Value, value, "#D4"); + Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#D5"); + } + + using (IDataReader rdr = cmd.ExecuteReader ()) { + expected = new byte [] { 0x35, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00 }; + + Assert.IsTrue (rdr.Read (), "#E1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#E2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#E3"); + Assert.AreEqual (expected, value, "#E4"); + Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#E5"); + + expected = new byte [] { 0x00, 0x33, 0x34, 0x00, + 0x33, 0x30, 0x35, 0x31 }; + + Assert.IsTrue (rdr.Read (), "#F1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#F2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#F3"); + Assert.AreEqual (expected, value, "#F4"); + Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#F5"); + + expected = new byte [8]; + + Assert.IsTrue (rdr.Read (), "#G1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#G2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#G3"); + Assert.AreEqual (expected, value, "#G4"); + Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#G5"); + + expected = DBNull.Value; + + Assert.IsTrue (rdr.Read (), "#H1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#H2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#H3"); + Assert.AreEqual (expected, value, "#H4"); + Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#H5"); + } + } + + [Test] + public void GetValue_Type_Image () + { + object value; + object expected; + + //Console.WriteLine ("GetValue_Type_Image - first_executereader"); + cmd.CommandText = "select type_blob from binary_family order by id asc"; + using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) { + expected = new byte [] { 0x32, 0x56, 0x00, + 0x44, 0x22 }; + + Assert.IsTrue (rdr.Read (), "#A1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#A2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#A3"); + Assert.AreEqual (expected, value, "#A4"); + Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#A5"); + + expected = long_bytes; + + Assert.IsTrue (rdr.Read (), "#B1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#B2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#B3"); + Assert.AreEqual (expected, value, "#B4"); + Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#B5"); + + expected = new byte [0]; + + Assert.IsTrue (rdr.Read (), "#C1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#C2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#C3"); + Assert.AreEqual (expected, value, "#C4"); + Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#C5"); + + expected = DBNull.Value; + + Assert.IsTrue (rdr.Read (), "#D1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#D2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#D3"); + Assert.AreEqual (DBNull.Value, value, "#D4"); + Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#D5"); + } + + //Console.WriteLine ("GetChars_Reader_Closed - second_executereader"); + using (IDataReader rdr = cmd.ExecuteReader ()) { + expected = new byte [] { 0x32, 0x56, 0x00, + 0x44, 0x22 }; + + Assert.IsTrue (rdr.Read (), "#E1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#E2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#E3"); + Assert.AreEqual (expected, value, "#E4"); + Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#E5"); + + expected = long_bytes; + + Assert.IsTrue (rdr.Read (), "#F1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#F2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#F3"); + Assert.AreEqual (expected, value, "#F4"); + Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#F5"); + + expected = new byte [0]; + + Assert.IsTrue (rdr.Read (), "#G1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#G2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#G3"); + Assert.AreEqual (expected, value, "#G4"); + Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#G5"); + + expected = DBNull.Value; + + Assert.IsTrue (rdr.Read (), "#H1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#H2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#H3"); + Assert.AreEqual (expected, value, "#H4"); + Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#H5"); + } + } + + [Test] + public void GetValue_Type_Integer () + { + object value; + object expected; + + cmd.CommandText = "select type_int from numeric_family order by id asc"; + using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) { + expected = int.MaxValue; + + Assert.IsTrue (rdr.Read (), "#A1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#A2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#A3"); + Assert.AreEqual (expected, value, "#A4"); + Assert.AreEqual (typeof (int), rdr.GetFieldType (0), "#A5"); + + expected = int.MinValue; + + Assert.IsTrue (rdr.Read (), "#B1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#B2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#B3"); + Assert.AreEqual (expected, value, "#B4"); + Assert.AreEqual (typeof (int), rdr.GetFieldType (0), "#B5"); + + expected = 0; + + Assert.IsTrue (rdr.Read (), "#C1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#C2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#C3"); + Assert.AreEqual (expected, value, "#C4"); + Assert.AreEqual (typeof (int), rdr.GetFieldType (0), "#C5"); + + expected = DBNull.Value; + + Assert.IsTrue (rdr.Read (), "#D1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#D2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#D3"); + Assert.AreEqual (DBNull.Value, value, "#D4"); + Assert.AreEqual (typeof (int), rdr.GetFieldType (0), "#D5"); + } + + using (IDataReader rdr = cmd.ExecuteReader ()) { + expected = int.MaxValue; + + Assert.IsTrue (rdr.Read (), "#E1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#E2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#E3"); + Assert.AreEqual (expected, value, "#E4"); + Assert.AreEqual (typeof (int), rdr.GetFieldType (0), "#E5"); + + expected = int.MinValue; + + Assert.IsTrue (rdr.Read (), "#F1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#F2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#F3"); + Assert.AreEqual (expected, value, "#F4"); + Assert.AreEqual (typeof (int), rdr.GetFieldType (0), "#F5"); + + expected = 0; + + Assert.IsTrue (rdr.Read (), "#G1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#G2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#G3"); + Assert.AreEqual (expected, value, "#G4"); + Assert.AreEqual (typeof (int), rdr.GetFieldType (0), "#G5"); + + expected = DBNull.Value; + + Assert.IsTrue (rdr.Read (), "#H1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#H2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#H3"); + Assert.AreEqual (expected, value, "#H4"); + Assert.AreEqual (typeof (int), rdr.GetFieldType (0), "#H5"); + } + } + + [Test] + public void GetValue_Type_NText () + { + object value; + object expected; + + cmd.CommandText = "select type_ntext from string_family order by id asc"; + using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) { + expected = "nt\u092d\u093ext"; + + Assert.IsTrue (rdr.Read (), "#A1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#A2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#A3"); + Assert.AreEqual (expected, value, "#A4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#A5"); + + expected = "nt\u092d\u093ext "; + + Assert.IsTrue (rdr.Read (), "#B1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#B2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#B3"); + Assert.AreEqual (expected, value, "#B4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#B5"); + + expected = string.Empty; + + Assert.IsTrue (rdr.Read (), "#C1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#C2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#C3"); + Assert.AreEqual (expected, value, "#C4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#C5"); + + expected = DBNull.Value; + + Assert.IsTrue (rdr.Read (), "#D1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#D2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#D3"); + Assert.AreEqual (expected, value, "#D4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#D5"); + } + + using (IDataReader rdr = cmd.ExecuteReader ()) { + expected = "nt\u092d\u093ext"; + + Assert.IsTrue (rdr.Read (), "#E1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#E2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#E3"); + Assert.AreEqual (expected, value, "#E4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#E5"); + + expected = "nt\u092d\u093ext "; + + Assert.IsTrue (rdr.Read (), "#F1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#F2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#F3"); + Assert.AreEqual (expected, value, "#F4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#F5"); + + expected = string.Empty; + + Assert.IsTrue (rdr.Read (), "#G1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#G2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#G3"); + Assert.AreEqual (expected, value, "#G4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#G5"); + + expected = DBNull.Value; + + Assert.IsTrue (rdr.Read (), "#H1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#H2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#H3"); + Assert.AreEqual (expected, value, "#H4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#H5"); + } + } + + [Test] + public void GetValue_Type_NVarChar () + { + object value; + object expected; + + cmd.CommandText = "select type_nvarchar from string_family order by id asc"; + using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) { + expected = "nv\u092d\u093e\u0930\u0924r"; + + Assert.IsTrue (rdr.Read (), "#A1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#A2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#A3"); + Assert.AreEqual (expected, value, "#A4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#A5"); + + expected = "nv\u092d\u093e\u0930\u0924r "; + + Assert.IsTrue (rdr.Read (), "#B1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#B2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#B3"); + Assert.AreEqual (expected, value, "#B4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#B5"); + + expected = string.Empty; + + Assert.IsTrue (rdr.Read (), "#C1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#C2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#C3"); + Assert.AreEqual (expected, value, "#C4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#C5"); + + expected = DBNull.Value; + + Assert.IsTrue (rdr.Read (), "#D1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#D2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#D3"); + Assert.AreEqual (expected, value, "#D4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#D5"); + } + + using (IDataReader rdr = cmd.ExecuteReader ()) { + expected = "nv\u092d\u093e\u0930\u0924r"; + + Assert.IsTrue (rdr.Read (), "#E1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#E2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#E3"); + Assert.AreEqual (expected, value, "#E4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#E5"); + + expected = "nv\u092d\u093e\u0930\u0924r "; + + Assert.IsTrue (rdr.Read (), "#F1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#F2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#F3"); + Assert.AreEqual (expected, value, "#F4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#F5"); + + expected = string.Empty; + + Assert.IsTrue (rdr.Read (), "#G1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#G2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#G3"); + Assert.AreEqual (expected, value, "#G4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#G5"); + + expected = DBNull.Value; + + Assert.IsTrue (rdr.Read (), "#H1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#H2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#H3"); + Assert.AreEqual (expected, value, "#H4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#H5"); + } + } + + [Test] + public void GetValue_Type_Real () + { + object value; + object expected; + + cmd.CommandText = "select type_float from numeric_family order by id asc"; + using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) { + expected = 3.40E+38F; + + Assert.IsTrue (rdr.Read (), "#A1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#A2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#A3"); + Assert.AreEqual (expected, value, "#A4"); + Assert.AreEqual (typeof (float), rdr.GetFieldType (0), "#A5"); + + expected = -3.40E+38F; + + Assert.IsTrue (rdr.Read (), "#B1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#B2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#B3"); + Assert.AreEqual (expected, value, "#B4"); + Assert.AreEqual (typeof (float), rdr.GetFieldType (0), "#B5"); + + expected = 0F; + + Assert.IsTrue (rdr.Read (), "#C1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#C2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#C3"); + Assert.AreEqual (expected, value, "#C4"); + Assert.AreEqual (typeof (float), rdr.GetFieldType (0), "#C5"); + + expected = DBNull.Value; + + Assert.IsTrue (rdr.Read (), "#D1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#D2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#D3"); + Assert.AreEqual (expected, value, "#D4"); + Assert.AreEqual (typeof (float), rdr.GetFieldType (0), "#D5"); + } + + using (IDataReader rdr = cmd.ExecuteReader ()) { + expected = 3.40E+38F; + + Assert.IsTrue (rdr.Read (), "#E1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#E2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#E3"); + Assert.AreEqual (expected, value, "#E4"); + Assert.AreEqual (typeof (float), rdr.GetFieldType (0), "#E5"); + + expected = -3.40E+38F; + + Assert.IsTrue (rdr.Read (), "#F1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#F2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#F3"); + Assert.AreEqual (expected, value, "#F4"); + Assert.AreEqual (typeof (float), rdr.GetFieldType (0), "#F5"); + + expected = 0F; + + Assert.IsTrue (rdr.Read (), "#G1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#G2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#G3"); + Assert.AreEqual (expected, value, "#G4"); + Assert.AreEqual (typeof (float), rdr.GetFieldType (0), "#G5"); + + expected = DBNull.Value; + + Assert.IsTrue (rdr.Read (), "#H1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#H2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#H3"); + Assert.AreEqual (expected, value, "#H4"); + Assert.AreEqual (typeof (float), rdr.GetFieldType (0), "#H5"); + } + } + + [Test] + public void GetValue_Type_SmallDateTime () + { + object value; + object expected; + + cmd.CommandText = "select type_smalldatetime from datetime_family order by id asc"; + using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) { + expected = DateTime.Parse ("2037-12-31 23:59:00"); + + Assert.IsTrue (rdr.Read (), "#A1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#A2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#A3"); + Assert.AreEqual (expected, value, "#A4"); + Assert.AreEqual (typeof (DateTime), rdr.GetFieldType (0), "#A5"); + + expected = DBNull.Value; + + Assert.IsTrue (rdr.Read (), "#B1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#B2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#B3"); + Assert.AreEqual (expected, value, "#B4"); + Assert.AreEqual (typeof (DateTime), rdr.GetFieldType (0), "#B5"); + } + + using (IDataReader rdr = cmd.ExecuteReader ()) { + expected = DateTime.Parse ("2037-12-31 23:59:00"); + + Assert.IsTrue (rdr.Read (), "#C1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#C2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#C3"); + Assert.AreEqual (expected, value, "#C4"); + Assert.AreEqual (typeof (DateTime), rdr.GetFieldType (0), "#C5"); + + expected = DBNull.Value; + + Assert.IsTrue (rdr.Read (), "#D1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#D2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#D3"); + Assert.AreEqual (expected, value, "#D4"); + Assert.AreEqual (typeof (DateTime), rdr.GetFieldType (0), "#D5"); + } + } + + [Test] + public void GetValue_Type_SmallInt () + { + object value; + object expected; + + cmd.CommandText = "select type_smallint from numeric_family order by id asc"; + using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) { + expected = short.MaxValue; + + Assert.IsTrue (rdr.Read (), "#A1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#A2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#A3"); + Assert.AreEqual (expected, value, "#A4"); + Assert.AreEqual (typeof (short), rdr.GetFieldType (0), "#A5"); + + expected = short.MinValue; + + Assert.IsTrue (rdr.Read (), "#B1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#B2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#B3"); + Assert.AreEqual (expected, value, "#B4"); + Assert.AreEqual (typeof (short), rdr.GetFieldType (0), "#B5"); + + expected = (short) 0; + + Assert.IsTrue (rdr.Read (), "#C1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#C2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#C3"); + Assert.AreEqual (expected, value, "#C4"); + Assert.AreEqual (typeof (short), rdr.GetFieldType (0), "#C5"); + + expected = DBNull.Value; + + Assert.IsTrue (rdr.Read (), "#D1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#D2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#D3"); + Assert.AreEqual (expected, value, "#D4"); + Assert.AreEqual (typeof (short), rdr.GetFieldType (0), "#D5"); + } + + using (IDataReader rdr = cmd.ExecuteReader ()) { + expected = short.MaxValue; + + Assert.IsTrue (rdr.Read (), "#E1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#E2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#E3"); + Assert.AreEqual (expected, value, "#E4"); + Assert.AreEqual (typeof (short), rdr.GetFieldType (0), "#E5"); + + expected = short.MinValue; + + Assert.IsTrue (rdr.Read (), "#F1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#F2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#F3"); + Assert.AreEqual (expected, value, "#F4"); + Assert.AreEqual (typeof (short), rdr.GetFieldType (0), "#F5"); + + expected = (short) 0; + + Assert.IsTrue (rdr.Read (), "#G1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#G2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#G3"); + Assert.AreEqual (expected, value, "#G4"); + Assert.AreEqual (typeof (short), rdr.GetFieldType (0), "#G5"); + + expected = DBNull.Value; + + Assert.IsTrue (rdr.Read (), "#H1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#H2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#H3"); + Assert.AreEqual (expected, value, "#H4"); + Assert.AreEqual (typeof (short), rdr.GetFieldType (0), "#H5"); + } + } + + [Test] + public void GetValue_Type_Text () + { + object value; + object expected; + + cmd.CommandText = "select type_text from string_family order by id asc"; + using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) { + expected = "text"; + + Assert.IsTrue (rdr.Read (), "#A1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#A2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#A3"); + Assert.AreEqual (expected, value, "#A4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#A5"); + + StringBuilder sb = new StringBuilder (); + for (int i = 0; i < 30; i++) + sb.Append ("longtext "); + expected = sb.ToString (); + + Assert.IsTrue (rdr.Read (), "#B1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#B2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#B3"); + Assert.AreEqual (expected, value, "#B4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#B5"); + + expected = string.Empty; + + Assert.IsTrue (rdr.Read (), "#C1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#C2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#C3"); + Assert.AreEqual (expected, value, "#C4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#C5"); + + expected = DBNull.Value; + + Assert.IsTrue (rdr.Read (), "#D1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#D2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#D3"); + Assert.AreEqual (expected, value, "#D4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#D5"); + } + + using (IDataReader rdr = cmd.ExecuteReader ()) { + expected = "text"; + + Assert.IsTrue (rdr.Read (), "#E1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#E2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#E3"); + Assert.AreEqual (expected, value, "#E4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#E5"); + + StringBuilder sb = new StringBuilder (); + for (int i = 0; i < 30; i++) + sb.Append ("longtext "); + expected = sb.ToString (); + + Assert.IsTrue (rdr.Read (), "#F1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#F2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#F3"); + Assert.AreEqual (expected, value, "#F4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#F5"); + + expected = string.Empty; + + Assert.IsTrue (rdr.Read (), "#G1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#G2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#G3"); + Assert.AreEqual (expected, value, "#G4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#G5"); + + expected = DBNull.Value; + + Assert.IsTrue (rdr.Read (), "#H1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#H2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#H3"); + Assert.AreEqual (expected, value, "#H4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#H5"); + } + } + + [Test] + public void GetValue_Type_TinyInt () + { + object value; + object expected; + + cmd.CommandText = "select type_tinyint from numeric_family order by id asc"; + using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) { + expected = byte.MaxValue; + + Assert.IsTrue (rdr.Read (), "#A1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#A2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#A3"); + Assert.AreEqual (expected, value, "#A4"); + Assert.AreEqual (typeof (byte), rdr.GetFieldType (0), "#A5"); + + expected = byte.MinValue; + + Assert.IsTrue (rdr.Read (), "#B1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#B2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#B3"); + Assert.AreEqual (expected, value, "#B4"); + Assert.AreEqual (typeof (byte), rdr.GetFieldType (0), "#B5"); + + expected = (byte) 0x00; + + Assert.IsTrue (rdr.Read (), "#C1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#C2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#C3"); + Assert.AreEqual (expected, value, "#C4"); + Assert.AreEqual (typeof (byte), rdr.GetFieldType (0), "#C5"); + + expected = DBNull.Value; + + Assert.IsTrue (rdr.Read (), "#D1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#D2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#D3"); + Assert.AreEqual (expected, value, "#D4"); + Assert.AreEqual (typeof (byte), rdr.GetFieldType (0), "#D5"); + } + + using (IDataReader rdr = cmd.ExecuteReader ()) { + expected = byte.MaxValue; + + Assert.IsTrue (rdr.Read (), "#E1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#E2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#E3"); + Assert.AreEqual (expected, value, "#E4"); + Assert.AreEqual (typeof (byte), rdr.GetFieldType (0), "#E5"); + + expected = byte.MinValue; + + Assert.IsTrue (rdr.Read (), "#F1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#F2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#F3"); + Assert.AreEqual (expected, value, "#F4"); + Assert.AreEqual (typeof (byte), rdr.GetFieldType (0), "#F5"); + + expected = (byte) 0x00; + + Assert.IsTrue (rdr.Read (), "#G1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#G2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#G3"); + Assert.AreEqual (expected, value, "#G4"); + Assert.AreEqual (typeof (byte), rdr.GetFieldType (0), "#G5"); + + expected = DBNull.Value; + + Assert.IsTrue (rdr.Read (), "#H1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#H2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#H3"); + Assert.AreEqual (expected, value, "#H4"); + Assert.AreEqual (typeof (byte), rdr.GetFieldType (0), "#H5"); + } + } + + [Test] + public void GetValue_Type_VarBinary () + { + object value; + object expected; + + cmd.CommandText = "select type_varbinary from binary_family order by id asc"; + using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) { + expected = new byte [] { 0x30, 0x31, 0x32, 0x33, + 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x30, + 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, + 0x38, 0x39, 0x30, 0x31, 0x32, 0x33, 0x34, + 0x35, 0x36, 0x37, 0x38, 0x39, 0x00, 0x44, + 0x53}; + + Assert.IsTrue (rdr.Read (), "#A1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#A2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#A3"); + Assert.AreEqual (expected, value, "#A4"); + Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#A5"); + + expected = new byte [] { 0x00, 0x39, 0x38, 0x37, + 0x36, 0x35, 0x00, 0x33, 0x32, 0x31, 0x30, + 0x31, 0x32, 0x33, 0x34 }; + + Assert.IsTrue (rdr.Read (), "#B1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#B2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#B3"); + Assert.AreEqual (expected, value, "#B4"); + Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#B5"); + + expected = new byte [0]; + + Assert.IsTrue (rdr.Read (), "#C1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#C2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#C3"); + Assert.AreEqual (expected, value, "#C4"); + Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#C5"); + + expected = DBNull.Value; + + Assert.IsTrue (rdr.Read (), "#D1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#D2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#D3"); + Assert.AreEqual (DBNull.Value, value, "#D4"); + Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#D5"); + } + + using (IDataReader rdr = cmd.ExecuteReader ()) { + expected = new byte [] { 0x30, 0x31, 0x32, 0x33, + 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x30, + 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, + 0x38, 0x39, 0x30, 0x31, 0x32, 0x33, 0x34, + 0x35, 0x36, 0x37, 0x38, 0x39, 0x00, 0x44, + 0x53}; + + Assert.IsTrue (rdr.Read (), "#E1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#E2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#E3"); + Assert.AreEqual (expected, value, "#E4"); + Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#E5"); + + expected = new byte [] { 0x00, 0x39, 0x38, 0x37, + 0x36, 0x35, 0x00, 0x33, 0x32, 0x31, 0x30, + 0x31, 0x32, 0x33, 0x34 }; + + Assert.IsTrue (rdr.Read (), "#F1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#F2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#F3"); + Assert.AreEqual (expected, value, "#F4"); + Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#F5"); + + expected = new byte [0]; + + Assert.IsTrue (rdr.Read (), "#G1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#G2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#G3"); + Assert.AreEqual (expected, value, "#G4"); + Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#G5"); + + expected = DBNull.Value; + + Assert.IsTrue (rdr.Read (), "#H1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#H2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#H3"); + Assert.AreEqual (expected, value, "#H4"); + Assert.AreEqual (typeof (byte []), rdr.GetFieldType (0), "#H5"); + } + } + + [Test] + public void GetValue_Type_VarChar () + { + object value; + object expected; + + cmd.CommandText = "select type_varchar from string_family order by id asc"; + using (IDataReader rdr = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) { + expected = "varchar"; + + Assert.IsTrue (rdr.Read (), "#A1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#A2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#A3"); + Assert.AreEqual (expected, value, "#A4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#A5"); + + expected = "varchar "; + + Assert.IsTrue (rdr.Read (), "#B1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#B2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#B3"); + Assert.AreEqual (expected, value, "#B4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#B5"); + + expected = string.Empty; + + Assert.IsTrue (rdr.Read (), "#C1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#C2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#C3"); + Assert.AreEqual (expected, value, "#C4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#C5"); + + expected = DBNull.Value; + + Assert.IsTrue (rdr.Read (), "#D1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#D2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#D3"); + Assert.AreEqual (expected, value, "#D4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#D5"); + } + + using (IDataReader rdr = cmd.ExecuteReader ()) { + expected = "varchar"; + + Assert.IsTrue (rdr.Read (), "#E1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#E2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#E3"); + Assert.AreEqual (expected, value, "#E4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#E5"); + + expected = "varchar "; + + Assert.IsTrue (rdr.Read (), "#F1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#F2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#F3"); + Assert.AreEqual (expected, value, "#F4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#F5"); + + expected = string.Empty; + + Assert.IsTrue (rdr.Read (), "#G1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#G2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#G3"); + Assert.AreEqual (expected, value, "#G4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#G5"); + + expected = DBNull.Value; + + Assert.IsTrue (rdr.Read (), "#H1"); + value = rdr.GetValue (0); + Assert.IsNotNull (value, "#H2"); + Assert.AreEqual (expected.GetType (), value.GetType (), "#H3"); + Assert.AreEqual (expected, value, "#H4"); + Assert.AreEqual (typeof (string), rdr.GetFieldType (0), "#H5"); + } + } + + [Test] + public void GetBytes () + { + //Console.WriteLine ("GetBytes - first_executereader"); + byte [] expected = new byte [] { 0x32, 0x56, 0x00, 0x44, 0x22 }; + cmd.CommandText = "SELECT type_blob FROM binary_family where id = 1"; + + using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) { + Assert.IsTrue (reader.Read (), "#A1"); + + // Get By Parts for the column blob + long totalsize = reader.GetBytes (0, 0, null, 0, 0); + int buffsize = 3; + int offset = 0; + long ret = 0; + long count = 0; + byte [] val = new byte [totalsize]; + //Console.WriteLine ("GetBytes:: totalsize={0}", totalsize); + do { + ret = reader.GetBytes (0, offset, val, offset, + (int) Math.Min (buffsize, totalsize - count)); + offset += (int) ret; + count += ret; + } while (count < totalsize); + + Assert.AreEqual (expected.Length, count, "#A2"); + Assert.AreEqual (expected, val, "#A3"); + } + + //Console.WriteLine ("GetBytes - second_executereader"); + using (IDataReader reader = cmd.ExecuteReader ()) { + Assert.IsTrue (reader.Read (), "#B1"); + + // Get By Parts for the column blob + long totalsize = reader.GetBytes (0, 0, null, 0, 0); + int buffsize = 3; + int offset = 0; + long ret = 0; + long count = 0; + byte [] val = new byte [totalsize]; + + do { + ret = reader.GetBytes (0, offset, val, offset, + (int) Math.Min (buffsize, totalsize - count)); + offset += (int) ret; + count += ret; + } while (count < totalsize); + + Assert.AreEqual (expected.Length, count, "#B2"); + Assert.AreEqual (expected, val, "#B3"); + } + + //Console.WriteLine ("GetBytes - third_executereader"); + // buffer size > (buffer offset + length) > remaining data + using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) { + Assert.IsTrue (reader.Read ()); + + long totalsize = reader.GetBytes (0, 0, null, 0, 0); + byte [] val = new byte [totalsize + 5]; + int buffer_offset = 3; + + long ret = reader.GetBytes (0, 0, val, buffer_offset, (int) totalsize); + Assert.AreEqual (expected.Length, ret, "#C1"); + for (int i = 0; i < buffer_offset; i++) + Assert.AreEqual (0x00, val [i], "#C2:" + i); + for (int i = 0; i < totalsize; i++) + Assert.AreEqual (expected [i], val [buffer_offset + i], "#C3:" + i); + } + + //Console.WriteLine ("GetBytes - fourth_executereader"); + // buffer size > (buffer offset + length) > remaining data + using (IDataReader reader = cmd.ExecuteReader ()) { + Assert.IsTrue (reader.Read ()); + + long totalsize = reader.GetBytes (0, 0, null, 0, 0); + byte [] val = new byte [totalsize + 5]; + int buffer_offset = 3; + + long ret = reader.GetBytes (0, 0, val, buffer_offset, (int) totalsize); + Assert.AreEqual (expected.Length, ret, "#D1"); + for (int i = 0; i < buffer_offset; i++) + Assert.AreEqual (0x00, val [i], "#D2:" + i); + for (int i = 0; i < totalsize; i++) + Assert.AreEqual (expected [i], val [buffer_offset + i], "#D3:" + i); + } + + /* FIXME: dataIndex is currently ignored */ + /* + behavior = CommandBehavior.SingleResult | CommandBehavior.SequentialAccess; + using (IDataReader reader = cmd.ExecuteReader (behavior)) { + Assert.IsTrue (reader.Read (), "#E1"); + + long totalsize = reader.GetBytes (0, 0, null, 0, 0); + + int bufferIndex = 3; + long ret = 0L; + byte [] val = new byte [totalsize + bufferIndex]; + for (int i = 0; i < val.Length; i++) + val [i] = 0x0a; + ret = reader.GetBytes (0, 1L, val, bufferIndex, (int) (totalsize - 2)); + Assert.AreEqual (3, ret, "#E2"); + Assert.AreEqual (new byte [] { 0x0a, 0x0a, 0x0a, 0x56, 0x00, 0x44, 0x0a, 0x0a }, val, "#E3"); + try { + reader.GetBytes (0, 3L, val, 1, 2); + Assert.Fail ("#E4"); + } catch (InvalidOperationException ex) { + // Invalid GetBytes attempt at dataIndex '3'. + // With CommandBehavior.SequentialAccess, you + // may only read from dataIndex '4' or greater + Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E5"); + Assert.IsNull (ex.InnerException, "#E6"); + Assert.IsNotNull (ex.Message, "#E7"); + Assert.IsTrue (ex.Message.IndexOf ("CommandBehavior.SequentialAccess") != -1, "#E8:" + ex.Message); + Assert.IsTrue (ex.Message.IndexOf ("'" + 3L.ToString (CultureInfo.InvariantCulture) + "'") != -1, "#E9:" + ex.Message); + Assert.IsTrue (ex.Message.IndexOf ("'" + 4L.ToString (CultureInfo.InvariantCulture) + "'") != -1, "#E10:" + ex.Message); + } + + ret = reader.GetBytes (0, 4L, val, bufferIndex + 4, 2); + Assert.AreEqual (1, ret, "#E11"); + Assert.AreEqual (new byte [] { 0x0a, 0x0a, 0x0a, 0x56, 0x00, 0x44, 0x0a, 0x22 }, val, "#E12"); + } + + //Console.WriteLine ("GetBytes - fifth_executereader"); + behavior = CommandBehavior.SingleResult; + using (IDataReader reader = cmd.ExecuteReader (behavior)) { + Assert.IsTrue (reader.Read (), "#F1"); + + long totalsize = reader.GetBytes (0, 0, null, 0, 0); + + int bufferIndex = 3; + long ret = 0L; + byte [] val = new byte [totalsize + bufferIndex]; + for (int i = 0; i < val.Length; i++) + val [i] = 0x0a; + ret = reader.GetBytes (0, 1L, val, bufferIndex, (int) (totalsize - 2)); + Assert.AreEqual (3, ret, "#F2"); + Assert.AreEqual (new byte [] { 0x0a, 0x0a, 0x0a, 0x56, 0x00, 0x44, 0x0a, 0x0a }, val, "#F3"); + ret = reader.GetBytes (0, 3L, val, 1, 2); + Assert.AreEqual (2, ret, "#F4"); + Assert.AreEqual (new byte [] { 0x0a, 0x44, 0x22, 0x56, 0x00, 0x44, 0x0a, 0x0a }, val, "#F5"); + } + */ + } + + [Test] + public void GetBytes_Buffer_Null () + { + //Console.WriteLine ("GetBytes_Buffer_Null- first_executereader"); + cmd.CommandText = "SELECT type_blob FROM binary_family where id in (1,2,3,4) order by id"; + + using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) { + Assert.IsTrue (reader.Read (), "#A1"); + Assert.AreEqual (5, reader.GetBytes (0, 0, null, 0, 0), "#A2"); + + Assert.IsTrue (reader.Read (), "#B1"); + Assert.AreEqual (275, reader.GetBytes (0, 0, null, 0, 0), "#B2"); + + Assert.IsTrue (reader.Read (), "#C1"); + Assert.AreEqual (0, reader.GetBytes (0, 0, null, 0, 0), "#C2"); + + Assert.IsTrue (reader.Read (), "#D1"); + if (conn is SqlConnection) { + try { + reader.GetBytes (0, 0, null, 0, 0); + Assert.Fail ("#D2"); + } catch (SqlNullValueException ex) { + // Data is Null. This method or + // property cannot be called on + // Null values + Assert.AreEqual (typeof (SqlNullValueException), ex.GetType (), "#D3"); + Assert.IsNull (ex.InnerException, "#D4"); + Assert.IsNotNull (ex.Message, "#D5"); + } + } else { + Assert.AreEqual (-1, reader.GetBytes (0, 0, null, 0, 0), "#D2"); + } + } + + using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) { + Assert.IsTrue (reader.Read (), "#E1"); + Assert.AreEqual (5, reader.GetBytes (0, 5, null, 3, 8), "#E2"); + + Assert.IsTrue (reader.Read (), "#F1"); + Assert.AreEqual (275, reader.GetBytes (0, 5, null, 3, 4), "#F2"); + + Assert.IsTrue (reader.Read (), "#G1"); + Assert.AreEqual (0, reader.GetBytes (0, 5, null, 3, 4), "#G2"); + + Assert.IsTrue (reader.Read (), "#H1"); + if (conn is SqlConnection) { + try { + reader.GetBytes (0, 5, null, 3, 4); + Assert.Fail ("#H2"); + } catch (SqlNullValueException ex) { + // Data is Null. This method or + // property cannot be called on + // Null values + Assert.AreEqual (typeof (SqlNullValueException), ex.GetType (), "#H3"); + Assert.IsNull (ex.InnerException, "#H4"); + Assert.IsNotNull (ex.Message, "#H5"); + } + } else { + Assert.AreEqual (-1, reader.GetBytes (0, 5, null, 3, 4), "#H2"); + } + } + + using (IDataReader reader = cmd.ExecuteReader ()) { + Assert.IsTrue (reader.Read (), "#I1"); + Assert.AreEqual (5, reader.GetBytes (0, 0, null, 0, 0), "#I2"); + + Assert.IsTrue (reader.Read (), "#J1"); + Assert.AreEqual (275, reader.GetBytes (0, 0, null, 0, 0), "#J2"); + + Assert.IsTrue (reader.Read (), "#K1"); + Assert.AreEqual (0, reader.GetBytes (0, 0, null, 0, 0), "#K2"); + + Assert.IsTrue (reader.Read (), "#L1"); + if (conn is SqlConnection) { + try { + reader.GetBytes (0, 0, null, 0, 0); + Assert.Fail ("#L2"); + } catch (SqlNullValueException ex) { + // Data is Null. This method or + // property cannot be called on + // Null values + Assert.AreEqual (typeof (SqlNullValueException), ex.GetType (), "#L3"); + Assert.IsNull (ex.InnerException, "#L4"); + Assert.IsNotNull (ex.Message, "#L5"); + } + } else { + if (RunningOnMono) + Assert.AreEqual (-1, reader.GetBytes (0, 0, null, 0, 0), "#L2"); + else { + try { + reader.GetBytes (0, 0, null, 0, 0); + Assert.Fail ("#L2"); + } catch (InvalidCastException) { + // Unable to cast object of type + // 'System.DBNull' to type 'System.Byte[]' + } + } + } + } + + using (IDataReader reader = cmd.ExecuteReader ()) { + Assert.IsTrue (reader.Read (), "#M1"); + Assert.AreEqual (5, reader.GetBytes (0, 5, null, 3, 8), "#M2"); + + Assert.IsTrue (reader.Read (), "#N1"); + Assert.AreEqual (275, reader.GetBytes (0, 5, null, 3, 4), "#N2"); + + Assert.IsTrue (reader.Read (), "#O1"); + Assert.AreEqual (0, reader.GetBytes (0, 5, null, 3, 4), "#O2"); + + Assert.IsTrue (reader.Read (), "#P1"); + if (conn is SqlConnection) { + try { + reader.GetBytes (0, 5, null, 3, 4); + Assert.Fail ("#P2"); + } catch (SqlNullValueException ex) { + // Data is Null. This method or + // property cannot be called on + // Null values + Assert.AreEqual (typeof (SqlNullValueException), ex.GetType (), "#P3"); + Assert.IsNull (ex.InnerException, "#P4"); + Assert.IsNotNull (ex.Message, "#P5"); + } + } else { + if (RunningOnMono) + Assert.AreEqual (-1, reader.GetBytes (0, 0, null, 0, 0), "#L2"); + else { + try { + reader.GetBytes (0, 0, null, 0, 0); + Assert.Fail ("#L2"); + } catch (InvalidCastException) { + // Unable to cast object of type + // 'System.DBNull' to type 'System.Byte[]' + } + } + } + } + } + + [Test] + [Category("NotWorking")] + public void GetBytes_DataIndex_Overflow () + { + cmd.CommandText = "SELECT type_blob FROM binary_family where id = 2"; + + //Console.WriteLine ("GetBytes_DataIndex_Overflow - first_executereader"); + using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) { + Assert.IsTrue (reader.Read ()); + + long totalsize = reader.GetBytes (0, 0, null, 0, 0); + byte [] val = new byte [totalsize * 2]; + long ret; + + // dataIndex > total size, length = 0 + ret = reader.GetBytes (0, totalsize + 5, val, 0, 0); + Assert.AreEqual (0, ret, "#C1"); + // dataIndex > total size, length < total size + ret = reader.GetBytes (0, totalsize + 5, val, 0, 5); + Assert.AreEqual (0, ret, "#C2"); + // dataIndex > total size, length > total size + ret = reader.GetBytes (0, totalsize + 5, val, 0, (int) (totalsize + 5)); + Assert.AreEqual (0, ret, "#C3"); + } + + //Console.WriteLine ("GetBytes_DataIndex_Overflow - second_executereader"); + using (IDataReader reader = cmd.ExecuteReader ()) { + Assert.IsTrue (reader.Read ()); + + long totalsize = reader.GetBytes (0, 0, null, 0, 0); + byte [] val = new byte [totalsize * 2]; + long ret; + + // dataIndex > total size, length = 0 + ret = reader.GetBytes (0, totalsize + 5, val, 0, 0); + Assert.AreEqual (0, ret, "#B1"); + // dataIndex > total size, length < total size + ret = reader.GetBytes (0, totalsize + 5, val, 0, 5); + Assert.AreEqual (0, ret, "#B2"); + // dataIndex > total size, length > total size + ret = reader.GetBytes (0, totalsize + 5, val, 0, (int) (totalsize + 5)); + Assert.AreEqual (0, ret, "#B3"); + } + } + + [Test] + public void GetBytes_DataIndex_OffSet () + { + //Console.WriteLine ("GetBytes_DataIndex_Offset - first_executereader"); + cmd.CommandText = "SELECT type_blob FROM binary_family where id = 2"; + + using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SingleResult | CommandBehavior.SequentialAccess)) { + Assert.IsTrue (reader.Read ()); + + long totalsize = reader.GetBytes (0, 0, null, 0, 0); + byte [] val = new byte [totalsize]; + long ret; + + // start reading at index 0 + ret = reader.GetBytes (0, 0, val, 0, 5); + Assert.AreEqual (5, ret, "#A1"); + for (int i = 0; i < ret; i++) + Assert.AreEqual (long_bytes [i], val [i], "#A2:" + i); + Assert.AreEqual (0x00, val [5], "#A3"); + + // attempt to read data prior to current pointer + try { + reader.GetBytes (0, 4, val, 0, 5); + Assert.Fail ("#B1"); + } catch (InvalidOperationException ex) { + // Invalid GetBytes attempt at dataIndex '4' + // With CommandBehavior.SequentialAccess, + // you may only read from dataIndex '5' + // or greater. + Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + Assert.IsTrue (ex.Message.IndexOf ("'4'") != -1, "#B5:" + ex.Message); + Assert.IsTrue (ex.Message.IndexOf ("'5'") != -1, "#B6:" + ex.Message); + } + + // continue reading at current pointer + ret = reader.GetBytes (0, 5, val, 5, 6); + Assert.AreEqual (6, ret, "#C1"); + for (int i = 0; i < 11; i++) + Assert.AreEqual (long_bytes [i], val [i], "#C2:" + i); + Assert.AreEqual (0x00, val [11], "#C3"); + + // skip 4 characters + ret = reader.GetBytes (0, 15, val, 13, (val.Length - 13)); + Assert.AreEqual (260, ret, "#D1"); + for (int i = 0; i < 11; i++) + Assert.AreEqual (long_bytes [i], val [i], "#D2:" + i); + for (int i = 11; i < 13; i++) + Assert.AreEqual (0x00, val [i], "#D3:" + i); + for (int i = 13; i < (totalsize - 4); i++) + Assert.AreEqual (long_bytes [i + 2], val [i], "#D4:" + i); + } + + //Console.WriteLine ("GetBytes_DataIndex_Offset - second_executereader"); + using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SingleResult | CommandBehavior.SequentialAccess)) { + Assert.IsTrue (reader.Read ()); + + long totalsize = reader.GetBytes (0, 0, null, 0, 0); + byte [] val = new byte [totalsize]; + long ret; + + int offset = (int) totalsize - 5; + int buffer_offset = 7; + + // start reading at a specific position + ret = reader.GetBytes (0, offset, val, buffer_offset, + val.Length - buffer_offset); + Assert.AreEqual (5, ret, "#E1"); + for (int i = 0; i < buffer_offset; i++) + Assert.AreEqual (0x00, val [i], "#E2:" + i); + for (int i = 0; i < ret; i++) + Assert.AreEqual (long_bytes [offset + i], val [buffer_offset + i], "#E3:" + i); + for (int i = (buffer_offset + (int) ret); i < val.Length; i++) + Assert.AreEqual (0x00, val [i], "#E4:" + i); + } + } + + [Test] + public void GetBytes_Reader_Closed () + { + //Console.WriteLine ("GetBytes_Reader_Closed - first_executereader"); + cmd.CommandText = "SELECT type_blob FROM binary_family where id = 1"; + + using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) { + Assert.IsTrue (reader.Read (), "#1"); + reader.Close (); + + try { + reader.GetBytes (0, 0, null, -1, 0); + Assert.Fail ("#2"); + } catch (InvalidOperationException ex) { + // No data exists for the row/column + Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#3"); + Assert.IsNull (ex.InnerException, "#4"); + Assert.IsNotNull (ex.Message, "#5"); + } + } + } + +#if DONT_RUN + [Test] + public void GetBytes_Reader_NoData () + { + //Console.WriteLine ("GetBytes_Reader_NoData - first_executereader"); + cmd.CommandText = "SELECT type_blob FROM binary_family where id = 1"; + + using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess)) { + try { + reader.GetBytes (0, 0, null, -1, 0); + Assert.Fail ("#2"); + } catch (InvalidOperationException ex) { + // No data exists for the row/column + Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#3"); + Assert.IsNull (ex.InnerException, "#4"); + Assert.IsNotNull (ex.Message, "#5"); + } + } + } +#endif + [Test] + public void GetSchemaTableTest_AutoIncrement () + { + cmd.CommandText = "select type_autoincrement from numeric_family"; + cmd.ExecuteNonQuery (); + using (IDataReader reader = cmd.ExecuteReader (CommandBehavior.SchemaOnly)) { + DataTable schemaTable = reader.GetSchemaTable (); + Assert.IsTrue ((bool) schemaTable.Rows [0]["IsAutoIncrement"], "#1"); + + if (!RunningOnMono) { + /* FIXME: we always set it to false */ + if (schemaTable.Columns.Contains ("IsIdentity")) + Assert.IsTrue ((bool) schemaTable.Rows [0] ["IsIdentity"], "#2"); + } + } + } + + [Test] + [Category("NotWorking")] + public void GetValues_Reader_Closed () + { + //Console.WriteLine ("GetValues_Reader_Closed - first_executereader"); + cmd.CommandText = "SELECT type_blob FROM binary_family where id = 1"; + + using (IDataReader rdr = cmd.ExecuteReader ()) { + Assert.IsTrue (rdr.Read ()); + rdr.Close (); + + try { + rdr.GetValues ((object []) null); + Assert.Fail ("#1"); + } catch (ArgumentNullException ex) { + // No data exists for the row/column + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + } + } + } + + [Test] + [Category("NotWorking")] + public void GetValues_Reader_NoData () + { + //Console.WriteLine ("GetValues_Reader_NoData - first_executereader"); + cmd.CommandText = "SELECT type_blob FROM binary_family where id = 666"; + + using (IDataReader rdr = cmd.ExecuteReader ()) { + try { + rdr.GetValues ((object []) null); + Assert.Fail ("#A1"); + } catch (ArgumentNullException ex) { + // No data exists for the row/column + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + } + + Assert.IsFalse (rdr.Read (), "#B"); + + try { + rdr.GetValues ((object []) null); + Assert.Fail ("#C1"); + } catch (ArgumentNullException ex) { + // No data exists for the row/column + Assert.IsNull (ex.InnerException, "#C3"); + Assert.IsNotNull (ex.Message, "#C4"); + } + } + } + + static bool RunningOnMono { + get { + return (Type.GetType ("System.MonoType", false) != null); } } }