anchor.diff:        {
           Type                    = typ
           Create                  = typ |> instantiate
  -        Methods                 = typ |> testCases
  +        Methods                 = typ |> testMethods
         } |> Some
       else
         None
   
  -  let runAsync: TestClass -> Async<TestClassResult> =
  -    let tryInstantiate (testObject: TestClass) =
  -      Result.catch testObject.Create
  -      |> Result.mapFailure TestError.OfConstructor
  +  let internal tryInstantiate (testClass: TestClass) =
  +    Result.catch testClass.Create
  +    |> Result.mapFailure TestError.OfConstructor
   
  -    let tryDispose testCase instance =
  -      Result.catch (fun () -> instance |> Disposable.dispose)
  -      |> Result.mapFailure (fun e -> TestError.OfDispose (testCase, e))
  +  let internal tryDispose testMethod instance =
  +    Result.catch (fun () -> instance |> Disposable.dispose)
  +    |> Result.mapFailure (fun e -> TestError.OfDispose (testMethod, e))
   
  -    let tryRunTestMethod (testCase: TestMethod) testClass =
  -      testClass |> tryInstantiate
  -      |> Result.bind
  -        (fun instance ->
  -          let methodResult =
  -            Result.catch (fun () -> instance |> testCase.Run)
  -            |> Result.mapFailure (fun e -> TestError.OfMethod (testCase, e))
  -          let disposeResult =
  -            instance |> tryDispose testCase
  -          match (methodResult, disposeResult) with
  -          | Success _, Failure error ->
  -            Failure error
  -          | _ ->
  -            methodResult
  +  let internal tryRunTestMethod (testMethod: TestMethod) testClass =
  +    testClass |> tryInstantiate
  +    |> Result.bind
  +      (fun instance ->
  +        let methodResult =
  +          Result.catch (fun () -> instance |> testMethod.Run)
  +          |> Result.mapFailure (fun e -> TestError.OfMethod (testMethod, e))
  +        let disposeResult =
  +          instance |> tryDispose testMethod
  +        match (methodResult, disposeResult) with
  +        | Success _, Failure error ->
  +          Failure error
  +        | _ ->
  +          methodResult
  +      )
  +
  +  let internal tryRunTestMethodsAsync (testClass: TestClass) =
  +    testClass.Methods
  +    |> Seq.map
  +      (fun testCase ->
  +        async { return testClass |> tryRunTestMethod testCase }
  +      )
  +    |> Async.Parallel
  +
  +  /// We report up to one instantiation error
  +  /// because we don't want to see the same error for each test method.
  +  let internal unitfyInstantiationErrors results =
  +    let (failureList, successList) =
  +      results |> Array.partition
  +        (function
  +          | Failure ({ TestError.Method = TestErrorMethod.Constructor }) -> true
  +          | x -> false
           )
  +    Array.append
  +      (failureList |> Seq.tryHead |> Option.toArray)
  +      successList
   
  -    let tryRunCasesAsync (testClass: TestClass) =
  -      let results =
  -        testClass.Methods
  -        |> Seq.map
  -          (fun testCase ->
  -            async { return testClass |> tryRunTestMethod testCase }
  -          )
  -        |> Async.Parallel
  -      (testClass, results)
  -
  -    /// We report up to one instantiation error
  -    /// because we don't want to see the same error for each test method.
  -    let unitfyInstantiationErrors results =
  -      let (failureList, successList) =
  -        results |> Array.partition
  -          (function
  -            | Failure ({ TestError.Method = TestErrorMethod.Constructor }) -> true
  -            | x -> false
  -          )
  -      Array.append
  -        (failureList |> Seq.tryHead |> Option.toArray)
  -        successList
  -
  -    fun testObject ->
  -      async {
  -        let (testObject, a) = testObject |> tryRunCasesAsync
  -        let! results = a
  -        let results = results |> unitfyInstantiationErrors
  -        return (testObject, results)
  -      }
  +  let runAsync testClass: Async<TestClassResult> =
  +    async {
  +      let! results = testClass |> tryRunTestMethodsAsync
  +      let results = results |> unitfyInstantiationErrors
  +      return (testClass, results)
  +    }
   
   [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
   module TestSuite =
  
positive.code: 
    let internal isTestClass (typ: Type) =
      typ.GetConstructor([||]) |> isNull |> not
      && typ |> testMethods |> Seq.isEmpty |> not
  
    let internal testCases (typ: Type) =
      typ
      |> testMethods
      |> Seq.map
        (fun m ->
          {
            Method                = m
            Run                   =
              fun this ->
                let tests = m.Invoke(this, [||]) :?> seq<Test>
                Test.OfTestGroup(m.Name, tests)
          }
        )
  
    let instantiate (typ: Type): unit -> TestInstance =
      let defaultConstructor =
        typ.GetConstructor([||])
      fun () -> defaultConstructor.Invoke([||])
  
negative.code: 
  [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
  module TestClass =
    let internal testMethodInfos (typ: Type) =
      typ.GetMethods(BindingFlags.Instance ||| BindingFlags.Public ||| BindingFlags.NonPublic)
      |> Seq.filter
        (fun m ->
  