public IReadOnlyList<MethodGroup> DiscoverTestMethodGroups(Assembly assembly)
{
RunContext.Set(options);
var conventions = new ConventionDiscoverer(assembly).GetConventions();
var discoveredTestMethodGroups = new List<MethodGroup>();
foreach (var convention in conventions)
{
var classDiscoverer = new ClassDiscoverer(convention);
var candidateTypes = assembly.GetTypes();
var testClasses = classDiscoverer.TestClasses(candidateTypes);
var methodDiscoverer = new MethodDiscoverer(convention);
foreach (var testClass in testClasses)
{
var distinctMethodGroups = new Dictionary<string, MethodGroup>();
foreach (var testMethod in methodDiscoverer.TestMethods(testClass))
{
var methodGroup = new MethodGroup(testMethod);
distinctMethodGroups[methodGroup.FullName] = methodGroup;
}
discoveredTestMethodGroups.AddRange(distinctMethodGroups.Values);
}
}
return discoveredTestMethodGroups;
}
public IReadOnlyList <MethodGroup> DiscoverTestMethodGroups(Assembly assembly)
{
RunContext.Set(options);
var conventions = new ConventionDiscoverer(assembly).GetConventions();
var discoveredTestMethodGroups = new List <MethodGroup>();
foreach (var convention in conventions)
{
var classDiscoverer = new ClassDiscoverer(convention);
var candidateTypes = assembly.GetTypes();
var testClasses = classDiscoverer.TestClasses(candidateTypes);
var methodDiscoverer = new MethodDiscoverer(convention);
foreach (var testClass in testClasses)
{
var distinctMethodGroups = new Dictionary <string, MethodGroup>();
foreach (var testMethod in methodDiscoverer.TestMethods(testClass))
{
var methodGroup = new MethodGroup(testMethod);
distinctMethodGroups[methodGroup.FullName] = methodGroup;
}
discoveredTestMethodGroups.AddRange(distinctMethodGroups.Values);
}
}
return(discoveredTestMethodGroups);
}
public void DiscoverMethods(Assembly assembly)
{
var discovery = new BehaviorDiscoverer(assembly, customArguments).GetDiscovery();
try
{
var classDiscoverer = new ClassDiscoverer(discovery);
var candidateTypes = assembly.GetTypes();
var testClasses = classDiscoverer.TestClasses(candidateTypes);
var methodDiscoverer = new MethodDiscoverer(discovery);
foreach (var testClass in testClasses)
{
foreach (var testMethod in methodDiscoverer.TestMethods(testClass))
{
bus.Publish(new MethodDiscovered(testMethod));
}
}
}
finally
{
discovery.Dispose();
}
}
public ExecutionSummary Run(Type testClass, bool isOnlyTestClass)
{
var methods = methodDiscoverer.TestMethods(testClass);
var summary = new ExecutionSummary();
if (!methods.Any())
{
return(summary);
}
Start(testClass);
var classStopwatch = Stopwatch.StartNew();
var orderedMethods = OrderedMethods(methods, summary);
bool classLifecycleFailed = false;
bool runCasesInvokedByLifecycle = false;
try
{
Action <Action <Case> > runCases = caseLifecycle =>
{
runCasesInvokedByLifecycle = true;
foreach (var @case in YieldCases(orderedMethods, summary))
{
Start(@case);
Exception caseLifecycleException = null;
string consoleOutput;
using (var console = new RedirectedConsole())
{
var caseStopwatch = Stopwatch.StartNew();
try
{
caseLifecycle(@case);
}
catch (Exception exception)
{
caseLifecycleException = exception;
}
caseStopwatch.Stop();
@case.Duration += caseStopwatch.Elapsed;
consoleOutput = console.Output;
@case.Output += consoleOutput;
}
Console.Write(consoleOutput);
var caseHasNormalResult = @case.State == CaseState.Failed || @case.State == CaseState.Passed;
var caseLifecycleFailed = caseLifecycleException != null;
if (caseHasNormalResult)
{
if (@case.State == CaseState.Failed)
{
Fail(@case, summary);
}
else if (!caseLifecycleFailed)
{
Pass(@case, summary);
}
}
if (caseLifecycleFailed)
{
Fail(new Case(@case, caseLifecycleException), summary);
}
else if (!caseHasNormalResult)
{
Skip(@case, summary);
}
}
};
var runContext = isOnlyTestClass && methods.Count == 1
? new TestClass(testClass, runCases, methods.Single())
: new TestClass(testClass, runCases);
execution.Execute(runContext);
}
catch (Exception exception)
{
classLifecycleFailed = true;
foreach (var method in orderedMethods)
{
Fail(method, exception, summary);
}
}
if (!runCasesInvokedByLifecycle && !classLifecycleFailed)
{
//No cases ran, and we didn't already emit a general
//failure for each method, so emit a general skip for
//each method.
foreach (var method in orderedMethods)
{
var @case = new Case(method);
Skip(@case, summary);
}
}
classStopwatch.Stop();
Complete(testClass, summary, classStopwatch.Elapsed);
return(summary);
}
public ClassResult Run(Type testClass)
{
var methods = methodDiscoverer.TestMethods(testClass);
var cases = new List <Case>();
var parameterGenerationFailures = new List <Case>();
foreach (var method in methods)
{
try
{
bool methodHasParameterizedCase = false;
foreach (var parameters in Parameters(method))
{
methodHasParameterizedCase = true;
cases.Add(new Case(method, parameters));
}
if (!methodHasParameterizedCase)
{
cases.Add(new Case(method));
}
}
catch (Exception parameterGenerationException)
{
var @case = new Case(method);
@case.Fail(parameterGenerationException);
parameterGenerationFailures.Add(@case);
}
}
var casesBySkipState = cases.ToLookup(SkipCase);
var casesToSkip = casesBySkipState[true].ToArray();
var casesToExecute = casesBySkipState[false].ToArray();
var classResult = new ClassResult(testClass.FullName);
if (casesToSkip.Any())
{
TryOrderCases(casesToSkip);
foreach (var @case in casesToSkip)
{
classResult.Add(Skip(@case));
}
}
if (casesToExecute.Any())
{
if (TryOrderCases(casesToExecute))
{
Run(testClass, casesToExecute);
}
foreach (var @case in casesToExecute)
{
classResult.Add(@case.Exceptions.Any() ? Fail(@case) : Pass(@case));
}
}
if (parameterGenerationFailures.Any())
{
var casesToFailWithoutRunning = parameterGenerationFailures.ToArray();
TryOrderCases(casesToFailWithoutRunning);
foreach (var caseToFailWithoutRunning in casesToFailWithoutRunning)
{
classResult.Add(Fail(caseToFailWithoutRunning));
}
}
return(classResult);
}
public ClassResult Run(Type testClass)
{
var methods = methodDiscoverer.TestMethods(testClass);
var cases = new List <Case>();
var parameterGenerationFailures = new List <Case>();
foreach (var method in methods)
{
try
{
bool methodHasParameterizedCase = false;
foreach (var parameters in Parameters(method))
{
methodHasParameterizedCase = true;
cases.Add(new Case(method, parameters));
}
if (!methodHasParameterizedCase)
{
cases.Add(new Case(method));
}
}
catch (Exception parameterGenerationException)
{
var @case = new Case(method);
@case.Fail(parameterGenerationException);
parameterGenerationFailures.Add(@case);
}
}
var casesToSkipList = new List <KeyValuePair <Case, string> >();
var casesToExecuteList = new List <Case>();
foreach (var @case in cases)
{
string reason;
if (SkipCase(@case, out reason))
{
casesToSkipList.Add(new KeyValuePair <Case, string>(@case, reason));
}
else
{
casesToExecuteList.Add(@case);
}
}
var casesToSkip = casesToSkipList.Select(x => x.Key).ToArray();
var casesToExecute = casesToExecuteList.ToArray();
var classResult = new ClassResult(testClass.FullName);
if (casesToSkip.Any())
{
TryOrderCases(casesToSkip);
foreach (var @case in casesToSkip)
{
classResult.Add(Skip(@case, casesToSkipList.Single(x => x.Key == @case).Value));
}
}
if (casesToExecute.Any())
{
if (TryOrderCases(casesToExecute))
{
Run(testClass, casesToExecute);
}
foreach (var @case in casesToExecute)
{
classResult.Add(@case.Exceptions.Any() ? Fail(@case) : Pass(@case));
}
}
if (parameterGenerationFailures.Any())
{
var casesToFailWithoutRunning = parameterGenerationFailures.ToArray();
TryOrderCases(casesToFailWithoutRunning);
foreach (var caseToFailWithoutRunning in casesToFailWithoutRunning)
{
classResult.Add(Fail(caseToFailWithoutRunning));
}
}
return(classResult);
}
public ClassResult Run(Type testClass)
{
var methods = methodDiscoverer.TestMethods(testClass);
var cases = new List <Case>();
foreach (var method in methods)
{
try
{
bool generatedInputParameters = false;
foreach (var parameters in Parameters(method))
{
generatedInputParameters = true;
cases.Add(new Case(method, parameters));
}
if (!generatedInputParameters)
{
if (method.GetParameters().Length > 0)
{
throw new Exception("This test case has declared parameters, but no parameter values have been provided to it.");
}
cases.Add(new Case(method));
}
}
catch (Exception parameterGenerationException)
{
var @case = new Case(method);
@case.Fail(parameterGenerationException);
cases.Add(@case);
}
}
var orderedCases = cases.ToArray();
try
{
orderCases(orderedCases);
}
catch (Exception exception)
{
// When an exception is thrown attempting to sort an array,
// the behavior is undefined, so at this point orderedCases
// is no longer reliable and needs to be fixed. The best we
// can do is go with the original order.
orderedCases = cases.ToArray();
foreach (var @case in cases)
{
@case.Fail(exception);
}
}
var classResult = new ClassResult(testClass.FullName);
var casesToExecute = new List <Case>();
foreach (var @case in orderedCases)
{
if (@case.Exceptions.Any())
{
classResult.Add(Fail(@case));
}
else
{
string reason;
bool skipCase;
try
{
skipCase = SkipCase(@case, out reason);
}
catch (Exception exception)
{
@case.Fail(exception);
classResult.Add(Fail(@case));
continue;
}
if (skipCase)
{
classResult.Add(Skip(@case, reason));
}
else
{
casesToExecute.Add(@case);
}
}
}
if (casesToExecute.Any())
{
Run(testClass, casesToExecute);
foreach (var @case in casesToExecute)
{
classResult.Add(@case.Exceptions.Any() ? Fail(@case) : Pass(@case));
}
}
return(classResult);
}