anchor.diff:          | Failed error -> "Failed: " + error
           | Exception e -> "Exception: " + e.ToString()
   
  -    type TestResults = (string * TestResult) list
  -
       type TestResultCounts = {
           Passed: int
           Failed: int
           Errored: int
       }
   
  -    let sumTestResults (results: TestResults) =
  +    let sumTestResults results =
           let counts = 
               results 
               |> Seq.map snd
  
positive.code:             then ok
              else failf "Expected %A but was %A" expected actual
  
      let exec beforeRun onPassed onFailed onException =
          let rec loop (parentName: string) (partialResults: TestResults) =
              function
              | TestLabel (name, test) -> loop (parentName + "/" + name) partialResults test
              | TestCase test -> 
                  let r = 
                      try
                          beforeRun parentName
                          match test() with
                          | Choice1Of2() -> 
                              let r = parentName, Passed
                              onPassed r
                              r
                          | Choice2Of2 error -> 
                              let r = parentName, Failed error
                              onFailed r
                              r
                      with e -> 
                          let r = parentName, Exception e
                          onException r
                          r                        
                  r::partialResults
              | TestList tests -> List.collect (loop parentName partialResults) tests
  
          loop "" []
  
      [<Extension>]
      [<CompiledName("Run")>]
      let run tests = 
          let printResult (n,t) = printfn "%s: %s" n (testResultToString t)
          let results = exec ignore printResult printResult printResult tests
          let summary = sumTestResults results
          printfn "%d tests run: %d passed, %d failed, %d errored"
              (summary.Errored + summary.Failed + summary.Passed)
  
negative.code: type Test with
      static member NewCase (f: Func<Choice<unit, string>>) = 
          TestCase f.Invoke
      static member NewList ([<ParamArray>] tests) = 
          Array.toList tests |> TestList
      static member NewList ([<ParamArray>] tests) =
          tests |> Array.map Test.NewCase |> Test.NewList