public void CloseConnections()
{
SqlCeConnectionPool.CloseSharedConnections();
TestConnectionString testConnection = new TestConnectionString();
testConnection.DeleteFile();
}
public void TearDown()
{
SqlCeConnectionPool.CloseSharedConnections();
TestConnectionString test = new TestConnectionString();
test.DeleteFile();
}
public void TestCleanup()
{
deleteCommand.Dispose();
insertCommand.Dispose();
updateCommand.Dispose();
base.TearDown();
SqlCeConnectionPool.CloseSharedConnections();
testConnection.DeleteFile();
}
public void PoolShouldCloseSharedConnection()
{
TestConnectionString testConnection = new TestConnectionString();
SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString);
using (DatabaseConnectionWrapper connection = SqlCeConnectionPool.CreateConnection(db)) {}
Assert.AreEqual(1, TestableSqlCeConnectionPool.PoolSize);
SqlCeConnectionPool.CloseSharedConnection(db);
Assert.AreEqual(0, TestableSqlCeConnectionPool.PoolSize);
}
public void DatabaseShouldCloseSharedConnection()
{
TestConnectionString file = new TestConnectionString();
SqlCeDatabase database = new SqlCeDatabase(file.ConnectionString);
using (DbConnection connection = SqlCeConnectionPool.CreateConnection(database)) {}
Assert.AreEqual(1, TestableSqlCeConnectionPool.PoolSize);
database.CloseSharedConnection();
Assert.AreEqual(0, TestableSqlCeConnectionPool.PoolSize);
}
public void ConnectionShouldRemainInPoolAfterReturnedConnectionDisposed()
{
TestConnectionString testConnection = new TestConnectionString();
SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString);
using (DbConnection connection = SqlCeConnectionPool.CreateConnection(db)) {}
DbConnection keepAlive = TestableSqlCeConnectionPool.GetConnection(0);
Assert.AreEqual(ConnectionState.Open, keepAlive.State);
}
public void ShouldNotAddConnectionToPoolIfOpenFails()
{
SqlCeDatabase db = new SqlCeDatabase("Data Source='invalid.sdf'");
try
{
DatabaseConnectionWrapper connection = SqlCeConnectionPool.CreateConnection(db);
}
catch (SqlCeException) {}
Assert.AreEqual(0, TestableSqlCeConnectionPool.PoolSize);
}
public void GetConnectionOpensConnectionInPool()
{
TestConnectionString testConnection = new TestConnectionString();
SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString);
using (DatabaseConnectionWrapper connection = SqlCeConnectionPool.CreateConnection(db))
{
DatabaseConnectionWrapper keepAlive = TestableSqlCeConnectionPool.GetConnection(0);
Assert.AreEqual(ConnectionState.Open, keepAlive.Connection.State);
}
}
public void GetConnectionReturnsDifferentConnectionThanOneInPool()
{
TestConnectionString testConnection = new TestConnectionString();
SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString);
using (DatabaseConnectionWrapper connection = SqlCeConnectionPool.CreateConnection(db))
{
DatabaseConnectionWrapper keepAlive = TestableSqlCeConnectionPool.GetConnection(0);
Assert.AreNotSame(connection, keepAlive);
}
}
public void GetConnectionAddsConnectionToPool()
{
TestConnectionString testConnection = new TestConnectionString();
SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString);
using (DatabaseConnectionWrapper connection = SqlCeConnectionPool.CreateConnection(db))
{
Assert.IsNotNull(connection);
Assert.AreEqual(1, TestableSqlCeConnectionPool.PoolSize);
}
}
public void GetConnectionWithPoolingReturnsSameConnection()
{
TestConnectionString testConnection = new TestConnectionString();
SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString);
using (DatabaseConnectionWrapper connection1 = SqlCeConnectionPool.CreateConnection(db, true))
{
using (DatabaseConnectionWrapper connection2 = SqlCeConnectionPool.CreateConnection(db, true))
{
Assert.AreSame(connection1, connection2);
Assert.AreEqual(1, TestableSqlCeConnectionPool.PoolSize);
}
}
}
public void GetConnectionReturnsNewConnectionButHasOnlyOneInPool()
{
TestConnectionString testConnection = new TestConnectionString();
SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString);
using (DatabaseConnectionWrapper connection1 = SqlCeConnectionPool.CreateConnection(db))
{
using (DatabaseConnectionWrapper connection2 = SqlCeConnectionPool.CreateConnection(db))
{
Assert.AreNotSame(connection1, connection2);
Assert.AreEqual(1, TestableSqlCeConnectionPool.PoolSize);
}
}
}
public void ExecuteResultSet_ShouldCloseConnection()
{
DbConnection connection;
using (DbCommand command = db.GetSqlStringCommand(queryString))
{
using (SqlCeResultSet reader = db.ExecuteResultSet(command))
{
connection = command.Connection;
}
// Force shared pool closed, this should close out shared connection used by the reader.
SqlCeConnectionPool.CloseSharedConnections();
Assert.AreEqual(ConnectionState.Closed, connection.State);
}
}
public void ExecuteResultSetWithBadCommandThrowsAndClosesConnection()
{
DbCommand badCommand = db.GetSqlStringCommand("select * from invalid");
try
{
db.ExecuteResultSet(badCommand);
}
catch (SqlCeException)
{
}
Assert.IsNotNull(badCommand.Connection); // Held open by pool
// Force shared connection closed
SqlCeConnectionPool.CloseSharedConnections();
Assert.IsNull(badCommand.Connection);
}
public void GetConnectionForTwoFilesAddsTwoConnectionsToPool()
{
TestConnectionString file1 = new TestConnectionString();
TestConnectionString file2 = new TestConnectionString("test2.sdf");
file2.CopyFile();
SqlCeDatabase db1 = new SqlCeDatabase(file1.ConnectionString);
SqlCeDatabase db2 = new SqlCeDatabase(file2.ConnectionString);
using (DbConnection connection1 = SqlCeConnectionPool.CreateConnection(db1))
{
using (DbConnection connection2 = SqlCeConnectionPool.CreateConnection(db2)) {}
}
Assert.AreEqual(2, TestableSqlCeConnectionPool.PoolSize);
SqlCeConnectionPool.CloseSharedConnections();
file2.DeleteFile();
}
public void CanExecuteReaderFromDbCommand()
{
// Repeating this from base instead of calling base class because base
// asserts don't match SQL CE database close semantics - we do explicit
// pooling in CE, so connection doesn't actually close on close.
IDataReader reader = db.ExecuteReader(queryCommand);
DbConnection connection = queryCommand.Connection;
string accumulator = "";
while (reader.Read())
{
accumulator += ((string)reader["RegionDescription"]).Trim();
}
reader.Close();
Assert.AreEqual("EasternWesternNorthernSouthern", accumulator);
Assert.AreEqual(ConnectionState.Open, connection.State);
// Forcing pool closed should close the connection
SqlCeConnectionPool.CloseSharedConnection(db);
Assert.AreEqual(ConnectionState.Closed, connection.State);
}
public void TearDown()
{
SqlCeConnectionPool.CloseSharedConnections();
}
public void DeleteDb()
{
SqlCeConnectionPool.CloseSharedConnections();
testConnection.DeleteFile();
}
