private bool InternalExecute()
{
this.Log.LogMessage("MbUnit {0} test runner",
typeof(Fixture).Assembly.GetName().Version);
this.DisplayTaskConfiguration();
// check data
this.VerifyData();
// create new report
this.result = new ReportResult();
// load and execute
using (
TestDomainDependencyGraph graph =
TestDomainDependencyGraph.BuildGraph(this.Assemblies, this.AssemblyPaths, FixtureFilters.Any, false))
{
graph.Log += new ErrorReporter(graph_Log);
ReportResult r = graph.RunTests();
graph.Log -= new ErrorReporter(graph_Log);
result.Merge(r);
}
this.GenerateReports();
return(result.Counter.FailureCount == 0);
}
public ReportResult GetReport()
{
ReportResult result = new ReportResult();
result.Date = DateTime.Now;
foreach (TreeTestDomain td in this.list)
{
if (td.TestEngine == null)
{
continue;
}
if (td.TestEngine.Report == null)
{
continue;
}
if (td.TestEngine.Report.Result == null)
{
continue;
}
result.Merge(td.TestEngine.Report.Result);
}
result.UpdateCounts();
return(result);
}
public int Main()
{
consoleOut.WriteLine("Start time: {0}", DateTime.Now.ToShortTimeString());
// add path
foreach (string assemblyPath in this.Arguments.AssemblyPath)
{
this.resolver.AddHintDirectory(assemblyPath);
}
// store real console
listener.Writer = Console.Out;
timer.Start();
try
{
ReportResult result = new ReportResult();
IFixtureFilter filter = arguments.GetFilter();
if (this.Arguments.Files.Length == 0)
{
consoleOut.WriteLine("[warning] No test assemblies to execute");
}
else
{
consoleOut.WriteLine("[info] Loading test assemblies");
using (
TestDomainDependencyGraph graph =
TestDomainDependencyGraph.BuildGraph(
this.Arguments.Files,
this.Arguments.AssemblyPath,
filter, this.Arguments.Verbose))
{
//define an assembly resolver routine in case the CLR cannot find our assemblies.
AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(AssemblyResolveHandler);
graph.Log += new ErrorReporter(graph_Log);
consoleOut.WriteLine("[info] Starting execution");
ReportResult r = graph.RunTests();
graph.Log -= new ErrorReporter(graph_Log);
result.Merge(r);
}
}
this.GenerateReport(arguments, result);
timer.Stop();
consoleOut.WriteLine("[info] MbUnit execution finished in {0}s.", timer.Duration);
return((0 == result.Counter.FailureCount) ? 0 : -1);
}
catch (System.Runtime.Remoting.RemotingException remote)
{
consoleOut.WriteLine("Could not load test domain. Please ensure you have referenced the installed version of MbUnit.Framework within your test assembly. \r\n The error message was: \r\n" + remote.Message);
return(-3);
}
catch (Exception ex)
{
consoleOut.WriteLine(ex.ToString());
return(-3);
}
}
private bool ExecuteTests(FileSet assemblySet)
{
if (assemblySet.FileNames.Count == 0)
{
this.Log(Level.Warning, "No tests in assembly set");
return(true);
}
// execute
string[] assemblieNames = new string[assemblySet.FileNames.Count];
assemblySet.FileNames.CopyTo(assemblieNames, 0);
// display information
this.Log(Level.Info, "Loading {0} assemblies", assemblySet.FileNames.Count);
foreach (string an in assemblieNames)
{
this.Log(Level.Info, "\tAssemblyName: {0}", an);
}
string[] dirNames = null;
if (this.AssemblyPaths != null)
{
dirNames = new string[this.AssemblyPaths.DirectoryNames.Count];
this.AssemblyPaths.DirectoryNames.CopyTo(dirNames, 0);
}
try
{
using (
TestDomainDependencyGraph graph =
TestDomainDependencyGraph.BuildGraph(assemblieNames, dirNames, FixtureFilters.Any, false))
{
graph.Log += new MbUnit.Core.Cons.CommandLine.ErrorReporter(graph_Log);
try
{
ReportResult r = graph.RunTests();
this.Log(Level.Info, "Finished running tests");
this.Log(Level.Info, "Merging results");
result.Merge(r);
return(r.Counter.FailureCount == 0);
}
finally
{
graph.Log -= new MbUnit.Core.Cons.CommandLine.ErrorReporter(graph_Log);
}
}
}
catch (Exception ex)
{
throw new BuildException("Unexpected engine error while running Tests", ex);
}
}
bool RunTestAssembly(string fileName, ReportResult reportResult)
{
Ensure.ArgumentIsNotNullOrEmptyString(fileName, "fileName");
string[] assemblyNames = new[] { fileName };
string[] dirNames = null;
if (AssemblyPaths != null)
{
dirNames = new string[AssemblyPaths.DirectoryNames.Count];
AssemblyPaths.DirectoryNames.CopyTo(dirNames, 0);
}
try
{
Log(Level.Info, "Loading assembly {0}", fileName);
using (
TestDomainDependencyGraph graph = TestDomainDependencyGraph.BuildGraph(assemblyNames,
dirNames,
CreateFilter(),
Verbose))
{
graph.Log += TestRunInfo_Log;
string originalWorkingDirectory = Environment.CurrentDirectory;
try
{
Environment.CurrentDirectory = WorkingDirectory.FullName;
ReportResult runResult = graph.RunTests();
Log(Level.Info, "Finished running tests");
Log(Level.Info, "Merging results");
reportResult.Merge(runResult);
UpdateNAntProperties(Properties, runResult);
return(runResult.Counter.FailureCount == 0);
}
finally
{
Environment.CurrentDirectory = originalWorkingDirectory;
graph.Log -= TestRunInfo_Log;
}
}
}
catch (Exception ex)
{
throw new BuildException("Unexpected error while running tests", ex);
}
}
public ReportResult RunTests()
{
ReportResult result = new ReportResult();
if (graph.VerticesCount == 0)
{
this.OnLog("No assembly to execute");
result.UpdateCounts();
return(result);
}
this.OnLog("Sorting assemblies by dependencies");
// create topological sort
ArrayList sortedVertices = new ArrayList();
TopologicalSortAlgorithm topo = new TopologicalSortAlgorithm(graph);
topo.Compute(sortedVertices);
if (sortedVertices.Count == 0)
{
throw new InvalidOperationException("Cannot be zero");
}
// set vertices colors
this.OnLog("Setting up fixture colors");
VertexColorDictionary colors = new VertexColorDictionary();
foreach (TestDomainVertex v in graph.Vertices)
{
colors.Add(v, GraphColor.White);
}
// execute each domain
foreach (TestDomainVertex v in sortedVertices)
{
// if vertex color is not white, skip it
GraphColor color = colors[v];
if (color != GraphColor.White)
{
this.OnLog("Skipping assembly {0} because dependent assembly failed", v.Domain.TestEngine.Explorer.AssemblyName);
// mark children
foreach (TestDomainVertex child in graph.AdjacentVertices(v))
{
colors[child] = GraphColor.Black;
}
continue;
}
this.OnLog("Loading {0}", v.Domain.TestEngine.Explorer.AssemblyName);
ReportCounter counter = v.Domain.TestEngine.GetTestCount();
this.OnLog("Found {0} tests", counter.RunCount);
this.OnLog("Running fixtures.");
v.Domain.TestEngine.RunPipes();
counter = v.Domain.TestEngine.GetTestCount();
this.OnLog("Tests finished: {0} tests, {1} success, {2} failures, {3} ignored"
, counter.RunCount
, counter.SuccessCount
, counter.FailureCount
, counter.IgnoreCount
);
result.Merge(v.Domain.TestEngine.Report.Result);
if (counter.FailureCount != 0)
{
// mark children as failed
colors[v] = GraphColor.Black;
foreach (TestDomainVertex child in graph.AdjacentVertices(v))
{
colors[child] = GraphColor.Black;
}
}
else
{
// mark vertex as succesfull
colors[v] = GraphColor.Gray;
}
}
result.UpdateCounts();
MbUnit.Framework.Assert.IsNotNull(result);
MbUnit.Framework.Assert.IsNotNull(result.Counter);
this.OnLog("All Tests finished: {0} tests, {1} success, {2} failures, {3} ignored in {4} seconds"
, result.Counter.RunCount
, result.Counter.SuccessCount
, result.Counter.FailureCount
, result.Counter.IgnoreCount
, result.Counter.Duration
);
return(result);
}