public void Ctor_throws_when_invalid_isolation_level()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
connection.Open();
var ex = Assert.Throws<ArgumentException>(() => connection.BeginTransaction(0));
Assert.Equal(Strings.FormatInvalidIsolationLevel(0), ex.Message);
}
}
public void Ctor_unsets_read_uncommitted_when_serializable()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
connection.Open();
using (connection.BeginTransaction(IsolationLevel.Serializable))
{
Assert.Equal(0L, connection.ExecuteScalar<long>("PRAGMA read_uncommitted"));
}
}
}
public void ConnectionString_setter_throws_when_open()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
connection.Open();
var ex = Assert.Throws<InvalidOperationException>(
() => connection.ConnectionString = "Filename=test.db");
Assert.Equal(Strings.ConnectionStringRequiresClosedConnection, ex.Message);
}
}
public void IsolationLevel_is_infered_when_unspecified()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
connection.Open();
connection.ExecuteNonQuery("PRAGMA read_uncommitted = 1");
using (var transaction = connection.BeginTransaction())
{
Assert.Equal(IsolationLevel.ReadUncommitted, transaction.IsolationLevel);
}
}
}
public void IsolationLevel_throws_when_completed()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
connection.Open();
var transaction = connection.BeginTransaction();
transaction.Dispose();
var ex = Assert.Throws<InvalidOperationException>(() => transaction.IsolationLevel);
Assert.Equal(Strings.TransactionCompleted, ex.Message);
}
}
public void HasRows_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT 1";
connection.Open();
using (var reader = command.ExecuteReader())
{
Assert.True(reader.HasRows);
}
}
}
}
public void FieldCount_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT 1";
connection.Open();
using (var reader = command.ExecuteReader())
{
Assert.Equal(1, reader.FieldCount);
}
}
}
}
public void ParameterName_doesnt_unset_bound_when_unchanged()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT @Parameter";
var parameter = command.Parameters.AddWithValue("@Parameter", 1);
connection.Open();
command.ExecuteNonQuery();
parameter.ParameterName = "@Parameter";
Assert.True(parameter.Bound);
}
}
}
public void RecordsAffected_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
connection.Open();
CreateTestTable(connection);
command.CommandText = "INSERT INTO TestTable (Int32Column) VALUES (2)";
using (var reader = command.ExecuteReader())
{
Assert.Equal(1, reader.RecordsAffected);
}
}
}
}
public void DataSource_returns_actual_filename_when_open()
{
using (var connection = new SQLiteConnection("Filename=test.db"))
{
connection.Open();
var result = connection.DataSource;
Assert.True(Path.IsPathRooted(result));
Assert.Equal("test.db", Path.GetFileName(result));
}
}
public void GetChar_not_supported()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT 't'";
connection.Open();
using (var reader = command.ExecuteReader())
{
reader.Read();
var ex = Assert.Throws<ArgumentException>(() => reader.GetChar(0));
Assert.Equal(Strings.FormatUnknownDataType(typeof(char)), ex.Message);
}
}
}
}
public void BeginTransaction_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
connection.Open();
using (var transaction = connection.BeginTransaction())
{
Assert.NotNull(transaction);
Assert.Same(transaction, connection.Transaction);
Assert.Equal(connection, transaction.Connection);
Assert.Equal(IsolationLevel.Serializable, transaction.IsolationLevel);
}
}
}
public void BeginTransaction_throws_when_parallel_transaction()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
connection.Open();
using (connection.BeginTransaction())
{
var ex = Assert.Throws<InvalidOperationException>(() => connection.BeginTransaction());
Assert.Equal(Strings.ParallelTransactionsNotSupported, ex.Message);
}
}
}
public void GetFieldValue_throws_when_null()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT NULL";
connection.Open();
using (var reader = command.ExecuteReader())
{
reader.Read();
Assert.Throws<InvalidCastException>(() => reader.GetFieldValue<long>(0));
Assert.Throws<InvalidCastException>(() => reader.GetFieldValue<double>(0));
Assert.Throws<InvalidCastException>(() => reader.GetFieldValue<string>(0));
Assert.Throws<InvalidCastException>(() => reader.GetFieldValue<byte[]>(0));
}
}
}
}
public void GetOrdinal_throws_when_unknown()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT 1";
connection.Open();
using (var reader = command.ExecuteReader())
{
var ex = Assert.Throws<IndexOutOfRangeException>(() => reader.GetOrdinal("Unknown"));
Assert.Equal("Unknown", ex.Message);
}
}
}
}
public void IsDBNull_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT NULL";
connection.Open();
using (var reader = command.ExecuteReader())
{
Assert.True(reader.IsDBNull(0));
}
}
}
}
public void Open_throws_when_error()
{
using (var connection = new SQLiteConnection("Filename=:*?\"<>|"))
{
var ex = Assert.Throws<SQLiteException>(() => connection.Open());
Assert.Equal(14, ex.ErrorCode);
}
}
public void Close_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT 1 UNION SELECT 2";
connection.Open();
using (var reader = command.ExecuteReader())
{
reader.Read();
reader.Read();
reader.Close();
Assert.Null(command.OpenReader);
Assert.True(reader.IsClosed);
}
// NOTE: This would equal two if not reset
Assert.Equal(1L, command.ExecuteScalar());
}
}
}
public void Open_can_be_called_when_disposed()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
connection.Dispose();
connection.Open();
}
}
private static void CreateTestTable(SQLiteConnection connection)
{
connection.Open();
connection.ExecuteNonQuery(@"
CREATE TABLE TestTable (
BooleanColumn BIT,
ByteColumn TINYINT,
DateTimeColumn DATETIME,
DecimalColumn DECIMAL,
FloatColumn SINGLE,
GuidColumn UNIQUEIDENTIFIER,
Int16Column SMALLINT,
Int32Column INT
)");
connection.ExecuteNonQuery(@"
INSERT INTO TestTable VALUES (
1,
1,
'2014-04-01 14:45:00',
'3.14',
3.14,
x'1cb113dcfbe69f44a8925e2a47b05350',
1,
1
)");
}
public void GetValues_when_null_scalar_column()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
connection.Open();
connection.ExecuteNonQuery(@"CREATE TABLE TestTable (Int32Column INT)");
connection.ExecuteNonQuery(@"INSERT INTO TestTable VALUES (NULL)");
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT * FROM TestTable";
using (var reader = command.ExecuteReader())
{
reader.Read();
var values = new object[1];
var count = reader.GetValues(values);
Assert.Equal(1, count);
Assert.Equal(DBNull.Value, values[0]);
}
}
}
}
public void GetValues_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT NULL, 1, 3.14, 'test', x'7e57'";
connection.Open();
using (var reader = command.ExecuteReader())
{
reader.Read();
var values = new object[5];
var count = reader.GetValues(values);
Assert.Equal(5, count);
Assert.Equal(DBNull.Value, values[0]);
Assert.Equal(1L, values[1]);
Assert.Equal(3.14, values[2]);
Assert.Equal("test", values[3]);
Assert.Equal(new byte[] { 0x7e, 0x57 }, values[4]);
}
}
}
}
public void GetValue_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT 1";
connection.Open();
using (var reader = command.ExecuteReader())
{
reader.Read();
Assert.Equal(1L, reader.GetValue(0));
}
}
}
}
public void Commit_throws_when_connection_closed()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
connection.Open();
using (var transaction = connection.BeginTransaction())
{
connection.Close();
var ex = Assert.Throws<InvalidOperationException>(() => transaction.Commit());
Assert.Equal(Strings.TransactionCompleted, ex.Message);
}
}
}
private static void CreateTestTable(SQLiteConnection connection)
{
connection.Open();
connection.ExecuteNonQuery(@"
CREATE TABLE TestTable (
TestColumn INTEGER
)");
}
public void Close_can_be_called_more_than_once()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
connection.Open();
connection.Close();
connection.Close();
}
}
public void GetOrdinal_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT 1 AS Column1";
connection.Open();
using (var reader = command.ExecuteReader())
{
Assert.Equal(0, reader.GetOrdinal("Column1"));
}
}
}
}
public void Dispose_closes_connection()
{
var connection = new SQLiteConnection("Filename=:memory:");
connection.Open();
var raised = false;
StateChangeEventHandler handler = (sender, e) =>
{
raised = true;
Assert.Equal(connection, sender);
Assert.Equal(ConnectionState.Open, e.OriginalState);
Assert.Equal(ConnectionState.Closed, e.CurrentState);
};
connection.StateChange += handler;
try
{
connection.Dispose();
Assert.True(raised);
Assert.Equal(ConnectionState.Closed, connection.State);
}
finally
{
connection.StateChange -= handler;
}
}
public void Open_throws_when_no_connection_string()
{
using (var connection = new SQLiteConnection())
{
var ex = Assert.Throws<InvalidOperationException>(() => connection.Open());
Assert.Equal(Strings.OpenRequiresSetConnectionString, ex.Message);
}
}
public void Dispose_can_be_called_more_than_once()
{
var connection = new SQLiteConnection("Filename=:memory:");
connection.Open();
connection.Dispose();
connection.Dispose();
}
