private void ExecuteTestAssembly(TestAssembly testAssembly)
{
this.TestListeners.BeforeAssembly(testAssembly);
// run assemblysetup
System.Runtime.CompilerServices.RuntimeHelpers.PrepareConstrainedRegions();
try
{
if (this.RunAssemblySetUp(testAssembly))
{
foreach (IFixture fixture in testAssembly.Fixtures)
{
using (FixtureRunner runner =
new FixtureRunner(
fixture,
testAssembly.GetTestCasesFromFixture(fixture),
this.TestListeners)
)
{
runner.Run();
}
// collect GC
GC.WaitForPendingFinalizers();
GC.Collect();
}
}
}
finally
{
// run assembly teardown
this.RunAssemblyTearDown(testAssembly);
this.TestListeners.AfterAssembly(testAssembly);
}
}
public void Run()
{
if (FixtureRunner != null)
{
FixtureRunner.RunTests(this);
}
}
public void SetUp()
{
mocks = new MockRepository();
browser = mocks.DynamicMock <IWebBrowser>();
resultParser = mocks.DynamicMock <IResultParser>();
resultListener = mocks.DynamicMock <IResultListener>();
fixtureRunner = new FixtureRunner(resultListener, browser, resultParser);
}
public override TestResult Run(EventListener listener, ITestFilter filter)
{
listener.TestStarted(this.TestName);
Fixture = Reflect.Construct(m_FixtureType);
RunFixtureSetUp();
var fixtureRunner = new FixtureRunner();
var concordionResult = fixtureRunner.Run(Fixture);
var testResult = NUnitTestResult(concordionResult, fixtureRunner.ResultPath);
RunFixtureTearDown();
listener.TestFinished(testResult);
return(testResult);
}
public void ConcordionTest()
{
var concordionResult = new FixtureRunner().Run(this);
if (concordionResult.HasExceptions)
{
throw new Exception("Exception in Concordion test: please see Concordion test reports");
}
else if (concordionResult.HasFailures)
{
Assert.Fail("Concordion Test Failures: " + concordionResult.FailureCount,
"for stack trace, please see Concordion test reports");
}
else
{
Assert.Pass();
}
}
public bool EmbeddedExecuted()
{
if (m_InTestRun)
{
return(true);
}
m_InTestRun = true;
var specificationConfig = new SpecificationConfig().Load(this.GetType());
specificationConfig.BaseInputDirectory = null;
var fixtureRunner = new FixtureRunner(specificationConfig);
var testResult = fixtureRunner.Run(this);
m_InTestRun = false;
return(!testResult.HasFailures && !testResult.HasExceptions);
}
/// <summary>
/// Perform the validation run, mark of any issues and return issues as well as analytics.
/// </summary>
/// <param name="currentAssembly">An assembly to pickup fixtures and templates from</param>
/// <returns>
/// The details of each validator fixture, template and instance which were checked
/// </returns>
public ValidatorRunResult Run(Assembly currentAssembly)
{
var validatorRunResult = new ValidatorRunResult();
validatorRunResult.RunDate = _dateToRun;
validatorRunResult.ShouldReport = true;
validatorRunResult.SummaryAtFixtureLevel = new ResultSummary();
validatorRunResult.SummaryAtTemplateLevel = new ResultSummary();
validatorRunResult.SummaryAtInstanceLevel = new ResultSummary();
validatorRunResult.FixtureResults = new List <ValidatorFixtureResult>();
try
{
foreach (var validatorFixtureInfo in currentAssembly.DefinedTypes.Where(ValidatorFixtureAttribute.HasAttribute))
{
var validatorFixtureRunner = new FixtureRunner(_environ, validatorFixtureInfo);
var validatorFixtureResult = validatorFixtureRunner.Run();
validatorRunResult.AddFixtureResult(validatorFixtureResult);
}
}
catch (Exception e)
{
validatorRunResult.Error = e;
}
if (validatorRunResult.Error != null)
{
validatorRunResult.Status = GroupStatus.Error;
}
else if (validatorRunResult.SummaryAtFixtureLevel.Failure > 0)
{
validatorRunResult.Status = GroupStatus.Failure;
}
else
{
validatorRunResult.Status = GroupStatus.Success;
}
return(validatorRunResult);
}
public bool DirectoryBasedExecuted(string baseInputDirectory)
{
if (m_InTestRun)
{
return(true);
}
m_InTestRun = true;
//work around for bug of NUnit GUI runner
baseInputDirectory = baseInputDirectory +
Path.DirectorySeparatorChar +
".." +
Path.DirectorySeparatorChar +
this.GetType().Assembly.GetName().Name;
var specificationConfig = new SpecificationConfig().Load(this.GetType());
specificationConfig.BaseInputDirectory = baseInputDirectory;
var fixtureRunner = new FixtureRunner(specificationConfig);
var testResult = fixtureRunner.Run(this);
m_InTestRun = false;
foreach (var failureDetail in testResult.FailureDetails)
{
Console.WriteLine(failureDetail.Message);
Console.WriteLine(failureDetail.StackTrace);
}
foreach (var errorDetail in testResult.ErrorDetails)
{
Console.WriteLine(errorDetail.Message);
Console.WriteLine(errorDetail.StackTrace);
Console.WriteLine(errorDetail.Exception);
}
return(!testResult.HasFailures && !testResult.HasExceptions);
}
void Run()
{
Begin();
try
{
if (!Ignore)
{
if (StartUpMethod != null)
{
try
{
StartUpMethod.Invoke(Instance, null);
}
catch (TargetInvocationException tie)
{
Exception exp = tie.InnerException;
foreach (ITest test in Tests)
{
test.Begin();
if (!test.Ignore)
{
test.Result.Message.AppendLine("Fixture set-up failed");
test.Result.SetFilteredStackTrace(exp.StackTrace);
test.Result.WriteExceptionToMessage(exp);
}
else
{
test.Result.WriteIgnoreToMessage(test, test.IgnoreReason);
}
test.End();
}
return;
}
}
try
{
FixtureRunner.RunTests(this);
}
catch (Exception exp)
{
foreach (ITest test in Tests)
{
if (!test.Ignore)
{
test.Result.Message.AppendLine("Fixture runner failed");
test.Result.WriteExceptionToOutput(exp);
if (test.Result.Status == TestStatus.Untested)
{
test.Begin();
test.Result.StackTrace = exp.StackTrace;
test.End();
}
}
else if (test.Result.Status == TestStatus.Untested)
{
test.Begin();
test.Result.WriteIgnoreToMessage(test, test.IgnoreReason);
test.End();
}
}
}
if (TearDownMethod != null)
{
try
{
TearDownMethod.Invoke(Instance, null);
}
catch (TargetInvocationException tie)
{
Exception exp = tie.InnerException;
foreach (ITest test in Tests)
{
if (!test.Ignore)
{
test.Result.Message.AppendLine("Fixture tear-down failed");
test.Result.WriteExceptionToOutput(exp);
}
}
}
}
}
else
{
foreach (ITest test in Tests)
{
test.Begin();
test.Result.WriteIgnoreToMessage(test, IgnoreReason);
test.End();
}
}
}
finally
{
End();
}
}
