public void ExtendedConstructor_FileNotFoundException_Not()
{
const string msg = "Test MSG";
const string path = "Test PATH";
try
{
Raise <FileNotFoundException> .IfNot(true, msg, path);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
try
{
Raise <FileNotFoundException> .IfNot(false, msg, path);
}
catch (FileNotFoundException fex)
{
Assert.That(fex.Message, Is.EqualTo(msg));
Assert.That(fex.FileName, Is.EqualTo(path));
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
public void ExtendedConstructor_BigCtorException_Not()
{
var x = 3;
var y = decimal.MinValue;
var z = "ZZZ";
var t = new KeyValuePair <string, string>(z, z + z);
try
{
Raise <BigCtorException> .IfNot(true, x, y, z, t);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
try
{
Raise <BigCtorException> .IfNot(false, x, y, z, t);
}
catch (BigCtorException fex)
{
Assert.That(fex.Message, Is.EqualTo(x.ToString()));
Assert.That(fex.X, Is.EqualTo(x));
Assert.That(fex.Y, Is.EqualTo(y));
Assert.That(fex.Z, Is.EqualTo(z));
Assert.That(fex.T, Is.EqualTo(t));
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
private static T GetLegacyAttribute <T>(MemberInfo attributeProvider) where T : Attribute
{
var dllImportAttributes = attributeProvider.GetCustomAttributes(typeof(T), false)
.Cast <T>()
.ToArray();
Raise <LegacyWrapperException> .IfNot(dllImportAttributes.Length == 1, $"{attributeProvider.Name} must contain exactly one {typeof(T).Name}");
return(dllImportAttributes[0]);
}
public void ExceptionPrivateConstructor3_Not()
{
try
{
Raise <PrivateCtorException> .IfNot(false, "msg");
}
catch (ThrowerException)
{
Should.Throw <ThrowerException>(() => Raise <PrivateCtorException> .IfNot(false, "msg"));
}
}
public FileNotFoundException RaiseGeneric()
{
try
{
Raise<FileNotFoundException>.IfNot(File.Exists(NotExistingFilePath), NotExistingFilePath, NotExistingFilePath);
}
catch (FileNotFoundException ex)
{
return ex;
}
return default(FileNotFoundException);
}
public void InvalidOperationException_WithMsg_Not()
{
try
{
Raise <InvalidOperationException> .IfNot(false, "Pino");
Assert.Fail();
}
catch (InvalidOperationException ex)
{
Assert.AreEqual("Pino", ex.Message);
Assert.Pass();
}
}
public void ExceptionInternalConstructor3_Not()
{
try
{
Raise <ThrowerException> .IfNot(false, "A RANDOM MSG");
Assert.Fail();
}
catch (ThrowerException ex)
{
Assert.AreNotEqual("A RANDOM MSG", ex.Message);
Assert.Pass();
}
}
public void ArgumentNullException_WithMsg_Not()
{
try
{
Raise <ArgumentNullException> .IfNot(false, "Pino");
Assert.Fail();
}
catch (ArgumentNullException ex)
{
Assert.AreEqual("Pino", ex.Message);
Assert.Pass();
}
}
public static void TypeCheck(string input)
{
FunctionDecl main;
using (var file = new FileStream(input, FileMode.Open)) {
var scanner = new Scanner(file);
var parser = new Parser(scanner);
Raise <ParseException> .IfNot(parser.Parse());
main = parser.Prog;
}
main.Accept(new TypecheckVisitor());
main.Accept(new ReturnCheckVisitor());
}
public void ExtendedConstructor_TooManyArgs_Not()
{
try
{
Raise <ArgumentException> .IfNot(false, 1, "SNAFU", 3.14M);
}
catch (ArgumentException aex)
{
Assert.Pass(aex.Message);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
private static void ThreadTest()
{
for (var i = 0; i < 10000; ++i)
{
var msg = i.ToString(CultureInfo.InvariantCulture);
try
{
Raise <ArgumentException> .IfNot(false, msg);
}
catch (ArgumentException ex)
{
Assert.AreEqual(msg, ex.Message);
}
}
}
public void TrueCond()
{
Raise <Exception> .IfNot(true);
}
public void ArgumentNullException_Not()
{
Should.Throw <ArgumentNullException>(() => Raise <ArgumentNullException> .IfNot(false));
}
public void ExceptionPrivateConstructor1_Not()
{
Should.Throw <ThrowerException>(() => Raise <PrivateCtorException> .IfNot(false));
}
public void ExceptionInternalConstructor2_Not()
{
Should.Throw <InternalCtorException>(() => Raise <InternalCtorException> .IfNot(false, "msg"));
}
public void ExceptionWithoutConstructor2_Not()
{
Should.Throw <ThrowerException>(() => Raise <NoCtorException> .IfNot(false, "msg"));
}
public void InvalidOperationException_Not()
{
Should.Throw <InvalidOperationException>(() => Raise <InvalidOperationException> .IfNot(false));
}
public void Visit(LoadStmt load)
{
const string module = "<Module>";
const string program = "Program";
const string sysFuncs = "SystemFunctions";
const string userFuncs = "UserFunctions";
var foundProgram = false;
var foundSysFuncs = false;
var foundUserFuncs = false;
TypeDefinition userFuncsType = null;
// We load the assembly given by the statement.
Raise <TypeCheckException> .IfNot(File.Exists(load.Assembly));
var asmDef = AssemblyDefinition.ReadAssembly(load.Assembly);
var modDef = asmDef.MainModule;
// Type loading; in the first pass, we load all types. After that,
// all field types are loaded: we have to do at least two passes
// since field types may rely on types declared in the assembly we have to load.
var loadedTypes = new LinkedList <TypeDefinition>();
foreach (var typeDef in modDef.Types)
{
switch (typeDef.Name)
{
case module:
continue;
case program:
foundProgram = true;
continue;
case sysFuncs:
foundSysFuncs = true;
continue;
case userFuncs:
foundUserFuncs = true;
userFuncsType = typeDef;
continue;
default:
LoadType(typeDef);
loadedTypes.AddLast(typeDef);
break;
}
}
// An assembly produced by this language must have
// a set of predefined types.
Raise <TypeCheckException> .IfNot(foundProgram && foundSysFuncs && foundUserFuncs, "Invalid assembly");
foreach (var typeDef in loadedTypes)
{
LoadTypeFields(typeDef);
}
// Function loading...
Debug.Assert(userFuncsType != null);
foreach (var funcDef in userFuncsType.Methods)
{
LoadFunc(funcDef);
}
}
public void AbstractException2_Not()
{
Should.Throw <ThrowerException>(() => Raise <AbstractException> .IfNot(false, "msg"));
}