anchor.diff:  
   [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
   module TestClass =
  -  let internal testMethods (typ: Type) =
  +  let internal testMethodInfos (typ: Type) =
       typ.GetMethods(BindingFlags.Instance ||| BindingFlags.Public ||| BindingFlags.NonPublic)
       |> Seq.filter
         (fun m ->
  
positive.code:       {
          Type                    = typ
          Create                  = typ |> instantiate
          Methods                 = typ |> testCases
        } |> Some
      else
        None
  
    let runAsync: TestClass -> Async<TestClassResult> =
      let tryInstantiate (testObject: TestClass) =
        Result.catch testObject.Create
        |> Result.mapFailure TestError.OfConstructor
  
      let tryDispose testCase instance =
        Result.catch (fun () -> instance |> Disposable.dispose)
        |> Result.mapFailure (fun e -> TestError.OfDispose (testCase, 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 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)
        }
  
  [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
  module TestSuite =
  
negative.code: 
    let internal isTestClass (typ: Type) =
      typ.GetConstructor([||]) |> isNull |> not
      && typ |> testMethodInfos |> Seq.isEmpty |> not
  
    let internal testMethod m =
      {
        Method                = m
        Run                   =
          fun this ->
            let tests = m.Invoke(this, [||]) :?> seq<Test>
            Test.OfTestGroup(m.Name, tests)
      }
  
    let internal testMethods (typ: Type) =
      typ
      |> testMethodInfos
      |> Seq.map testMethod
  
    let internal instantiate (typ: Type): unit -> TestInstance =
      let defaultConstructor =
        typ.GetConstructor([||])
      fun () -> defaultConstructor.Invoke([||])
  