public ReadOnlyException ConstructorTest02(string message, Exception exceptionInner)
{
ReadOnlyException target = new ReadOnlyException(message, exceptionInner);
return(target);
// TODO: add assertions to method ReadOnlyExceptionTests.ConstructorTest02(String, Exception)
}
public ReadOnlyException ConstructorTest01(string message)
{
ReadOnlyException target = new ReadOnlyException(message);
return(target);
// TODO: add assertions to method ReadOnlyExceptionTests.ConstructorTest01(String)
}
public ReadOnlyException ConstructorTest()
{
ReadOnlyException target = new ReadOnlyException();
return(target);
// TODO: add assertions to method ReadOnlyExceptionTests.ConstructorTest()
}
public void ConstructorTest()
{
const string message = "msg";
// Ensure ex.Message becomes the message property.
ReadOnlyException ex = new ReadOnlyException(message);
Assert.AreEqual(message, ex.Message);
// Ensure ex.Message and ex.InnerException are passed in properly.
Exception inner = new Exception("innerException");
ex = new ReadOnlyException(message, inner);
Assert.AreEqual(message, ex.Message);
Assert.AreSame(inner, ex.InnerException);
}
public Exception ProcessException(Exception innerException, DbConnection connection, string commandText, DbTransaction transaction)
{
Logger.LogException(innerException);
if (innerException is SqliteException ex)
{
SQLException sqlEx;
#if MICROSOFT_DATA_SQLITE
var errorCode = (SqliteResultCode)ex.SqliteErrorCode;
#elif SYSTEM_DATA_SQLITE
var errorCode = (SqliteResultCode)ex.ErrorCode;
#endif
switch (errorCode)
{
case SqliteResultCode.Corrupt:
case SqliteResultCode.NotADb:
case SqliteResultCode.Perm:
case SqliteResultCode.IoErr:
case SqliteResultCode.CantOpen:
case SqliteResultCode.Full:
case SqliteResultCode.Auth:
{
return(new FileAccessException(errorCode.ToString(), innerException));
}
case SqliteResultCode.ReadOnly:
{
sqlEx = new ReadOnlyException(null, innerException);
break;
}
case SqliteResultCode.Locked:
{
sqlEx = new ConnectionException("file is locked", ex);
break;
}
case SqliteResultCode.Constraint:
{
if (innerException.Message.IndexOf("UNIQUE constraint failed", StringComparison.OrdinalIgnoreCase) >= 0)
{
sqlEx = new UniqueConstraintException(null, innerException);
}
else
{
sqlEx = new ConstraintException(null, innerException);
}
break;
}
default:
{
sqlEx = new SQLException(null, innerException);
break;
}
}
if (connection != null)
{
try
{
sqlEx.ConnectionString = connection.ConnectionString;
sqlEx.ConnectionState = connection.State.ToString();
}
catch (ObjectDisposedException)
{
sqlEx.ConnectionState = "Disposed";
}
}
if (connection != null)
{
sqlEx.CommandText = commandText;
//newEx.Data.Add("CommandText", comm.CommandText);
}
return(sqlEx);
}
#if MICROSOFT_DATA_SQLITE
else if ((innerException is InvalidOperationException ioex) &&
ioex.Source == "Microsoft.Data.Sqlite")
{
return(new SQLException(null, innerException)
{
CommandText = commandText
});
}
protected override Exception ThrowExceptionHelper(DbConnection conn, DbCommand comm, Exception innerException)
{
if (innerException is SQLiteException)
{
SQLException sqlEx;
var ex = innerException as SQLiteException;
#if Mono
var errorCode = ex.ErrorCode;
#else
var errorCode = ex.ResultCode;
#endif
switch (errorCode)
{
case SQLiteErrorCode.Corrupt:
#if Mono
case SQLiteErrorCode.NotADatabase:
#else
case SQLiteErrorCode.NotADb:
#endif
case SQLiteErrorCode.Perm:
#if Mono
case SQLiteErrorCode.IOErr:
#else
case SQLiteErrorCode.IoErr:
#endif
case SQLiteErrorCode.CantOpen:
case SQLiteErrorCode.Full:
case SQLiteErrorCode.Auth:
{
return new FileAccessException(errorCode.ToString(), innerException);
}
case SQLiteErrorCode.ReadOnly:
{
sqlEx = new ReadOnlyException(null, innerException);
break;
}
case SQLiteErrorCode.Locked:
{
sqlEx = new ConnectionException("file is locked", ex);
break;
}
case SQLiteErrorCode.Constraint:
{
if (innerException.Message.IndexOf("UNIQUE constraint failed", StringComparison.OrdinalIgnoreCase) >= 0)
{
sqlEx = new UniqueConstraintException(null, innerException);
}
else
{
sqlEx = new ConstraintException(null, innerException);
}
break;
}
default:
{
sqlEx = new SQLException(null, innerException);
break;
}
}
if (conn != null)
{
try
{
sqlEx.ConnectionString = conn.ConnectionString;
sqlEx.ConnectionState = conn.State.ToString();
}
catch (ObjectDisposedException)
{
sqlEx.ConnectionState = "Disposed";
}
}
if (comm != null)
{
sqlEx.CommandText = comm.CommandText;
//newEx.Data.Add("CommandText", comm.CommandText);
}
return sqlEx;
}
else
{
return new ORMException(null, innerException);
}
}
public void ReadOnlyTest()
{
IIrcConfig config = new ReadOnlyIrcConfig(ircConfig);
// First, ensure properties are all equal
Assert.AreEqual(this.ircConfig.Server, config.Server);
Assert.AreEqual(this.ircConfig.Channel, config.Channel);
Assert.AreEqual(this.ircConfig.Port, config.Port);
Assert.AreEqual(this.ircConfig.UserName, config.UserName);
Assert.AreEqual(this.ircConfig.Nick, config.Nick);
Assert.AreEqual(this.ircConfig.RealName, config.RealName);
Assert.AreEqual(this.ircConfig.Password, config.Password);
Assert.AreEqual(this.ircConfig.QuitMessage, config.QuitMessage);
Assert.AreNotSame(this.ircConfig.BridgeBots, config.BridgeBots); // Should not be same reference.
// Next, ensure trying to convert to an IRCConfig results in a null (someone's going to do this).
Assert.IsNull(config as IrcConfig);
// Lastly, ensure setters throw exceptions.
ReadOnlyIrcConfig roConfig = config as ReadOnlyIrcConfig;
ReadOnlyException ex =
Assert.Throws <ReadOnlyException>(
delegate()
{
roConfig.Server = "NewServer";
}
);
Assert.IsTrue(ex.Message.Contains("Server"));
ex = Assert.Throws <ReadOnlyException>(
delegate()
{
roConfig.Channel = "#NewChannel";
}
);
Assert.IsTrue(ex.Message.Contains("Channel"));
ex = Assert.Throws <ReadOnlyException>(
delegate()
{
roConfig.Port = 4;
}
);
Assert.IsTrue(ex.Message.Contains("Port"));
ex = Assert.Throws <ReadOnlyException>(
delegate()
{
roConfig.UserName = "******";
}
);
Assert.IsTrue(ex.Message.Contains("UserName"));
ex = Assert.Throws <ReadOnlyException>(
delegate()
{
roConfig.Nick = "NewNick";
}
);
Assert.IsTrue(ex.Message.Contains("Nick"));
ex = Assert.Throws <ReadOnlyException>(
delegate()
{
roConfig.RealName = "NewRName";
}
);
Assert.IsTrue(ex.Message.Contains("RealName"));
ex = Assert.Throws <ReadOnlyException>(
delegate()
{
roConfig.Password = "******";
}
);
Assert.IsTrue(ex.Message.Contains("Password"));
ex = Assert.Throws <ReadOnlyException>(
delegate()
{
roConfig.QuitMessage = "I am quitting";
}
);
Assert.IsTrue(ex.Message.Contains("QuitMessage"));
}
