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 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); }