CaseResult Pass(Case @case)
{
var result = new PassResult(@case);
listener.CasePassed(result);
return(result);
}
public void CasePassed(PassResult result)
{
var @case = result.Case;
Message("testStarted name='{0}'", @case.Name);
Output(@case, result.Output);
Message("testFinished name='{0}' duration='{1}'", @case.Name, DurationInMilliseconds(result.Duration));
}
public void CasePassed(PassResult result)
{
tdnet.TestFinished(new TestResult
{
Name = result.Name,
State = TestState.Passed
});
}
public void CasePassed(PassResult result)
{
var @case = result.Case;
Message("testStarted name='{0}'", @case.Name);
Output(@case, result.Output);
Message("testFinished name='{0}' duration='{1}'", @case.Name, DurationInMilliseconds(result.Duration));
}
public void CasePassed(PassResult result)
{
var @case = result.Case;
tdnet.TestFinished(new TestResult
{
Name = @case.Name,
State = TestState.Passed
});
}
public ConventionResult Run(Convention convention, Listener listener, params Type[] candidateTypes)
{
var executionPlan = new ExecutionPlan(convention);
var conventionResult = new ConventionResult(convention.GetType().FullName);
foreach (var testClass in convention.Classes.Filter(candidateTypes))
{
var classResult = new ClassResult(testClass.FullName);
var methods = convention.Methods.Filter(testClass);
var cases = methods.SelectMany(method => CasesForMethod(convention, method)).ToArray();
var casesBySkipState = cases.ToLookup(convention.CaseExecution.SkipPredicate);
var casesToSkip = casesBySkipState[true];
var casesToExecute = casesBySkipState[false];
foreach (var @case in casesToSkip)
{
var skipResult = new SkipResult(@case, convention.CaseExecution.SkipReasonProvider(@case));
listener.CaseSkipped(skipResult);
classResult.Add(CaseResult.Skipped(skipResult.Case.Name, skipResult.Reason));
}
var caseExecutions = casesToExecute.Select(@case => new CaseExecution(@case)).ToArray();
if (caseExecutions.Any())
{
convention.ClassExecution.OrderCases(caseExecutions);
var classExecution = new ClassExecution(executionPlan, testClass, caseExecutions);
executionPlan.Execute(classExecution);
foreach (var caseExecution in caseExecutions)
{
if (caseExecution.Exceptions.Any())
{
var failResult = new FailResult(caseExecution, convention.HideExceptionDetails);
listener.CaseFailed(failResult);
classResult.Add(CaseResult.Failed(failResult.Case.Name, failResult.Duration, failResult.ExceptionSummary));
}
else
{
var passResult = new PassResult(caseExecution);
listener.CasePassed(passResult);
classResult.Add(CaseResult.Passed(passResult.Case.Name, passResult.Duration));
}
}
}
conventionResult.Add(classResult);
}
return conventionResult;
}
public void CasePassed(PassResult result)
{
var testCase = new TestCase(result.Case.Name, new Uri(Constants.EXECUTOR_URI_STRING), source);
frameworkHandle.RecordStart(testCase);
var testResult = new TestResult(testCase)
{
Outcome = TestOutcome.Passed
};
frameworkHandle.RecordEnd(testCase, TestOutcome.Passed);
frameworkHandle.RecordResult(testResult);
}
public void CasePassed(PassResult result)
{
var testResult = new TestResult(TestCase(result.MethodGroup))
{
DisplayName = result.Name,
Outcome = Map(CaseStatus.Passed),
Duration = result.Duration,
ComputerName = Environment.MachineName
};
AttachCapturedConsoleOutput(result.Output, testResult);
log.RecordResult(testResult);
}
public ConventionResult Execute(Listener listener, params Type[] candidateTypes)
{
var conventionResult = new ConventionResult(GetType().FullName);
foreach (var testClass in Classes.Filter(candidateTypes))
{
var classResult = new ClassResult(testClass.FullName);
var methods = Methods.Filter(testClass);
var cases = methods.SelectMany(method => CasesForMethod(testClass, method)).ToArray();
var casesBySkipState = cases.ToLookup(CaseExecution.SkipPredicate);
var casesToSkip = casesBySkipState[true];
var casesToExecute = casesBySkipState[false];
foreach (var @case in casesToSkip)
{
var skipResult = new SkipResult(@case, CaseExecution.SkipReasonProvider(@case));
listener.CaseSkipped(skipResult);
classResult.Add(CaseResult.Skipped(skipResult.Case.Name, skipResult.Reason));
}
var caseExecutions = casesToExecute.Select(@case => new CaseExecution(@case)).ToArray();
if (caseExecutions.Any())
{
ClassExecution.Behavior.Execute(testClass, this, caseExecutions);
foreach (var caseExecution in caseExecutions)
{
if (caseExecution.Exceptions.Any())
{
var failResult = new FailResult(caseExecution, AssertionLibrary);
listener.CaseFailed(failResult);
classResult.Add(CaseResult.Failed(failResult.Case.Name, failResult.Duration, failResult.ExceptionSummary));
}
else
{
var passResult = new PassResult(caseExecution);
listener.CasePassed(passResult);
classResult.Add(CaseResult.Passed(passResult.Case.Name, passResult.Duration));
}
}
}
conventionResult.Add(classResult);
}
return(conventionResult);
}
public void CasePassed(PassResult result)
{
var caseResult = (CaseResult)result;
Post(new TestResult
{
testFramework = "Fixie",
fileName = fileName,
testName = caseResult.Name,
outcome = "Passed",
durationMilliseconds = caseResult.Duration.TotalMilliseconds.ToString("0"),
StdOut = caseResult.Output,
ErrorMessage = null,
ErrorStackTrace = null
});
}
public void CasePassed(PassResult result)
{
if (isParameterized)
{
var newTask = new TestCaseTask(result.Case.Name, nodeRunner.CurrentTask.AssemblyLocation);
server.CreateDynamicElement(newTask);
nodeRunner.AddTask(newTask);
}
var task = nodeRunner.CurrentTask;
if (!string.IsNullOrWhiteSpace(result.Output))
{
server.TaskOutput(task, result.Output, TaskOutputType.STDOUT);
}
task.CloseTask(TaskResult.Success, result.Case.Name);
if (isParameterized)
{
nodeRunner.FinishCurrentTask(task);
}
}
public ConventionResult Execute(Listener listener, params Type[] candidateTypes)
{
var conventionResult = new ConventionResult(GetType().FullName);
foreach (var testClass in Classes.Filter(candidateTypes))
{
var classResult = new ClassResult(testClass.FullName);
var methods = Methods.Filter(testClass);
var cases = methods.SelectMany(method => CasesForMethod(testClass, method)).ToArray();
var casesBySkipState = cases.ToLookup(CaseExecution.SkipPredicate);
var casesToSkip = casesBySkipState[true];
var casesToExecute = casesBySkipState[false];
foreach (var @case in casesToSkip)
{
listener.CaseSkipped(@case);
classResult.Add(CaseResult.Skipped(@case.Name, CaseExecution.SkipReasonProvider(@case)));
}
var caseExecutions = casesToExecute.Select(@case => new CaseExecution(@case)).ToArray();
if (caseExecutions.Any())
{
ClassExecution.Behavior.Execute(testClass, this, caseExecutions);
foreach (var caseExecution in caseExecutions)
{
if (caseExecution.Exceptions.Any())
{
var failResult = new FailResult(caseExecution);
listener.CaseFailed(failResult);
classResult.Add(CaseResult.Failed(failResult.Case.Name, failResult.Duration, failResult.PrimaryExceptionMessage(), failResult.CompoundStackTrace(), failResult.PrimaryExceptionTypeName()));
}
else
{
var passResult = new PassResult(caseExecution);
listener.CasePassed(passResult);
classResult.Add(CaseResult.Passed(passResult.Case.Name, passResult.Duration));
}
}
}
conventionResult.Add(classResult);
}
return conventionResult;
}
public void CasePassed(PassResult result)
{
log.Add(string.Format("{0} passed.", result.Name));
}
public void CasePassed(PassResult result)
{
}
public void CasePassed(PassResult result)
{
log.Add($"{result.Name} passed");
}
public void CasePassed(PassResult result)
{
}
public void CasePassed(PassResult result)
{
var @case = result.Case;
log.Add(string.Format("{0} passed.", @case.Name));
}
public void CasePassed(PassResult result)
{
var @case = result.Case;
log.Add(string.Format("{0} passed.", @case.Name));
}
public void CasePassed(PassResult result) => Log.Add(result);