public void Execute(InstanceExecution instanceExecution)
{
foreach (var caseExecution in instanceExecution.CaseExecutions)
{
using (var console = new RedirectedConsole())
{
var stopwatch = new Stopwatch();
stopwatch.Start();
try
{
var executionPlan = instanceExecution.ExecutionPlan;
var instance = instanceExecution.Instance;
executionPlan.Execute(caseExecution, instance);
}
catch (Exception exception)
{
caseExecution.Fail(exception);
}
stopwatch.Stop();
caseExecution.Duration = stopwatch.Elapsed;
caseExecution.Output = console.Output;
}
Console.Write(caseExecution.Output);
}
}
public void Execute(InstanceExecution instanceExecution)
{
try
{
outer(instanceExecution, () => inner.Execute(instanceExecution));
}
catch (Exception exception)
{
instanceExecution.FailCases(exception);
}
}
public CustomConvention()
{
Classes
.Where(x => factMethods.Filter(x).Any());
Cases = new MethodFilter()
.HasOrInherits <FactAttribute>();
ClassExecution
.CreateInstancePerCase()
.SetUpTearDown(PrepareFixtureData, DisposeFixtureData);
InstanceExecution
.SetUpTearDown(InjectFixtureData, fixture => { });
}
public CustomConvention()
{
Classes
.Where(HasAnyFactMethods);
Methods
.HasOrInherits <FactAttribute>();
ClassExecution
.CreateInstancePerCase()
.SetUpTearDown(PrepareFixtureData, DisposeFixtureData)
.ShuffleCases();
InstanceExecution
.SetUp(InjectFixtureData);
}
public void Execute(ClassExecution classExecution)
{
try
{
var instance = construct(classExecution.TestClass);
var executionPlan = classExecution.ExecutionPlan;
var instanceExecution = new InstanceExecution(executionPlan, classExecution.TestClass, instance, classExecution.CaseExecutions);
executionPlan.Execute(instanceExecution);
Dispose(instance);
}
catch (Exception exception)
{
classExecution.FailCases(exception);
}
}
public CustomConvention()
{
Classes.Where(x => x.GetFields(fieldFlags).Any(fieldInfo => fieldInfo.FieldType == typeof(given)));
Cases = new CustomCaseFilter().SetFilterMethod(x => x.GetFields(fieldFlags).Where(fieldInfo => fieldInfo.FieldType == typeof(then)));
ClassExecution
.CreateInstancePerTestClass();
InstanceExecution
.SetUpTearDown(fixture =>
{
InvokeFieldsOfType(typeof(given), fixture.TestClass, fixture.Instance);
InvokeFieldsOfType(typeof(when), fixture.TestClass, fixture.Instance);
},
fixture => InvokeFieldsOfType(typeof(after), fixture.TestClass, fixture.Instance));
}
public CustomConvention()
{
Classes
.HasOrInherits <TestFixtureAttribute>();
Cases = new MethodFilter()
.HasOrInherits <TestAttribute>();
ClassExecution
.CreateInstancePerTestClass();
InstanceExecution
.SetUpTearDown <TestFixtureSetUpAttribute, TestFixtureTearDownAttribute>();
CaseExecution
.SetUpTearDown <SetUpAttribute, TearDownAttribute>();
}
public CustomConvention()
{
Classes
.HasOrInherits <TestFixtureAttribute>();
Methods
.HasOrInherits <TestAttribute>();
ClassExecution
.CreateInstancePerTestClass()
.SortCases((caseA, caseB) => String.Compare(caseA.Name, caseB.Name, StringComparison.Ordinal));
InstanceExecution
.SetUpTearDown <TestFixtureSetUpAttribute, TestFixtureTearDownAttribute>();
CaseExecution
.SetUpTearDown <SetUpAttribute, TearDownAttribute>();
}
public void ShouldPerformCaseExecutionBehaviorForAllGivenCases()
{
var caseA = new Case(testClass.GetInstanceMethod("Pass"));
var caseB = new Case(testClass.GetInstanceMethod("Fail"));
var caseExecutions = new[]
{
new CaseExecution(caseA),
new CaseExecution(caseB)
};
var executeCases = new ExecuteCases();
var executionPlan = new ExecutionPlan(convention);
var instanceExecution = new InstanceExecution(executionPlan, testClass, new SampleTestClass(), caseExecutions);
executeCases.Execute(instanceExecution);
caseExecutions[0].Exceptions.Any().ShouldBeFalse();
caseExecutions[1].Exceptions.Single().Message.ShouldEqual("'Fail' failed!");
log.ShouldEqual("Pass", "Fail");
}
public CustomConvention()
{
Classes
.Where(type => type.IsInNamespace(GetType().Namespace))
.NameEndsWith("Tests");
Cases = new MethodFilter()
.Where(method => method.Void())
.Where(method => LifecycleMethods.All(x => x != method.Name))
.ZeroParameters();
ClassExecution
.CreateInstancePerTestClass();
InstanceExecution
.SetUpTearDown("FixtureSetUp", "FixtureTearDown");
CaseExecution
.SetUpTearDown("SetUp", "TearDown");
}
public CustomConvention()
{
Classes
.Where(type => type.IsInNamespace(GetType().Namespace))
.NameEndsWith("Tests");
Methods
.Where(method => method.IsVoid())
.Where(method => LifecycleMethods.All(x => x != method.Name));
ClassExecution
.CreateInstancePerTestClass()
.SortCases((caseA, caseB) => String.Compare(caseA.Name, caseB.Name, StringComparison.Ordinal));
InstanceExecution
.SetUpTearDown("FixtureSetUp", "FixtureTearDown");
CaseExecution
.SetUpTearDown("SetUp", "TearDown");
}
void InjectFixtureData(InstanceExecution instanceExecution)
{
foreach (var injectionMethod in fixtures.Keys)
injectionMethod.Invoke(instanceExecution.Instance, new[] { fixtures[injectionMethod] });
}
protected static void InstanceTearDown(InstanceExecution instanceExecution)
{
instanceExecution.TestClass.ShouldEqual(typeof(SampleTestClass));
WhereAmI();
}
