using System.Data;
using System.Data.Common;
using System.Data.SqlClient;
-#if NET_2_0
using System.Data.Sql;
-#endif
using System.Globalization;
-#if NET_2_0
using System.Xml;
-#endif
using NUnit.Framework;
-namespace MonoTests.System.Data.SqlClient
+namespace MonoTests.System.Data.Connected.SqlClient
{
[TestFixture]
[Category ("sqlserver")]
{
SqlConnection conn;
SqlCommand cmd;
- string connectionString = ConnectionManager.Singleton.ConnectionString;
+ string connectionString = ConnectionManager.Instance.Sql.ConnectionString;
EngineConfig engine;
static readonly decimal SMALLMONEY_MAX = 214748.3647m;
[SetUp]
public void SetUp ()
{
- engine = ConnectionManager.Singleton.Engine;
+ engine = ConnectionManager.Instance.Sql.EngineConfig;
}
[TearDown]
Assert.AreSame (connA, cmd.Connection, "#A4");
Assert.IsNull (cmd.Container, "#A5");
Assert.IsTrue (cmd.DesignTimeVisible, "#A6");
-#if NET_2_0
Assert.IsNull (cmd.Notification, "#A7");
Assert.IsTrue (cmd.NotificationAutoEnlist, "#A8");
-#endif
Assert.IsNotNull (cmd.Parameters, "#A9");
Assert.AreEqual (0, cmd.Parameters.Count, "#A10");
Assert.IsNull (cmd.Site, "#A11");
Assert.AreSame (connA, cmd.Connection, "#B4");
Assert.IsNull (cmd.Container, "#B5");
Assert.IsTrue (cmd.DesignTimeVisible, "#B6");
-#if NET_2_0
Assert.IsNull (cmd.Notification, "#B7");
Assert.IsTrue (cmd.NotificationAutoEnlist, "#B8");
-#endif
Assert.IsNotNull (cmd.Parameters, "#B9");
Assert.AreEqual (0, cmd.Parameters.Count, "#B10");
Assert.IsNull (cmd.Site, "#B11");
[Test] // bug #341743
public void Dispose_Connection_Disposed ()
{
- conn = (SqlConnection) ConnectionManager.Singleton.Connection;
- ConnectionManager.Singleton.OpenConnection ();
+ conn = ConnectionManager.Instance.Sql.Connection;
cmd = conn.CreateCommand ();
cmd.CommandText = "SELECT 'a'";
}
[Test]
+ [Category("NotWorking")]
public void ExecuteScalar ()
{
conn = new SqlConnection (connectionString);
[Test]
public void ExecuteScalar_CommandText_Empty ()
{
- conn = (SqlConnection) ConnectionManager.Singleton.Connection;
- ConnectionManager.Singleton.OpenConnection ();
+ conn = ConnectionManager.Instance.Sql.Connection;
cmd = conn.CreateCommand ();
Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
Assert.IsNull (ex.InnerException, "#A3");
Assert.IsNotNull (ex.Message, "#A4");
-#if NET_2_0
Assert.IsTrue (ex.Message.StartsWith ("ExecuteScalar"), "#A5:" + ex.Message);
-#else
- Assert.IsTrue (ex.Message.StartsWith ("ExecuteReader"), "#A5:" + ex.Message);
-#endif
}
cmd.CommandText = string.Empty;
Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
Assert.IsNull (ex.InnerException, "#B3");
Assert.IsNotNull (ex.Message, "#B4");
-#if NET_2_0
Assert.IsTrue (ex.Message.StartsWith ("ExecuteScalar"), "#B5:" + ex.Message);
-#else
- Assert.IsTrue (ex.Message.StartsWith ("ExecuteReader"), "#B5:" + ex.Message);
-#endif
}
cmd.CommandText = null;
Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
Assert.IsNull (ex.InnerException, "#C3");
Assert.IsNotNull (ex.Message, "#C4");
-#if NET_2_0
Assert.IsTrue (ex.Message.StartsWith ("ExecuteScalar"), "#C5:" + ex.Message);
-#else
- Assert.IsTrue (ex.Message.StartsWith ("ExecuteReader"), "#C5:" + ex.Message);
-#endif
}
}
Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
Assert.IsNull (ex.InnerException, "#3");
Assert.IsNotNull (ex.Message, "#4");
-#if NET_2_0
Assert.IsTrue (ex.Message.IndexOf ("ExecuteScalar") != -1, "#5:" + ex.Message);
-#else
- Assert.IsTrue (ex.Message.IndexOf ("Execute") != -1, "#5:" + ex.Message);
-#endif
}
}
}
Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
Assert.IsNull (ex.InnerException, "#3");
Assert.IsNotNull (ex.Message, "#4");
-#if NET_2_0
Assert.IsTrue (ex.Message.StartsWith ("ExecuteScalar:"), "#5");
-#else
- Assert.IsTrue (ex.Message.StartsWith ("ExecuteReader:"), "#5");
-#endif
} finally {
trans.Dispose ();
}
}
[Test]
+ [Category("NotWorking")]
public void ExecuteNonQuery ()
{
conn = new SqlConnection (connectionString);
Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
Assert.IsNull (ex.InnerException, "#3");
Assert.IsNotNull (ex.Message, "#4");
-#if NET_2_0
Assert.IsTrue (ex.Message.IndexOf ("ExecuteNonQuery") != -1, "#5:" + ex.Message);
-#else
- Assert.IsTrue (ex.Message.IndexOf ("Execute") != -1, "#5:" + ex.Message);
-#endif
}
}
}
Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
Assert.IsNull (ex.InnerException, "#3");
Assert.IsNotNull (ex.Message, "#4");
-#if NET_2_0
Assert.IsTrue (ex.Message.IndexOf ("ExecuteReader") != -1, "#5:" + ex.Message);
-#else
- Assert.IsTrue (ex.Message.IndexOf ("Execute") != -1, "#5:" + ex.Message);
-#endif
}
}
}
// Test InvalidOperation Exception is thrown if Parameter Type
// is not explicitly set
-#if NET_2_0
cmd.Parameters.AddWithValue ("@ID", 2);
-#else
- cmd.Parameters.Add ("@ID", 2);
-#endif
try {
cmd.Prepare ();
Assert.Fail ("#A1");
Assert.IsNotNull (ex.Message, "#B4");
}
+ // Test Exception is not thrown if DbType is set - #569543
+ try {
+ cmd.CommandText = "select type_guid from string_family where type_guid=@p1";
+ cmd.Parameters.Clear ();
+ cmd.Parameters.Add ("@p1", SqlDbType.UniqueIdentifier);
+ cmd.Parameters ["@p1"].Value = new Guid ("1C47DD1D-891B-47E8-AAC8-F36608B31BC5");
+ cmd.Prepare ();
+ } catch (Exception ex) {
+ Assert.Fail ("#B5 "+ex.Message);
+ }
+
// Test Exception is not thrown for Stored Procs
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "ABFSDSFSF";
Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
Assert.IsNull (ex.InnerException, "#3");
Assert.IsNotNull (ex.Message, "#4");
-#if NET_2_0
Assert.IsTrue (ex.Message.IndexOf ("Prepare") != -1, "#5:" + ex.Message);
-#else
- Assert.IsTrue (ex.Message.IndexOf ("Execute") != -1, "#5:" + ex.Message);
-#endif
}
// Text, parameters cleared
}
[Test]
+ [Category("NotWorking")]
public void Prepare_Transaction_Only ()
{
SqlTransaction trans = null;
// Text, without parameters
cmd = new SqlCommand ("select count(*) from whatever");
cmd.Transaction = trans;
-#if NET_2_0
- try {
- cmd.Prepare ();
- Assert.Fail ("#A1");
- } catch (NullReferenceException) {
- }
-#else
- cmd.Prepare ();
-#endif
+ cmd.Prepare();
// Text, with parameters
cmd = new SqlCommand ("select count(*) from whatever");
cmd.Parameters.Add ("@TestPar1", SqlDbType.Int);
cmd.Transaction = trans;
- try {
- cmd.Prepare ();
- Assert.Fail ("#B1");
-#if NET_2_0
- } catch (NullReferenceException) {
- }
-#else
- } catch (InvalidOperationException ex) {
- // Prepare: Connection property has not been
- // initialized
- Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
- Assert.IsNull (ex.InnerException, "#B3");
- Assert.IsNotNull (ex.Message, "#B4");
- Assert.IsTrue (ex.Message.StartsWith ("Prepare:"), "#B5");
- }
-#endif
+ Assert.Throws<InvalidOperationException>(() => cmd.Prepare());
// Text, parameters cleared
cmd = new SqlCommand ("select count(*) from whatever");
cmd.Parameters.Add ("@TestPar1", SqlDbType.Int);
cmd.Parameters.Clear ();
cmd.Transaction = trans;
-#if NET_2_0
- try {
- cmd.Prepare ();
- Assert.Fail ("#C1");
- } catch (NullReferenceException) {
- }
-#else
- cmd.Prepare ();
-#endif
+ cmd.Prepare();
// StoredProcedure, without parameters
cmd = new SqlCommand ("FindCustomer");
cmd.CommandType = CommandType.StoredProcedure;
cmd.Transaction = trans;
-#if NET_2_0
- try {
- cmd.Prepare ();
- Assert.Fail ("#D1");
- } catch (NullReferenceException) {
- }
-#else
- cmd.Prepare ();
-#endif
+ cmd.Prepare();
// StoredProcedure, with parameters
cmd = new SqlCommand ("FindCustomer");
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add ("@TestPar1", SqlDbType.Int);
cmd.Transaction = trans;
-#if NET_2_0
- try {
- cmd.Prepare ();
- Assert.Fail ("#E1");
- } catch (NullReferenceException) {
- }
-#else
- cmd.Prepare ();
-#endif
+ cmd.Prepare();
}
[Test] // bug #412576
SqlCommand cmdB = new SqlCommand ("select @@version", connA, trans);
using (SqlDataReader reader = cmdB.ExecuteReader ()) {
-#if NET_2_0
cmdA.Connection = connA;
Assert.AreSame (connA, cmdA.Connection, "#A1");
Assert.AreSame (trans, cmdA.Transaction, "#A2");
-#else
- try {
- cmdA.Connection = connA;
- Assert.Fail ("#A1");
- } catch (InvalidOperationException ex) {
- // The SqlCommand is currently busy
- // Open, Fetching
- Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
- Assert.IsNull (ex.InnerException, "#A3");
- Assert.IsNotNull (ex.Message, "#A4");
-
- Assert.AreSame (connA, cmdA.Connection, "#A5");
- Assert.AreSame (trans, cmdA.Transaction, "#A6");
- }
-#endif
-#if NET_2_0
cmdA.Connection = connB;
Assert.AreSame (connB, cmdA.Connection, "#B1");
Assert.AreSame (trans, cmdA.Transaction, "#B2");
-#else
- try {
- cmdA.Connection = connB;
- Assert.Fail ("#B1");
- } catch (InvalidOperationException ex) {
- // The SqlCommand is currently busy
- // Open, Fetching
- Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
- Assert.IsNull (ex.InnerException, "#B3");
- Assert.IsNotNull (ex.Message, "#B4");
-
- Assert.AreSame (connA, cmdA.Connection, "#B5");
- Assert.AreSame (trans, cmdA.Transaction, "#B6");
- }
-#endif
-#if NET_2_0
cmdA.Connection = null;
Assert.IsNull (cmdA.Connection, "#C1");
Assert.AreSame (trans, cmdA.Transaction, "#C2");
-#else
- try {
- cmdA.Connection = null;
- Assert.Fail ("#C1");
- } catch (InvalidOperationException ex) {
- // The SqlCommand is currently busy
- // Open, Fetching
- Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
- Assert.IsNull (ex.InnerException, "#C3");
- Assert.IsNotNull (ex.Message, "#C4");
-
- Assert.AreSame (connA, cmdA.Connection, "#C5");
- Assert.AreSame (trans, cmdA.Transaction, "#C6");
- }
-#endif
}
} finally {
if (trans != null)
SqlCommand cmdB = new SqlCommand ("select * from employee", connA, transA);
using (SqlDataReader reader = cmdB.ExecuteReader ()) {
-#if NET_2_0
cmdA.Transaction = transA;
Assert.AreSame (transA, cmdA.Transaction, "#A1");
-#else
- try {
- cmdA.Transaction = transA;
- Assert.Fail ("#A1");
- } catch (InvalidOperationException ex) {
- // The SqlCommand is currently busy
- // Open, Fetching
- Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
- Assert.IsNull (ex.InnerException, "#A3");
- Assert.IsNotNull (ex.Message, "#A4");
-
- Assert.AreSame (transA, cmdA.Transaction, "#A5");
- }
-#endif
-#if NET_2_0
cmdA.Transaction = transB;
Assert.AreSame (transB, cmdA.Transaction, "#B1");
-#else
- try {
- cmdA.Transaction = transB;
- Assert.Fail ("#B1");
- } catch (InvalidOperationException ex) {
- // The SqlCommand is currently busy
- // Open, Fetching
- Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
- Assert.IsNull (ex.InnerException, "#B3");
- Assert.IsNotNull (ex.Message, "#B4");
-
- Assert.AreSame (transA, cmdA.Transaction, "#B5");
- }
-#endif
-#if NET_2_0
cmdA.Transaction = null;
Assert.IsNull (cmdA.Transaction, "#C1");
-#else
- try {
- cmdA.Transaction = null;
- Assert.Fail ("#C1");
- } catch (InvalidOperationException ex) {
- // The SqlCommand is currently busy
- // Open, Fetching
- Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
- Assert.IsNull (ex.InnerException, "#C3");
- Assert.IsNotNull (ex.Message, "#C4");
-
- Assert.AreSame (transA, cmdA.Transaction, "#C5");
- }
-#endif
}
cmdA.Transaction = transA;
SqlParameter idParam;
SqlParameter dojParam;
- conn = (SqlConnection) ConnectionManager.Singleton.Connection;
- conn.Open ();
+ conn = ConnectionManager.Instance.Sql.Connection;
// parameters with leading '@'
try {
idParam = cmd.Parameters.Add ("id", SqlDbType.Int);
idParam.Direction = ParameterDirection.ReturnValue;
-#if NET_2_0
Assert.AreEqual (1, cmd.ExecuteNonQuery (), "#B1");
cmd.Dispose ();
Assert.IsFalse (dr.Read (), "#B9");
cmd.Dispose ();
dr.Close ();
-#else
- try {
- cmd.ExecuteNonQuery ();
- Assert.Fail ("#B1");
- } catch (SqlException ex) {
- Assert.AreEqual (typeof (SqlException), ex.GetType (), "#B2");
- Assert.AreEqual ((byte) 16, ex.Class, "#B3");
- Assert.IsNull (ex.InnerException, "#B4");
- Assert.IsNotNull (ex.Message, "#B5");
- Assert.IsTrue (ex.Message.IndexOf ("#sp_temp_insert_employee") != -1, "#B6:"+ ex.Message);
- if (ClientVersion == 7) {
- // fname is not a parameter for procedure #sp_temp_insert_employee
- Assert.IsTrue (ex.Message.IndexOf ("fname") != -1, "#B7: " + ex.Message);
- Assert.AreEqual (8145, ex.Number, "#B8");
- Assert.AreEqual ((byte) 2, ex.State, "#B9");
- } else {
- // Procedure or Function '#sp_temp_insert_employee' expects
- // parameter '@fname', which was not supplied
- Assert.IsTrue (ex.Message.IndexOf ("'@fname'") != -1, "#B7: " + ex.Message);
- Assert.AreEqual (201, ex.Number, "#B8");
- Assert.AreEqual ((byte) 4, ex.State, "#B9");
- }
- }
-#endif
} finally {
if (cmd != null)
cmd.Dispose ();
}
[Test] // bug #319598
+ [Category("NotWorking")]
public void LongQueryTest ()
{
if (ClientVersion == 7)
}
[Test] // bug #319598
+ [Category("NotWorking")]
public void LongStoredProcTest ()
{
if (ClientVersion == 7)
[Test]
public void EnumParameterTest ()
{
- conn = (SqlConnection) ConnectionManager.Singleton.Connection;
+ conn = ConnectionManager.Instance.Sql.Connection;
try {
- ConnectionManager.Singleton.OpenConnection ();
// create temp sp here, should normally be created in Setup of test
// case, but cannot be done right now because of ug #68978
DBHelper.ExecuteNonQuery (conn, "CREATE PROCEDURE #Bug66630 ("
DBHelper.ExecuteNonQuery (conn, "if exists (select name from sysobjects " +
" where name like '#temp_Bug66630' and type like 'P') " +
" drop procedure #temp_Bug66630; ");
- ConnectionManager.Singleton.CloseConnection ();
+ ConnectionManager.Instance.Sql.CloseConnection ();
}
}
}
[Test]
+ [Category("NotWorking")]
public void StoredProc_ParameterTest ()
{
string create_query = CREATE_TMP_SP_PARAM_TEST;
[Test]
public void OutputParamSizeTest1 ()
{
- conn = (SqlConnection) ConnectionManager.Singleton.Connection;
- ConnectionManager.Singleton.OpenConnection ();
+ conn = ConnectionManager.Instance.Sql.Connection;
cmd = new SqlCommand ();
cmd.Connection = conn;
[Test]
public void OutputParamSizeTest2 ()
{
- conn = (SqlConnection) ConnectionManager.Singleton.Connection;
- ConnectionManager.Singleton.OpenConnection ();
+ conn = ConnectionManager.Instance.Sql.Connection;
cmd = new SqlCommand ();
cmd.Connection = conn;
[Test]
public void OutputParamSizeTest3 ()
{
- conn = (SqlConnection) ConnectionManager.Singleton.Connection;
- ConnectionManager.Singleton.OpenConnection ();
+ conn = ConnectionManager.Instance.Sql.Connection;
cmd = new SqlCommand ();
cmd.Connection = conn;
[Test]
public void OutputParamSizeTest4 ()
{
- conn = (SqlConnection) ConnectionManager.Singleton.Connection;
- ConnectionManager.Singleton.OpenConnection ();
+ conn = ConnectionManager.Instance.Sql.Connection;
cmd = new SqlCommand ();
cmd.Connection = conn;
{
SqlParameter newId, id;
- conn = (SqlConnection) ConnectionManager.Singleton.Connection;
- ConnectionManager.Singleton.OpenConnection ();
+ conn = ConnectionManager.Instance.Sql.Connection;
cmd = conn.CreateCommand ();
cmd.CommandText = "set @NewId=@Id + 2";
newId.Direction = ParameterDirection.Output;
id = cmd.Parameters.Add ("Id", SqlDbType.Int);
id.Value = 6;
-#if NET_2_0
cmd.ExecuteNonQuery ();
Assert.AreEqual (8, newId.Value, "#B1");
Assert.AreEqual (6, id.Value, "#B2");
-#else
- try {
- cmd.ExecuteNonQuery ();
- Assert.Fail ("#B1");
- } catch (SqlException ex) {
- // Incorrect syntax near 'NewId'.
- // Must declare the scalar variable "@Id"
- Assert.AreEqual (typeof (SqlException), ex.GetType (), "#B2");
- Assert.AreEqual ((byte) 15, ex.Class, "#B3");
- Assert.IsNull (ex.InnerException, "#B4");
- Assert.IsNotNull (ex.Message, "#B5");
- Assert.IsTrue (ex.Message.IndexOf ("'NewId'") != -1, "#B6: " + ex.Message);
- if (ClientVersion == 7) {
- Assert.IsTrue (ex.Message.IndexOf ("'@Id'") != -1, "#B7: " + ex.Message);
- Assert.AreEqual (170, ex.Number, "#B8");
- } else {
- Assert.IsTrue (ex.Message.IndexOf ("\"@Id\"") != -1, "#B7: " + ex.Message);
- Assert.AreEqual (102, ex.Number, "#B8");
- }
- Assert.AreEqual ((byte) 1, ex.State, "#B9");
- }
-#endif
}
[Test]
Assert.AreEqual (typeof (OverflowException), ex.GetType (), "#2");
Assert.IsNull (ex.InnerException, "#3");
Assert.IsNotNull (ex.Message, "#4");
-#if NET_2_0
Assert.IsTrue (ex.Message.IndexOf (string.Format (
CultureInfo.InvariantCulture, "'{0}'",
overflow)) != -1, "#5:" + ex.Message);
-#else
- Assert.IsTrue (ex.Message.IndexOf (string.Format (
- CultureInfo.CurrentCulture, "'{0}'",
- overflow)) != -1, "#5:" + ex.Message);
-#endif
Assert.IsTrue (ex.Message.IndexOf (string.Format (
CultureInfo.InvariantCulture, "{0:N4}",
SMALLMONEY_MIN)) != -1, "#6:" + ex.Message);
Assert.AreEqual (typeof (OverflowException), ex.GetType (), "#2");
Assert.IsNull (ex.InnerException, "#3");
Assert.IsNotNull (ex.Message, "#4");
-#if NET_2_0
Assert.IsTrue (ex.Message.IndexOf (string.Format (
CultureInfo.InvariantCulture, "'{0}'",
overflow)) != -1, "#5:" + ex.Message);
-#else
- Assert.IsTrue (ex.Message.IndexOf (string.Format (
- CultureInfo.CurrentCulture, "'{0}'",
- overflow)) != -1, "#5:" + ex.Message);
-#endif
Assert.IsTrue (ex.Message.IndexOf (string.Format (
CultureInfo.InvariantCulture, "{0:N4}",
SMALLMONEY_MIN)) != -1, "#6:" + ex.Message);
}
}
-#if NET_2_0
[Test]
public void NotificationTest ()
{
{
cmd = new SqlCommand ();
string connectionString1 = null;
- connectionString1 = ConnectionManager.Singleton.ConnectionString + "Asynchronous Processing=true";
+ connectionString1 = ConnectionManager.Instance.Sql.ConnectionString + ";Asynchronous Processing=true";
try {
SqlConnection conn1 = new SqlConnection (connectionString1);
conn1.Open ();
Assert.AreEqual ("kumar", reader["lname"], "#1 ");
}
} finally {
- ConnectionManager.Singleton.CloseConnection ();
+ ConnectionManager.Instance.Sql.CloseConnection ();
}
}
[Test]
+ [Ignore("MS .NET doesn't throw IOE here. TODO: check corefx")]
public void BeginExecuteXmlReaderExceptionTest ()
{
cmd = new SqlCommand ();
try {
/*IAsyncResult result = */cmd.BeginExecuteXmlReader ();
} catch (InvalidOperationException) {
- Assert.AreEqual (ConnectionManager.Singleton.ConnectionString, connectionString, "#1 Connection string has changed");
+ Assert.AreEqual (ConnectionManager.Instance.Sql.ConnectionString, connectionString, "#1 Connection string has changed");
return;
}
Assert.Fail ("Expected Exception InvalidOperationException not thrown");
} finally {
- ConnectionManager.Singleton.CloseConnection ();
+ ConnectionManager.Instance.Sql.CloseConnection ();
}
}
-#endif
[Test]
public void SqlCommandDisposeTest ()
{
IDataReader reader = null;
+ conn = ConnectionManager.Instance.Sql.Connection;
try {
- conn = (SqlConnection) ConnectionManager.Singleton.Connection;
- ConnectionManager.Singleton.OpenConnection ();
IDbCommand command = conn.CreateCommand ();
try {
while (reader.Read ()) ;
} finally {
reader.Dispose ();
- ConnectionManager.Singleton.CloseConnection ();
+ ConnectionManager.Instance.Sql.CloseConnection ();
}
}
out int param3Val,
out int rvalVal)
{
+ conn = ConnectionManager.Instance.Sql.Connection;
try {
- conn = (SqlConnection) ConnectionManager.Singleton.Connection;
- ConnectionManager.Singleton.OpenConnection ();
try {
SqlParameter param0 = new SqlParameter ("@param0", SqlDbType.Int);
cmd = null;
}
} finally {
- ConnectionManager.Singleton.CloseConnection ();
+ ConnectionManager.Instance.Sql.CloseConnection ();
conn = null;
}
}
Assert.AreEqual (100, param0Val);
}
+ [Test]
+ public void DeriveParameterTest_FullSchema ()
+ {
+ string create_tbl = "CREATE TABLE decimalCheck (deccheck DECIMAL (19, 5) null)";
+ string create_sp = "CREATE PROCEDURE sp_bug584833(@deccheck decimal(19,5) OUT)"
+ + "AS " + Environment.NewLine
+ + "BEGIN" + Environment.NewLine
+ + "INSERT INTO decimalCheck values (@deccheck)" + Environment.NewLine
+ + "SELECT @deccheck=deccheck from decimalCheck" + Environment.NewLine
+ + "END";
+
+ conn = ConnectionManager.Instance.Sql.Connection;
+ try {
+ cmd = conn.CreateCommand ();
+ cmd.CommandText = create_tbl;
+ cmd.ExecuteNonQuery ();
+
+ cmd.CommandText = create_sp;
+ cmd.ExecuteNonQuery ();
+
+ cmd.CommandText = "dbo.sp_bug584833";
+ cmd.CommandType = CommandType.StoredProcedure;
+
+ SqlCommandBuilder.DeriveParameters (cmd);
+ Assert.AreEqual (2, cmd.Parameters.Count, "#DPT - FullSchema - Parameter count mismatch");
+ Assert.AreEqual ("@deccheck", cmd.Parameters[1].ParameterName, "#DPT - FullSchema - Parameter name mismatch");
+ Assert.AreEqual (SqlDbType.Decimal, cmd.Parameters[1].SqlDbType, "#DPT - FullSchema - Parameter type mismatch");
+ } finally {
+ cmd.Parameters.Clear ();
+ cmd.CommandText = "drop procedure sp_bug584833";
+ cmd.CommandType = CommandType.Text;
+ cmd.ExecuteNonQuery ();
+ cmd.CommandText = "drop table decimalCheck";
+ cmd.ExecuteNonQuery ();
+ cmd.Dispose ();
+ cmd = null;
+ ConnectionManager.Instance.Sql.CloseConnection ();
+ conn = null;
+ }
+
+ }
+
+ [Test]
+ public void DeriveParameterTest_SPName ()
+ {
+ string create_tbl = "CREATE TABLE decimalCheck (deccheck DECIMAL (19, 5) null)";
+ string create_sp = "CREATE PROCEDURE sp_bug584833(@deccheck decimal(19,5) OUT)"
+ + "AS " + Environment.NewLine
+ + "BEGIN" + Environment.NewLine
+ + "INSERT INTO decimalCheck values (@deccheck)" + Environment.NewLine
+ + "SELECT @deccheck=deccheck from decimalCheck" + Environment.NewLine
+ + "END";
+
+ conn = ConnectionManager.Instance.Sql.Connection;
+ try {
+
+ cmd = conn.CreateCommand ();
+ cmd.CommandText = create_tbl;
+ cmd.ExecuteNonQuery ();
+
+ cmd.CommandText = create_sp;
+ cmd.ExecuteNonQuery ();
+
+ cmd.CommandText = "sp_bug584833";
+ cmd.CommandType = CommandType.StoredProcedure;
+
+ SqlCommandBuilder.DeriveParameters (cmd);
+ Assert.AreEqual (2, cmd.Parameters.Count, "#DPT - SPName - Parameter count mismatch");
+ Assert.AreEqual ("@deccheck", cmd.Parameters[1].ParameterName, "#DPT - SPName - Parameter name mismatch");
+ Assert.AreEqual (SqlDbType.Decimal, cmd.Parameters[1].SqlDbType, "#DPT - SPName - Parameter type mismatch");
+ } finally {
+ cmd.Parameters.Clear ();
+ cmd.CommandType = CommandType.Text;
+ cmd.CommandText = "drop procedure sp_bug584833";
+ cmd.ExecuteNonQuery ();
+ cmd.CommandText = "drop table decimalCheck";
+ cmd.ExecuteNonQuery ();
+ cmd.Dispose ();
+ cmd = null;
+ ConnectionManager.Instance.Sql.CloseConnection ();
+ conn = null;
+ }
+ }
+
+ [Test]
+ public void DeriveParameterTest_UserSchema ()
+ {
+ string create_tbl = "CREATE TABLE decimalCheck (deccheck DECIMAL (19, 5) null)";
+ string create_sp = "CREATE PROCEDURE sp_bug584833(@deccheck decimal(19,5) OUT)"
+ + "AS " + Environment.NewLine
+ + "BEGIN" + Environment.NewLine
+ + "INSERT INTO decimalCheck values (@deccheck)" + Environment.NewLine
+ + "SELECT @deccheck=deccheck from decimalCheck" + Environment.NewLine
+ + "END";
+
+ try {
+ conn = ConnectionManager.Instance.Sql.Connection;
+
+ cmd = conn.CreateCommand ();
+ cmd.CommandText = create_tbl;
+ cmd.ExecuteNonQuery ();
+
+ cmd.CommandText = create_sp;
+ cmd.ExecuteNonQuery ();
+
+ cmd.CommandText = "dbo.sp_bug584833";
+ cmd.CommandType = CommandType.StoredProcedure;
+
+ SqlCommandBuilder.DeriveParameters (cmd);
+ Assert.AreEqual (2, cmd.Parameters.Count, "#DPT - user schema - Parameter count mismatch");
+ Assert.AreEqual ("@deccheck", cmd.Parameters[1].ParameterName, "#DPT - user schema - Parameter name mismatch");
+ Assert.AreEqual (SqlDbType.Decimal, cmd.Parameters[1].SqlDbType, "#DPT - user schema - Parameter type mismatch");
+ } finally {
+ cmd.Parameters.Clear ();
+ cmd.CommandType = CommandType.Text;
+ cmd.CommandText = "drop procedure dbo.sp_bug584833";
+ cmd.ExecuteNonQuery ();
+ cmd.CommandText = "drop table decimalCheck";
+ cmd.ExecuteNonQuery ();
+ cmd.Dispose ();
+ cmd = null;
+ ConnectionManager.Instance.Sql.CloseConnection ();
+ conn = null;
+ }
+ }
+
+ [Test] // bug#561667
+ public void CmdDispose_DataReaderReset ()
+ {
+ conn = ConnectionManager.Instance.Sql.Connection;
+ try
+ {
+ string query1 = "SELECT fname FROM employee where lname='kumar'";
+ string query2 = "SELECT type_int FROM numeric_family where type_bit = 1";
+ DataTable t = null;
+
+ t = GetColumns(conn, query1);
+ Assert.AreEqual ("suresh", t.Rows[0][0], "CmdDD#1: Query1 result mismatch");
+ t = GetColumns(conn, query2);
+ Assert.AreEqual (int.MaxValue, t.Rows[0][0], "CmdDD#2: Query2 result mismatch");
+ } finally {
+ ConnectionManager.Instance.Sql.CloseConnection ();
+ conn = null;
+ }
+ }
+
+ private DataTable GetColumns(DbConnection connection, string query)
+ {
+ DataTable t = new DataTable("Columns");
+ using (DbCommand c = connection.CreateCommand())
+ {
+ c.CommandText = query;
+ t.Load(c.ExecuteReader());
+ }
+ return t;
+ }
+
// used as workaround for bugs in NUnit 2.2.0
static void AreEqual (object x, object y, string msg)
{
projects / mono.git / blobdiff