private CompareInfo _compareInfo;
private int _defaultLocaleID;
- public FieldNameLookup(string[] fieldNames, int defaultLocaleID)
- { // V1.2.3300
- if (null == fieldNames)
- {
- throw ADP.ArgumentNull("fieldNames");
- }
- _fieldNames = fieldNames;
- _defaultLocaleID = defaultLocaleID;
- }
-
- public FieldNameLookup(System.Collections.ObjectModel.ReadOnlyCollection<string> columnNames, int defaultLocaleID)
- {
- int length = columnNames.Count;
- string[] fieldNames = new string[length];
- for (int i = 0; i < length; ++i)
- {
- fieldNames[i] = columnNames[i];
- Debug.Assert(null != fieldNames[i]);
- }
- _fieldNames = fieldNames;
- _defaultLocaleID = defaultLocaleID;
- GenerateLookup();
- }
-
public FieldNameLookup(IDataRecord reader, int defaultLocaleID)
{ // V1.2.3300
// Licensed to the .NET Foundation under one or more agreements.
// See the LICENSE file in the project root for more information.
-using System;
using System.Collections.Generic;
-using System.Runtime.InteropServices;
-using Xunit;
namespace System.Data.OleDb.Tests
{
public static class Helpers
{
public const string IsDriverAvailable = nameof(Helpers) + "." + nameof(GetIsDriverAvailable);
+ public const string IsAceDriverAvailable = nameof(Helpers) + "." + nameof(GetIsAceDriverAvailable);
private static readonly bool s_skipAllTemporarily = true; // [ActiveIssue(37538)]
public static bool GetIsDriverAvailable() => !s_skipAllTemporarily && Nested.IsAvailable;
+ public static bool GetIsAceDriverAvailable() => GetIsDriverAvailable() && !PlatformDetection.Is32BitProcess;
public static string ProviderName => Nested.ProviderName;
public static string GetTableName(string memberName) => memberName + ".csv";
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using Xunit;
-using System.Collections.Generic;
-using System.Data.OleDb;
using System.IO;
using System.Runtime.CompilerServices;
-using System.Text.RegularExpressions;
-using System.Transactions;
+using Xunit;
namespace System.Data.OleDb.Tests
{
[OuterLoop]
[ConditionalFact(Helpers.IsDriverAvailable)]
+ public void QuoteIdentifier_Null_Throws()
+ {
+ RunTest((command, tableName) => {
+ using (var cmd = (OleDbCommand)OleDbFactory.Instance.CreateCommand())
+ {
+ cmd.CommandType = CommandType.StoredProcedure;
+ cmd.CommandText = @"SELECT * FROM " + tableName;
+ cmd.Connection = (OleDbConnection)OleDbFactory.Instance.CreateConnection();
+ cmd.Transaction = transaction;
+ using (var builder = (OleDbCommandBuilder)OleDbFactory.Instance.CreateCommandBuilder())
+ {
+ AssertExtensions.Throws<ArgumentNullException>(
+ () => builder.QuoteIdentifier(null, cmd.Connection),
+ $"Value cannot be null.\r\nParameter name: unquotedIdentifier");
+ }
+ }
+ });
+ }
+
+ [OuterLoop]
+ [ConditionalFact(Helpers.IsDriverAvailable)]
public void UnquoteIdentifier_Null_Throws()
{
RunTest((command, tableName) => {
cmd.CommandText = @"SELECT * FROM " + tableName;
cmd.Connection = (OleDbConnection)OleDbFactory.Instance.CreateConnection();
cmd.Transaction = transaction;
- var builder = (OleDbCommandBuilder)OleDbFactory.Instance.CreateCommandBuilder();
- Assert.Throws<ArgumentNullException>(() => builder.UnquoteIdentifier(null, cmd.Connection));
+ using (var builder = (OleDbCommandBuilder)OleDbFactory.Instance.CreateCommandBuilder())
+ {
+ AssertExtensions.Throws<ArgumentNullException>(
+ () => builder.UnquoteIdentifier(null, cmd.Connection),
+ $"Value cannot be null.\r\nParameter name: quotedIdentifier");
+ }
}
});
}
[OuterLoop]
[ConditionalFact(Helpers.IsDriverAvailable)]
- public void Ctor_Defaults()
+ public void QuoteUnquote_CustomPrefixSuffix_Success()
{
RunTest((command, tableName) => {
using (var cmd = (OleDbCommand)OleDbFactory.Instance.CreateCommand())
{
+ cmd.Transaction = transaction;
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = @"SELECT * FROM " + tableName;
cmd.Connection = (OleDbConnection)OleDbFactory.Instance.CreateConnection();
cmd.Connection.ConnectionString = connection.ConnectionString;
- cmd.Transaction = transaction;
- DataSet ds = new DataSet();
- OleDbDataAdapter adapter = new OleDbDataAdapter(cmd);
- OleDbCommandBuilder commandBuilder = new OleDbCommandBuilder(adapter);
- Assert.Equal(adapter, commandBuilder.DataAdapter);
+ using (var adapter = new OleDbDataAdapter(cmd.CommandText, connection))
+ using (var builder = new OleDbCommandBuilder(adapter))
+ {
+ // Custom prefix & suffix
+ builder.QuotePrefix = "'";
+ builder.QuoteSuffix = "'";
+
+ Assert.Equal(adapter, builder.DataAdapter);
+ Assert.Equal("'Test'", builder.QuoteIdentifier("Test", connection));
+ Assert.Equal("'Te''st'", builder.QuoteIdentifier("Te'st", connection));
+ Assert.Equal("Test", builder.UnquoteIdentifier("'Test'", connection));
+ Assert.Equal("Te'st", builder.UnquoteIdentifier("'Te''st'", connection));
+
+ // Ensure we don't need active connection:
+ Assert.Equal("'Test'", builder.QuoteIdentifier("Test", null));
+ Assert.Equal("Test", builder.UnquoteIdentifier("'Test'", null));
+
+ builder.QuotePrefix = string.Empty;
+ string quoteErrMsg = $"{nameof(builder.QuoteIdentifier)} requires open connection when the quote prefix has not been set.";
+ string unquoteErrMsg = $"{nameof(builder.UnquoteIdentifier)} requires open connection when the quote prefix has not been set.";
+
+ Assert.Equal("`Test`", builder.QuoteIdentifier("Test", connection));
+ Assert.Equal("Test", builder.UnquoteIdentifier("`Test`", connection));
+
+ Assert.NotNull(adapter.SelectCommand.Connection);
+ Assert.Equal("`Test`", builder.QuoteIdentifier("Test"));
+ Assert.Equal("Test", builder.UnquoteIdentifier("`Test`"));
+
+ adapter.SelectCommand.Connection = null;
+ AssertExtensions.Throws<InvalidOperationException>(() => builder.QuoteIdentifier("Test"), quoteErrMsg);
+ AssertExtensions.Throws<InvalidOperationException>(() => builder.UnquoteIdentifier("'Test'"), unquoteErrMsg);
+ }
}
});
}
command.ExecuteNonQuery();
}
}
-}
\ No newline at end of file
+}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using Xunit;
-using System.Collections.Generic;
-using System.Data.OleDb;
+using System.Data;
using System.IO;
using System.Runtime.CompilerServices;
-using System.Text.RegularExpressions;
+using Xunit;
namespace System.Data.OleDb.Tests
{
public class OleDbCommandTests : OleDbTestBase
{
[ConditionalFact(Helpers.IsDriverAvailable)]
+ public void UpdatedRowSource_SetInvalidValue_Throws()
+ {
+ const int InvalidValue = 50;
+ using (var cmd = (OleDbCommand)OleDbFactory.Instance.CreateCommand())
+ {
+ Assert.Equal(UpdateRowSource.Both, cmd.UpdatedRowSource);
+ cmd.UpdatedRowSource = UpdateRowSource.FirstReturnedRecord;
+ Assert.Equal(UpdateRowSource.FirstReturnedRecord, cmd.UpdatedRowSource);
+ AssertExtensions.Throws<ArgumentOutOfRangeException>(
+ () => cmd.UpdatedRowSource = (UpdateRowSource)InvalidValue,
+ $"The {nameof(UpdateRowSource)} enumeration value, {InvalidValue}, is invalid.\r\nParameter name: {nameof(UpdateRowSource)}"
+ );
+ }
+ }
+
+ [ConditionalFact(Helpers.IsDriverAvailable)]
+ public void CommandTimeout_SetInvalidValue_Throws()
+ {
+ const int InvalidValue = -1;
+ using (var cmd = new OleDbCommand(default, connection, transaction))
+ {
+ AssertExtensions.Throws<ArgumentException>(
+ () => cmd.CommandTimeout = InvalidValue,
+ $"Invalid CommandTimeout value {InvalidValue}; the value must be >= 0.\r\nParameter name: {nameof(cmd.CommandTimeout)}"
+ );
+ }
+ }
+
+ [ConditionalFact(Helpers.IsDriverAvailable)]
+ public void ResetCommandTimeout_ResetsToDefault()
+ {
+ using (var cmd = new OleDbCommand(default, connection, transaction))
+ {
+ const int DefaultValue = 30;
+ Assert.Equal(DefaultValue, cmd.CommandTimeout);
+ cmd.CommandTimeout = DefaultValue + 50;
+ Assert.Equal(DefaultValue + 50, cmd.CommandTimeout);
+ cmd.ResetCommandTimeout();
+ Assert.Equal(DefaultValue, cmd.CommandTimeout);
+ }
+ }
+
+ [ConditionalFact(Helpers.IsDriverAvailable)]
public void CommandType_SetInvalidValue_Throws()
{
+ const int InvalidValue = 0;
using (var cmd = (OleDbCommand)OleDbFactory.Instance.CreateCommand())
{
AssertExtensions.Throws<ArgumentOutOfRangeException>(
- () => cmd.CommandType = (CommandType)0,
- $"The CommandType enumeration value, 0, is invalid.\r\nParameter name: {nameof(cmd.CommandType)}"
+ () => cmd.CommandType = (CommandType)InvalidValue,
+ $"The CommandType enumeration value, {InvalidValue}, is invalid.\r\nParameter name: {nameof(cmd.CommandType)}"
);
}
}
[OuterLoop]
[ConditionalFact(Helpers.IsDriverAvailable)]
+ public void Prepare_ClosedConnection_Throws()
+ {
+ RunTest((command, tableName) => {
+ command.CommandText = @"SELECT * FROM " + tableName;
+ var currentConnection = command.Connection;
+ var oleDbConnection = new OleDbConnection(ConnectionString);
+ oleDbConnection.Open();
+ command.Connection = oleDbConnection;
+ oleDbConnection.Close();
+ AssertExtensions.Throws<InvalidOperationException>(
+ () => command.Prepare(),
+ $"{nameof(command.Prepare)} requires an open and available Connection. The connection's current state is closed."
+ );
+ command.Connection = currentConnection;
+ });
+ }
+
+ [OuterLoop]
+ [ConditionalFact(Helpers.IsDriverAvailable)]
+ public void Prepare_MultipleCases_ThrowsForInvalidQuery()
+ {
+ RunTest((command, tableName) => {
+ Assert.Equal(ConnectionState.Open, connection.State);
+ command.CommandText = "INVALID_STATEMENT";
+ AssertExtensions.Throws<OleDbException>(
+ () => command.Prepare(),
+ "Invalid SQL statement; expected 'DELETE', 'INSERT', 'PROCEDURE', 'SELECT', or 'UPDATE'."
+ );
+ command.CommandText = @"UPDATE " + tableName + " SET NumPlants ? WHERE Firstname = ?";
+ AssertExtensions.Throws<OleDbException>(
+ () => command.Prepare(),
+ $"Syntax error in UPDATE statement."
+ );
+ });
+ }
+
+ [OuterLoop]
+ [ConditionalFact(Helpers.IsDriverAvailable)]
+ public void Prepare_InsertMultipleItems_UseTableDirectToVerify()
+ {
+ RunTest((command, tableName) => {
+ command.CommandText = @"INSERT INTO " + tableName + " (Firstname, NumPlants) VALUES (?, ?)";
+ command.Prepare(); // Good to use when command used multiple times
+
+ command.Parameters.Add(command.CreateParameter());
+ command.Parameters.Add(command.CreateParameter());
+
+ object[] newItems = new object[] {
+ new { Firstname = "John", NumPlants = 7 },
+ new { Firstname = "Mark", NumPlants = 12 },
+ new { Firstname = "Nick", NumPlants = 6 }
+ };
+ foreach (dynamic item in newItems)
+ {
+ command.Parameters[0].Value = item.Firstname;
+ command.Parameters[1].Value = item.NumPlants;
+ command.ExecuteNonQuery();
+ }
+ var currentCommandType = command.CommandType;
+ command.CommandType = CommandType.TableDirect;
+ command.CommandText = tableName;
+ using (OleDbDataReader reader = command.ExecuteReader())
+ {
+ Assert.True(reader.Read(), "skip existing row");
+ Assert.True(reader.Read(), "skip existing row");
+ foreach (dynamic item in newItems)
+ {
+ Assert.True(reader.Read(), "validate new row");
+ Assert.Equal(item.Firstname, reader["Firstname"]);
+ Assert.Equal(item.NumPlants, reader["NumPlants"]);
+ }
+ object x;
+ AssertExtensions.Throws<IndexOutOfRangeException>(() => x = reader["MissingColumn"], "MissingColumn");
+ }
+ command.CommandType = currentCommandType;
+ });
+ }
+
+ [OuterLoop]
+ [ConditionalFact(Helpers.IsDriverAvailable)]
+ public void Parameters_AddNullParameter_Throws()
+ {
+ RunTest((command, tableName) => {
+ AssertExtensions.Throws<ArgumentNullException>(
+ () => command.Parameters.Add(null),
+ $"The {nameof(OleDbParameterCollection)} only accepts non-null {nameof(OleDbParameter)} type objects.\r\nParameter name: value"
+ );
+ command.CommandText = "SELECT * FROM " + tableName + " WHERE NumPlants = ?";
+ command.Parameters.Add(new OleDbParameter("@p1", 7));
+ using (OleDbDataReader reader = command.ExecuteReader())
+ {
+ Assert.True(reader.Read());
+ Assert.Equal("John", reader["Firstname"]);
+ Assert.Equal(7, reader["NumPlants"]);
+ Assert.False(reader.Read(), "Expected to find only one item");
+ }
+ });
+ }
+
+ [OuterLoop]
+ [ConditionalFact(Helpers.IsDriverAvailable)]
+ public void ExecuteNonQuery_NullConnection_Throws()
+ {
+ RunTest((command, tableName) => {
+ command.CommandText = @"SELECT * FROM " + tableName;
+ var currentConnection = command.Connection;
+ command.Connection = null;
+ AssertExtensions.Throws<InvalidOperationException>(
+ () => command.ExecuteNonQuery(),
+ $"{nameof(command.ExecuteNonQuery)}: {nameof(command.Connection)} property has not been initialized."
+ );
+ command.Connection = currentConnection;
+ });
+ }
+
+ [OuterLoop]
+ [ConditionalFact(Helpers.IsDriverAvailable)]
public void CommandType_InvalidType_Throws()
{
RunTest((command, tableName) => {
command.ExecuteNonQuery();
}
}
-}
\ No newline at end of file
+}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using Xunit;
using System.Collections.Generic;
using System.Data.Common;
-using System.Data.OleDb;
using System.IO;
-using System.Text;
-using System.Text.RegularExpressions;
+using Xunit;
namespace System.Data.OleDb.Tests
{
}
[ConditionalFact(Helpers.IsDriverAvailable)]
+ public void StateChange_ChangeState_TriggersEvent()
+ {
+ int timesCalled = 0;
+ Action<object, StateChangeEventArgs> OnStateChange = (sender, args) => {
+ timesCalled++;
+ };
+ using (var oleDbConnection = new OleDbConnection(ConnectionString))
+ {
+ oleDbConnection.StateChange += new StateChangeEventHandler(OnStateChange);
+ oleDbConnection.Open();
+ oleDbConnection.Close();
+ Assert.Equal(2, timesCalled);
+ }
+ }
+
+ [ConditionalFact(Helpers.IsDriverAvailable)]
public void BeginTransaction_InvalidIsolationLevel_Throws()
{
using (var oleDbConnection = new OleDbConnection(ConnectionString))
}
}
+ [ConditionalFact(Helpers.IsAceDriverAvailable)]
+ public void BeginTransaction_CallTwice_Throws()
+ {
+ using (var conn = new OleDbConnection(ConnectionString))
+ {
+ conn.Open();
+ using (var tx = conn.BeginTransaction())
+ {
+ var cmd = conn.CreateCommand();
+ cmd.CommandText = "CREATE TABLE table_x.csv (column_y NVARCHAR(40));";
+ cmd.Transaction = tx;
+ cmd.ExecuteNonQuery();
+ AssertExtensions.Throws<InvalidOperationException>(
+ () => conn.BeginTransaction(),
+ $"{nameof(OleDbConnection)} does not support parallel transactions."
+ );
+ }
+ conn.Close();
+ }
+ }
+
+ [ConditionalFact(Helpers.IsAceDriverAvailable)]
+ public void CommitTransaction_AfterConnectionClosed_Throws()
+ {
+ using (var conn = new OleDbConnection(ConnectionString))
+ {
+ conn.Open();
+ using (var tx = conn.BeginTransaction())
+ {
+ var cmd = conn.CreateCommand();
+ cmd.CommandText = "CREATE TABLE table_x.csv (column_y NVARCHAR(40));";
+ cmd.Transaction = tx;
+ cmd.ExecuteNonQuery();
+ conn.Close();
+ AssertExtensions.Throws<InvalidOperationException>(
+ () => tx.Commit(),
+ $"This {nameof(OleDbTransaction)} has completed; it is no longer usable."
+ );
+ }
+ }
+ }
+
+ [ConditionalFact(Helpers.IsDriverAvailable)]
+ public void GetDefaults_AnyGivenState_DoesNotThrow()
+ {
+ const int DefaultTimeout = 15;
+ Action<OleDbConnection> VerifyDefaults = (conn) => {
+ Assert.Equal(DefaultTimeout, conn.ConnectionTimeout);
+ Assert.Contains(conn.DataSource, TestDirectory);
+ Assert.Empty(conn.Database);
+ };
+ using (var oleDbConnection = new OleDbConnection())
+ {
+ VerifyDefaults(oleDbConnection);
+ oleDbConnection.ConnectionString = ConnectionString;
+ oleDbConnection.Open();
+ VerifyDefaults(oleDbConnection);
+ oleDbConnection.Close();
+ VerifyDefaults(oleDbConnection);
+ }
+ }
+
+ [ConditionalFact(Helpers.IsDriverAvailable)]
+ public void CreateCommand_AsDbConnection_IsOleDb()
+ {
+ DbConnection dbConnection = connection as DbConnection;
+ DbCommand dbCommand = dbConnection.CreateCommand();
+ Assert.NotNull(dbCommand);
+ Assert.IsType<OleDbCommand>(dbCommand);
+ }
+
[ConditionalFact(Helpers.IsDriverAvailable)]
public void Provider_SetProperlyFromCtor()
{
}
}
+ [ConditionalFact(Helpers.IsDriverAvailable)]
+ public void GetSchema_NoArgs_ReturnsMetaDataCollections()
+ {
+ if (PlatformDetection.IsWindows7)
+ {
+ return; // [ActiveIssue(37438)]
+ }
+
+ DataTable t1 = connection.GetSchema();
+ DataTable t2 = connection.GetSchema(DbMetaDataCollectionNames.MetaDataCollections);
+ Assert.Equal(t1.Rows.Count, t2.Rows.Count);
+
+ foreach (DataColumn dc in t1.Columns)
+ {
+ for (int i = 0; i < t1.Rows.Count; i++)
+ {
+ Assert.Equal(t1.Rows[i][dc.ColumnName], t2.Rows[i][dc.ColumnName]);
+ }
+ }
+ }
+
[ConditionalTheory(Helpers.IsDriverAvailable)]
[InlineData(nameof(DbMetaDataCollectionNames.MetaDataCollections), "CollectionName")]
[InlineData(nameof(DbMetaDataCollectionNames.DataSourceInformation), "CompositeIdentifierSeparatorPattern")]
$"Column '{MissingColumn}' does not belong to table {tableName}.");
}
+ [OuterLoop]
[ConditionalFact(Helpers.IsDriverAvailable)]
+ public void GetOleDbSchemaTable_ReturnsTableInfo()
+ {
+ string tableName = Helpers.GetTableName(nameof(GetOleDbSchemaTable_ReturnsTableInfo));
+ command.CommandText = @"CREATE TABLE t1.csv (CustomerName NVARCHAR(40));";
+ command.ExecuteNonQuery();
+ command.CommandText = @"CREATE TABLE t2.csv (CustomerName NVARCHAR(40));";
+ command.ExecuteNonQuery();
+ DataTable listedTables = connection.GetOleDbSchemaTable(
+ OleDbSchemaGuid.Tables, new object[] {null, null, null, "Table"});
+
+ Assert.NotNull(listedTables);
+ Assert.Equal(2, listedTables.Rows.Count);
+ Assert.Equal("t1#csv", listedTables.Rows[0][2].ToString());
+ Assert.Equal("t2#csv", listedTables.Rows[1][2].ToString());
+
+ command.CommandText = @"DROP TABLE t1.csv";
+ command.ExecuteNonQuery();
+ command.CommandText = @"DROP TABLE t2.csv";
+ command.ExecuteNonQuery();
+ }
+
+ [ConditionalFact(Helpers.IsAceDriverAvailable)]
public void ChangeDatabase_EmptyDatabase_Throws()
{
using (var oleDbConnection = new OleDbConnection(ConnectionString))
{
oleDbConnection.Open();
+ Assert.Throws<ArgumentException>(() => oleDbConnection.ChangeDatabase(null));
+ Assert.Throws<ArgumentException>(() => oleDbConnection.ChangeDatabase(" "));
Assert.Throws<ArgumentException>(() => oleDbConnection.ChangeDatabase(string.Empty));
+ AssertExtensions.Throws<InvalidOperationException>(
+ () => oleDbConnection.ChangeDatabase("ReadOnlyShouldThrow"),
+ "The 'current catalog' property was read-only, or the consumer attempted to set values of properties " +
+ "in the Initialization property group after the data source object was initialized. " +
+ "Consumers can set the value of a read-only property to its current value. " +
+ "This status is also returned if a settable column property could not be set for the particular column."
+ );
}
}
Assert.Empty(connectionStringBuilder.Provider);
}
}
-}
\ No newline at end of file
+}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using Xunit;
-using System.Collections.Generic;
-using System.Data.OleDb;
using System.IO;
using System.Runtime.CompilerServices;
-using System.Text.RegularExpressions;
-using System.Transactions;
+using Xunit;
namespace System.Data.OleDb.Tests
{
command.ExecuteNonQuery();
}
}
-}
\ No newline at end of file
+}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using Xunit;
-using System.Collections.Generic;
-using System.Data.OleDb;
using System.IO;
using System.Runtime.CompilerServices;
-using System.Text.RegularExpressions;
+using Xunit;
namespace System.Data.OleDb.Tests
{
public class OleDbDataReaderTests : OleDbTestBase
{
+ [OuterLoop]
+ [ConditionalFact(Helpers.IsDriverAvailable)]
+ public void FieldCount_NoMetadata_ReturnsZero()
+ {
+ command.CommandText = @"CREATE TABLE sample.csv;";
+ using (OleDbDataReader reader = command.ExecuteReader())
+ {
+ Assert.Equal(0, reader.FieldCount);
+ Assert.Equal(0, reader.VisibleFieldCount);
+ }
+ }
+
[ConditionalFact(Helpers.IsDriverAvailable)]
public void ExecuteNonQuery_TableNameWithoutCsvExtension_Throws()
{
reader.Read();
Assert.True(reader.HasRows);
DataTable schema = reader.GetSchemaTable();
- Assert.Equal(4, schema.Rows.Count);
+ Assert.Equal(5, schema.Rows.Count);
AssertExtensions.Throws<IndexOutOfRangeException>(
- () => reader.GetString(5),
+ () => reader.GetString(6),
"Index was outside the bounds of the array.");
});
}
Assert.Equal("XYZ", values[1]);
Assert.Equal(42.2, values[2]);
Assert.Equal(48.3f, values[3]);
+ Assert.Equal(new DateTime(2015, 1, 11, 12, 54, 1), values[4]);
});
}
{
RunTest((reader) => {
DataTable schema = reader.GetSchemaTable();
- Assert.Equal(4, schema.Rows.Count);
+ Assert.Equal(5, schema.Rows.Count);
Assert.Equal("CustomerName", schema.Rows[1].Field<String>("ColumnName"));
Assert.Equal(typeof(string), schema.Rows[1].Field<Type>("DataType"));
Assert.Equal(40, schema.Rows[1].Field<int>("ColumnSize"));
{
RunTest((reader) => {
DataTable schema = reader.GetSchemaTable();
- Assert.Equal(4, schema.Rows.Count);
+ Assert.Equal(5, schema.Rows.Count);
Assert.Equal("CustomerID", schema.Rows[0].Field<String>("ColumnName"));
Assert.Equal("CustomerName", schema.Rows[1].Field<String>("ColumnName"));
Assert.Equal("SingleAmount", schema.Rows[2].Field<String>("ColumnName"));
Assert.Equal("RealAmount", schema.Rows[3].Field<String>("ColumnName"));
+ Assert.Equal("DateChecked", schema.Rows[4].Field<String>("ColumnName"));
});
}
{
RunTest((reader) => {
DataTable schema = reader.GetSchemaTable();
- Assert.Equal(4, schema.Rows.Count);
+ Assert.Equal(5, schema.Rows.Count);
Assert.Equal(typeof(int), schema.Rows[0].Field<Type>("DataType"));
Assert.Equal(typeof(string), schema.Rows[1].Field<Type>("DataType"));
Assert.Equal(typeof(double), schema.Rows[2].Field<Type>("DataType"));
Assert.Equal(typeof(float), schema.Rows[3].Field<Type>("DataType"));
+ Assert.Equal(typeof(DateTime), schema.Rows[4].Field<Type>("DataType"));
});
}
}
[OuterLoop]
+ [ConditionalFact(Helpers.IsDriverAvailable)]
+ public void Read_GetDateTime_Success()
+ {
+ RunTest((reader) => {
+ Assert.True(reader.HasRows);
+ reader.Read();
+ Assert.Throws<InvalidCastException>(() => reader.GetFloat(2));
+ Assert.Equal(new DateTime(2015, 1, 11, 12, 54, 1), reader.GetDateTime(4));
+ });
+ }
+
+ [OuterLoop]
[ConditionalTheory(Helpers.IsDriverAvailable)]
[InlineData(0)]
[InlineData(1)]
});
}
+ [OuterLoop]
+ [ConditionalFact(Helpers.IsDriverAvailable)]
+ public void InnerReader_OpenReaderExists_Throws()
+ {
+ RunTest((reader) => {
+ AssertExtensions.Throws<InvalidOperationException>(
+ () => command.ExecuteReader(),
+ "There is already an open DataReader associated with this Command which must be closed first."
+ );
+ });
+ }
+
[ConditionalFact(Helpers.IsDriverAvailable)]
public void GetEnumerator_BadType_Throws()
{
CustomerID INT,
CustomerName NVARCHAR(40),
SingleAmount FLOAT,
- RealAmount REAL);";
+ RealAmount REAL,
+ DateChecked DATETIME);";
command.ExecuteNonQuery();
Assert.True(File.Exists(Path.Combine(TestDirectory, tableName)));
CustomerID,
CustomerName,
SingleAmount,
- RealAmount)
- VALUES ( 123, 'XYZ', @value, @realValue );";
+ RealAmount,
+ DateChecked)
+ VALUES ( 123, 'XYZ', @value, @realValue, '01/11/2015 12:54:01' );";
#pragma warning disable 612,618
command.Parameters.Add("@value", 42.2);
command.Parameters.Add("@realValue", 48.3);
command.ExecuteNonQuery();
}
- command.CommandText = "SELECT CustomerID, CustomerName, SingleAmount, RealAmount FROM " + tableName;
+ command.CommandText = "SELECT CustomerID, CustomerName, SingleAmount, RealAmount, DateChecked FROM " + tableName;
using (OleDbDataReader reader = schemaOnly ? command.ExecuteReader(CommandBehavior.SchemaOnly) : command.ExecuteReader())
{
testAction(reader);
command.ExecuteNonQuery();
}
}
-}
\ No newline at end of file
+}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using Xunit;
using System.Collections.Generic;
-using System.Data.OleDb;
-using System.IO;
using System.Linq;
-using System.Text.RegularExpressions;
+using Xunit;
namespace System.Data.OleDb.Tests
{
}
}
}
-}
\ No newline at end of file
+}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using Xunit;
-using System.Data.OleDb;
using System.IO;
+using Xunit;
namespace System.Data.OleDb.Tests
{
projects / platform / upstream / dotnet / runtime.git / commitdiff