public List<Test> GetTests(TestStatus testStatus = TestStatus.Ready)
 {
     using (var context = GetContext())
     {
         return context.Tests.Where(t => t.Status == (byte)testStatus).ToList();
     }
 }

        public static void InvokeCurrentCallback(string testName, TestStatus status, ExceptionDetails exceptionDetails, string traceLog)
        {
            if (_currentCallback == null)
                return;

            _currentCallback(testName, status, exceptionDetails, traceLog);
        }

 public StepRunnerEventArgs(Guid scenarioId, Guid criterionId, Guid stepId, DateTime now, double duration, TestStatus status, string screenShotUrl=null):
     this(scenarioId, criterionId,stepId,now)
 {
     Duration = duration;
     Status = status;
     ScreenShotUrl = screenShotUrl;
 }

 public ProjectFinishedRunning(Guid projectId, TestStatus status, DateTime finishedAt, string screenShotUrl)
 {
     ProjectId = projectId;
     Status = status;
     FinishedAt = finishedAt;
     ScreenShotUrl = screenShotUrl;
 }

        public async Task<bool> Run()
        {
            this.Status = TestStatus.Running;
            if (this.TestStatusChanged != null)
            {
                this.TestStatusChanged(this, new TestStatusChangedEventArgs(this.Status));
            }

            bool passed;
            try
            {
                passed = await this.execution(this);
                this.Status = passed ? TestStatus.Passed : TestStatus.Failed;
                this.AddLog("Test {0}", this.Status);
            }
            catch (Exception ex)
            {
                this.AddLog("Test failed with exception: {0}", ex);
                passed = false;
                this.Status = TestStatus.Failed;
            }

            if (this.TestStatusChanged != null)
            {
                this.TestStatusChanged(this, new TestStatusChangedEventArgs(this.Status));
            }

            return passed;
        }

 public TestResult(TestStatus status, string name, string message, IStackLine[] stackTrace)
 {
     _status = status;
     _name = name;
     _message = message;
     _stackTrace = stackTrace;
 }

 private TestResult[] queryByStatus(TestStatus status)
 {
     var query = from t in _testResults
                 where t.Status.Equals(status)
                 select t;
     return query.ToArray();
 }

        public void Status_ConstructorWithTwoArguments_ReturnsConstructorArgumentStatus(TestStatus status)
        {
            // Arrange N/A

            ResultState resultState = new ResultState(status, string.Empty);

            Assert.AreEqual(status, resultState.Status);
        }

 public ZumoTest(string name, TestExecution execution)
 {
     this.Name = name;
     this.Data = new Dictionary<string, object>();
     this.logs = new List<string>();
     this.execution = execution;
     this.Status = TestStatus.NotRun;
 }

 public TestSuiteResult(TestStatus status, long timeTaken, uint total, uint passes, uint skipped)
 {
     Status = status;
     TimeTaken = timeTaken;
     Total = total;
     Passes = passes;
     Skipped = skipped;
 }

 /// <summary>
 /// Default Constructor
 /// </summary>
 public TestedAttribute(string reference, string description, TestStatus status = TestStatus.Tested)
 {
     TestReference = reference;
     TestDescription = description;
     Status = status;
     if (status == TestStatus.Undocumented)
         throw new ArgumentException("TestStatus.Undocumented should not be used.  This is for Audit purposes only.");
 }

 public CriterionFinishedRunning(Guid projectId, Guid scenarioId, Guid criterionId, TestStatus status, DateTime finishedAt, string screenShotUrl)
 {
     ProjectId = projectId;
     ScenarioId = scenarioId;
     CriterionId = criterionId;
     Status = status;
     FinishedAt = finishedAt;
     ScreenShotUrl = screenShotUrl;
 }

 public void Reset()
 {
     this.logs.Clear();
     this.Status = TestStatus.NotRun;
     if (this.TestStatusChanged != null)
     {
         this.TestStatusChanged(this, new TestStatusChangedEventArgs(this.Status));
     }
 }

 public ScenarioFinishedRunning(Guid projectId, Guid scenarioId, string scenarioName, TestStatus status, DateTime finishedAt, string screenShotUrl)
 {
     ProjectId = projectId;
     ScenarioId = scenarioId;
     ScenarioName = scenarioName;
     Status = status;
     FinishedAt = finishedAt;
     ScreenShotUrl = screenShotUrl;
 }

 private static TestStepFinished GetTestStepFinished(TestStatus testStatus)
 {
     var testStepRun = new TestStepRun(new TestStepData("id", "name", "fullName", "testId"))
     {
         Step = new TestStepData("id", "name", "fullName", "testId") { IsTestCase = true },
         Result = new TestResult(new TestOutcome(testStatus))
     };
     return new TestStepFinished(null, testStepRun);
 }

        /// <summary>
        /// Adds an error to the test result error collection.
        /// </summary>
        /// <param name="message">The error message.</param>
        /// <exception cref="ArgumentNullException">
        ///     Thrown if <paramref name="message"/> is <see langword="null" />.
        /// </exception>
        /// <exception cref="ArgumentException">
        ///     Thrown if <paramref name="message"/> is an empty string.
        /// </exception>
        public void AddError(string message)
        {
            {
                Lokad.Enforce.Argument(() => message);
                Lokad.Enforce.Argument(() => message, Lokad.Rules.StringIs.NotEmpty);
            }

            m_Errors.Add(message);
            m_Status = TestStatus.Failed;
        }

        private void AssertTestResult(string expectedOutput, TestStatus expectedStatus, Type fixtureType, string methodName)
        {
            CodeReference codeReference = CodeReference.CreateFromMember(fixtureType.GetMethod(methodName));

            TestStepRun run = Runner.GetPrimaryTestStepRun(codeReference);
            Assert.AreEqual(expectedStatus, run.Result.Outcome.Status);

            string actualOutput = run.TestLog.GetStream(MarkupStreamNames.Default).ToString();
            Assert.AreEqual(expectedOutput, actualOutput);
        }

 public void Expand(TestStatus state)
 {
     BeginUpdate();
     
     CollapseAll();
     
     foreach (TreeNodeAdv node in AllNodes)
         ExpandNode(node, state);
     
     EndUpdate();
 }

 private string checkbox(TestStatus status)
 {
     switch(status) {
         case TestStatus.Idle:					return "[ ]";
         case TestStatus.WaitingForDependencies: return "[ ]";
         case TestStatus.Running:				return "[.]";
         case TestStatus.FinishedError:			return "[!]";
         case TestStatus.FinishedSuccessfully:	return "[X]";
         default: throw new ApplicationException("unknown status:" + status);
     }
 }

 protected StepFinishedRunning(Guid projectId, Guid storyId, Guid scenarioId, Guid criterionId, Guid stepId, TestStatus testStatus, DateTime finishedAt, double duration, string screenShotUrl)
 {
     ProjectId = projectId;
     StoryId = storyId;
     ScenarioId = scenarioId;
     CriterionId = criterionId;
     StepId = stepId;
     Status = testStatus;
     FinishedAt = finishedAt;
     Duration = duration;
     ScreenShotUrl = screenShotUrl;
 }