public NSpecExampleTest( Example example )
: base(example.Spec, null)
{
this.Kind = TestKinds.Test;
this.IsTestCase = true;
this._example = example;
}
public void Exercise(Example example, nspec nspec)
{
if (example.Pending) return;
if (contextLevelFailure != null)
{
example.Exception = contextLevelFailure;
return;
}
try
{
RunBefores(nspec);
RunActs(nspec);
example.Run(nspec);
Afters();
}
catch (TargetInvocationException e)
{
example.Exception = e.InnerException;
}
catch (Exception e)
{
example.Exception = e;
}
}
protected void Exercise(Example example)
{
Context.AddExample(example);
if(!example.Pending)
example.Run(Context);
}
public string Write(Example e, int level = 1)
{
var failure = e.Exception == null ? "" : " - FAILED - {0}".With(e.Exception.CleanMessage());
var whiteSpace = Environment.NewLine + indent.Times(level);
return e.Pending ? whiteSpace + e.Spec + " - PENDING" : whiteSpace + e.Spec + failure;
}
public void AddExample(Example example)
{
example.Context = this;
Examples.Add(example);
example.Pending |= IsPending();
}
public void Write(Example example, int level)
{
var result = example.Failed()
? new TestResultDTO { Outcome = TestOutcome.Failed, StackTrace = GetStackTrace(example.Exception), Message = example.Exception.Message }
: new TestResultDTO { Outcome = example.Pending ? TestOutcome.Skipped : TestOutcome.Passed };
result.TestName = example.FullName();
result.Source = this.Source;
this.observer.Receive(result);
}
public void AddExample(Example example)
{
example.Context = this;
example.Tags.AddRange(Tags);
Examples.Add(example);
example.Pending |= IsPending();
}
public void should_be_marked_as_pending_if_parent_context_is_pending()
{
var context = new Context("pending context", null, isPending: true);
var example = new Example("example name");
context.AddExample(example);
example.Pending.should_be_true();
}
public void should_concatenate_its_contexts_name_into_a_full_name()
{
var context = new Context("context name");
var example = new Example("example name");
context.AddExample(example);
example.FullName().should_be("context name. example name.");
}
public string WriteFailure(Example example)
{
var failure = Environment.NewLine + example.FullName().Replace("_", " ") + Environment.NewLine;
failure += example.Exception.CleanMessage() +
Environment.NewLine + example.Exception.GetOrFallback( e=> e.StackTrace,"").Split('\n')
.Where(l => !new[] { "NSpec.Domain","NSpec.AssertionExtensions","NUnit.Framework" }.Any(l.Contains))
.Flatten(Environment.NewLine).TrimEnd() + Environment.NewLine;
return failure;
}
static string GetStackTrace(Example example)
{
if (example.Passed || example.Pending) return String.Empty;
var stackTrace =
example.Exception
.GetOrFallback(e => e.StackTrace, "").Split('\n')
.Where(l => !internalNameSpaces.Any(l.Contains));
return stackTrace.Flatten(Environment.NewLine).TrimEnd() + Environment.NewLine;
}
public void should_be_marked_as_pending_if_any_parent_context_is_pending()
{
var parentContext = new Context("parent pending context", 0, isPending: true);
var context = new Context("not pending");
var example = new Example("example name");
parentContext.AddContext(context);
context.AddExample(example);
example.Pending.should_be_true();
}
public void BuildMethodLevelExamples(Context classContext, Type specClass)
{
specClass
.Methods()
.Where(s => conventions.IsMethodLevelExample(s.Name))
.Do(methodInfo =>
{
var methodExample = new Example(methodInfo, TagStringFor(methodInfo));
classContext.AddExample(methodExample);
});
}
NSpecExampleTest CreateGallioTestFrom(Example nspecExample)
{
try
{
NSpecExampleTest exampleTest = new NSpecExampleTest(nspecExample);
return exampleTest;
}
catch
{
throw new Exception(String.Format("Error adding example {0}", nspecExample.Spec));
}
}
public MethodInfo GetAction(Example example)
{
if (example is MethodExample)
{
return example.GetType()
.GetField("method", BindingFlags.Instance | BindingFlags.NonPublic)
.GetValue(example) as MethodInfo;
}
var action = example.GetType()
.GetField("action", BindingFlags.Instance | BindingFlags.NonPublic)
.GetValue(example) as Action;
return action.Method;
}
public void setup()
{
try
{
throw new Exception("BOOM!");
}
catch (Exception exception)
{
example = new Example("example name") { Exception = exception };
}
var context = new Context("context name");
context.AddExample(example);
output = new ConsoleFormatter().WriteFailure(example);
}
public string WriteFailure(Example example)
{
var failure = Environment.NewLine + example.FullName().Replace("_", " ") + Environment.NewLine;
failure += example.Exception.CleanMessage() + Environment.NewLine;
var stackTrace =
example.Exception
.GetOrFallback(e => e.StackTrace, "").Split('\n')
.Where(l => !internalNameSpaces.Any(l.Contains));
var flattenedStackTrace = stackTrace.Flatten(Environment.NewLine).TrimEnd() + Environment.NewLine;
failure += flattenedStackTrace;
return failure;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:NSpecAdapterForxUnit.ExampleCommand"/> to a specific <see cref="T:NSpec.Domain.Example"/>.
/// </summary>
/// <param name="method">The method that contains the <paramref name="example"/>.</param>
/// <param name="example">The example to run.</param>
/// <param name="instance">The instance to run the example.</param>
/// <exception cref="T:System.ArgumentNullException">One of the arguments is <see langword="null"/>. </exception>
public ExampleCommand(IMethodInfo method, Example example, nspec instance)
{
if (method == null)
{
throw new ArgumentNullException("method");
}
if (example == null)
{
throw new ArgumentNullException("example");
}
if (instance == null)
{
throw new ArgumentNullException("instance");
}
this.Method = method;
this.Example = example;
this.Instance = instance;
}
void ILiveFormatter.Write(Example e, int level)
{
base.Write(e, level);
}
public void AddExample(Example example)
{
example.Context = this;
Examples.Add(example);
}
public void Write(Example example, int level)
{
WrittenExamples.Add(example);
}
static TestState GetState(Example example)
{
if (example.Pending) return TestState.Ignored;
if (example.Passed) return TestState.Passed;
return TestState.Failed;
}
static TestState GetState(Example example)
{
if (example.Pending) return TestState.Ignored;
if (example.HasRun && example.Exception == null) return TestState.Passed;
return TestState.Failed;
}
public void Exercise(Example example, nspec nspec, bool failFast)
{
if (nspec.tagsFilter.ShouldSkip(example.Tags)) return;
example.HasRun = true;
if (example.Pending) return;
RunAndHandleException(RunBefores, nspec, ref contextLevelException);
RunAndHandleException(RunActs, nspec, ref contextLevelException);
RunAndHandleException(example.Run, nspec, ref example.ExampleLevelException);
RunAndHandleException(RunAfters, nspec, ref contextLevelException);
if (example.ExampleLevelException != null && contextLevelException != null && example.ExampleLevelException.GetType() != typeof(ExceptionNotThrown))
example.ExampleLevelException = new ExampleFailureException("Context Failure: " + contextLevelException.Message + ", Example Failure: " + example.ExampleLevelException.Message, contextLevelException);
if (example.ExampleLevelException == null && contextLevelException != null)
example.ExampleLevelException = new ExampleFailureException("Context Failure: " + contextLevelException.Message, contextLevelException);
}
public void Exercise(Example example, nspec nspec)
{
if (example.ShouldSkip(nspec.tagsFilter)) return;
RunAndHandleException(RunBefores, nspec, ref Exception);
RunAndHandleException(RunActs, nspec, ref Exception);
RunAndHandleException(example.Run, nspec, ref example.Exception);
RunAndHandleException(RunAfters, nspec, ref Exception);
example.AssignProperException(Exception);
}
private void GenerateUniqueExampleName(Context context, ref string output, Example ex)
{
output += "-" + context.Name;
if (context.Parent != null)
GenerateUniqueExampleName(context.Parent, ref output, ex);
else
output = ex.Spec + output;
}
public void AddExample(Example example)
{
example.Context = this;
Examples.Add(example);
}
public void Write(Example e, int level)
{
var failure = e.Exception == null ? "" : " - FAILED - {0}".With(e.Exception.CleanMessage());
var whiteSpace = indent.Times(level);
var result = e.Pending ? whiteSpace + e.Spec + " - PENDING" : whiteSpace + e.Spec + failure;
_sessionResults.Messages.Add(result);
}
