public static void Test(string srcConstr, string dstConstr, string dstTable)
{
Task t = TestAsync(srcConstr, dstConstr, dstTable);
DataTestUtility.AssertThrowsWrapper <AggregateException, InvalidOperationException>(() => t.Wait());
Assert.True(t.IsCompleted, "Task did not complete! Status: " + t.Status);
}
private void ReadCommitedIsolationLevel_ShouldReceiveTimeoutExceptionBecauseItWaitsForUncommitedTransaction()
{
using (SqlConnection connection1 = new SqlConnection(_connectionString))
{
connection1.Open();
SqlTransaction tx1 = connection1.BeginTransaction();
using (SqlCommand command1 = connection1.CreateCommand())
{
command1.Transaction = tx1;
command1.CommandText = "INSERT INTO " + _tempTableName1 + " VALUES ( 'ZYXWV', 'XYZ', 'John' );";
command1.ExecuteNonQuery();
}
using (SqlConnection connection2 = new SqlConnection(_connectionString))
{
SqlCommand command2 =
new SqlCommand("select * from " + _tempTableName1 + " where CustomerID='ZYXWV'",
connection2);
connection2.Open();
SqlTransaction tx2 = connection2.BeginTransaction(IsolationLevel.ReadCommitted);
command2.Transaction = tx2;
DataTestUtility.AssertThrowsWrapper <SqlException>(() => command2.ExecuteReader(), SystemDataResourceManager.Instance.SQL_Timeout as string);
tx2.Rollback();
connection2.Close();
}
tx1.Rollback();
connection1.Close();
}
}
public void Test_DoubleStart_DifferentConnStr()
{
SqlConnectionStringBuilder cb = new SqlConnectionStringBuilder(_startConnectionString);
// just change something that doesn't impact the dependency dispatcher
if (cb.ShouldSerialize("connect timeout"))
{
cb.ConnectTimeout = cb.ConnectTimeout + 1;
}
else
{
cb.ConnectTimeout = 50;
}
Assert.True(SqlDependency.Start(_startConnectionString), "Failed to start listener.");
try
{
DataTestUtility.AssertThrowsWrapper <InvalidOperationException>(() => SqlDependency.Start(cb.ToString()));
}
finally
{
Assert.True(SqlDependency.Stop(_startConnectionString), "Failed to stop listener.");
Assert.False(SqlDependency.Stop(cb.ToString()), "Expected failure when trying to completely stop listener.");
}
}
private static void OpenBadConnection <T>(string connectionString, string errorMessage = null) where T : Exception
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
DataTestUtility.AssertThrowsWrapper <T>(() => conn.Open(), errorMessage);
}
}
public static void InvalidDBTest()
{
using (var connection = new SqlConnection(@"Data Source=(localdb)\MSSQLLOCALDB;Database=DOES_NOT_EXIST;Pooling=false;"))
{
DataTestUtility.AssertThrowsWrapper <SqlException>(() => connection.Open());
}
}
public static void Test(string srcConstr, string dstConstr, string dstTable)
{
using (SqlConnection dstConn = new SqlConnection(dstConstr))
using (SqlCommand dstCmd = dstConn.CreateCommand())
{
dstConn.Open();
try
{
Helpers.TryExecute(dstCmd, "create table " + dstTable + " (col1 int, col2 nvarchar(20), col3 nvarchar(10))");
using (SqlConnection srcConn = new SqlConnection(srcConstr))
using (SqlCommand srcCmd = new SqlCommand("select top 5 EmployeeID, LastName, FirstName from employees", srcConn))
{
srcConn.Open();
using (DbDataReader reader = srcCmd.ExecuteReader())
using (SqlConnection conn3 = new SqlConnection(srcConstr))
{
conn3.Open();
// Start a local transaction on the wrong connection.
SqlTransaction myTrans = conn3.BeginTransaction();
string errorMsg = SystemDataResourceManager.Instance.SQL_BulkLoadConflictingTransactionOption;
DataTestUtility.AssertThrowsWrapper <ArgumentException>(() => new SqlBulkCopy(dstConn, SqlBulkCopyOptions.UseInternalTransaction, myTrans), exceptionMessage: errorMsg);
}
}
}
finally
{
Helpers.TryExecute(dstCmd, "drop table " + dstTable);
}
}
}
public void UDTParams_Binary()
{
using (SqlConnection conn = new SqlConnection(_connStr))
using (SqlCommand cmd = new SqlCommand("vicinity", conn))
{
conn.Open();
cmd.CommandType = CommandType.StoredProcedure;
SqlParameter p = cmd.Parameters.Add("@boundary", SqlDbType.VarBinary, 8);
p.Direction = ParameterDirection.Input;
byte[] value = new byte[8];
value[0] = 0xF0;
value[1] = 0;
value[2] = 0;
value[3] = 0;
value[4] = 0xF0;
value[5] = 0;
value[6] = 0;
value[7] = 0;
p.Value = new SqlBinary(value);
DataTestUtility.AssertThrowsWrapper <SqlException>(
() => cmd.ExecuteReader(),
"Error converting data type varbinary to Point.");
}
}
public void UDTFields_WrongType()
{
using (SqlConnection cn = new SqlConnection(_connStr))
using (SqlCommand cmd = new SqlCommand("select name,location from cities order by name", cn))
{
cn.Open();
cmd.CommandType = CommandType.Text;
using (SqlDataReader reader = cmd.ExecuteReader())
{
reader.Read();
DataTestUtility.AssertEqualsWithDescription(
"beaverton", reader.GetValue(0),
"Unexpected reader value.");
DataTestUtility.AssertEqualsWithDescription(
"14.8660687473185", ((Point)reader.GetValue(1)).Distance().ToString(),
"Unexpected distance value.");
reader.Read();
// retrieve the UDT as a string
DataTestUtility.AssertThrowsWrapper <InvalidCastException>(
() => reader.GetString(1),
"Unable to cast object of type 'System.Byte[]' to type 'System.String'.");
}
}
}
private void ExceptionTest()
{
using (SqlConnection connection = new SqlConnection(_connectionString))
{
connection.Open();
SqlTransaction tx = connection.BeginTransaction();
string invalidSaveStateMessage = SystemDataResourceManager.Instance.SQL_NullEmptyTransactionName;
string executeCommandWithoutTransactionMessage = SystemDataResourceManager.Instance.ADP_TransactionRequired("ExecuteNonQuery");
string transactionConflictErrorMessage = SystemDataResourceManager.Instance.ADP_TransactionConnectionMismatch;
string parallelTransactionErrorMessage = SystemDataResourceManager.Instance.ADP_ParallelTransactionsNotSupported("SqlConnection");
DataTestUtility.AssertThrowsWrapper <InvalidOperationException>(() =>
{
SqlCommand command = new SqlCommand("sql", connection);
command.ExecuteNonQuery();
}, executeCommandWithoutTransactionMessage);
DataTestUtility.AssertThrowsWrapper <InvalidOperationException>(() =>
{
SqlConnection con1 = new SqlConnection(_connectionString);
con1.Open();
SqlCommand command = new SqlCommand("sql", con1);
command.Transaction = tx;
command.ExecuteNonQuery();
}, transactionConflictErrorMessage);
DataTestUtility.AssertThrowsWrapper <InvalidOperationException>(() =>
{
connection.BeginTransaction(null);
}, parallelTransactionErrorMessage);
DataTestUtility.AssertThrowsWrapper <InvalidOperationException>(() =>
{
connection.BeginTransaction("");
}, parallelTransactionErrorMessage);
DataTestUtility.AssertThrowsWrapper <ArgumentException>(() =>
{
tx.Rollback(null);
}, invalidSaveStateMessage);
DataTestUtility.AssertThrowsWrapper <ArgumentException>(() =>
{
tx.Rollback("");
}, invalidSaveStateMessage);
DataTestUtility.AssertThrowsWrapper <ArgumentException>(() =>
{
tx.Save(null);
}, invalidSaveStateMessage);
DataTestUtility.AssertThrowsWrapper <ArgumentException>(() =>
{
tx.Save("");
}, invalidSaveStateMessage);
}
}
public static void Test(string srcConstr, string dstConstr, string dstTable)
{
cts = new CancellationTokenSource();
cts.Cancel();
Task t = TestAsync(srcConstr, dstConstr, dstTable, cts.Token);
DataTestUtility.AssertThrowsWrapper <AggregateException, TaskCanceledException>(() => t.Wait());
Assert.True(t.IsCompleted, "Task did not complete! Status: " + t.Status);
}
public static void LocalDBNotSupportedOnUapTest()
{
SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder(@"server=(localdb)\MSSQLLocalDB");
builder.IntegratedSecurity = true;
builder.ConnectTimeout = 2;
DataTestUtility.AssertThrowsWrapper <PlatformNotSupportedException>(() => OpenConnection(builder.ConnectionString));
}
public static void Test(string srcConstr, string dstConstr, string dstTable)
{
#if DEBUG
string initialQueryTemplate = "create table {0} (col1 int, col2 nvarchar(20), col3 nvarchar(10), col4 varchar(8000))";
string sourceQuery = "select EmployeeID, LastName, FirstName, REPLICATE('a', 8000) from employees";
string initialQuery = string.Format(initialQueryTemplate, dstTable);
using (SqlConnection dstConn = new SqlConnection(dstConstr))
using (SqlCommand dstCmd = dstConn.CreateCommand())
{
dstConn.Open();
try
{
Helpers.TryExecute(dstCmd, initialQuery);
using (SqlConnection srcConn = new SqlConnection(srcConstr))
using (SqlCommand srcCmd = new SqlCommand(sourceQuery, srcConn))
{
srcConn.Open();
using (DbDataReader reader = srcCmd.ExecuteReader())
{
using (SqlBulkCopy bulkcopy = new SqlBulkCopy(dstConn))
{
bulkcopy.DestinationTableName = dstTable;
// Close the bulk copy's connection when it notifies us
bulkcopy.NotifyAfter = 1;
bulkcopy.SqlRowsCopied += (sender, e) =>
{
dstConn.Close();
};
using (AsyncDebugScope debugScope = new AsyncDebugScope())
{
// Force all writes to pend, this will guarantee that we will go through the correct code path
debugScope.ForceAsyncWriteDelay = 1;
// Check that the copying fails
string message = string.Format(SystemDataResourceManager.Instance.ADP_OpenConnectionRequired, "WriteToServer", SystemDataResourceManager.Instance.ADP_ConnectionStateMsg_Closed);
DataTestUtility.AssertThrowsWrapper <AggregateException, InvalidOperationException>(() => bulkcopy.WriteToServerAsync(reader).Wait(5000), innerExceptionMessage: message);
}
}
}
}
}
finally
{
Helpers.TryDropTable(dstConstr, dstTable);
}
}
#endif
}
private static void TimeoutCancel(string constr)
{
using (SqlConnection con = new SqlConnection(constr))
{
con.Open();
SqlCommand cmd = con.CreateCommand();
cmd.CommandTimeout = 1;
cmd.CommandText = "WAITFOR DELAY '00:00:30';select * from Customers";
string errorMessage = SystemDataResourceManager.Instance.SQL_Timeout;
DataTestUtility.AssertThrowsWrapper <SqlException>(() => cmd.ExecuteReader(), errorMessage);
VerifyConnection(cmd);
}
}
public void Test_SingleDependency_NoStart()
{
using (SqlConnection conn = new SqlConnection(_execConnectionString))
using (SqlCommand cmd = new SqlCommand("SELECT a, b, c FROM " + _tableName, conn))
{
conn.Open();
SqlDependency dep = new SqlDependency(cmd);
dep.OnChange += delegate(object o, SqlNotificationEventArgs args)
{
Console.WriteLine("4 Notification callback. Type={0}, Info={1}, Source={2}", args.Type, args.Info, args.Source);
};
DataTestUtility.AssertThrowsWrapper <InvalidOperationException>(() => cmd.ExecuteReader());
}
}
public void UDTParams_Invalid()
{
using (SqlConnection conn = new SqlConnection(_connStr))
using (SqlCommand cmd = new SqlCommand("vicinity", conn))
{
conn.Open();
cmd.CommandType = CommandType.StoredProcedure;
SqlParameter p = cmd.Parameters.Add("@boundary", SqlDbType.Udt);
p.UdtTypeName = "UdtTestDb.dbo.Point";
p.Value = 32;
DataTestUtility.AssertThrowsWrapper <ArgumentException>(
() => cmd.ExecuteReader(),
"Specified type is not registered on the target server. System.Int32");
}
}
public static void Test(string srcConstr, string dstConstr, string dstTable)
{
using (SqlConnection dstConn = new SqlConnection(dstConstr))
using (SqlCommand dstCmd = dstConn.CreateCommand())
{
dstConn.Open();
try
{
Helpers.Execute(dstCmd, "create table " + dstTable + " (orderid int, customerid nchar(5), rdate datetime, freight money, shipname nvarchar(40))");
using (SqlConnection srcConn = new SqlConnection(srcConstr))
using (SqlCommand srcCmd = new SqlCommand("select top 100 * from orders", srcConn))
{
srcConn.Open();
using (DbDataReader reader = srcCmd.ExecuteReader())
using (bulkcopy = new SqlBulkCopy(dstConn, SqlBulkCopyOptions.UseInternalTransaction, null))
{
bulkcopy.SqlRowsCopied += new SqlRowsCopiedEventHandler(OnRowCopied);
bulkcopy.DestinationTableName = dstTable;
bulkcopy.NotifyAfter = 50;
SqlBulkCopyColumnMappingCollection ColumnMappings = bulkcopy.ColumnMappings;
ColumnMappings.Add("OrderID", "orderid");
ColumnMappings.Add("CustomerID", "customerid");
ColumnMappings.Add("RequiredDate", "rdate");
ColumnMappings.Add("Freight", "freight");
ColumnMappings.Add("ShipName", "shipname");
bulkcopy.NotifyAfter = 3;
DataTestUtility.AssertThrowsWrapper <OperationAbortedException>(() => bulkcopy.WriteToServer(reader));
bulkcopy.SqlRowsCopied -= new SqlRowsCopiedEventHandler(OnRowCopied);
bulkcopy.Close();
}
}
}
finally
{
Helpers.Execute(dstCmd, "drop table " + dstTable);
}
}
}
public static void Test(string srcConstr, string dstConstr, string dstTable)
{
using (SqlConnection dstConn = new SqlConnection(dstConstr))
using (SqlCommand dstCmd = dstConn.CreateCommand())
{
dstConn.Open();
try
{
Helpers.TryExecute(dstCmd, "create table " + dstTable + " (col1 int, col2 nvarchar(20), col3 nvarchar(10))");
using (SqlConnection srcConn = new SqlConnection(srcConstr))
using (SqlCommand srcCmd = new SqlCommand("select top 5 EmployeeID, LastName, FirstName from employees", srcConn))
{
srcConn.Open();
using (DbDataReader reader = srcCmd.ExecuteReader())
using (SqlConnection conn3 = new SqlConnection(srcConstr))
{
conn3.Open();
// Start a local transaction on the wrong connection.
SqlTransaction myTrans = conn3.BeginTransaction();
using (SqlBulkCopy bulkcopy = new SqlBulkCopy(dstConn, SqlBulkCopyOptions.Default, myTrans))
{
SqlBulkCopyColumnMappingCollection ColumnMappings = bulkcopy.ColumnMappings;
bulkcopy.DestinationTableName = dstTable;
string exceptionMsg = SystemDataResourceManager.Instance.ADP_TransactionConnectionMismatch;
DataTestUtility.AssertThrowsWrapper <InvalidOperationException>(() => bulkcopy.WriteToServer(reader), exceptionMessage: exceptionMsg);
SqlCommand myCmd = dstConn.CreateCommand();
myCmd.CommandText = "select * from " + dstTable;
myCmd.Transaction = myTrans;
DataTestUtility.AssertThrowsWrapper <InvalidOperationException>(() => myCmd.ExecuteReader(), exceptionMessage: exceptionMsg);
}
}
}
}
finally
{
Helpers.TryExecute(dstCmd, "drop table " + dstTable);
}
}
}
public static void Test(string srcConstr, string dstConstr, string dstTable)
{
using (SqlConnection dstConn = new SqlConnection(dstConstr))
using (SqlCommand dstCmd = dstConn.CreateCommand())
{
dstConn.Open();
try
{
Helpers.TryExecute(dstCmd, "create table " + dstTable + " (col1 int, col2 nvarchar(20), col3 nvarchar(10))");
using (SqlConnection srcConn = new SqlConnection(srcConstr))
using (SqlCommand srcCmd = new SqlCommand("select top 5 EmployeeID, LastName, FirstName from employees", srcConn))
{
srcConn.Open();
using (DbDataReader reader = srcCmd.ExecuteReader())
using (SqlBulkCopy bulkcopy = new SqlBulkCopy(dstConn, SqlBulkCopyOptions.UseInternalTransaction, null))
{
bulkcopy.DestinationTableName = dstTable;
SqlBulkCopyColumnMappingCollection ColumnMappings = bulkcopy.ColumnMappings;
SqlCommand myCmd = dstConn.CreateCommand();
myCmd.CommandText = "begin transaction";
myCmd.ExecuteNonQuery();
try
{
DataTestUtility.AssertThrowsWrapper <InvalidOperationException>(() => bulkcopy.WriteToServer(reader));
}
finally
{
myCmd.CommandText = "rollback transaction";
myCmd.ExecuteNonQuery();
}
}
}
}
finally
{
Helpers.TryExecute(dstCmd, "drop table " + dstTable);
}
}
}
public void UDTParams_NullInput()
{
string spInsertCustomer = DataTestUtility.GetUniqueNameForSqlServer("spUdtTest2_InsertCustomer");
string tableName = DataTestUtility.GetUniqueNameForSqlServer("UdtTest2_Customer");
using (SqlConnection conn = new SqlConnection(_connStr))
using (SqlCommand cmd = conn.CreateCommand())
{
conn.Open();
cmd.Transaction = conn.BeginTransaction();
cmd.CommandText = "create table " + tableName + " (name nvarchar(30), address Address)";
cmd.ExecuteNonQuery();
cmd.CommandText = "create proc " + spInsertCustomer + "(@name nvarchar(30), @addr Address OUTPUT)" + " AS insert into " + tableName + " values (@name, @addr)";
cmd.ExecuteNonQuery();
try
{
cmd.CommandText = spInsertCustomer;
cmd.CommandType = CommandType.StoredProcedure;
SqlParameter pName = cmd.Parameters.Add("@name", SqlDbType.NVarChar, 20);
SqlParameter p = cmd.Parameters.Add("@addr", SqlDbType.Udt);
p.UdtTypeName = "UdtTestDb.dbo.Address";
p.Value = null;
pName.Value = "john";
string spInsertCustomerNoBrackets = spInsertCustomer;
if (spInsertCustomer.StartsWith("[") && spInsertCustomer.EndsWith("]"))
{
spInsertCustomerNoBrackets = spInsertCustomer.Substring(1, spInsertCustomer.Length - 2);
}
string errorMsg = "Procedure or function '" + spInsertCustomerNoBrackets + "' expects parameter '@addr', which was not supplied.";
DataTestUtility.AssertThrowsWrapper <SqlException>(
() => cmd.ExecuteNonQuery(),
errorMsg);
}
finally
{
cmd.Transaction.Rollback();
}
}
}
private static void TimeOutDuringRead(string constr)
{
// Create the proxy
ProxyServer proxy = ProxyServer.CreateAndStartProxy(constr, out constr);
proxy.SimulatedPacketDelay = 100;
proxy.SimulatedOutDelay = true;
try
{
using (SqlConnection conn = new SqlConnection(constr))
{
// Start the command
conn.Open();
SqlCommand cmd = new SqlCommand("SELECT @p", conn);
cmd.Parameters.AddWithValue("p", new byte[20000]);
SqlDataReader reader = cmd.ExecuteReader();
reader.Read();
// Tweak the timeout to 1ms, stop the proxy from proxying and then try GetValue (which should timeout)
reader.SetDefaultTimeout(1);
proxy.PauseCopying();
string errorMessage = SystemDataResourceManager.Instance.SQL_Timeout;
DataTestUtility.AssertThrowsWrapper <SqlException>(() => reader.GetValue(0), errorMessage);
// Return everything to normal and close
proxy.ResumeCopying();
reader.SetDefaultTimeout(30000);
reader.Dispose();
}
proxy.Stop();
}
catch
{
// In case of error, stop the proxy and dump its logs (hopefully this will help with debugging
proxy.Stop();
Console.WriteLine(proxy.GetServerEventLog());
Assert.True(false, "Error while reading through proxy");
throw;
}
}
private static void MultipleExecutesInSameTransactionTest_shouldThrowsUnsupported(string connectionString)
{
string expectedErrorMessage = SystemDataResourceManager.Instance.ADP_ParallelTransactionsNotSupported(typeof(SqlConnection).Name);
string tempTableName = "";
try
{
tempTableName = CreateTempTable(connectionString);
DataTestUtility.AssertThrowsWrapper <InvalidOperationException>(
actionThatFails: () => { MultipleExecutesInSameTransactionTest(connectionString, tempTableName); },
exceptionMessage: expectedErrorMessage);
}
finally
{
if (!string.IsNullOrEmpty(tempTableName))
{
DropTempTable(connectionString, tempTableName);
}
}
}
public void UDTParams_Invalid2()
{
string spInsertCustomer = DataTestUtility.GetUniqueNameForSqlServer("spUdtTest2_InsertCustomer");
string tableName = DataTestUtility.GetUniqueNameForSqlServer("UdtTest2");
using (SqlConnection conn = new SqlConnection(_connStr))
using (SqlCommand cmd = conn.CreateCommand())
{
conn.Open();
cmd.Transaction = conn.BeginTransaction();
cmd.CommandText = "create table " + tableName + " (name nvarchar(30), address Address)";
cmd.ExecuteNonQuery();
cmd.CommandText = "create proc " + spInsertCustomer + "(@name nvarchar(30), @addr Address OUTPUT)" + " AS insert into " + tableName + " values (@name, @addr)";
cmd.ExecuteNonQuery();
try
{
cmd.CommandText = spInsertCustomer;
cmd.CommandType = CommandType.StoredProcedure;
SqlParameter pName = cmd.Parameters.Add("@fname", SqlDbType.NVarChar, 20);
SqlParameter p = cmd.Parameters.Add("@addr", SqlDbType.Udt);
Address addr = Address.Parse("customer whose name is address");
p.UdtTypeName = "UdtTestDb.dbo.Address";
p.Value = addr;
pName.Value = addr;
DataTestUtility.AssertThrowsWrapper <InvalidCastException>(
() => cmd.ExecuteReader(),
"Failed to convert parameter value from a Address to a String.");
}
finally
{
cmd.Transaction.Rollback();
}
}
}
private static void PlainCancelAsync(string connString)
{
using (SqlConnection conn = new SqlConnection(connString))
using (SqlCommand cmd = new SqlCommand("select * from dbo.Orders; waitfor delay '00:00:10'; select * from dbo.Orders", conn))
{
conn.Open();
Task <SqlDataReader> readerTask = cmd.ExecuteReaderAsync();
DataTestUtility.AssertThrowsWrapper <SqlException>(
() =>
{
readerTask.Wait(2000);
SqlDataReader reader = readerTask.Result;
cmd.Cancel();
do
{
while (reader.Read())
{
}
}while (reader.NextResult());
},
"A severe error occurred on the current command. The results, if any, should be discarded.");
}
}
private static void ExecuteCommandCancelExpected(object state)
{
var stateTuple = (Tuple <bool, SqlCommand, Barrier>)state;
bool async = stateTuple.Item1;
SqlCommand command = stateTuple.Item2;
Barrier threadsReady = stateTuple.Item3;
string errorMessage = SystemDataResourceManager.Instance.SQL_OperationCancelled;
DataTestUtility.AssertThrowsWrapper <SqlException>(() =>
{
threadsReady.SignalAndWait();
using (SqlDataReader r = command.ExecuteReader())
{
do
{
while (r.Read())
{
}
} while (r.NextResult());
}
}, errorMessage);
}
public static void Test(string srcConstr, string dstConstr, string dstTable)
{
using (SqlConnection dstConn = new SqlConnection(dstConstr))
using (SqlCommand dstCmd = dstConn.CreateCommand())
{
dstConn.Open();
try
{
Helpers.Execute(dstCmd, "create table " + dstTable + " (col1 int, col3 nvarchar(10))");
using (SqlConnection srcConn = new SqlConnection(srcConstr))
using (SqlCommand srcCmd = new SqlCommand("select top 5 EmployeeID, LastName, FirstName from employees", srcConn))
{
srcConn.Open();
using (DbDataReader reader = srcCmd.ExecuteReader())
using (SqlBulkCopy bulkcopy = new SqlBulkCopy(dstConn))
{
bulkcopy.DestinationTableName = dstTable;
SqlBulkCopyColumnMappingCollection ColumnMappings = bulkcopy.ColumnMappings;
ColumnMappings.Add("EmployeeID", "col1");
ColumnMappings.Add("LastName", "col2"); // this column does not exist
ColumnMappings.Add("FirstName", "col3");
string errorMsg = SystemDataResourceManager.Instance.SQL_BulkLoadNonMatchingColumnMapping;
DataTestUtility.AssertThrowsWrapper <InvalidOperationException>(() => bulkcopy.WriteToServer(reader), exceptionMessage: errorMsg);
}
}
}
finally
{
Helpers.Execute(dstCmd, "drop table " + dstTable);
}
}
}
public void TestSqlUserDefinedAggregateAttributeMaxByteSize()
{
Func <int, SqlUserDefinedAggregateAttribute> create
= (size) => new SqlUserDefinedAggregateAttribute(Format.UserDefined)
{
MaxByteSize = size
};
SqlUserDefinedAggregateAttribute attribute1 = create(-1);
SqlUserDefinedAggregateAttribute attribute2 = create(0);
SqlUserDefinedAggregateAttribute attribute3 = create(SqlUserDefinedAggregateAttribute.MaxByteSizeValue);
string udtError = SystemDataResourceManager.Instance.SQLUDT_MaxByteSizeValue;
string errorMessage = (new ArgumentOutOfRangeException("MaxByteSize", 8001, udtError)).Message;
DataTestUtility.AssertThrowsWrapper <ArgumentOutOfRangeException>(
() => create(SqlUserDefinedAggregateAttribute.MaxByteSizeValue + 1),
errorMessage);
errorMessage = (new ArgumentOutOfRangeException("MaxByteSize", -2, udtError)).Message;
DataTestUtility.AssertThrowsWrapper <ArgumentOutOfRangeException>(
() => create(-2),
errorMessage);
}
public static void CodeCoverageSqlClient()
{
SqlParameterCollection opc = new SqlCommand().Parameters;
Assert.True(opc.Count == 0, string.Format("FAILED: Expected count: {0}. Actual count: {1}.", 0, opc.Count));
Assert.False(((IList)opc).IsReadOnly, "FAILED: Expected collection to NOT be read only.");
Assert.False(((IList)opc).IsFixedSize, "FAILED: Expected collection to NOT be fixed size.");
Assert.False(((IList)opc).IsSynchronized, "FAILED: Expected collection to NOT be synchronized.");
DataTestUtility.AssertEqualsWithDescription("Object", ((IList)opc).SyncRoot.GetType().Name, "FAILED: Incorrect SyncRoot Name");
{
string failValue;
DataTestUtility.AssertThrowsWrapper <IndexOutOfRangeException>(() => failValue = opc[0].ParameterName, "Invalid index 0 for this SqlParameterCollection with Count=0.");
DataTestUtility.AssertThrowsWrapper <IndexOutOfRangeException>(() => failValue = opc["@p1"].ParameterName, "An SqlParameter with ParameterName '@p1' is not contained by this SqlParameterCollection.");
}
DataTestUtility.AssertThrowsWrapper <ArgumentNullException>(() => opc.Add(null), "The SqlParameterCollection only accepts non-null SqlParameter type objects.");
opc.Add((object)new SqlParameter());
IEnumerator enm = opc.GetEnumerator();
Assert.True(enm.MoveNext(), "FAILED: Expected MoveNext to be true");
DataTestUtility.AssertEqualsWithDescription("Parameter1", ((SqlParameter)enm.Current).ParameterName, "FAILED: Incorrect ParameterName");
opc.Add(new SqlParameter());
DataTestUtility.AssertEqualsWithDescription("Parameter2", opc[1].ParameterName, "FAILED: Incorrect ParameterName");
opc.Add(new SqlParameter(null, null));
opc.Add(new SqlParameter(null, SqlDbType.Int));
DataTestUtility.AssertEqualsWithDescription("Parameter4", opc["Parameter4"].ParameterName, "FAILED: Incorrect ParameterName");
opc.Add(new SqlParameter("Parameter5", SqlDbType.NVarChar, 20));
opc.Add(new SqlParameter(null, SqlDbType.NVarChar, 20, "a"));
opc.RemoveAt(opc[3].ParameterName);
DataTestUtility.AssertEqualsWithDescription(-1, opc.IndexOf(null), "FAILED: Incorrect index for null value");
SqlParameter p = opc[0];
DataTestUtility.AssertThrowsWrapper <ArgumentException>(() => opc.Add((object)p), "The SqlParameter is already contained by another SqlParameterCollection.");
DataTestUtility.AssertThrowsWrapper <ArgumentException>(() => new SqlCommand().Parameters.Add(p), "The SqlParameter is already contained by another SqlParameterCollection.");
DataTestUtility.AssertThrowsWrapper <ArgumentNullException>(() => opc.Remove(null), "The SqlParameterCollection only accepts non-null SqlParameter type objects.");
string pname = p.ParameterName;
p.ParameterName = pname;
p.ParameterName = pname.ToUpper();
p.ParameterName = pname.ToLower();
p.ParameterName = "@p1";
p.ParameterName = pname;
opc.Clear();
opc.Add(p);
opc.Clear();
opc.AddWithValue("@p1", null);
DataTestUtility.AssertEqualsWithDescription(-1, opc.IndexOf(p.ParameterName), "FAILED: Incorrect index for parameter name");
opc[0] = p;
DataTestUtility.AssertEqualsWithDescription(0, opc.IndexOf(p.ParameterName), "FAILED: Incorrect index for parameter name");
Assert.True(opc.Contains(p.ParameterName), "FAILED: Expected collection to contain provided parameter.");
Assert.True(opc.Contains(opc[0]), "FAILED: Expected collection to contain provided parameter.");
opc[0] = p;
opc[p.ParameterName] = new SqlParameter(p.ParameterName, null);
opc[p.ParameterName] = new SqlParameter();
opc.RemoveAt(0);
new SqlCommand().Parameters.Clear();
new SqlCommand().Parameters.CopyTo(new object[0], 0);
Assert.False(new SqlCommand().Parameters.GetEnumerator().MoveNext(), "FAILED: Expected MoveNext to be false");
DataTestUtility.AssertThrowsWrapper <InvalidCastException>(() => new SqlCommand().Parameters.Add(0), "The SqlParameterCollection only accepts non-null SqlParameter type objects, not Int32 objects.");
DataTestUtility.AssertThrowsWrapper <InvalidCastException>(() => new SqlCommand().Parameters.Insert(0, 0), "The SqlParameterCollection only accepts non-null SqlParameter type objects, not Int32 objects.");
DataTestUtility.AssertThrowsWrapper <InvalidCastException>(() => new SqlCommand().Parameters.Remove(0), "The SqlParameterCollection only accepts non-null SqlParameter type objects, not Int32 objects.");
DataTestUtility.AssertThrowsWrapper <ArgumentException>(() => new SqlCommand().Parameters.Remove(new SqlParameter()), "Attempted to remove an SqlParameter that is not contained by this SqlParameterCollection.");
}
