Args (#82)

* Bump WoofWare.Myriad.Plugins.Attributes from 3.1.4 to 3.1.6

Bumps [WoofWare.Myriad.Plugins.Attributes](https://github.com/Smaug123/WoofWare.Myriad) from 3.1.4 to 3.1.6.
- [Release notes](https://github.com/Smaug123/WoofWare.Myriad/releases)
- [Changelog](https://github.com/Smaug123/WoofWare.Myriad/blob/main/CHANGELOG.md)
- [Commits](https://github.com/Smaug123/WoofWare.Myriad/compare/WoofWare.Myriad.Plugins.Attributes.3.1.4...WoofWare.Myriad.Plugins.Attributes.3.1.6)

---
updated-dependencies:
- dependency-name: WoofWare.Myriad.Plugins.Attributes
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

* Bump ApiSurface from 4.0.40 to 4.0.41

Bumps [ApiSurface](https://github.com/G-Research/ApiSurface) from 4.0.40 to 4.0.41.
- [Release notes](https://github.com/G-Research/ApiSurface/releases)
- [Commits](https://github.com/G-Research/ApiSurface/compare/ApiSurface.4.0.40...ApiSurface.4.0.41)

---
updated-dependencies:
- dependency-name: ApiSurface
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

* Bump fantomas from 6.3.7 to 6.3.9

Bumps [fantomas](https://github.com/fsprojects/fantomas) from 6.3.7 to 6.3.9.
- [Release notes](https://github.com/fsprojects/fantomas/releases)
- [Changelog](https://github.com/fsprojects/fantomas/blob/main/CHANGELOG.md)
- [Commits](https://github.com/fsprojects/fantomas/compare/v6.3.7...v6.3.9)

---
updated-dependencies:
- dependency-name: fantomas
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

* Bump WoofWare.DotnetRuntimeLocator from 0.1.3 to 0.1.4

Bumps [WoofWare.DotnetRuntimeLocator](https://github.com/Smaug123/WoofWare.DotnetRuntimeLocator) from 0.1.3 to 0.1.4.
- [Release notes](https://github.com/Smaug123/WoofWare.DotnetRuntimeLocator/releases)
- [Commits](https://github.com/Smaug123/WoofWare.DotnetRuntimeLocator/compare/WoofWare.DotnetRuntimeLocator.0.1.3...WoofWare.DotnetRuntimeLocator.0.1.4)

---
updated-dependencies:
- dependency-name: WoofWare.DotnetRuntimeLocator
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

* Deps

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Smaug123 <3138005+Smaug123@users.noreply.github.com>

.config/dotnet-tools.json

@@ -3,7 +3,7 @@
   "isRoot": true,
   "tools": {
     "fantomas": {
-      "version": "6.3.7",
+      "version": "6.3.9",
       "commands": [
         "fantomas"
       ]

.github/workflows/dotnet.yaml

@@ -71,9 +71,10 @@ jobs:
     - name: Build
       run: 'nix develop --command dotnet build --no-restore --configuration Release'
     - name: Test using self
-      run: 'nix develop --command dotnet exec ./TestRunner/bin/Release/net8.0/TestRunner.dll ./Consumer/bin/Release/net8.0/Consumer.dll --trx TrxOut/out.trx'
+      run: 'nix develop --command dotnet exec ./WoofWare.NUnitTestRunner/bin/Release/net8.0/WoofWare.NUnitTestRunner.dll ./Consumer/bin/Release/net8.0/Consumer.dll --trx TrxOut/out.trx'
     - name: Parse Trx files
       uses: NasAmin/trx-parser@v0.6.0
+      if: always()
       id: trx-parser
       with:
         TRX_PATH: ${{ github.workspace }}/TrxOut
@@ -96,9 +97,9 @@ jobs:
       - name: Prepare analyzers
         run: nix develop --command dotnet restore analyzers/analyzers.fsproj
       - name: Build project
-        run: nix develop --command dotnet build ./TestRunner/TestRunner.fsproj
+        run: nix develop --command dotnet build ./WoofWare.NUnitTestRunner/WoofWare.NUnitTestRunner.fsproj
       - name: Run analyzers
-        run: nix run .#fsharp-analyzers -- --project ./TestRunner/TestRunner.fsproj --analyzers-path ./.analyzerpackages/g-research.fsharp.analyzers/*/ --verbosity detailed --report ./analysis.sarif --treat-as-error GRA-STRING-001 GRA-STRING-002 GRA-STRING-003 GRA-UNIONCASE-001 GRA-INTERPOLATED-001 GRA-TYPE-ANNOTATE-001 GRA-VIRTUALCALL-001 GRA-IMMUTABLECOLLECTIONEQUALITY-001 GRA-JSONOPTS-001 GRA-LOGARGFUNCFULLAPP-001 GRA-DISPBEFOREASYNC-001 --exclude-analyzers PartialAppAnalyzer
+        run: nix run .#fsharp-analyzers -- --project ./WoofWare.NUnitTestRunner/WoofWare.NUnitTestRunner.fsproj --analyzers-path ./.analyzerpackages/g-research.fsharp.analyzers/*/ --verbosity detailed --report ./analysis.sarif --treat-as-error GRA-STRING-001 GRA-STRING-002 GRA-STRING-003 GRA-UNIONCASE-001 GRA-INTERPOLATED-001 GRA-TYPE-ANNOTATE-001 GRA-VIRTUALCALL-001 GRA-IMMUTABLECOLLECTIONEQUALITY-001 GRA-JSONOPTS-001 GRA-LOGARGFUNCFULLAPP-001 GRA-DISPBEFOREASYNC-001 --exclude-analyzers PartialAppAnalyzer
 
   build-nix:
     runs-on: ubuntu-latest
@@ -186,12 +187,12 @@ jobs:
       uses: actions/upload-artifact@v4
       with:
         name: nuget-package-lib
-        path: TestRunner.Lib/bin/Release/WoofWare.NUnitTestRunner.Lib.*.nupkg
+        path: WoofWare.NUnitTestRunner.Lib/bin/Release/WoofWare.NUnitTestRunner.Lib.*.nupkg
     - name: Upload NuGet artifact (tool)
       uses: actions/upload-artifact@v4
       with:
         name: nuget-package-tool
-        path: TestRunner/bin/Release/WoofWare.NUnitTestRunner.*.nupkg
+        path: WoofWare.NUnitTestRunner/bin/Release/WoofWare.NUnitTestRunner.*.nupkg
 
   expected-pack:
     needs: [nuget-pack]

Consumer/Consumer.fsproj

@@ -10,6 +10,10 @@
     <ItemGroup>
         <Compile Include="NoAttribute.fs" />
         <Compile Include="Inconclusive.fs" />
+        <Compile Include="TestNonParallel.fs" />
+        <Compile Include="TestParallel.fs" />
+        <Compile Include="TestStdout.fs" />
+        <Compile Include="TestParameterisedFixture.fs" />
         <Compile Include="TestSetUp.fs" />
         <Compile Include="TestValues.fs" />
         <None Include="some-config.json">

Consumer/TestCaseData.fs

@@ -25,10 +25,22 @@ module TestCaseData =
     let ``Consume test data from multiple sources`` (i : int, s : string, arr : float[]) =
         lock multipleSources (fun () -> multipleSources.Add (i, s, arr))
 
-    let optional = [ Some "hi" ; None ] |> List.map TestCaseData
+    let optionalData = [ Some "hi" ; None ] |> List.map TestCaseData
 
-    [<TestCaseSource(nameof optional)>]
-    let ``Consume options`` (s : string option) : unit = s |> shouldEqual s
+    [<TestCaseSource(nameof optionalData)>]
+    let ``Consume options, TestCaseData`` (s : string option) : unit = s |> shouldEqual s
+
+    let optionalRaw = [ Some "hi" ; None ]
+
+    [<TestCaseSource(nameof optionalRaw)>]
+    let ``Consume options, raw`` (s : string option) : unit = s |> shouldEqual s
+
+    [<TestCase(30, 15, 44, false)>]
+    let bug66 (i : int, j : int, k : int, l : bool) =
+        i |> shouldEqual 30
+        j |> shouldEqual 15
+        k |> shouldEqual 44
+        l |> shouldEqual false
 
     [<OneTimeTearDown>]
     let tearDown () =

Consumer/TestNonParallel.fs

@@ -0,0 +1,19 @@
+namespace Consumer
+
+open System
+open System.Threading
+open NUnit.Framework
+open FsUnitTyped
+
+[<TestFixture>]
+[<NonParallelizable>]
+module TestNonParallel =
+    let defaults = List.init 40 id
+    let lock = ref 0
+
+    [<TestCaseSource(nameof defaults)>]
+    let ``Default thing, but not parallel`` (i : int) =
+        Interlocked.Increment lock |> shouldEqual 1
+        Thread.Sleep (TimeSpan.FromMilliseconds (float i))
+        lock.Value <- 0
+        i |> shouldEqual i

Consumer/TestParallel.fs

@@ -0,0 +1,66 @@
+namespace Consumer
+
+open System
+open System.Threading
+open NUnit.Framework
+open FsUnitTyped
+
+[<TestFixture>]
+[<Parallelizable>]
+module TestParallelDefault =
+
+    let defaults = List.init 60 id
+
+    [<TestCaseSource(nameof defaults)>]
+    let ``Default thing, no scope`` (i : int) =
+        Console.WriteLine i
+        Thread.Sleep (TimeSpan.FromMilliseconds (float i))
+        i |> shouldEqual i
+
+[<TestFixture>]
+[<Parallelizable(ParallelScope.All)>]
+module TestParallelAllScope =
+
+    let defaults = List.init 60 id
+
+    [<TestCaseSource(nameof defaults)>]
+    let ``Thing, all scope`` (i : int) =
+        Console.WriteLine i
+        Thread.Sleep (TimeSpan.FromMilliseconds (float i))
+        i |> shouldEqual i
+
+[<TestFixture>]
+[<Parallelizable(ParallelScope.Self)>]
+module TestParallelSelfScope =
+
+    let defaults = List.init 60 id
+
+    [<TestCaseSource(nameof defaults)>]
+    let ``Thing, self scope`` (i : int) =
+        Console.WriteLine i
+        Thread.Sleep (TimeSpan.FromMilliseconds (float i))
+        i |> shouldEqual i
+
+[<TestFixture>]
+[<Parallelizable(ParallelScope.Children)>]
+module TestParallelChildrenScope =
+
+    let defaults = List.init 60 id
+
+    [<TestCaseSource(nameof defaults)>]
+    let ``Thing, children scope`` (i : int) =
+        Console.WriteLine i
+        Thread.Sleep (TimeSpan.FromMilliseconds (float i))
+        i |> shouldEqual i
+
+[<TestFixture>]
+[<Parallelizable(ParallelScope.Fixtures)>]
+module TestParallelFixturesScope =
+
+    let defaults = List.init 60 id
+
+    [<TestCaseSource(nameof defaults)>]
+    let ``Thing, fixtures scope`` (i : int) =
+        Console.WriteLine i
+        Thread.Sleep (TimeSpan.FromMilliseconds (float i))
+        i |> shouldEqual i

Consumer/TestParameterisedFixture.fs

@@ -0,0 +1,18 @@
+namespace Consumer
+
+open NUnit.Framework
+open FsUnitTyped
+
+[<TestFixture true>]
+[<TestFixture false>]
+type TestParameterisedFixture (v : bool) =
+    [<Test>]
+    member _.Thing () = v |> shouldEqual v
+
+[<TestFixture(3, true)>]
+[<TestFixture(6, false)>]
+type TestParameterisedFixtureMultiple (i : int, v : bool) =
+    [<Test>]
+    member _.Thing () =
+        v |> shouldEqual v
+        i |> shouldEqual i

Consumer/TestSetUp.fs

@@ -1,5 +1,6 @@
 namespace Consumer
 
+open System
 open FsUnitTyped
 open System.Threading
 open NUnit.Framework
@@ -11,6 +12,8 @@ module TestSetUp =
 
     [<OneTimeSetUp>]
     let oneTimeSetUp () =
+        Console.WriteLine "I'm being set up for the first time!"
+
         if Interlocked.Increment haveOneTimeSetUp <> 1 then
             failwith "one time setup happened more than once"
 
@@ -22,12 +25,14 @@ module TestSetUp =
 
     [<SetUp>]
     let setUp () =
+        Console.WriteLine "It's a set-up!"
         haveOneTimeSetUp.Value |> shouldEqual 1
         let newId = Interlocked.Increment setUpTimes
         lock setUpTimesSeen (fun () -> setUpTimesSeen.Add newId)
 
     [<TearDown>]
     let tearDown () =
+        Console.WriteLine "I'm a tear-down!"
         let newId = Interlocked.Increment tearDownTimes
         lock tearDownTimesSeen (fun () -> tearDownTimesSeen.Add newId)
 
@@ -35,19 +40,23 @@ module TestSetUp =
 
     [<OneTimeTearDown>]
     let oneTimeTearDown () =
+        Console.WriteLine "I'm being torn down, finally!"
+
         if Interlocked.Increment haveOneTimeTearDown <> 1 then
             failwith "one time tear down happened more than once"
 
         setUpTimesSeen
         |> Seq.toList
+        |> List.sort
         // Six tests: one for Test, two for the TestCase, three for the Repeat.
         |> shouldEqual [ 1..6 ]
 
-        tearDownTimesSeen |> Seq.toList |> shouldEqual [ 1..6 ]
+        tearDownTimesSeen |> Seq.toList |> List.sort |> shouldEqual [ 1..6 ]
 
     [<Test>]
     let ``Test 1`` () =
         haveOneTimeTearDown.Value |> shouldEqual 0
+        Console.WriteLine "By the way, I'm test 1"
         1 |> shouldEqual 1
 
     [<TestCase "h">]

Consumer/TestStdout.fs

@@ -0,0 +1,13 @@
+namespace Consumer
+
+open System
+open NUnit.Framework
+
+[<TestFixture>]
+module TestStdout =
+
+    [<Test>]
+    let ``Stdout is redirected`` () =
+        Console.Out.WriteLine "Hi!"
+        Console.WriteLine "Hi! part 2"
+        Console.Error.WriteLine "Bye!"

Consumer/TestValues.fs

@@ -86,14 +86,42 @@ module TestValues =
 
     [<OneTimeTearDown>]
     let ``Values are all OK`` () =
-        seen1 |> Seq.toList |> shouldEqual [ true ; false ]
-        seen2 |> Seq.toList |> shouldEqual [ (true, false) ; (false, true) ]
-        seen3 |> Seq.toList |> shouldEqual [ (88, box 29) ; (31, box 0) ]
-        seen4 |> Seq.toList |> shouldEqual [ ("hi", box "ohh") ; ("bye", null) ]
-        seen5 |> Seq.toList |> shouldEqual [ (88, box 29) ; (31, box 29) ]
-        seen6 |> Seq.toList |> shouldEqual [ ("hi", box "ohh") ; ("bye", box "ohh") ]
-        seen7 |> Seq.toList |> shouldEqual [ (88, box 29) ; (31, box 29) ]
-        seen8 |> Seq.toList |> shouldEqual [ ("hi", box "ohh") ; ("bye", box "ohh") ]
+        seen1 |> Seq.toList |> List.sort |> shouldEqual [ false ; true ]
+
+        seen2
+        |> Seq.toList
+        |> List.sort
+        |> shouldEqual [ (false, true) ; (true, false) ]
+
+        seen3
+        |> Seq.toList
+        |> List.sortBy fst
+        |> shouldEqual [ (31, box 0) ; (88, box 29) ]
+
+        seen4
+        |> Seq.toList
+        |> List.sortBy fst
+        |> shouldEqual [ ("bye", null) ; ("hi", box "ohh") ]
+
+        seen5
+        |> Seq.toList
+        |> List.sortBy fst
+        |> shouldEqual [ (31, box 29) ; (88, box 29) ]
+
+        seen6
+        |> Seq.toList
+        |> List.sortBy fst
+        |> shouldEqual [ ("bye", box "ohh") ; ("hi", box "ohh") ]
+
+        seen7
+        |> Seq.toList
+        |> List.sortBy fst
+        |> shouldEqual [ (31, box 29) ; (88, box 29) ]
+
+        seen8
+        |> Seq.toList
+        |> List.sortBy fst
+        |> shouldEqual [ ("bye", box "ohh") ; ("hi", box "ohh") ]
 
         seen9
         |> Seq.toList

README.md

@@ -8,3 +8,9 @@ To supply special characters in a string, XML-encode them and `"quote"` the stri
 We support at least the [documented `dotnet test` examples](https://learn.microsoft.com/en-us/dotnet/core/testing/selective-unit-tests).
 However, we would recommend phrasing some of them differently, for maximum peace of mind:
 * `FullyQualifiedName=MyNamespace.MyTestsClass<ParameterType1%2CParameterType2>.MyTestMethod`. This would be better phrased with quotes and escaping as `FullyQualifiedName="MyNamespace.MyTestsClass&lt;ParameterType1%2CParameterType2&gt;.MyTestMethod"`
+
+## Parallelism
+
+WoofWare.NUnitTestRunner has *limited* support for parallelism.
+By default, we run tests serially; we may or may not respect the NUnit parallelism attributes to any given extent (but we will never incorrectly run tests in parallel).
+For example, as of this writing, we do not run any tests in parallel (but the internal infrastructure is set up so that we will be able to do this soon).

TestRunner.Lib/AssemblyInfo.fs

@@ -1,7 +0,0 @@
-namespace TestRunner.AssemblyInfo
-
-open System.Runtime.CompilerServices
-
-[<assembly : InternalsVisibleTo("TestRunner.Test")>]
-
-do ()

TestRunner.Lib/SurfaceBaseline.txt

@@ -1,531 +0,0 @@
-TestRunner.Combinatorial inherit obj, implements TestRunner.Combinatorial System.IEquatable, System.Collections.IStructuralEquatable, TestRunner.Combinatorial System.IComparable, System.IComparable, System.Collections.IStructuralComparable - union type with 2 cases
-TestRunner.Combinatorial+Tags inherit obj
-TestRunner.Combinatorial+Tags.Combinatorial [static field]: int = 0
-TestRunner.Combinatorial+Tags.Sequential [static field]: int = 1
-TestRunner.Combinatorial.Combinatorial [static property]: [read-only] TestRunner.Combinatorial
-TestRunner.Combinatorial.get_Combinatorial [static method]: unit -> TestRunner.Combinatorial
-TestRunner.Combinatorial.get_IsCombinatorial [method]: unit -> bool
-TestRunner.Combinatorial.get_IsSequential [method]: unit -> bool
-TestRunner.Combinatorial.get_Sequential [static method]: unit -> TestRunner.Combinatorial
-TestRunner.Combinatorial.get_Tag [method]: unit -> int
-TestRunner.Combinatorial.IsCombinatorial [property]: [read-only] bool
-TestRunner.Combinatorial.IsSequential [property]: [read-only] bool
-TestRunner.Combinatorial.Sequential [static property]: [read-only] TestRunner.Combinatorial
-TestRunner.Combinatorial.Tag [property]: [read-only] int
-TestRunner.Filter inherit obj, implements TestRunner.Filter System.IEquatable, System.Collections.IStructuralEquatable, TestRunner.Filter System.IComparable, System.IComparable, System.Collections.IStructuralComparable - union type with 6 cases
-TestRunner.Filter+And inherit TestRunner.Filter
-TestRunner.Filter+And.get_Item1 [method]: unit -> TestRunner.Filter
-TestRunner.Filter+And.get_Item2 [method]: unit -> TestRunner.Filter
-TestRunner.Filter+And.Item1 [property]: [read-only] TestRunner.Filter
-TestRunner.Filter+And.Item2 [property]: [read-only] TestRunner.Filter
-TestRunner.Filter+FullyQualifiedName inherit TestRunner.Filter
-TestRunner.Filter+FullyQualifiedName.get_Item [method]: unit -> TestRunner.Match
-TestRunner.Filter+FullyQualifiedName.Item [property]: [read-only] TestRunner.Match
-TestRunner.Filter+Name inherit TestRunner.Filter
-TestRunner.Filter+Name.get_Item [method]: unit -> TestRunner.Match
-TestRunner.Filter+Name.Item [property]: [read-only] TestRunner.Match
-TestRunner.Filter+Not inherit TestRunner.Filter
-TestRunner.Filter+Not.get_Item [method]: unit -> TestRunner.Filter
-TestRunner.Filter+Not.Item [property]: [read-only] TestRunner.Filter
-TestRunner.Filter+Or inherit TestRunner.Filter
-TestRunner.Filter+Or.get_Item1 [method]: unit -> TestRunner.Filter
-TestRunner.Filter+Or.get_Item2 [method]: unit -> TestRunner.Filter
-TestRunner.Filter+Or.Item1 [property]: [read-only] TestRunner.Filter
-TestRunner.Filter+Or.Item2 [property]: [read-only] TestRunner.Filter
-TestRunner.Filter+Tags inherit obj
-TestRunner.Filter+Tags.And [static field]: int = 5
-TestRunner.Filter+Tags.FullyQualifiedName [static field]: int = 0
-TestRunner.Filter+Tags.Name [static field]: int = 1
-TestRunner.Filter+Tags.Not [static field]: int = 3
-TestRunner.Filter+Tags.Or [static field]: int = 4
-TestRunner.Filter+Tags.TestCategory [static field]: int = 2
-TestRunner.Filter+TestCategory inherit TestRunner.Filter
-TestRunner.Filter+TestCategory.get_Item [method]: unit -> TestRunner.Match
-TestRunner.Filter+TestCategory.Item [property]: [read-only] TestRunner.Match
-TestRunner.Filter.get_IsAnd [method]: unit -> bool
-TestRunner.Filter.get_IsFullyQualifiedName [method]: unit -> bool
-TestRunner.Filter.get_IsName [method]: unit -> bool
-TestRunner.Filter.get_IsNot [method]: unit -> bool
-TestRunner.Filter.get_IsOr [method]: unit -> bool
-TestRunner.Filter.get_IsTestCategory [method]: unit -> bool
-TestRunner.Filter.get_Tag [method]: unit -> int
-TestRunner.Filter.IsAnd [property]: [read-only] bool
-TestRunner.Filter.IsFullyQualifiedName [property]: [read-only] bool
-TestRunner.Filter.IsName [property]: [read-only] bool
-TestRunner.Filter.IsNot [property]: [read-only] bool
-TestRunner.Filter.IsOr [property]: [read-only] bool
-TestRunner.Filter.IsTestCategory [property]: [read-only] bool
-TestRunner.Filter.NewAnd [static method]: (TestRunner.Filter, TestRunner.Filter) -> TestRunner.Filter
-TestRunner.Filter.NewFullyQualifiedName [static method]: TestRunner.Match -> TestRunner.Filter
-TestRunner.Filter.NewName [static method]: TestRunner.Match -> TestRunner.Filter
-TestRunner.Filter.NewNot [static method]: TestRunner.Filter -> TestRunner.Filter
-TestRunner.Filter.NewOr [static method]: (TestRunner.Filter, TestRunner.Filter) -> TestRunner.Filter
-TestRunner.Filter.NewTestCategory [static method]: TestRunner.Match -> TestRunner.Filter
-TestRunner.Filter.Tag [property]: [read-only] int
-TestRunner.FilterModule inherit obj
-TestRunner.FilterModule.parse [static method]: string -> TestRunner.Filter
-TestRunner.FilterModule.shouldRun [static method]: TestRunner.Filter -> (TestRunner.TestFixture -> TestRunner.SingleTestMethod -> bool)
-TestRunner.FixtureRunResults inherit obj, implements TestRunner.FixtureRunResults System.IEquatable, System.Collections.IStructuralEquatable
-TestRunner.FixtureRunResults..ctor [constructor]: ((TestRunner.TestMemberFailure * TestRunner.IndividualTestRunMetadata) list, (TestRunner.SingleTestMethod * TestRunner.TestMemberSuccess * TestRunner.IndividualTestRunMetadata) list, (TestRunner.UserMethodFailure * TestRunner.IndividualTestRunMetadata) list)
-TestRunner.FixtureRunResults.Failed [property]: [read-only] (TestRunner.TestMemberFailure * TestRunner.IndividualTestRunMetadata) list
-TestRunner.FixtureRunResults.get_Failed [method]: unit -> (TestRunner.TestMemberFailure * TestRunner.IndividualTestRunMetadata) list
-TestRunner.FixtureRunResults.get_IndividualTestRunMetadata [method]: unit -> (TestRunner.IndividualTestRunMetadata * Microsoft.FSharp.Core.FSharpChoice<TestRunner.TestMemberFailure, TestRunner.TestMemberSuccess, TestRunner.UserMethodFailure>) list
-TestRunner.FixtureRunResults.get_OtherFailures [method]: unit -> (TestRunner.UserMethodFailure * TestRunner.IndividualTestRunMetadata) list
-TestRunner.FixtureRunResults.get_Success [method]: unit -> (TestRunner.SingleTestMethod * TestRunner.TestMemberSuccess * TestRunner.IndividualTestRunMetadata) list
-TestRunner.FixtureRunResults.IndividualTestRunMetadata [property]: [read-only] (TestRunner.IndividualTestRunMetadata * Microsoft.FSharp.Core.FSharpChoice<TestRunner.TestMemberFailure, TestRunner.TestMemberSuccess, TestRunner.UserMethodFailure>) list
-TestRunner.FixtureRunResults.OtherFailures [property]: [read-only] (TestRunner.UserMethodFailure * TestRunner.IndividualTestRunMetadata) list
-TestRunner.FixtureRunResults.Success [property]: [read-only] (TestRunner.SingleTestMethod * TestRunner.TestMemberSuccess * TestRunner.IndividualTestRunMetadata) list
-TestRunner.IndividualTestRunMetadata inherit obj, implements TestRunner.IndividualTestRunMetadata System.IEquatable, System.Collections.IStructuralEquatable, TestRunner.IndividualTestRunMetadata System.IComparable, System.IComparable, System.Collections.IStructuralComparable
-TestRunner.IndividualTestRunMetadata..ctor [constructor]: (System.TimeSpan, System.DateTimeOffset, System.DateTimeOffset, string, System.Guid, System.Guid, string, string, string option, string option)
-TestRunner.IndividualTestRunMetadata.ClassName [property]: [read-only] string
-TestRunner.IndividualTestRunMetadata.ComputerName [property]: [read-only] string
-TestRunner.IndividualTestRunMetadata.End [property]: [read-only] System.DateTimeOffset
-TestRunner.IndividualTestRunMetadata.ExecutionId [property]: [read-only] System.Guid
-TestRunner.IndividualTestRunMetadata.get_ClassName [method]: unit -> string
-TestRunner.IndividualTestRunMetadata.get_ComputerName [method]: unit -> string
-TestRunner.IndividualTestRunMetadata.get_End [method]: unit -> System.DateTimeOffset
-TestRunner.IndividualTestRunMetadata.get_ExecutionId [method]: unit -> System.Guid
-TestRunner.IndividualTestRunMetadata.get_Start [method]: unit -> System.DateTimeOffset
-TestRunner.IndividualTestRunMetadata.get_StdErr [method]: unit -> string option
-TestRunner.IndividualTestRunMetadata.get_StdOut [method]: unit -> string option
-TestRunner.IndividualTestRunMetadata.get_TestId [method]: unit -> System.Guid
-TestRunner.IndividualTestRunMetadata.get_TestName [method]: unit -> string
-TestRunner.IndividualTestRunMetadata.get_Total [method]: unit -> System.TimeSpan
-TestRunner.IndividualTestRunMetadata.Start [property]: [read-only] System.DateTimeOffset
-TestRunner.IndividualTestRunMetadata.StdErr [property]: [read-only] string option
-TestRunner.IndividualTestRunMetadata.StdOut [property]: [read-only] string option
-TestRunner.IndividualTestRunMetadata.TestId [property]: [read-only] System.Guid
-TestRunner.IndividualTestRunMetadata.TestName [property]: [read-only] string
-TestRunner.IndividualTestRunMetadata.Total [property]: [read-only] System.TimeSpan
-TestRunner.ITestProgress - interface with 5 member(s)
-TestRunner.ITestProgress.OnTestFailed [method]: string -> TestRunner.TestMemberFailure -> unit
-TestRunner.ITestProgress.OnTestFixtureStart [method]: string -> int -> unit
-TestRunner.ITestProgress.OnTestMemberFinished [method]: string -> unit
-TestRunner.ITestProgress.OnTestMemberSkipped [method]: string -> unit
-TestRunner.ITestProgress.OnTestMemberStart [method]: string -> unit
-TestRunner.Match inherit obj, implements TestRunner.Match System.IEquatable, System.Collections.IStructuralEquatable, TestRunner.Match System.IComparable, System.IComparable, System.Collections.IStructuralComparable - union type with 2 cases
-TestRunner.Match+Contains inherit TestRunner.Match
-TestRunner.Match+Contains.get_Item [method]: unit -> string
-TestRunner.Match+Contains.Item [property]: [read-only] string
-TestRunner.Match+Exact inherit TestRunner.Match
-TestRunner.Match+Exact.get_Item [method]: unit -> string
-TestRunner.Match+Exact.Item [property]: [read-only] string
-TestRunner.Match+Tags inherit obj
-TestRunner.Match+Tags.Contains [static field]: int = 1
-TestRunner.Match+Tags.Exact [static field]: int = 0
-TestRunner.Match.get_IsContains [method]: unit -> bool
-TestRunner.Match.get_IsExact [method]: unit -> bool
-TestRunner.Match.get_Tag [method]: unit -> int
-TestRunner.Match.IsContains [property]: [read-only] bool
-TestRunner.Match.IsExact [property]: [read-only] bool
-TestRunner.Match.NewContains [static method]: string -> TestRunner.Match
-TestRunner.Match.NewExact [static method]: string -> TestRunner.Match
-TestRunner.Match.Tag [property]: [read-only] int
-TestRunner.Modifier inherit obj, implements TestRunner.Modifier System.IEquatable, System.Collections.IStructuralEquatable, TestRunner.Modifier System.IComparable, System.IComparable, System.Collections.IStructuralComparable - union type with 2 cases
-TestRunner.Modifier+Explicit inherit TestRunner.Modifier
-TestRunner.Modifier+Explicit.get_reason [method]: unit -> string option
-TestRunner.Modifier+Explicit.reason [property]: [read-only] string option
-TestRunner.Modifier+Ignored inherit TestRunner.Modifier
-TestRunner.Modifier+Ignored.get_reason [method]: unit -> string option
-TestRunner.Modifier+Ignored.reason [property]: [read-only] string option
-TestRunner.Modifier+Tags inherit obj
-TestRunner.Modifier+Tags.Explicit [static field]: int = 0
-TestRunner.Modifier+Tags.Ignored [static field]: int = 1
-TestRunner.Modifier.get_IsExplicit [method]: unit -> bool
-TestRunner.Modifier.get_IsIgnored [method]: unit -> bool
-TestRunner.Modifier.get_Tag [method]: unit -> int
-TestRunner.Modifier.IsExplicit [property]: [read-only] bool
-TestRunner.Modifier.IsIgnored [property]: [read-only] bool
-TestRunner.Modifier.NewExplicit [static method]: string option -> TestRunner.Modifier
-TestRunner.Modifier.NewIgnored [static method]: string option -> TestRunner.Modifier
-TestRunner.Modifier.Tag [property]: [read-only] int
-TestRunner.SingleTestMethod inherit obj, implements TestRunner.SingleTestMethod System.IEquatable, System.Collections.IStructuralEquatable
-TestRunner.SingleTestMethod..ctor [constructor]: (System.Reflection.MethodInfo, TestRunner.TestKind, TestRunner.Modifier list, string list, int option, TestRunner.Combinatorial option)
-TestRunner.SingleTestMethod.Categories [property]: [read-only] string list
-TestRunner.SingleTestMethod.Combinatorial [property]: [read-only] TestRunner.Combinatorial option
-TestRunner.SingleTestMethod.get_Categories [method]: unit -> string list
-TestRunner.SingleTestMethod.get_Combinatorial [method]: unit -> TestRunner.Combinatorial option
-TestRunner.SingleTestMethod.get_Kind [method]: unit -> TestRunner.TestKind
-TestRunner.SingleTestMethod.get_Method [method]: unit -> System.Reflection.MethodInfo
-TestRunner.SingleTestMethod.get_Modifiers [method]: unit -> TestRunner.Modifier list
-TestRunner.SingleTestMethod.get_Name [method]: unit -> string
-TestRunner.SingleTestMethod.get_Repeat [method]: unit -> int option
-TestRunner.SingleTestMethod.Kind [property]: [read-only] TestRunner.TestKind
-TestRunner.SingleTestMethod.Method [property]: [read-only] System.Reflection.MethodInfo
-TestRunner.SingleTestMethod.Modifiers [property]: [read-only] TestRunner.Modifier list
-TestRunner.SingleTestMethod.Name [property]: [read-only] string
-TestRunner.SingleTestMethod.Repeat [property]: [read-only] int option
-TestRunner.SingleTestMethodModule inherit obj
-TestRunner.SingleTestMethodModule.parse [static method]: string list -> System.Reflection.MethodInfo -> System.Reflection.CustomAttributeData list -> (TestRunner.SingleTestMethod option * System.Reflection.CustomAttributeData list)
-TestRunner.TestFailure inherit obj, implements TestRunner.TestFailure System.IEquatable, System.Collections.IStructuralEquatable - union type with 3 cases
-TestRunner.TestFailure+SetUpFailed inherit TestRunner.TestFailure
-TestRunner.TestFailure+SetUpFailed.get_Item [method]: unit -> TestRunner.UserMethodFailure
-TestRunner.TestFailure+SetUpFailed.Item [property]: [read-only] TestRunner.UserMethodFailure
-TestRunner.TestFailure+Tags inherit obj
-TestRunner.TestFailure+Tags.SetUpFailed [static field]: int = 1
-TestRunner.TestFailure+Tags.TearDownFailed [static field]: int = 2
-TestRunner.TestFailure+Tags.TestFailed [static field]: int = 0
-TestRunner.TestFailure+TearDownFailed inherit TestRunner.TestFailure
-TestRunner.TestFailure+TearDownFailed.get_Item [method]: unit -> TestRunner.UserMethodFailure
-TestRunner.TestFailure+TearDownFailed.Item [property]: [read-only] TestRunner.UserMethodFailure
-TestRunner.TestFailure+TestFailed inherit TestRunner.TestFailure
-TestRunner.TestFailure+TestFailed.get_Item [method]: unit -> TestRunner.UserMethodFailure
-TestRunner.TestFailure+TestFailed.Item [property]: [read-only] TestRunner.UserMethodFailure
-TestRunner.TestFailure.get_IsSetUpFailed [method]: unit -> bool
-TestRunner.TestFailure.get_IsTearDownFailed [method]: unit -> bool
-TestRunner.TestFailure.get_IsTestFailed [method]: unit -> bool
-TestRunner.TestFailure.get_Name [method]: unit -> string
-TestRunner.TestFailure.get_Tag [method]: unit -> int
-TestRunner.TestFailure.IsSetUpFailed [property]: [read-only] bool
-TestRunner.TestFailure.IsTearDownFailed [property]: [read-only] bool
-TestRunner.TestFailure.IsTestFailed [property]: [read-only] bool
-TestRunner.TestFailure.Name [property]: [read-only] string
-TestRunner.TestFailure.NewSetUpFailed [static method]: TestRunner.UserMethodFailure -> TestRunner.TestFailure
-TestRunner.TestFailure.NewTearDownFailed [static method]: TestRunner.UserMethodFailure -> TestRunner.TestFailure
-TestRunner.TestFailure.NewTestFailed [static method]: TestRunner.UserMethodFailure -> TestRunner.TestFailure
-TestRunner.TestFailure.Tag [property]: [read-only] int
-TestRunner.TestFixture inherit obj, implements TestRunner.TestFixture System.IEquatable, System.Collections.IStructuralEquatable
-TestRunner.TestFixture..ctor [constructor]: (System.Reflection.Assembly, string, System.Reflection.MethodInfo option, System.Reflection.MethodInfo option, System.Reflection.MethodInfo list, System.Reflection.MethodInfo list, TestRunner.SingleTestMethod list)
-TestRunner.TestFixture.ContainingAssembly [property]: [read-only] System.Reflection.Assembly
-TestRunner.TestFixture.Empty [static method]: System.Reflection.Assembly -> string -> TestRunner.TestFixture
-TestRunner.TestFixture.get_ContainingAssembly [method]: unit -> System.Reflection.Assembly
-TestRunner.TestFixture.get_Name [method]: unit -> string
-TestRunner.TestFixture.get_OneTimeSetUp [method]: unit -> System.Reflection.MethodInfo option
-TestRunner.TestFixture.get_OneTimeTearDown [method]: unit -> System.Reflection.MethodInfo option
-TestRunner.TestFixture.get_SetUp [method]: unit -> System.Reflection.MethodInfo list
-TestRunner.TestFixture.get_TearDown [method]: unit -> System.Reflection.MethodInfo list
-TestRunner.TestFixture.get_Tests [method]: unit -> TestRunner.SingleTestMethod list
-TestRunner.TestFixture.Name [property]: [read-only] string
-TestRunner.TestFixture.OneTimeSetUp [property]: [read-only] System.Reflection.MethodInfo option
-TestRunner.TestFixture.OneTimeTearDown [property]: [read-only] System.Reflection.MethodInfo option
-TestRunner.TestFixture.SetUp [property]: [read-only] System.Reflection.MethodInfo list
-TestRunner.TestFixture.TearDown [property]: [read-only] System.Reflection.MethodInfo list
-TestRunner.TestFixture.Tests [property]: [read-only] TestRunner.SingleTestMethod list
-TestRunner.TestFixtureModule inherit obj
-TestRunner.TestFixtureModule.parse [static method]: System.Type -> TestRunner.TestFixture
-TestRunner.TestFixtureModule.run [static method]: TestRunner.ITestProgress -> (TestRunner.TestFixture -> TestRunner.SingleTestMethod -> bool) -> TestRunner.TestFixture -> TestRunner.FixtureRunResults
-TestRunner.TestKind inherit obj, implements TestRunner.TestKind System.IEquatable, System.Collections.IStructuralEquatable - union type with 3 cases
-TestRunner.TestKind+Data inherit TestRunner.TestKind
-TestRunner.TestKind+Data.get_Item [method]: unit -> obj list list
-TestRunner.TestKind+Data.Item [property]: [read-only] obj list list
-TestRunner.TestKind+Source inherit TestRunner.TestKind
-TestRunner.TestKind+Source.get_Item [method]: unit -> string list
-TestRunner.TestKind+Source.Item [property]: [read-only] string list
-TestRunner.TestKind+Tags inherit obj
-TestRunner.TestKind+Tags.Data [static field]: int = 2
-TestRunner.TestKind+Tags.Single [static field]: int = 0
-TestRunner.TestKind+Tags.Source [static field]: int = 1
-TestRunner.TestKind.get_IsData [method]: unit -> bool
-TestRunner.TestKind.get_IsSingle [method]: unit -> bool
-TestRunner.TestKind.get_IsSource [method]: unit -> bool
-TestRunner.TestKind.get_Single [static method]: unit -> TestRunner.TestKind
-TestRunner.TestKind.get_Tag [method]: unit -> int
-TestRunner.TestKind.IsData [property]: [read-only] bool
-TestRunner.TestKind.IsSingle [property]: [read-only] bool
-TestRunner.TestKind.IsSource [property]: [read-only] bool
-TestRunner.TestKind.NewData [static method]: obj list list -> TestRunner.TestKind
-TestRunner.TestKind.NewSource [static method]: string list -> TestRunner.TestKind
-TestRunner.TestKind.Single [static property]: [read-only] TestRunner.TestKind
-TestRunner.TestKind.Tag [property]: [read-only] int
-TestRunner.TestMemberFailure inherit obj, implements TestRunner.TestMemberFailure System.IEquatable, System.Collections.IStructuralEquatable - union type with 2 cases
-TestRunner.TestMemberFailure+Failed inherit TestRunner.TestMemberFailure
-TestRunner.TestMemberFailure+Failed.get_Item [method]: unit -> TestRunner.TestFailure list
-TestRunner.TestMemberFailure+Failed.Item [property]: [read-only] TestRunner.TestFailure list
-TestRunner.TestMemberFailure+Malformed inherit TestRunner.TestMemberFailure
-TestRunner.TestMemberFailure+Malformed.get_reasons [method]: unit -> string list
-TestRunner.TestMemberFailure+Malformed.reasons [property]: [read-only] string list
-TestRunner.TestMemberFailure+Tags inherit obj
-TestRunner.TestMemberFailure+Tags.Failed [static field]: int = 1
-TestRunner.TestMemberFailure+Tags.Malformed [static field]: int = 0
-TestRunner.TestMemberFailure.get_IsFailed [method]: unit -> bool
-TestRunner.TestMemberFailure.get_IsMalformed [method]: unit -> bool
-TestRunner.TestMemberFailure.get_Tag [method]: unit -> int
-TestRunner.TestMemberFailure.IsFailed [property]: [read-only] bool
-TestRunner.TestMemberFailure.IsMalformed [property]: [read-only] bool
-TestRunner.TestMemberFailure.NewFailed [static method]: TestRunner.TestFailure list -> TestRunner.TestMemberFailure
-TestRunner.TestMemberFailure.NewMalformed [static method]: string list -> TestRunner.TestMemberFailure
-TestRunner.TestMemberFailure.Tag [property]: [read-only] int
-TestRunner.TestMemberSuccess inherit obj, implements TestRunner.TestMemberSuccess System.IEquatable, System.Collections.IStructuralEquatable, TestRunner.TestMemberSuccess System.IComparable, System.IComparable, System.Collections.IStructuralComparable - union type with 4 cases
-TestRunner.TestMemberSuccess+Explicit inherit TestRunner.TestMemberSuccess
-TestRunner.TestMemberSuccess+Explicit.get_reason [method]: unit -> string option
-TestRunner.TestMemberSuccess+Explicit.reason [property]: [read-only] string option
-TestRunner.TestMemberSuccess+Ignored inherit TestRunner.TestMemberSuccess
-TestRunner.TestMemberSuccess+Ignored.get_reason [method]: unit -> string option
-TestRunner.TestMemberSuccess+Ignored.reason [property]: [read-only] string option
-TestRunner.TestMemberSuccess+Inconclusive inherit TestRunner.TestMemberSuccess
-TestRunner.TestMemberSuccess+Inconclusive.get_reason [method]: unit -> string option
-TestRunner.TestMemberSuccess+Inconclusive.reason [property]: [read-only] string option
-TestRunner.TestMemberSuccess+Tags inherit obj
-TestRunner.TestMemberSuccess+Tags.Explicit [static field]: int = 2
-TestRunner.TestMemberSuccess+Tags.Ignored [static field]: int = 1
-TestRunner.TestMemberSuccess+Tags.Inconclusive [static field]: int = 3
-TestRunner.TestMemberSuccess+Tags.Ok [static field]: int = 0
-TestRunner.TestMemberSuccess.get_IsExplicit [method]: unit -> bool
-TestRunner.TestMemberSuccess.get_IsIgnored [method]: unit -> bool
-TestRunner.TestMemberSuccess.get_IsInconclusive [method]: unit -> bool
-TestRunner.TestMemberSuccess.get_IsOk [method]: unit -> bool
-TestRunner.TestMemberSuccess.get_Ok [static method]: unit -> TestRunner.TestMemberSuccess
-TestRunner.TestMemberSuccess.get_Tag [method]: unit -> int
-TestRunner.TestMemberSuccess.IsExplicit [property]: [read-only] bool
-TestRunner.TestMemberSuccess.IsIgnored [property]: [read-only] bool
-TestRunner.TestMemberSuccess.IsInconclusive [property]: [read-only] bool
-TestRunner.TestMemberSuccess.IsOk [property]: [read-only] bool
-TestRunner.TestMemberSuccess.NewExplicit [static method]: string option -> TestRunner.TestMemberSuccess
-TestRunner.TestMemberSuccess.NewIgnored [static method]: string option -> TestRunner.TestMemberSuccess
-TestRunner.TestMemberSuccess.NewInconclusive [static method]: string option -> TestRunner.TestMemberSuccess
-TestRunner.TestMemberSuccess.Ok [static property]: [read-only] TestRunner.TestMemberSuccess
-TestRunner.TestMemberSuccess.Tag [property]: [read-only] int
-TestRunner.TestProgress inherit obj
-TestRunner.TestProgress.toStderr [static method]: unit -> TestRunner.ITestProgress
-TestRunner.TrxCounters inherit obj, implements TestRunner.TrxCounters System.IEquatable, System.Collections.IStructuralEquatable
-TestRunner.TrxCounters..ctor [constructor]: (System.UInt32, System.UInt32, System.UInt32, System.UInt32, System.UInt32, System.UInt32, System.UInt32, System.UInt32, System.UInt32, System.UInt32, System.UInt32, System.UInt32, System.UInt32, System.UInt32, System.UInt32, System.UInt32)
-TestRunner.TrxCounters.Aborted [property]: [read-only] System.UInt32
-TestRunner.TrxCounters.AddFailed [method]: unit -> TestRunner.TrxCounters
-TestRunner.TrxCounters.AddInconclusive [method]: unit -> TestRunner.TrxCounters
-TestRunner.TrxCounters.AddNotExecuted [method]: unit -> TestRunner.TrxCounters
-TestRunner.TrxCounters.AddPassed [method]: unit -> TestRunner.TrxCounters
-TestRunner.TrxCounters.Completed [property]: [read-only] System.UInt32
-TestRunner.TrxCounters.Disconnected [property]: [read-only] System.UInt32
-TestRunner.TrxCounters.Errors [property]: [read-only] System.UInt32
-TestRunner.TrxCounters.Executed [property]: [read-only] System.UInt32
-TestRunner.TrxCounters.Failed [property]: [read-only] System.UInt32
-TestRunner.TrxCounters.get_Aborted [method]: unit -> System.UInt32
-TestRunner.TrxCounters.get_Completed [method]: unit -> System.UInt32
-TestRunner.TrxCounters.get_Disconnected [method]: unit -> System.UInt32
-TestRunner.TrxCounters.get_Errors [method]: unit -> System.UInt32
-TestRunner.TrxCounters.get_Executed [method]: unit -> System.UInt32
-TestRunner.TrxCounters.get_Failed [method]: unit -> System.UInt32
-TestRunner.TrxCounters.get_Inconclusive [method]: unit -> System.UInt32
-TestRunner.TrxCounters.get_InProgress [method]: unit -> System.UInt32
-TestRunner.TrxCounters.get_NotExecuted [method]: unit -> System.UInt32
-TestRunner.TrxCounters.get_NotRunnable [method]: unit -> System.UInt32
-TestRunner.TrxCounters.get_Passed [method]: unit -> System.UInt32
-TestRunner.TrxCounters.get_PassedButRunAborted [method]: unit -> System.UInt32
-TestRunner.TrxCounters.get_Pending [method]: unit -> System.UInt32
-TestRunner.TrxCounters.get_Timeout [method]: unit -> System.UInt32
-TestRunner.TrxCounters.get_Total [method]: unit -> System.UInt32
-TestRunner.TrxCounters.get_Warning [method]: unit -> System.UInt32
-TestRunner.TrxCounters.get_Zero [static method]: unit -> TestRunner.TrxCounters
-TestRunner.TrxCounters.Inconclusive [property]: [read-only] System.UInt32
-TestRunner.TrxCounters.InProgress [property]: [read-only] System.UInt32
-TestRunner.TrxCounters.NotExecuted [property]: [read-only] System.UInt32
-TestRunner.TrxCounters.NotRunnable [property]: [read-only] System.UInt32
-TestRunner.TrxCounters.Passed [property]: [read-only] System.UInt32
-TestRunner.TrxCounters.PassedButRunAborted [property]: [read-only] System.UInt32
-TestRunner.TrxCounters.Pending [property]: [read-only] System.UInt32
-TestRunner.TrxCounters.Timeout [property]: [read-only] System.UInt32
-TestRunner.TrxCounters.Total [property]: [read-only] System.UInt32
-TestRunner.TrxCounters.Warning [property]: [read-only] System.UInt32
-TestRunner.TrxCounters.Zero [static property]: [read-only] TestRunner.TrxCounters
-TestRunner.TrxDeployment inherit obj, implements TestRunner.TrxDeployment System.IEquatable, System.Collections.IStructuralEquatable
-TestRunner.TrxDeployment..ctor [constructor]: string
-TestRunner.TrxDeployment.get_RunDeploymentRoot [method]: unit -> string
-TestRunner.TrxDeployment.RunDeploymentRoot [property]: [read-only] string
-TestRunner.TrxErrorInfo inherit obj, implements TestRunner.TrxErrorInfo System.IEquatable, System.Collections.IStructuralEquatable
-TestRunner.TrxErrorInfo..ctor [constructor]: (string option, string option)
-TestRunner.TrxErrorInfo.get_Message [method]: unit -> string option
-TestRunner.TrxErrorInfo.get_StackTrace [method]: unit -> string option
-TestRunner.TrxErrorInfo.Message [property]: [read-only] string option
-TestRunner.TrxErrorInfo.StackTrace [property]: [read-only] string option
-TestRunner.TrxExecution inherit obj, implements TestRunner.TrxExecution System.IEquatable, System.Collections.IStructuralEquatable
-TestRunner.TrxExecution..ctor [constructor]: System.Guid
-TestRunner.TrxExecution.get_Id [method]: unit -> System.Guid
-TestRunner.TrxExecution.Id [property]: [read-only] System.Guid
-TestRunner.TrxOutcome inherit obj, implements TestRunner.TrxOutcome System.IEquatable, System.Collections.IStructuralEquatable - union type with 3 cases
-TestRunner.TrxOutcome+Tags inherit obj
-TestRunner.TrxOutcome+Tags.Completed [static field]: int = 0
-TestRunner.TrxOutcome+Tags.Failed [static field]: int = 2
-TestRunner.TrxOutcome+Tags.Warning [static field]: int = 1
-TestRunner.TrxOutcome.Completed [static property]: [read-only] TestRunner.TrxOutcome
-TestRunner.TrxOutcome.Failed [static property]: [read-only] TestRunner.TrxOutcome
-TestRunner.TrxOutcome.get_Completed [static method]: unit -> TestRunner.TrxOutcome
-TestRunner.TrxOutcome.get_Failed [static method]: unit -> TestRunner.TrxOutcome
-TestRunner.TrxOutcome.get_IsCompleted [method]: unit -> bool
-TestRunner.TrxOutcome.get_IsFailed [method]: unit -> bool
-TestRunner.TrxOutcome.get_IsWarning [method]: unit -> bool
-TestRunner.TrxOutcome.get_Tag [method]: unit -> int
-TestRunner.TrxOutcome.get_Warning [static method]: unit -> TestRunner.TrxOutcome
-TestRunner.TrxOutcome.IsCompleted [property]: [read-only] bool
-TestRunner.TrxOutcome.IsFailed [property]: [read-only] bool
-TestRunner.TrxOutcome.IsWarning [property]: [read-only] bool
-TestRunner.TrxOutcome.Parse [static method]: string -> TestRunner.TrxOutcome option
-TestRunner.TrxOutcome.Tag [property]: [read-only] int
-TestRunner.TrxOutcome.Warning [static property]: [read-only] TestRunner.TrxOutcome
-TestRunner.TrxOutput inherit obj, implements TestRunner.TrxOutput System.IEquatable, System.Collections.IStructuralEquatable
-TestRunner.TrxOutput..ctor [constructor]: (string option, TestRunner.TrxErrorInfo option)
-TestRunner.TrxOutput.ErrorInfo [property]: [read-only] TestRunner.TrxErrorInfo option
-TestRunner.TrxOutput.get_ErrorInfo [method]: unit -> TestRunner.TrxErrorInfo option
-TestRunner.TrxOutput.get_StdOut [method]: unit -> string option
-TestRunner.TrxOutput.StdOut [property]: [read-only] string option
-TestRunner.TrxReport inherit obj, implements TestRunner.TrxReport System.IEquatable, System.Collections.IStructuralEquatable
-TestRunner.TrxReport..ctor [constructor]: (System.Guid, string, TestRunner.TrxReportTimes, TestRunner.TrxTestSettings, TestRunner.TrxUnitTestResult list, TestRunner.TrxUnitTest list, TestRunner.TrxTestEntry list, TestRunner.TrxTestListEntry list, TestRunner.TrxResultsSummary)
-TestRunner.TrxReport.get_Id [method]: unit -> System.Guid
-TestRunner.TrxReport.get_Name [method]: unit -> string
-TestRunner.TrxReport.get_Results [method]: unit -> TestRunner.TrxUnitTestResult list
-TestRunner.TrxReport.get_ResultsSummary [method]: unit -> TestRunner.TrxResultsSummary
-TestRunner.TrxReport.get_Settings [method]: unit -> TestRunner.TrxTestSettings
-TestRunner.TrxReport.get_TestDefinitions [method]: unit -> TestRunner.TrxUnitTest list
-TestRunner.TrxReport.get_TestEntries [method]: unit -> TestRunner.TrxTestEntry list
-TestRunner.TrxReport.get_TestLists [method]: unit -> TestRunner.TrxTestListEntry list
-TestRunner.TrxReport.get_Times [method]: unit -> TestRunner.TrxReportTimes
-TestRunner.TrxReport.Id [property]: [read-only] System.Guid
-TestRunner.TrxReport.Name [property]: [read-only] string
-TestRunner.TrxReport.Results [property]: [read-only] TestRunner.TrxUnitTestResult list
-TestRunner.TrxReport.ResultsSummary [property]: [read-only] TestRunner.TrxResultsSummary
-TestRunner.TrxReport.Settings [property]: [read-only] TestRunner.TrxTestSettings
-TestRunner.TrxReport.TestDefinitions [property]: [read-only] TestRunner.TrxUnitTest list
-TestRunner.TrxReport.TestEntries [property]: [read-only] TestRunner.TrxTestEntry list
-TestRunner.TrxReport.TestLists [property]: [read-only] TestRunner.TrxTestListEntry list
-TestRunner.TrxReport.Times [property]: [read-only] TestRunner.TrxReportTimes
-TestRunner.TrxReportModule inherit obj
-TestRunner.TrxReportModule.parse [static method]: string -> Microsoft.FSharp.Core.FSharpResult<TestRunner.TrxReport, string>
-TestRunner.TrxReportModule.toXml [static method]: TestRunner.TrxReport -> System.Xml.XmlDocument
-TestRunner.TrxReportTimes inherit obj, implements TestRunner.TrxReportTimes System.IEquatable, System.Collections.IStructuralEquatable
-TestRunner.TrxReportTimes..ctor [constructor]: (System.DateTimeOffset, System.DateTimeOffset, System.DateTimeOffset, System.DateTimeOffset)
-TestRunner.TrxReportTimes.Creation [property]: [read-only] System.DateTimeOffset
-TestRunner.TrxReportTimes.Finish [property]: [read-only] System.DateTimeOffset
-TestRunner.TrxReportTimes.get_Creation [method]: unit -> System.DateTimeOffset
-TestRunner.TrxReportTimes.get_Finish [method]: unit -> System.DateTimeOffset
-TestRunner.TrxReportTimes.get_Queuing [method]: unit -> System.DateTimeOffset
-TestRunner.TrxReportTimes.get_Start [method]: unit -> System.DateTimeOffset
-TestRunner.TrxReportTimes.Queuing [property]: [read-only] System.DateTimeOffset
-TestRunner.TrxReportTimes.Start [property]: [read-only] System.DateTimeOffset
-TestRunner.TrxResultsSummary inherit obj, implements TestRunner.TrxResultsSummary System.IEquatable, System.Collections.IStructuralEquatable
-TestRunner.TrxResultsSummary..ctor [constructor]: (TestRunner.TrxOutcome, TestRunner.TrxCounters, TestRunner.TrxOutput, TestRunner.TrxRunInfo list)
-TestRunner.TrxResultsSummary.Counters [property]: [read-only] TestRunner.TrxCounters
-TestRunner.TrxResultsSummary.get_Counters [method]: unit -> TestRunner.TrxCounters
-TestRunner.TrxResultsSummary.get_Outcome [method]: unit -> TestRunner.TrxOutcome
-TestRunner.TrxResultsSummary.get_Output [method]: unit -> TestRunner.TrxOutput
-TestRunner.TrxResultsSummary.get_RunInfos [method]: unit -> TestRunner.TrxRunInfo list
-TestRunner.TrxResultsSummary.Outcome [property]: [read-only] TestRunner.TrxOutcome
-TestRunner.TrxResultsSummary.Output [property]: [read-only] TestRunner.TrxOutput
-TestRunner.TrxResultsSummary.RunInfos [property]: [read-only] TestRunner.TrxRunInfo list
-TestRunner.TrxRunInfo inherit obj, implements TestRunner.TrxRunInfo System.IEquatable, System.Collections.IStructuralEquatable
-TestRunner.TrxRunInfo..ctor [constructor]: (string, TestRunner.TrxOutcome, System.DateTimeOffset, string)
-TestRunner.TrxRunInfo.ComputerName [property]: [read-only] string
-TestRunner.TrxRunInfo.get_ComputerName [method]: unit -> string
-TestRunner.TrxRunInfo.get_Outcome [method]: unit -> TestRunner.TrxOutcome
-TestRunner.TrxRunInfo.get_Text [method]: unit -> string
-TestRunner.TrxRunInfo.get_Timestamp [method]: unit -> System.DateTimeOffset
-TestRunner.TrxRunInfo.Outcome [property]: [read-only] TestRunner.TrxOutcome
-TestRunner.TrxRunInfo.Text [property]: [read-only] string
-TestRunner.TrxRunInfo.Timestamp [property]: [read-only] System.DateTimeOffset
-TestRunner.TrxTestEntry inherit obj, implements TestRunner.TrxTestEntry System.IEquatable, System.Collections.IStructuralEquatable
-TestRunner.TrxTestEntry..ctor [constructor]: (System.Guid, System.Guid, System.Guid)
-TestRunner.TrxTestEntry.ExecutionId [property]: [read-only] System.Guid
-TestRunner.TrxTestEntry.get_ExecutionId [method]: unit -> System.Guid
-TestRunner.TrxTestEntry.get_TestId [method]: unit -> System.Guid
-TestRunner.TrxTestEntry.get_TestListId [method]: unit -> System.Guid
-TestRunner.TrxTestEntry.TestId [property]: [read-only] System.Guid
-TestRunner.TrxTestEntry.TestListId [property]: [read-only] System.Guid
-TestRunner.TrxTestListEntry inherit obj, implements TestRunner.TrxTestListEntry System.IEquatable, System.Collections.IStructuralEquatable
-TestRunner.TrxTestListEntry..ctor [constructor]: (string, System.Guid)
-TestRunner.TrxTestListEntry.get_Id [method]: unit -> System.Guid
-TestRunner.TrxTestListEntry.get_Name [method]: unit -> string
-TestRunner.TrxTestListEntry.Id [property]: [read-only] System.Guid
-TestRunner.TrxTestListEntry.Name [property]: [read-only] string
-TestRunner.TrxTestMethod inherit obj, implements TestRunner.TrxTestMethod System.IEquatable, System.Collections.IStructuralEquatable
-TestRunner.TrxTestMethod..ctor [constructor]: (string, System.Uri, string, string)
-TestRunner.TrxTestMethod.AdapterTypeName [property]: [read-only] System.Uri
-TestRunner.TrxTestMethod.ClassName [property]: [read-only] string
-TestRunner.TrxTestMethod.CodeBase [property]: [read-only] string
-TestRunner.TrxTestMethod.get_AdapterTypeName [method]: unit -> System.Uri
-TestRunner.TrxTestMethod.get_ClassName [method]: unit -> string
-TestRunner.TrxTestMethod.get_CodeBase [method]: unit -> string
-TestRunner.TrxTestMethod.get_Name [method]: unit -> string
-TestRunner.TrxTestMethod.Name [property]: [read-only] string
-TestRunner.TrxTestOutcome inherit obj, implements TestRunner.TrxTestOutcome System.IEquatable, System.Collections.IStructuralEquatable - union type with 4 cases
-TestRunner.TrxTestOutcome+Tags inherit obj
-TestRunner.TrxTestOutcome+Tags.Failed [static field]: int = 1
-TestRunner.TrxTestOutcome+Tags.Inconclusive [static field]: int = 3
-TestRunner.TrxTestOutcome+Tags.NotExecuted [static field]: int = 2
-TestRunner.TrxTestOutcome+Tags.Passed [static field]: int = 0
-TestRunner.TrxTestOutcome.Failed [static property]: [read-only] TestRunner.TrxTestOutcome
-TestRunner.TrxTestOutcome.get_Failed [static method]: unit -> TestRunner.TrxTestOutcome
-TestRunner.TrxTestOutcome.get_Inconclusive [static method]: unit -> TestRunner.TrxTestOutcome
-TestRunner.TrxTestOutcome.get_IsFailed [method]: unit -> bool
-TestRunner.TrxTestOutcome.get_IsInconclusive [method]: unit -> bool
-TestRunner.TrxTestOutcome.get_IsNotExecuted [method]: unit -> bool
-TestRunner.TrxTestOutcome.get_IsPassed [method]: unit -> bool
-TestRunner.TrxTestOutcome.get_NotExecuted [static method]: unit -> TestRunner.TrxTestOutcome
-TestRunner.TrxTestOutcome.get_Passed [static method]: unit -> TestRunner.TrxTestOutcome
-TestRunner.TrxTestOutcome.get_Tag [method]: unit -> int
-TestRunner.TrxTestOutcome.Inconclusive [static property]: [read-only] TestRunner.TrxTestOutcome
-TestRunner.TrxTestOutcome.IsFailed [property]: [read-only] bool
-TestRunner.TrxTestOutcome.IsInconclusive [property]: [read-only] bool
-TestRunner.TrxTestOutcome.IsNotExecuted [property]: [read-only] bool
-TestRunner.TrxTestOutcome.IsPassed [property]: [read-only] bool
-TestRunner.TrxTestOutcome.NotExecuted [static property]: [read-only] TestRunner.TrxTestOutcome
-TestRunner.TrxTestOutcome.Parse [static method]: string -> TestRunner.TrxTestOutcome option
-TestRunner.TrxTestOutcome.Passed [static property]: [read-only] TestRunner.TrxTestOutcome
-TestRunner.TrxTestOutcome.Tag [property]: [read-only] int
-TestRunner.TrxTestSettings inherit obj, implements TestRunner.TrxTestSettings System.IEquatable, System.Collections.IStructuralEquatable
-TestRunner.TrxTestSettings..ctor [constructor]: (string, System.Guid, TestRunner.TrxDeployment)
-TestRunner.TrxTestSettings.Deployment [property]: [read-only] TestRunner.TrxDeployment
-TestRunner.TrxTestSettings.get_Deployment [method]: unit -> TestRunner.TrxDeployment
-TestRunner.TrxTestSettings.get_Id [method]: unit -> System.Guid
-TestRunner.TrxTestSettings.get_Name [method]: unit -> string
-TestRunner.TrxTestSettings.Id [property]: [read-only] System.Guid
-TestRunner.TrxTestSettings.Name [property]: [read-only] string
-TestRunner.TrxUnitTest inherit obj, implements TestRunner.TrxUnitTest System.IEquatable, System.Collections.IStructuralEquatable
-TestRunner.TrxUnitTest..ctor [constructor]: (string, string, System.Guid, TestRunner.TrxExecution, TestRunner.TrxTestMethod)
-TestRunner.TrxUnitTest.Execution [property]: [read-only] TestRunner.TrxExecution
-TestRunner.TrxUnitTest.get_Execution [method]: unit -> TestRunner.TrxExecution
-TestRunner.TrxUnitTest.get_Id [method]: unit -> System.Guid
-TestRunner.TrxUnitTest.get_Name [method]: unit -> string
-TestRunner.TrxUnitTest.get_Storage [method]: unit -> string
-TestRunner.TrxUnitTest.get_TestMethod [method]: unit -> TestRunner.TrxTestMethod
-TestRunner.TrxUnitTest.Id [property]: [read-only] System.Guid
-TestRunner.TrxUnitTest.Name [property]: [read-only] string
-TestRunner.TrxUnitTest.Storage [property]: [read-only] string
-TestRunner.TrxUnitTest.TestMethod [property]: [read-only] TestRunner.TrxTestMethod
-TestRunner.TrxUnitTestResult inherit obj, implements TestRunner.TrxUnitTestResult System.IEquatable, System.Collections.IStructuralEquatable
-TestRunner.TrxUnitTestResult..ctor [constructor]: (System.Guid, System.Guid, string, string, System.TimeSpan, System.DateTimeOffset, System.DateTimeOffset, System.Guid, TestRunner.TrxTestOutcome, System.Guid, string, TestRunner.TrxOutput option)
-TestRunner.TrxUnitTestResult.ComputerName [property]: [read-only] string
-TestRunner.TrxUnitTestResult.Duration [property]: [read-only] System.TimeSpan
-TestRunner.TrxUnitTestResult.EndTime [property]: [read-only] System.DateTimeOffset
-TestRunner.TrxUnitTestResult.ExecutionId [property]: [read-only] System.Guid
-TestRunner.TrxUnitTestResult.get_ComputerName [method]: unit -> string
-TestRunner.TrxUnitTestResult.get_Duration [method]: unit -> System.TimeSpan
-TestRunner.TrxUnitTestResult.get_EndTime [method]: unit -> System.DateTimeOffset
-TestRunner.TrxUnitTestResult.get_ExecutionId [method]: unit -> System.Guid
-TestRunner.TrxUnitTestResult.get_Outcome [method]: unit -> TestRunner.TrxTestOutcome
-TestRunner.TrxUnitTestResult.get_Output [method]: unit -> TestRunner.TrxOutput option
-TestRunner.TrxUnitTestResult.get_RelativeResultsDirectory [method]: unit -> string
-TestRunner.TrxUnitTestResult.get_StartTime [method]: unit -> System.DateTimeOffset
-TestRunner.TrxUnitTestResult.get_TestId [method]: unit -> System.Guid
-TestRunner.TrxUnitTestResult.get_TestListId [method]: unit -> System.Guid
-TestRunner.TrxUnitTestResult.get_TestName [method]: unit -> string
-TestRunner.TrxUnitTestResult.get_TestType [method]: unit -> System.Guid
-TestRunner.TrxUnitTestResult.Outcome [property]: [read-only] TestRunner.TrxTestOutcome
-TestRunner.TrxUnitTestResult.Output [property]: [read-only] TestRunner.TrxOutput option
-TestRunner.TrxUnitTestResult.RelativeResultsDirectory [property]: [read-only] string
-TestRunner.TrxUnitTestResult.StartTime [property]: [read-only] System.DateTimeOffset
-TestRunner.TrxUnitTestResult.TestId [property]: [read-only] System.Guid
-TestRunner.TrxUnitTestResult.TestListId [property]: [read-only] System.Guid
-TestRunner.TrxUnitTestResult.TestName [property]: [read-only] string
-TestRunner.TrxUnitTestResult.TestType [property]: [read-only] System.Guid
-TestRunner.UserMethodFailure inherit obj, implements TestRunner.UserMethodFailure System.IEquatable, System.Collections.IStructuralEquatable - union type with 2 cases
-TestRunner.UserMethodFailure+ReturnedNonUnit inherit TestRunner.UserMethodFailure
-TestRunner.UserMethodFailure+ReturnedNonUnit.get_name [method]: unit -> string
-TestRunner.UserMethodFailure+ReturnedNonUnit.get_result [method]: unit -> obj
-TestRunner.UserMethodFailure+ReturnedNonUnit.name [property]: [read-only] string
-TestRunner.UserMethodFailure+ReturnedNonUnit.result [property]: [read-only] obj
-TestRunner.UserMethodFailure+Tags inherit obj
-TestRunner.UserMethodFailure+Tags.ReturnedNonUnit [static field]: int = 0
-TestRunner.UserMethodFailure+Tags.Threw [static field]: int = 1
-TestRunner.UserMethodFailure+Threw inherit TestRunner.UserMethodFailure
-TestRunner.UserMethodFailure+Threw.get_Item2 [method]: unit -> System.Exception
-TestRunner.UserMethodFailure+Threw.get_name [method]: unit -> string
-TestRunner.UserMethodFailure+Threw.Item2 [property]: [read-only] System.Exception
-TestRunner.UserMethodFailure+Threw.name [property]: [read-only] string
-TestRunner.UserMethodFailure.get_IsReturnedNonUnit [method]: unit -> bool
-TestRunner.UserMethodFailure.get_IsThrew [method]: unit -> bool
-TestRunner.UserMethodFailure.get_Name [method]: unit -> string
-TestRunner.UserMethodFailure.get_Tag [method]: unit -> int
-TestRunner.UserMethodFailure.IsReturnedNonUnit [property]: [read-only] bool
-TestRunner.UserMethodFailure.IsThrew [property]: [read-only] bool
-TestRunner.UserMethodFailure.Name [property]: [read-only] string
-TestRunner.UserMethodFailure.NewReturnedNonUnit [static method]: (string, obj) -> TestRunner.UserMethodFailure
-TestRunner.UserMethodFailure.NewThrew [static method]: (string, System.Exception) -> TestRunner.UserMethodFailure
-TestRunner.UserMethodFailure.Tag [property]: [read-only] int

TestRunner/Progress.fs

@@ -1,24 +0,0 @@
-namespace TestRunner
-
-open Spectre.Console
-
-[<RequireQualifiedAccess>]
-module Progress =
-    let spectre () : ITestProgress =
-        { new ITestProgress with
-            member _.OnTestFailed name failure =
-                AnsiConsole.Console.MarkupLine
-                    $"[red]Test '%s{Markup.Escape name}' failed: %s{Markup.Escape (failure.ToString ())}[/]"
-
-            member _.OnTestFixtureStart name testCount =
-                AnsiConsole.Console.MarkupLine $"[white]Running tests: %s{Markup.Escape name}[/]"
-
-            member _.OnTestMemberFinished name =
-                AnsiConsole.Console.MarkupLine $"[gray]Finished test: %s{Markup.Escape name}[/]"
-
-            member _.OnTestMemberSkipped name =
-                AnsiConsole.Console.MarkupLine $"[yellow]Skipping test due to filter: %s{Markup.Escape name}[/]"
-
-            member _.OnTestMemberStart name =
-                AnsiConsole.Console.MarkupLine $"[white]Running test: %s{Markup.Escape name}[/]"
-        }

TestRunner/version.json

@@ -1,11 +0,0 @@
-{
-  "version": "0.1-prerelease",
-  "publicReleaseRefSpec": ["^refs/heads/main$"],
-  "pathFilters": [
-    "./",
-    "^TestRunner.Test/",
-    "../TestRunner.Lib",
-    ":/Directory.Build.props",
-    ":/README.md"
-  ]
-}

WoofWare.NUnitTestRunner.Lib/Array.fs

@@ -1,4 +1,4 @@
-namespace TestRunner
+namespace WoofWare.NUnitTestRunner
 
 [<RequireQualifiedAccess>]
 module internal Array =

WoofWare.NUnitTestRunner.Lib/AssemblyInfo.fs

@@ -0,0 +1,7 @@
+namespace WoofWare.NUnitTestRunner.AssemblyInfo
+
+open System.Runtime.CompilerServices
+
+[<assembly : InternalsVisibleTo("WoofWare.NUnitTestRunner.Test")>]
+
+do ()

WoofWare.NUnitTestRunner.Lib/Context.fs

@@ -0,0 +1,180 @@
+namespace WoofWare.NUnitTestRunner
+
+open System
+open System.Collections.Generic
+open System.IO
+open System.Reflection
+open System.Runtime.Loader
+open System.Text
+open System.Threading
+
+type internal OutputStreamId = | OutputStreamId of Guid
+
+type private ThreadAwareWriter
+    (
+        local : AsyncLocal<OutputStreamId>,
+        underlying : Dictionary<OutputStreamId, TextWriter>,
+        mem : Dictionary<OutputStreamId, MemoryStream>
+    )
+    =
+    inherit TextWriter ()
+    override _.get_Encoding () = Encoding.Default
+
+    override this.Write (v : char) : unit =
+        use prev = ExecutionContext.Capture ()
+
+        (fun _ ->
+            (fun () ->
+                match underlying.TryGetValue local.Value with
+                | true, output -> output.Write v
+                | false, _ ->
+                    let wanted =
+                        underlying |> Seq.map (fun (KeyValue (a, b)) -> $"%O{a}") |> String.concat "\n"
+
+                    failwith $"no such context: %O{local.Value}\nwanted:\n"
+            )
+            |> lock underlying
+        )
+        |> fun action -> ExecutionContext.Run (prev, action, ())
+
+    override this.WriteLine (v : string) : unit =
+        use prev = ExecutionContext.Capture ()
+
+        (fun _ ->
+            (fun () ->
+                match underlying.TryGetValue local.Value with
+                | true, output -> output.WriteLine v
+                | false, _ ->
+                    let wanted =
+                        underlying |> Seq.map (fun (KeyValue (a, b)) -> $"%O{a}") |> String.concat "\n"
+
+                    failwith $"no such context: %O{local.Value}\nwanted:\n"
+            )
+            |> lock underlying
+        )
+        |> fun action -> ExecutionContext.Run (prev, action, ())
+
+/// Wraps up the necessary context to intercept global state.
+type TestContexts =
+    private
+        {
+            /// Accesses to this must be locked on StdOutWriters.
+            StdOuts : Dictionary<OutputStreamId, MemoryStream>
+            /// Accesses to this must be locked on StdErrWriters.
+            StdErrs : Dictionary<OutputStreamId, MemoryStream>
+            StdOutWriters : Dictionary<OutputStreamId, TextWriter>
+            StdErrWriters : Dictionary<OutputStreamId, TextWriter>
+            StdOutWriter : TextWriter
+            StdErrWriter : TextWriter
+            AsyncLocal : AsyncLocal<OutputStreamId>
+        }
+
+    /// Call this exactly once.
+    static member Empty () =
+        let stdouts = Dictionary ()
+        let stderrs = Dictionary ()
+        let stdoutWriters = Dictionary ()
+        let stderrWriters = Dictionary ()
+        let local = AsyncLocal ()
+        let stdoutWriter = new ThreadAwareWriter (local, stdoutWriters, stdouts)
+        let stderrWriter = new ThreadAwareWriter (local, stderrWriters, stderrs)
+
+        {
+            StdOuts = stdouts
+            StdErrs = stderrs
+            StdOutWriter = stdoutWriter
+            StdErrWriter = stderrWriter
+            StdOutWriters = stdoutWriters
+            StdErrWriters = stderrWriters
+            AsyncLocal = local
+        }
+
+    member internal this.Stdout : TextWriter = this.StdOutWriter
+    member internal this.Stderr : TextWriter = this.StdErrWriter
+
+    member internal this.DumpStdout (id : OutputStreamId) : string =
+        lock
+            this.StdOutWriters
+            (fun () ->
+                this.StdOutWriters.[id].Flush ()
+                this.StdOuts.[id].ToArray ()
+            )
+        |> Encoding.Default.GetString
+
+    member internal this.DumpStderr (id : OutputStreamId) : string =
+        lock
+            this.StdErrWriters
+            (fun () ->
+                this.StdErrWriters.[id].Flush ()
+                this.StdErrs.[id].ToArray ()
+            )
+        |> Encoding.Default.GetString
+
+    member internal this.NewOutputs () =
+        let id = Guid.NewGuid () |> OutputStreamId
+        let msOut = new MemoryStream ()
+        let wrOut = new StreamWriter (msOut)
+        let msErr = new MemoryStream ()
+        let wrErr = new StreamWriter (msErr)
+
+        lock
+            this.StdOutWriters
+            (fun () ->
+                this.StdOutWriters.Add (id, wrOut)
+                this.StdOuts.Add (id, msOut)
+            )
+
+        lock
+            this.StdErrWriters
+            (fun () ->
+                this.StdErrWriters.Add (id, wrErr)
+                this.StdErrs.Add (id, msErr)
+            )
+
+        id
+
+    interface IDisposable with
+        member this.Dispose () =
+            // TODO: dispose the streams
+            ()
+
+/// A separate AssemblyLoadContext within which you can run the tests in the given DLL.
+/// Supply places to find the .NET runtimes.
+type LoadContext (dll : FileInfo, runtimes : DirectoryInfo list, contexts : TestContexts) =
+    inherit AssemblyLoadContext ()
+
+    /// Load the assembly with the given name into this assembly context.
+    /// This additionally monkey-patches System.Console: it performs SetOut and SetError on them
+    /// so that they redirect their outputs into the given `TestContexts`.
+    override this.Load (target : AssemblyName) : Assembly =
+        let path = Path.Combine (dll.Directory.FullName, $"%s{target.Name}.dll")
+
+        let assy =
+            if File.Exists path then
+                this.LoadFromAssemblyPath path
+            else
+
+            runtimes
+            |> List.tryPick (fun di ->
+                let path = Path.Combine (di.FullName, $"%s{target.Name}.dll")
+
+                if File.Exists path then
+                    this.LoadFromAssemblyPath path |> Some
+                else
+                    None
+            )
+            |> Option.defaultValue null
+
+        if target.Name = "System.Console" then
+            if isNull assy then
+                failwith "could not monkey-patch System.Console"
+            else
+                let consoleType = assy.GetType "System.Console"
+                let setOut = consoleType.GetMethod "SetOut"
+                setOut.Invoke ((null : obj), [| contexts.Stdout |]) |> unbox<unit>
+                let setErr = consoleType.GetMethod "SetError"
+                setErr.Invoke ((null : obj), [| contexts.Stderr |]) |> unbox<unit>
+
+            assy
+        else
+            assy

WoofWare.NUnitTestRunner.Lib/Domain.fs

@@ -1,5 +1,6 @@
-namespace TestRunner
+namespace WoofWare.NUnitTestRunner
 
+open System
 open System.Reflection
 
 /// A modifier on whether a given test should be run.
@@ -30,6 +31,36 @@ type Combinatorial =
     /// each", and so on. Spare slots are filled with `Unchecked.defaultof<_>`.
     | Sequential
 
+/// Describes the level of parallelism permitted in some context.
+[<RequireQualifiedAccess>]
+type ClassParallelScope =
+    /// "I may be run in parallel with other tests, although my children might not be able to run in parallel with each
+    /// other".
+    | Self
+    /// "The set of things I contain may be run in parallel with itself".
+    | Children
+    /// "Fixtures within me may be run in parallel with each other, but the tests within a given fixture might not
+    /// be runnable in parallel with each other".
+    | Fixtures
+    /// "All my descendents are happy to run in parallel with anything else, and also so am I".
+    | All
+
+/// Describes the level of parallelism permitted within an assembly.
+[<RequireQualifiedAccess>]
+type AssemblyParallelScope =
+    /// "The set of things I contain may be run in parallel with itself".
+    | Children
+    /// "Fixtures within me may be run in parallel with each other, but the tests within a given fixture might not
+    /// necessarily be runnable in parallel with each other".
+    | Fixtures
+
+/// Describes whether a test can be run concurrently with other tests.
+type Parallelizable<'scope> =
+    /// This test is happy, under some conditions (specified by the scope), to be run alongside other tests.
+    | Yes of 'scope
+    /// This test must always be run on its own.
+    | No
+
 /// A single method or member which holds some tests. (Often such a member will represent only one test, but e.g.
 /// if it has [<TestCaseSource>] then it represents multiple tests.)
 type SingleTestMethod =
@@ -48,6 +79,8 @@ type SingleTestMethod =
         /// If this test has data supplied by `[<Value>]` annotations, specifies how those annotations are combined
         /// to produce the complete collection of args.
         Combinatorial : Combinatorial option
+        /// If this test has declared a parallelisability, that goes here.
+        Parallelize : Parallelizable<unit> option
     }
 
     /// Human-readable name of this test method.
@@ -55,6 +88,7 @@ type SingleTestMethod =
 
 /// A test fixture (usually represented by the [<TestFixture>]` attribute), which may contain many tests,
 /// each of which may run many times.
+[<NoComparison>]
 type TestFixture =
     {
         /// The assembly which contains this TestFixture, loaded into a separate context.
@@ -62,6 +96,8 @@ type TestFixture =
         /// Fully-qualified name of this fixture (e.g. MyThing.Test.Foo for `[<TestFixture>] module Foo` in the
         /// `MyThing.Test` assembly).
         Name : string
+        /// The type which is this fixture, containing the tests as members.
+        Type : Type
         /// A method which is run once when this test fixture starts, before any other setup logic and before
         /// any tests run. If this method fails, no tests will run and no per-test setup/teardown logic will run,
         /// but OneTimeTearDown will run.
@@ -77,20 +113,28 @@ type TestFixture =
         /// Methods which are run in some arbitrary order after each individual test, even if the test or its setup
         /// failed. If the first TearDown we run fails, we don't define whether the other TearDowns run.
         TearDown : MethodInfo list
+        /// You might have defined e.g. `[<TestFixture true>] type Foo (v : bool) = ...`. If so, this gives the
+        /// various possible parameters.
+        Parameters : obj list list
         /// The individual test methods present within this fixture.
         Tests : SingleTestMethod list
+        /// If this fixture has declared a parallelisability, that goes here.
+        Parallelize : Parallelizable<ClassParallelScope> option
     }
 
     /// A test fixture about which we know nothing. No tests, no setup/teardown.
-    static member Empty (containingAssembly : Assembly) (name : string) =
+    static member Empty (ty : Type) (par : Parallelizable<ClassParallelScope> option) (args : obj list list) =
         {
-            ContainingAssembly = containingAssembly
-            Name = name
+            ContainingAssembly = ty.Assembly
+            Type = ty
+            Name = ty.Name
             OneTimeSetUp = None
             OneTimeTearDown = None
             SetUp = []
             TearDown = []
+            Parameters = args
             Tests = []
+            Parallelize = par
         }
 
 /// User code in the unit under test has failed somehow.

WoofWare.NUnitTestRunner.Lib/DotnetRuntime.fs

@@ -0,0 +1,93 @@
+namespace WoofWare.NUnitTestRunner
+
+open System
+open System.IO
+open WoofWare.DotnetRuntimeLocator
+
+/// Functions for locating .NET runtimes.
+[<RequireQualifiedAccess>]
+module DotnetRuntime =
+    let private selectRuntime (config : RuntimeOptions) (f : DotnetEnvironmentInfo) : DirectoryInfo list =
+        let rollForward =
+            match Environment.GetEnvironmentVariable "DOTNET_ROLL_FORWARD" with
+            | null ->
+                config.RollForward
+                |> Option.map RollForward.Parse
+                |> Option.defaultValue RollForward.Minor
+            | s -> RollForward.Parse s
+
+        let desiredVersions =
+            match config.Framework with
+            | Some f -> [ Version f.Version, f.Name ]
+            | None ->
+
+            match config.Frameworks with
+            | Some f -> f |> List.map (fun f -> Version f.Version, f.Name)
+            | None ->
+                failwith
+                    "Could not deduce a framework version due to lack of either Framework or Frameworks in runtimeconfig"
+
+        let compatiblyNamedRuntimes =
+            f.Frameworks
+            |> Seq.collect (fun availableFramework ->
+                desiredVersions
+                |> List.choose (fun (desiredVersion, desiredName) ->
+                    if desiredName = availableFramework.Name then
+                        Some
+                            {|
+                                Desired = desiredVersion
+                                Name = desiredName
+                                Installed = availableFramework
+                                InstalledVersion = Version availableFramework.Version
+                            |}
+                    else
+                        None
+                )
+            )
+            |> Seq.toList
+
+        match rollForward with
+        | RollForward.Minor ->
+            let available =
+                compatiblyNamedRuntimes
+                |> Seq.filter (fun data ->
+                    data.InstalledVersion.Major = data.Desired.Major
+                    && data.InstalledVersion.Minor >= data.Desired.Minor
+                )
+                |> Seq.groupBy (fun data -> data.Name)
+                |> Seq.map (fun (name, data) ->
+                    let data =
+                        data
+                        |> Seq.minBy (fun data -> data.InstalledVersion.Minor, data.InstalledVersion.Build)
+
+                    name, data.Installed
+                )
+                |> Seq.toList
+
+            // TODO: maybe we can ask the SDK if we don't have any runtimes.
+            // But we keep on trucking: maybe we're self-contained, and we'll actually find all the runtime next to the
+            // DLL.
+            available
+            |> List.map (fun (_name, runtime) -> DirectoryInfo $"%s{runtime.Path}/%s{runtime.Version}")
+        | _ -> failwith "non-minor RollForward not supported yet; please shout if you want it"
+
+    /// Given an executable DLL, locate the .NET runtime that can best run it.
+    let locate (dll : FileInfo) : DirectoryInfo list =
+        let runtimeConfig =
+            let name =
+                if not (dll.Name.EndsWith (".dll", StringComparison.OrdinalIgnoreCase)) then
+                    failwith $"Expected DLL %s{dll.FullName} to end in .dll"
+
+                dll.Name.Substring (0, dll.Name.Length - 4)
+
+            Path.Combine (dll.Directory.FullName, $"%s{name}.runtimeconfig.json")
+            |> File.ReadAllText
+            |> System.Text.Json.Nodes.JsonNode.Parse
+            |> RuntimeConfig.jsonParse
+            |> fun f -> f.RuntimeOptions
+
+        let availableRuntimes = DotnetEnvironmentInfo.Get ()
+
+        let runtime = selectRuntime runtimeConfig availableRuntimes
+
+        dll.Directory :: runtime

WoofWare.NUnitTestRunner.Lib/Filter.fs

@@ -1,4 +1,4 @@
-namespace TestRunner
+namespace WoofWare.NUnitTestRunner
 
 open System
 open System.IO
@@ -291,9 +291,10 @@ module Filter =
             fun a b -> inner1 a b || inner2 a b
         | Filter.Name (Match.Exact m) -> fun _fixture method -> method.Method.Name = m
         | Filter.Name (Match.Contains m) -> fun _fixture method -> method.Method.Name.Contains m
-        | Filter.FullyQualifiedName (Match.Exact m) -> fun fixture method -> (fixture.Name + method.Method.Name) = m
+        | Filter.FullyQualifiedName (Match.Exact m) ->
+            fun _fixture method -> (method.Method.DeclaringType.FullName + "." + method.Method.Name) = m
         | Filter.FullyQualifiedName (Match.Contains m) ->
-            fun fixture method -> (fixture.Name + method.Method.Name).Contains m
+            fun _fixture method -> (method.Method.DeclaringType.FullName + "." + method.Method.Name).Contains m
         | Filter.TestCategory (Match.Contains m) ->
             fun _fixture method -> method.Categories |> List.exists (fun cat -> cat.Contains m)
         | Filter.TestCategory (Match.Exact m) -> fun _fixture method -> method.Categories |> List.contains m

WoofWare.NUnitTestRunner.Lib/List.fs

@@ -1,4 +1,4 @@
-namespace TestRunner
+namespace WoofWare.NUnitTestRunner
 
 [<RequireQualifiedAccess>]
 module internal List =

WoofWare.NUnitTestRunner.Lib/ParallelQueue.fs

@@ -0,0 +1,422 @@
+namespace WoofWare.NUnitTestRunner
+
+open System
+open System.Threading
+open System.Threading.Tasks
+
+type private ThunkEvaluator<'ret> =
+    abstract Eval<'a> : (unit -> 'a) -> AsyncReplyChannel<'a> -> 'ret
+
+type private ThunkCrate =
+    abstract Apply<'ret> : ThunkEvaluator<'ret> -> 'ret
+
+[<RequireQualifiedAccess>]
+module private ThunkCrate =
+    let make<'a> (t : unit -> 'a) (rc : AsyncReplyChannel<'a>) : ThunkCrate =
+        { new ThunkCrate with
+            member _.Apply e = e.Eval t rc
+        }
+
+type private FakeUnit = FakeUnit
+
+/// A handle to a running test fixture.
+type TestFixtureRunningToken = private | TestFixtureRunningToken of TestFixture
+
+/// A handle to a test fixture whose setup method has been called.
+type TestFixtureSetupToken = private | TestFixtureSetupToken of TestFixture
+
+[<RequireQualifiedAccess>]
+module private TestFixtureSetupToken =
+    let vouchNoSetupRequired (TestFixtureRunningToken tf) = TestFixtureSetupToken tf
+
+/// A handle to a test fixture whose setup method has been called.
+type TestFixtureTearDownToken = private | TestFixtureTearDownToken of TestFixture
+
+[<RequireQualifiedAccess>]
+module private TestFixtureTearDownToken =
+    let vouchNoTearDownRequired (TestFixtureSetupToken tf) = TestFixtureTearDownToken tf
+
+[<RequireQualifiedAccess>]
+type private MailboxMessage =
+    | Quit of AsyncReplyChannel<unit>
+    /// Check current state, see if we need to start more tests, etc.
+    | Reconcile
+    | RunTest of within : TestFixture * Parallelizable<unit> option * test : ThunkCrate
+    | BeginTestFixture of TestFixture * AsyncReplyChannel<TestFixtureRunningToken>
+    | EndTestFixture of TestFixtureTearDownToken * AsyncReplyChannel<unit>
+
+type private RunningFixture =
+    {
+        Fixture : TestFixture
+        RunningCanParallelize : bool
+        Running : Task list
+        Waiting : ((unit -> Task) * Parallelizable<unit> option) list
+    }
+
+    static member Make (f : TestFixture) =
+        {
+            Fixture = f
+            Running = []
+            RunningCanParallelize = true
+            Waiting = []
+        }
+
+type private RunningState =
+    {
+        MaxParallelism : int
+        // TODO: make these efficiently look-up-able
+        CurrentlyRunning : RunningFixture list
+        Waiting : (TestFixture * AsyncReplyChannel<TestFixtureRunningToken>) list
+    }
+
+    member this.NewTest (tf : TestFixture) (par : Parallelizable<unit> option) (test : unit -> Task) =
+        {
+            MaxParallelism = this.MaxParallelism
+            Waiting = this.Waiting
+            CurrentlyRunning =
+                let found = ref 0
+
+                this.CurrentlyRunning
+                |> List.map (fun f ->
+                    if Object.ReferenceEquals (f.Fixture, tf) then
+                        Interlocked.Increment found |> ignore<int>
+
+                        { f with
+                            Waiting = (test, par) :: f.Waiting
+                        }
+                    else
+                        f
+                )
+                |> fun l ->
+                    match found.Value with
+                    | 1 -> l
+                    | 0 -> failwith $"Unexpectedly did not find the running test fixture '%s{tf.Name}' to add a test to"
+                    | _ -> failwith $"Unexpectedly found the running test fixture '%s{tf.Name}' multiple times in list"
+        }
+
+    member this.CompleteFixture (tf : TestFixture) : RunningState =
+        let rec go (acc : RunningFixture list) (running : RunningFixture list) =
+            match running with
+            | [] -> failwith "Caller has somehow called EndTestFixture while we're not running that test fixture"
+            | runningFixture :: tail ->
+                if Object.ReferenceEquals (runningFixture.Fixture, tf) then
+                    match runningFixture.Running, runningFixture.Waiting with
+                    | [], [] -> acc @ tail
+                    | r, [] ->
+                        failwith $"Caller has called EndTestFixture while its tests are still running (%i{r.Length})"
+                    | [], r ->
+                        failwith $"Caller has called EndTestFixture while it has tests waiting to run (%i{r.Length})"
+                    | r, s ->
+                        failwith
+                            $"Caller has called EndTestFixture while it has tests waiting to run (%i{s.Length}) and test running (%i{r.Length})"
+                else
+                    go (runningFixture :: acc) tail
+
+        let currentlyRunning = go [] this.CurrentlyRunning
+
+        {
+            CurrentlyRunning = currentlyRunning
+            Waiting = this.Waiting
+            MaxParallelism = this.MaxParallelism
+        }
+
+type private MailboxState =
+    | Idle
+    | Running of RunningState
+
+/// Run some things in parallel.
+/// TODO: actually implement the parallelism! Right now this just runs everything serially.
+/// TODO: consume the cancellation token
+type ParallelQueue
+    (parallelism : int option, _scope : Parallelizable<AssemblyParallelScope> option, ?ct : CancellationToken)
+    =
+    let parallelism =
+        match parallelism with
+        | None -> max (Environment.ProcessorCount / 2) 2
+        | Some p -> p
+
+    let rec processTask (state : MailboxState) (m : MailboxProcessor<MailboxMessage>) =
+        async {
+            let! message = m.Receive ()
+
+            match message with
+            | MailboxMessage.Quit rc -> rc.Reply ()
+            | MailboxMessage.Reconcile ->
+                match state with
+                | Idle -> return! processTask state m
+                | Running r ->
+
+                match r.CurrentlyRunning with
+                | [] ->
+                    match r.Waiting with
+                    | [] -> return! processTask Idle m
+                    | (head, rc) :: tail ->
+                        rc.Reply (TestFixtureRunningToken head)
+
+                        let newRunning =
+                            {
+                                Fixture = head
+                                Running = []
+                                RunningCanParallelize = true
+                                Waiting = []
+                            }
+
+                        let state =
+                            {
+                                MaxParallelism = r.MaxParallelism
+                                CurrentlyRunning = [ newRunning ]
+                                Waiting = tail
+                            }
+                        // For now, we'll just run one fixture at a time. When we run multiple fixtures in parallel,
+                        // we probably want to call Reconcile here again.
+                        return! processTask (Running state) m
+                | [ currentlyRunning ] ->
+                    let currentlyRunningTasks =
+                        currentlyRunning.Running |> List.filter (fun t -> not t.IsCompleted)
+
+                    let r =
+                        { r with
+                            CurrentlyRunning =
+                                [
+                                    { currentlyRunning with
+                                        Running = currentlyRunningTasks
+                                    }
+                                ]
+                        }
+
+                    match currentlyRunningTasks with
+                    | [] ->
+                        match currentlyRunning.Waiting with
+                        | [] ->
+                            // Nothing to run yet
+                            return! processTask (Running r) m
+                        | (head, par) :: tail ->
+                            let par =
+                                match par with
+                                | None -> true
+                                | Some Parallelizable.No -> false
+                                | Some (Parallelizable.Yes ()) -> true
+
+                            let state =
+                                {
+                                    Fixture = currentlyRunning.Fixture
+                                    RunningCanParallelize = par
+                                    Waiting = tail
+                                    Running = [ head () ]
+                                }
+
+                            m.Post MailboxMessage.Reconcile
+
+                            return!
+                                processTask
+                                    (Running
+                                        { r with
+                                            CurrentlyRunning = [ state ]
+                                        })
+                                    m
+
+                    | currentlyRunningTasks ->
+
+                    if currentlyRunningTasks.Length >= parallelism then
+                        return! processTask (Running r) m
+                    else
+
+                    match currentlyRunning.Waiting, currentlyRunning.RunningCanParallelize with
+                    | [], _ ->
+                        // No new candidates.
+                        return! processTask (Running r) m
+                    | _, false ->
+                        // The running test(s) can't have others added.
+                        return! processTask (Running r) m
+                    | (head, par) :: tail, true ->
+                        match par with
+                        | Some Parallelizable.No -> return! processTask (Running r) m
+                        | Some (Parallelizable.Yes ()) ->
+                            let state =
+                                {
+                                    RunningState.MaxParallelism = r.MaxParallelism
+                                    Waiting = r.Waiting
+                                    CurrentlyRunning =
+                                        [
+                                            {
+                                                Fixture = currentlyRunning.Fixture
+                                                RunningCanParallelize = true
+                                                Running = head () :: currentlyRunning.Running
+                                                Waiting = tail
+                                            }
+                                        ]
+                                }
+
+                            m.Post MailboxMessage.Reconcile
+                            return! processTask (Running state) m
+                        | None ->
+                            match currentlyRunning.Fixture.Parallelize with
+                            | Some Parallelizable.No
+                            | Some (Parallelizable.Yes ClassParallelScope.Self)
+                            | Some (Parallelizable.Yes ClassParallelScope.Fixtures) ->
+                                // Can't add this test to the parallel queue right now
+                                return! processTask (Running r) m
+                            | None
+                            | Some (Parallelizable.Yes ClassParallelScope.All)
+                            | Some (Parallelizable.Yes ClassParallelScope.Children) ->
+                                let state =
+                                    {
+                                        Fixture = currentlyRunning.Fixture
+                                        RunningCanParallelize = true
+                                        Waiting = tail
+                                        Running = (head ()) :: currentlyRunningTasks
+                                    }
+
+                                m.Post MailboxMessage.Reconcile
+
+                                return!
+                                    processTask
+                                        (Running
+                                            { r with
+                                                CurrentlyRunning = [ state ]
+                                            })
+                                        m
+                | _ -> failwith "Logic error: we currently only run one fixture at a time"
+            | MailboxMessage.BeginTestFixture (tf, rc) ->
+                match state with
+                | Running state ->
+                    let state =
+                        {
+                            MaxParallelism = state.MaxParallelism
+                            CurrentlyRunning = state.CurrentlyRunning
+                            Waiting = (tf, rc) :: state.Waiting
+                        }
+                        |> Running
+
+                    m.Post MailboxMessage.Reconcile
+                    return! processTask state m
+                | Idle ->
+                    let state =
+                        {
+                            MaxParallelism = parallelism
+                            CurrentlyRunning = []
+                            Waiting = [ (tf, rc) ]
+                        }
+                        |> Running
+
+                    m.Post MailboxMessage.Reconcile
+                    return! processTask state m
+            | MailboxMessage.EndTestFixture (TestFixtureTearDownToken tf, rc) ->
+                match state with
+                | Idle ->
+                    return failwith "Caller has somehow called EndTestFixture while we're not running a test fixture"
+                | Running state ->
+                    let state = state.CompleteFixture tf
+                    rc.Reply ()
+                    m.Post MailboxMessage.Reconcile
+                    return! processTask (Running state) m
+            | MailboxMessage.RunTest (withinFixture, par, message) ->
+                let t () =
+                    { new ThunkEvaluator<_> with
+                        member _.Eval<'b> (t : unit -> 'b) rc =
+                            let tcs = TaskCompletionSource ()
+                            use ec = ExecutionContext.Capture ()
+
+                            fun () ->
+                                ExecutionContext.Run (
+                                    ec,
+                                    (fun _ ->
+                                        let result = t ()
+                                        tcs.SetResult ()
+                                        m.Post MailboxMessage.Reconcile
+                                        rc.Reply result
+                                    ),
+                                    ()
+                                )
+                            |> Task.Factory.StartNew
+                            |> ignore<Task>
+
+                            tcs.Task
+                    }
+                    |> message.Apply
+
+                let state =
+                    match state with
+                    | Idle -> failwith "somehow asked the queue to run tests when there is no active fixture"
+                    | Running state -> state.NewTest withinFixture par t |> Running
+
+                m.Post MailboxMessage.Reconcile
+
+                return! processTask state m
+        }
+
+    let mb = new MailboxProcessor<_> (processTask MailboxState.Idle)
+    do mb.Start ()
+
+    /// Request to run the given action, freely in parallel with other running tests.
+    /// The resulting Task will return when the action has completed.
+    member _.Run<'a>
+        (TestFixtureSetupToken parent)
+        (scope : Parallelizable<unit> option)
+        (action : unit -> 'a)
+        : 'a Task
+        =
+        (fun rc -> MailboxMessage.RunTest (parent, scope, ThunkCrate.make action rc))
+        |> mb.PostAndAsyncReply
+        |> Async.StartAsTask
+
+    /// Declare that we wish to start the given test fixture. The resulting Task will return
+    /// when you are allowed to start running tests from that fixture.
+    /// Once you've finished running tests from that fixture, call EndTestFixture.
+    member _.StartTestFixture (tf : TestFixture) : Task<TestFixtureRunningToken> =
+        fun rc -> MailboxMessage.BeginTestFixture (tf, rc)
+        |> mb.PostAndAsyncReply
+        |> Async.StartAsTask
+
+    /// Run the given one-time setup for the test fixture.
+    member _.RunTestSetup (TestFixtureRunningToken parent) (action : unit -> 'a) : ('a * TestFixtureSetupToken) Task =
+        task {
+            let par =
+                parent.Parallelize
+                |> Option.map (fun p ->
+                    match p with
+                    | Parallelizable.No -> Parallelizable.No
+                    | Parallelizable.Yes _ -> Parallelizable.Yes ()
+                )
+
+            let! response =
+                (fun rc -> MailboxMessage.RunTest (parent, par, ThunkCrate.make action rc))
+                |> mb.PostAndAsyncReply
+
+            return response, TestFixtureSetupToken parent
+        }
+
+    /// Run the given one-time tear-down for the test fixture.
+    member _.RunTestTearDown
+        (TestFixtureSetupToken parent)
+        (action : unit -> 'a)
+        : ('a * TestFixtureTearDownToken) Task
+        =
+        task {
+            let par =
+                parent.Parallelize
+                |> Option.map (fun p ->
+                    match p with
+                    | Parallelizable.No -> Parallelizable.No
+                    | Parallelizable.Yes _ -> Parallelizable.Yes ()
+                )
+
+            let! response =
+                (fun rc -> MailboxMessage.RunTest (parent, par, ThunkCrate.make action rc))
+                |> mb.PostAndAsyncReply
+
+            return response, TestFixtureTearDownToken parent
+        }
+
+    /// Declare that we have finished submitting requests to run in the given test fixture.
+    /// You don't need to worry about when the resulting Task returns, but we provide it just in case.
+    member _.EndTestFixture (tf : TestFixtureTearDownToken) : Task<unit> =
+        (fun rc -> MailboxMessage.EndTestFixture (tf, rc))
+        |> mb.PostAndAsyncReply
+        |> Async.StartAsTask
+
+    interface IDisposable with
+        member _.Dispose () =
+            // Still race conditions, of course: people could still be submitting after we finish the sync.
+            mb.PostAndReply MailboxMessage.Quit
+            (mb :> IDisposable).Dispose ()

WoofWare.NUnitTestRunner.Lib/Result.fs

@@ -1,4 +1,4 @@
-namespace TestRunner
+namespace WoofWare.NUnitTestRunner
 
 [<RequireQualifiedAccess>]
 module internal Result =

WoofWare.NUnitTestRunner.Lib/RuntimeConfig.fs

@@ -1,17 +1,17 @@
-namespace TestRunner
+namespace WoofWare.NUnitTestRunner
 
 open System
 open WoofWare.Myriad.Plugins
 
 [<JsonParse>]
-type FrameworkDescription =
+type internal FrameworkDescription =
     {
         Name : string
         Version : string
     }
 
 [<JsonParse>]
-type RuntimeOptions =
+type internal RuntimeOptions =
     {
         Tfm : string
         Framework : FrameworkDescription option
@@ -20,13 +20,13 @@ type RuntimeOptions =
     }
 
 [<JsonParse>]
-type RuntimeConfig =
+type internal RuntimeConfig =
     {
         RuntimeOptions : RuntimeOptions
     }
 
 [<RequireQualifiedAccess>]
-type RollForward =
+type internal RollForward =
     | Minor
     | Major
     | LatestPatch

WoofWare.NUnitTestRunner.Lib/SingleTestMethod.fs

@@ -1,4 +1,4 @@
-namespace TestRunner
+namespace WoofWare.NUnitTestRunner
 
 open System
 open System.Reflection
@@ -18,75 +18,95 @@ module SingleTestMethod =
         (attrs : CustomAttributeData list)
         : SingleTestMethod option * CustomAttributeData list
         =
-        let remaining, isTest, sources, hasData, modifiers, categories, repeat, comb =
-            (([], false, [], None, [], [], None, None), attrs)
-            ||> List.fold (fun (remaining, isTest, sources, hasData, mods, cats, repeat, comb) attr ->
+        let remaining, isTest, sources, hasData, modifiers, categories, repeat, comb, par =
+            (([], false, [], None, [], [], None, None, None), attrs)
+            ||> List.fold (fun (remaining, isTest, sources, hasData, mods, cats, repeat, comb, par) attr ->
                 match attr.AttributeType.FullName with
                 | "NUnit.Framework.TestAttribute" ->
                     if attr.ConstructorArguments.Count > 0 then
                         failwith "Unexpectedly got arguments to the Test attribute"
 
-                    (remaining, true, sources, hasData, mods, cats, repeat, comb)
+                    (remaining, true, sources, hasData, mods, cats, repeat, comb, par)
                 | "NUnit.Framework.TestCaseAttribute" ->
                     let args = attr.ConstructorArguments |> Seq.map _.Value |> Seq.toList
 
+                    let args =
+                        match args with
+                        | [ :? System.Collections.ICollection as x ] ->
+                            x
+                            |> Seq.cast<CustomAttributeTypedArgument>
+                            |> Seq.map (fun v -> v.Value)
+                            |> Seq.toList
+                        | _ -> args
+
                     match hasData with
-                    | None -> (remaining, isTest, sources, Some [ List.ofSeq args ], mods, cats, repeat, comb)
+                    | None -> (remaining, isTest, sources, Some [ List.ofSeq args ], mods, cats, repeat, comb, par)
                     | Some existing ->
-                        (remaining, isTest, sources, Some ((List.ofSeq args) :: existing), mods, cats, repeat, comb)
+                        let args = (List.ofSeq args) :: existing |> Some
+                        (remaining, isTest, sources, args, mods, cats, repeat, comb, par)
                 | "NUnit.Framework.TestCaseSourceAttribute" ->
                     let arg = attr.ConstructorArguments |> Seq.exactlyOne |> _.Value |> unbox<string>
 
-                    (remaining, isTest, arg :: sources, hasData, mods, cats, repeat, comb)
+                    (remaining, isTest, arg :: sources, hasData, mods, cats, repeat, comb, par)
                 | "NUnit.Framework.ExplicitAttribute" ->
                     let reason =
                         attr.ConstructorArguments
                         |> Seq.tryHead
                         |> Option.map (_.Value >> unbox<string>)
 
-                    (remaining, isTest, sources, hasData, (Modifier.Explicit reason) :: mods, cats, repeat, comb)
+                    (remaining, isTest, sources, hasData, (Modifier.Explicit reason) :: mods, cats, repeat, comb, par)
                 | "NUnit.Framework.IgnoreAttribute" ->
                     let reason =
                         attr.ConstructorArguments
                         |> Seq.tryHead
                         |> Option.map (_.Value >> unbox<string>)
 
-                    (remaining, isTest, sources, hasData, (Modifier.Ignored reason) :: mods, cats, repeat, comb)
+                    (remaining, isTest, sources, hasData, (Modifier.Ignored reason) :: mods, cats, repeat, comb, par)
                 | "NUnit.Framework.CategoryAttribute" ->
                     let category =
                         attr.ConstructorArguments |> Seq.exactlyOne |> _.Value |> unbox<string>
 
-                    (remaining, isTest, sources, hasData, mods, category :: cats, repeat, comb)
+                    (remaining, isTest, sources, hasData, mods, category :: cats, repeat, comb, par)
                 | "NUnit.Framework.RepeatAttribute" ->
                     match repeat with
                     | Some _ -> failwith $"Got RepeatAttribute multiple times on %s{method.Name}"
                     | None ->
 
                     let repeat = attr.ConstructorArguments |> Seq.exactlyOne |> _.Value |> unbox<int>
-                    (remaining, isTest, sources, hasData, mods, cats, Some repeat, comb)
+                    (remaining, isTest, sources, hasData, mods, cats, Some repeat, comb, par)
                 | "NUnit.Framework.CombinatorialAttribute" ->
                     match comb with
                     | Some _ ->
                         failwith $"Got CombinatorialAttribute or SequentialAttribute multiple times on %s{method.Name}"
                     | None ->
-                        (remaining, isTest, sources, hasData, mods, cats, repeat, Some Combinatorial.Combinatorial)
+                        (remaining, isTest, sources, hasData, mods, cats, repeat, Some Combinatorial.Combinatorial, par)
                 | "NUnit.Framework.SequentialAttribute" ->
                     match comb with
                     | Some _ ->
                         failwith $"Got CombinatorialAttribute or SequentialAttribute multiple times on %s{method.Name}"
-                    | None -> (remaining, isTest, sources, hasData, mods, cats, repeat, Some Combinatorial.Sequential)
+                    | None ->
+                        (remaining, isTest, sources, hasData, mods, cats, repeat, Some Combinatorial.Sequential, par)
+                | "NUnit.Framework.NonParallelizableAttribute" ->
+                    match par with
+                    | Some _ -> failwith $"Got a parallelization attribute multiple times on %s{method.Name}"
+                    | None -> (remaining, isTest, sources, hasData, mods, cats, repeat, comb, Some Parallelizable.No)
+                | "NUnit.Framework.ParallelizableAttribute" ->
+                    match par with
+                    | Some _ -> failwith $"Got multiple parallelization attributes on %s{method.Name}"
+                    | None ->
+                        (remaining, isTest, sources, hasData, mods, cats, repeat, comb, Some (Parallelizable.Yes ()))
                 | s when s.StartsWith ("NUnit.Framework", StringComparison.Ordinal) ->
                     failwith $"Unrecognised attribute on function %s{method.Name}: %s{attr.AttributeType.FullName}"
-                | _ -> (attr :: remaining, isTest, sources, hasData, mods, cats, repeat, comb)
+                | _ -> (attr :: remaining, isTest, sources, hasData, mods, cats, repeat, comb, par)
             )
 
         let test =
-            match isTest, sources, hasData, modifiers, categories, repeat, comb with
-            | _, _ :: _, Some _, _, _, _, _ ->
+            match isTest, sources, hasData, modifiers, categories, repeat, comb, par with
+            | _, _ :: _, Some _, _, _, _, _, _ ->
                 failwith
                     $"Test '%s{method.Name}' unexpectedly has both TestData and TestCaseSource; not currently supported"
-            | false, [], None, [], _, _, _ -> None
-            | _, _ :: _, None, mods, categories, repeat, comb ->
+            | false, [], None, [], _, _, _, _ -> None
+            | _, _ :: _, None, mods, categories, repeat, comb, par ->
                 {
                     Kind = TestKind.Source sources
                     Method = method
@@ -94,9 +114,10 @@ module SingleTestMethod =
                     Categories = categories @ parentCategories
                     Repeat = repeat
                     Combinatorial = comb
+                    Parallelize = par
                 }
                 |> Some
-            | _, [], Some data, mods, categories, repeat, comb ->
+            | _, [], Some data, mods, categories, repeat, comb, par ->
                 {
                     Kind = TestKind.Data data
                     Method = method
@@ -104,9 +125,10 @@ module SingleTestMethod =
                     Categories = categories @ parentCategories
                     Repeat = repeat
                     Combinatorial = comb
+                    Parallelize = par
                 }
                 |> Some
-            | true, [], None, mods, categories, repeat, comb ->
+            | true, [], None, mods, categories, repeat, comb, par ->
                 {
                     Kind = TestKind.Single
                     Method = method
@@ -114,9 +136,10 @@ module SingleTestMethod =
                     Categories = categories @ parentCategories
                     Repeat = repeat
                     Combinatorial = comb
+                    Parallelize = par
                 }
                 |> Some
-            | false, [], None, _ :: _, _, _, _ ->
+            | false, [], None, _ :: _, _, _, _, _ ->
                 failwith
                     $"Unexpectedly got test modifiers but no test settings on '%s{method.Name}', which you probably didn't intend."
 

WoofWare.NUnitTestRunner.Lib/SurfaceBaseline.txt

@@ -0,0 +1,612 @@
+WoofWare.NUnitTestRunner.AssemblyParallelScope inherit obj, implements WoofWare.NUnitTestRunner.AssemblyParallelScope System.IEquatable, System.Collections.IStructuralEquatable, WoofWare.NUnitTestRunner.AssemblyParallelScope System.IComparable, System.IComparable, System.Collections.IStructuralComparable - union type with 2 cases
+WoofWare.NUnitTestRunner.AssemblyParallelScope+Tags inherit obj
+WoofWare.NUnitTestRunner.AssemblyParallelScope+Tags.Children [static field]: int = 0
+WoofWare.NUnitTestRunner.AssemblyParallelScope+Tags.Fixtures [static field]: int = 1
+WoofWare.NUnitTestRunner.AssemblyParallelScope.Children [static property]: [read-only] WoofWare.NUnitTestRunner.AssemblyParallelScope
+WoofWare.NUnitTestRunner.AssemblyParallelScope.Fixtures [static property]: [read-only] WoofWare.NUnitTestRunner.AssemblyParallelScope
+WoofWare.NUnitTestRunner.AssemblyParallelScope.get_Children [static method]: unit -> WoofWare.NUnitTestRunner.AssemblyParallelScope
+WoofWare.NUnitTestRunner.AssemblyParallelScope.get_Fixtures [static method]: unit -> WoofWare.NUnitTestRunner.AssemblyParallelScope
+WoofWare.NUnitTestRunner.AssemblyParallelScope.get_IsChildren [method]: unit -> bool
+WoofWare.NUnitTestRunner.AssemblyParallelScope.get_IsFixtures [method]: unit -> bool
+WoofWare.NUnitTestRunner.AssemblyParallelScope.get_Tag [method]: unit -> int
+WoofWare.NUnitTestRunner.AssemblyParallelScope.IsChildren [property]: [read-only] bool
+WoofWare.NUnitTestRunner.AssemblyParallelScope.IsFixtures [property]: [read-only] bool
+WoofWare.NUnitTestRunner.AssemblyParallelScope.Tag [property]: [read-only] int
+WoofWare.NUnitTestRunner.ClassParallelScope inherit obj, implements WoofWare.NUnitTestRunner.ClassParallelScope System.IEquatable, System.Collections.IStructuralEquatable, WoofWare.NUnitTestRunner.ClassParallelScope System.IComparable, System.IComparable, System.Collections.IStructuralComparable - union type with 4 cases
+WoofWare.NUnitTestRunner.ClassParallelScope+Tags inherit obj
+WoofWare.NUnitTestRunner.ClassParallelScope+Tags.All [static field]: int = 3
+WoofWare.NUnitTestRunner.ClassParallelScope+Tags.Children [static field]: int = 1
+WoofWare.NUnitTestRunner.ClassParallelScope+Tags.Fixtures [static field]: int = 2
+WoofWare.NUnitTestRunner.ClassParallelScope+Tags.Self [static field]: int = 0
+WoofWare.NUnitTestRunner.ClassParallelScope.All [static property]: [read-only] WoofWare.NUnitTestRunner.ClassParallelScope
+WoofWare.NUnitTestRunner.ClassParallelScope.Children [static property]: [read-only] WoofWare.NUnitTestRunner.ClassParallelScope
+WoofWare.NUnitTestRunner.ClassParallelScope.Fixtures [static property]: [read-only] WoofWare.NUnitTestRunner.ClassParallelScope
+WoofWare.NUnitTestRunner.ClassParallelScope.get_All [static method]: unit -> WoofWare.NUnitTestRunner.ClassParallelScope
+WoofWare.NUnitTestRunner.ClassParallelScope.get_Children [static method]: unit -> WoofWare.NUnitTestRunner.ClassParallelScope
+WoofWare.NUnitTestRunner.ClassParallelScope.get_Fixtures [static method]: unit -> WoofWare.NUnitTestRunner.ClassParallelScope
+WoofWare.NUnitTestRunner.ClassParallelScope.get_IsAll [method]: unit -> bool
+WoofWare.NUnitTestRunner.ClassParallelScope.get_IsChildren [method]: unit -> bool
+WoofWare.NUnitTestRunner.ClassParallelScope.get_IsFixtures [method]: unit -> bool
+WoofWare.NUnitTestRunner.ClassParallelScope.get_IsSelf [method]: unit -> bool
+WoofWare.NUnitTestRunner.ClassParallelScope.get_Self [static method]: unit -> WoofWare.NUnitTestRunner.ClassParallelScope
+WoofWare.NUnitTestRunner.ClassParallelScope.get_Tag [method]: unit -> int
+WoofWare.NUnitTestRunner.ClassParallelScope.IsAll [property]: [read-only] bool
+WoofWare.NUnitTestRunner.ClassParallelScope.IsChildren [property]: [read-only] bool
+WoofWare.NUnitTestRunner.ClassParallelScope.IsFixtures [property]: [read-only] bool
+WoofWare.NUnitTestRunner.ClassParallelScope.IsSelf [property]: [read-only] bool
+WoofWare.NUnitTestRunner.ClassParallelScope.Self [static property]: [read-only] WoofWare.NUnitTestRunner.ClassParallelScope
+WoofWare.NUnitTestRunner.ClassParallelScope.Tag [property]: [read-only] int
+WoofWare.NUnitTestRunner.Combinatorial inherit obj, implements WoofWare.NUnitTestRunner.Combinatorial System.IEquatable, System.Collections.IStructuralEquatable, WoofWare.NUnitTestRunner.Combinatorial System.IComparable, System.IComparable, System.Collections.IStructuralComparable - union type with 2 cases
+WoofWare.NUnitTestRunner.Combinatorial+Tags inherit obj
+WoofWare.NUnitTestRunner.Combinatorial+Tags.Combinatorial [static field]: int = 0
+WoofWare.NUnitTestRunner.Combinatorial+Tags.Sequential [static field]: int = 1
+WoofWare.NUnitTestRunner.Combinatorial.Combinatorial [static property]: [read-only] WoofWare.NUnitTestRunner.Combinatorial
+WoofWare.NUnitTestRunner.Combinatorial.get_Combinatorial [static method]: unit -> WoofWare.NUnitTestRunner.Combinatorial
+WoofWare.NUnitTestRunner.Combinatorial.get_IsCombinatorial [method]: unit -> bool
+WoofWare.NUnitTestRunner.Combinatorial.get_IsSequential [method]: unit -> bool
+WoofWare.NUnitTestRunner.Combinatorial.get_Sequential [static method]: unit -> WoofWare.NUnitTestRunner.Combinatorial
+WoofWare.NUnitTestRunner.Combinatorial.get_Tag [method]: unit -> int
+WoofWare.NUnitTestRunner.Combinatorial.IsCombinatorial [property]: [read-only] bool
+WoofWare.NUnitTestRunner.Combinatorial.IsSequential [property]: [read-only] bool
+WoofWare.NUnitTestRunner.Combinatorial.Sequential [static property]: [read-only] WoofWare.NUnitTestRunner.Combinatorial
+WoofWare.NUnitTestRunner.Combinatorial.Tag [property]: [read-only] int
+WoofWare.NUnitTestRunner.DotnetRuntime inherit obj
+WoofWare.NUnitTestRunner.DotnetRuntime.locate [static method]: System.IO.FileInfo -> System.IO.DirectoryInfo list
+WoofWare.NUnitTestRunner.Filter inherit obj, implements WoofWare.NUnitTestRunner.Filter System.IEquatable, System.Collections.IStructuralEquatable, WoofWare.NUnitTestRunner.Filter System.IComparable, System.IComparable, System.Collections.IStructuralComparable - union type with 6 cases
+WoofWare.NUnitTestRunner.Filter+And inherit WoofWare.NUnitTestRunner.Filter
+WoofWare.NUnitTestRunner.Filter+And.get_Item1 [method]: unit -> WoofWare.NUnitTestRunner.Filter
+WoofWare.NUnitTestRunner.Filter+And.get_Item2 [method]: unit -> WoofWare.NUnitTestRunner.Filter
+WoofWare.NUnitTestRunner.Filter+And.Item1 [property]: [read-only] WoofWare.NUnitTestRunner.Filter
+WoofWare.NUnitTestRunner.Filter+And.Item2 [property]: [read-only] WoofWare.NUnitTestRunner.Filter
+WoofWare.NUnitTestRunner.Filter+FullyQualifiedName inherit WoofWare.NUnitTestRunner.Filter
+WoofWare.NUnitTestRunner.Filter+FullyQualifiedName.get_Item [method]: unit -> WoofWare.NUnitTestRunner.Match
+WoofWare.NUnitTestRunner.Filter+FullyQualifiedName.Item [property]: [read-only] WoofWare.NUnitTestRunner.Match
+WoofWare.NUnitTestRunner.Filter+Name inherit WoofWare.NUnitTestRunner.Filter
+WoofWare.NUnitTestRunner.Filter+Name.get_Item [method]: unit -> WoofWare.NUnitTestRunner.Match
+WoofWare.NUnitTestRunner.Filter+Name.Item [property]: [read-only] WoofWare.NUnitTestRunner.Match
+WoofWare.NUnitTestRunner.Filter+Not inherit WoofWare.NUnitTestRunner.Filter
+WoofWare.NUnitTestRunner.Filter+Not.get_Item [method]: unit -> WoofWare.NUnitTestRunner.Filter
+WoofWare.NUnitTestRunner.Filter+Not.Item [property]: [read-only] WoofWare.NUnitTestRunner.Filter
+WoofWare.NUnitTestRunner.Filter+Or inherit WoofWare.NUnitTestRunner.Filter
+WoofWare.NUnitTestRunner.Filter+Or.get_Item1 [method]: unit -> WoofWare.NUnitTestRunner.Filter
+WoofWare.NUnitTestRunner.Filter+Or.get_Item2 [method]: unit -> WoofWare.NUnitTestRunner.Filter
+WoofWare.NUnitTestRunner.Filter+Or.Item1 [property]: [read-only] WoofWare.NUnitTestRunner.Filter
+WoofWare.NUnitTestRunner.Filter+Or.Item2 [property]: [read-only] WoofWare.NUnitTestRunner.Filter
+WoofWare.NUnitTestRunner.Filter+Tags inherit obj
+WoofWare.NUnitTestRunner.Filter+Tags.And [static field]: int = 5
+WoofWare.NUnitTestRunner.Filter+Tags.FullyQualifiedName [static field]: int = 0
+WoofWare.NUnitTestRunner.Filter+Tags.Name [static field]: int = 1
+WoofWare.NUnitTestRunner.Filter+Tags.Not [static field]: int = 3
+WoofWare.NUnitTestRunner.Filter+Tags.Or [static field]: int = 4
+WoofWare.NUnitTestRunner.Filter+Tags.TestCategory [static field]: int = 2
+WoofWare.NUnitTestRunner.Filter+TestCategory inherit WoofWare.NUnitTestRunner.Filter
+WoofWare.NUnitTestRunner.Filter+TestCategory.get_Item [method]: unit -> WoofWare.NUnitTestRunner.Match
+WoofWare.NUnitTestRunner.Filter+TestCategory.Item [property]: [read-only] WoofWare.NUnitTestRunner.Match
+WoofWare.NUnitTestRunner.Filter.get_IsAnd [method]: unit -> bool
+WoofWare.NUnitTestRunner.Filter.get_IsFullyQualifiedName [method]: unit -> bool
+WoofWare.NUnitTestRunner.Filter.get_IsName [method]: unit -> bool
+WoofWare.NUnitTestRunner.Filter.get_IsNot [method]: unit -> bool
+WoofWare.NUnitTestRunner.Filter.get_IsOr [method]: unit -> bool
+WoofWare.NUnitTestRunner.Filter.get_IsTestCategory [method]: unit -> bool
+WoofWare.NUnitTestRunner.Filter.get_Tag [method]: unit -> int
+WoofWare.NUnitTestRunner.Filter.IsAnd [property]: [read-only] bool
+WoofWare.NUnitTestRunner.Filter.IsFullyQualifiedName [property]: [read-only] bool
+WoofWare.NUnitTestRunner.Filter.IsName [property]: [read-only] bool
+WoofWare.NUnitTestRunner.Filter.IsNot [property]: [read-only] bool
+WoofWare.NUnitTestRunner.Filter.IsOr [property]: [read-only] bool
+WoofWare.NUnitTestRunner.Filter.IsTestCategory [property]: [read-only] bool
+WoofWare.NUnitTestRunner.Filter.NewAnd [static method]: (WoofWare.NUnitTestRunner.Filter, WoofWare.NUnitTestRunner.Filter) -> WoofWare.NUnitTestRunner.Filter
+WoofWare.NUnitTestRunner.Filter.NewFullyQualifiedName [static method]: WoofWare.NUnitTestRunner.Match -> WoofWare.NUnitTestRunner.Filter
+WoofWare.NUnitTestRunner.Filter.NewName [static method]: WoofWare.NUnitTestRunner.Match -> WoofWare.NUnitTestRunner.Filter
+WoofWare.NUnitTestRunner.Filter.NewNot [static method]: WoofWare.NUnitTestRunner.Filter -> WoofWare.NUnitTestRunner.Filter
+WoofWare.NUnitTestRunner.Filter.NewOr [static method]: (WoofWare.NUnitTestRunner.Filter, WoofWare.NUnitTestRunner.Filter) -> WoofWare.NUnitTestRunner.Filter
+WoofWare.NUnitTestRunner.Filter.NewTestCategory [static method]: WoofWare.NUnitTestRunner.Match -> WoofWare.NUnitTestRunner.Filter
+WoofWare.NUnitTestRunner.Filter.Tag [property]: [read-only] int
+WoofWare.NUnitTestRunner.FilterModule inherit obj
+WoofWare.NUnitTestRunner.FilterModule.parse [static method]: string -> WoofWare.NUnitTestRunner.Filter
+WoofWare.NUnitTestRunner.FilterModule.shouldRun [static method]: WoofWare.NUnitTestRunner.Filter -> (WoofWare.NUnitTestRunner.TestFixture -> WoofWare.NUnitTestRunner.SingleTestMethod -> bool)
+WoofWare.NUnitTestRunner.FixtureRunResults inherit obj, implements WoofWare.NUnitTestRunner.FixtureRunResults System.IEquatable, System.Collections.IStructuralEquatable
+WoofWare.NUnitTestRunner.FixtureRunResults..ctor [constructor]: ((WoofWare.NUnitTestRunner.TestMemberFailure * WoofWare.NUnitTestRunner.IndividualTestRunMetadata) list, (WoofWare.NUnitTestRunner.SingleTestMethod * WoofWare.NUnitTestRunner.TestMemberSuccess * WoofWare.NUnitTestRunner.IndividualTestRunMetadata) list, (WoofWare.NUnitTestRunner.UserMethodFailure * WoofWare.NUnitTestRunner.IndividualTestRunMetadata) list)
+WoofWare.NUnitTestRunner.FixtureRunResults.Failed [property]: [read-only] (WoofWare.NUnitTestRunner.TestMemberFailure * WoofWare.NUnitTestRunner.IndividualTestRunMetadata) list
+WoofWare.NUnitTestRunner.FixtureRunResults.get_Failed [method]: unit -> (WoofWare.NUnitTestRunner.TestMemberFailure * WoofWare.NUnitTestRunner.IndividualTestRunMetadata) list
+WoofWare.NUnitTestRunner.FixtureRunResults.get_IndividualTestRunMetadata [method]: unit -> (WoofWare.NUnitTestRunner.IndividualTestRunMetadata * Microsoft.FSharp.Core.FSharpChoice<WoofWare.NUnitTestRunner.TestMemberFailure, WoofWare.NUnitTestRunner.TestMemberSuccess, WoofWare.NUnitTestRunner.UserMethodFailure>) list
+WoofWare.NUnitTestRunner.FixtureRunResults.get_OtherFailures [method]: unit -> (WoofWare.NUnitTestRunner.UserMethodFailure * WoofWare.NUnitTestRunner.IndividualTestRunMetadata) list
+WoofWare.NUnitTestRunner.FixtureRunResults.get_Success [method]: unit -> (WoofWare.NUnitTestRunner.SingleTestMethod * WoofWare.NUnitTestRunner.TestMemberSuccess * WoofWare.NUnitTestRunner.IndividualTestRunMetadata) list
+WoofWare.NUnitTestRunner.FixtureRunResults.IndividualTestRunMetadata [property]: [read-only] (WoofWare.NUnitTestRunner.IndividualTestRunMetadata * Microsoft.FSharp.Core.FSharpChoice<WoofWare.NUnitTestRunner.TestMemberFailure, WoofWare.NUnitTestRunner.TestMemberSuccess, WoofWare.NUnitTestRunner.UserMethodFailure>) list
+WoofWare.NUnitTestRunner.FixtureRunResults.OtherFailures [property]: [read-only] (WoofWare.NUnitTestRunner.UserMethodFailure * WoofWare.NUnitTestRunner.IndividualTestRunMetadata) list
+WoofWare.NUnitTestRunner.FixtureRunResults.Success [property]: [read-only] (WoofWare.NUnitTestRunner.SingleTestMethod * WoofWare.NUnitTestRunner.TestMemberSuccess * WoofWare.NUnitTestRunner.IndividualTestRunMetadata) list
+WoofWare.NUnitTestRunner.IndividualTestRunMetadata inherit obj, implements WoofWare.NUnitTestRunner.IndividualTestRunMetadata System.IEquatable, System.Collections.IStructuralEquatable, WoofWare.NUnitTestRunner.IndividualTestRunMetadata System.IComparable, System.IComparable, System.Collections.IStructuralComparable
+WoofWare.NUnitTestRunner.IndividualTestRunMetadata..ctor [constructor]: (System.TimeSpan, System.DateTimeOffset, System.DateTimeOffset, string, System.Guid, System.Guid, string, string, string option, string option)
+WoofWare.NUnitTestRunner.IndividualTestRunMetadata.ClassName [property]: [read-only] string
+WoofWare.NUnitTestRunner.IndividualTestRunMetadata.ComputerName [property]: [read-only] string
+WoofWare.NUnitTestRunner.IndividualTestRunMetadata.End [property]: [read-only] System.DateTimeOffset
+WoofWare.NUnitTestRunner.IndividualTestRunMetadata.ExecutionId [property]: [read-only] System.Guid
+WoofWare.NUnitTestRunner.IndividualTestRunMetadata.get_ClassName [method]: unit -> string
+WoofWare.NUnitTestRunner.IndividualTestRunMetadata.get_ComputerName [method]: unit -> string
+WoofWare.NUnitTestRunner.IndividualTestRunMetadata.get_End [method]: unit -> System.DateTimeOffset
+WoofWare.NUnitTestRunner.IndividualTestRunMetadata.get_ExecutionId [method]: unit -> System.Guid
+WoofWare.NUnitTestRunner.IndividualTestRunMetadata.get_Start [method]: unit -> System.DateTimeOffset
+WoofWare.NUnitTestRunner.IndividualTestRunMetadata.get_StdErr [method]: unit -> string option
+WoofWare.NUnitTestRunner.IndividualTestRunMetadata.get_StdOut [method]: unit -> string option
+WoofWare.NUnitTestRunner.IndividualTestRunMetadata.get_TestId [method]: unit -> System.Guid
+WoofWare.NUnitTestRunner.IndividualTestRunMetadata.get_TestName [method]: unit -> string
+WoofWare.NUnitTestRunner.IndividualTestRunMetadata.get_Total [method]: unit -> System.TimeSpan
+WoofWare.NUnitTestRunner.IndividualTestRunMetadata.Start [property]: [read-only] System.DateTimeOffset
+WoofWare.NUnitTestRunner.IndividualTestRunMetadata.StdErr [property]: [read-only] string option
+WoofWare.NUnitTestRunner.IndividualTestRunMetadata.StdOut [property]: [read-only] string option
+WoofWare.NUnitTestRunner.IndividualTestRunMetadata.TestId [property]: [read-only] System.Guid
+WoofWare.NUnitTestRunner.IndividualTestRunMetadata.TestName [property]: [read-only] string
+WoofWare.NUnitTestRunner.IndividualTestRunMetadata.Total [property]: [read-only] System.TimeSpan
+WoofWare.NUnitTestRunner.ITestProgress - interface with 5 member(s)
+WoofWare.NUnitTestRunner.ITestProgress.OnTestFailed [method]: string -> WoofWare.NUnitTestRunner.TestMemberFailure -> unit
+WoofWare.NUnitTestRunner.ITestProgress.OnTestFixtureStart [method]: string -> int -> unit
+WoofWare.NUnitTestRunner.ITestProgress.OnTestMemberFinished [method]: string -> unit
+WoofWare.NUnitTestRunner.ITestProgress.OnTestMemberSkipped [method]: string -> unit
+WoofWare.NUnitTestRunner.ITestProgress.OnTestMemberStart [method]: string -> unit
+WoofWare.NUnitTestRunner.LoadContext inherit System.Runtime.Loader.AssemblyLoadContext
+WoofWare.NUnitTestRunner.LoadContext..ctor [constructor]: (System.IO.FileInfo, System.IO.DirectoryInfo list, WoofWare.NUnitTestRunner.TestContexts)
+WoofWare.NUnitTestRunner.Match inherit obj, implements WoofWare.NUnitTestRunner.Match System.IEquatable, System.Collections.IStructuralEquatable, WoofWare.NUnitTestRunner.Match System.IComparable, System.IComparable, System.Collections.IStructuralComparable - union type with 2 cases
+WoofWare.NUnitTestRunner.Match+Contains inherit WoofWare.NUnitTestRunner.Match
+WoofWare.NUnitTestRunner.Match+Contains.get_Item [method]: unit -> string
+WoofWare.NUnitTestRunner.Match+Contains.Item [property]: [read-only] string
+WoofWare.NUnitTestRunner.Match+Exact inherit WoofWare.NUnitTestRunner.Match
+WoofWare.NUnitTestRunner.Match+Exact.get_Item [method]: unit -> string
+WoofWare.NUnitTestRunner.Match+Exact.Item [property]: [read-only] string
+WoofWare.NUnitTestRunner.Match+Tags inherit obj
+WoofWare.NUnitTestRunner.Match+Tags.Contains [static field]: int = 1
+WoofWare.NUnitTestRunner.Match+Tags.Exact [static field]: int = 0
+WoofWare.NUnitTestRunner.Match.get_IsContains [method]: unit -> bool
+WoofWare.NUnitTestRunner.Match.get_IsExact [method]: unit -> bool
+WoofWare.NUnitTestRunner.Match.get_Tag [method]: unit -> int
+WoofWare.NUnitTestRunner.Match.IsContains [property]: [read-only] bool
+WoofWare.NUnitTestRunner.Match.IsExact [property]: [read-only] bool
+WoofWare.NUnitTestRunner.Match.NewContains [static method]: string -> WoofWare.NUnitTestRunner.Match
+WoofWare.NUnitTestRunner.Match.NewExact [static method]: string -> WoofWare.NUnitTestRunner.Match
+WoofWare.NUnitTestRunner.Match.Tag [property]: [read-only] int
+WoofWare.NUnitTestRunner.Modifier inherit obj, implements WoofWare.NUnitTestRunner.Modifier System.IEquatable, System.Collections.IStructuralEquatable, WoofWare.NUnitTestRunner.Modifier System.IComparable, System.IComparable, System.Collections.IStructuralComparable - union type with 2 cases
+WoofWare.NUnitTestRunner.Modifier+Explicit inherit WoofWare.NUnitTestRunner.Modifier
+WoofWare.NUnitTestRunner.Modifier+Explicit.get_reason [method]: unit -> string option
+WoofWare.NUnitTestRunner.Modifier+Explicit.reason [property]: [read-only] string option
+WoofWare.NUnitTestRunner.Modifier+Ignored inherit WoofWare.NUnitTestRunner.Modifier
+WoofWare.NUnitTestRunner.Modifier+Ignored.get_reason [method]: unit -> string option
+WoofWare.NUnitTestRunner.Modifier+Ignored.reason [property]: [read-only] string option
+WoofWare.NUnitTestRunner.Modifier+Tags inherit obj
+WoofWare.NUnitTestRunner.Modifier+Tags.Explicit [static field]: int = 0
+WoofWare.NUnitTestRunner.Modifier+Tags.Ignored [static field]: int = 1
+WoofWare.NUnitTestRunner.Modifier.get_IsExplicit [method]: unit -> bool
+WoofWare.NUnitTestRunner.Modifier.get_IsIgnored [method]: unit -> bool
+WoofWare.NUnitTestRunner.Modifier.get_Tag [method]: unit -> int
+WoofWare.NUnitTestRunner.Modifier.IsExplicit [property]: [read-only] bool
+WoofWare.NUnitTestRunner.Modifier.IsIgnored [property]: [read-only] bool
+WoofWare.NUnitTestRunner.Modifier.NewExplicit [static method]: string option -> WoofWare.NUnitTestRunner.Modifier
+WoofWare.NUnitTestRunner.Modifier.NewIgnored [static method]: string option -> WoofWare.NUnitTestRunner.Modifier
+WoofWare.NUnitTestRunner.Modifier.Tag [property]: [read-only] int
+WoofWare.NUnitTestRunner.Parallelizable`1 inherit obj, implements 'scope WoofWare.NUnitTestRunner.Parallelizable System.IEquatable, System.Collections.IStructuralEquatable, 'scope WoofWare.NUnitTestRunner.Parallelizable System.IComparable, System.IComparable, System.Collections.IStructuralComparable - union type with 2 cases
+WoofWare.NUnitTestRunner.Parallelizable`1+Tags inherit obj
+WoofWare.NUnitTestRunner.Parallelizable`1+Tags.No [static field]: int = 1
+WoofWare.NUnitTestRunner.Parallelizable`1+Tags.Yes [static field]: int = 0
+WoofWare.NUnitTestRunner.Parallelizable`1+Yes inherit 'scope WoofWare.NUnitTestRunner.Parallelizable
+WoofWare.NUnitTestRunner.Parallelizable`1+Yes.get_Item [method]: unit -> 'scope
+WoofWare.NUnitTestRunner.Parallelizable`1+Yes.Item [property]: [read-only] 'scope
+WoofWare.NUnitTestRunner.Parallelizable`1.get_IsNo [method]: unit -> bool
+WoofWare.NUnitTestRunner.Parallelizable`1.get_IsYes [method]: unit -> bool
+WoofWare.NUnitTestRunner.Parallelizable`1.get_No [static method]: unit -> 'scope WoofWare.NUnitTestRunner.Parallelizable
+WoofWare.NUnitTestRunner.Parallelizable`1.get_Tag [method]: unit -> int
+WoofWare.NUnitTestRunner.Parallelizable`1.IsNo [property]: [read-only] bool
+WoofWare.NUnitTestRunner.Parallelizable`1.IsYes [property]: [read-only] bool
+WoofWare.NUnitTestRunner.Parallelizable`1.NewYes [static method]: 'scope -> 'scope WoofWare.NUnitTestRunner.Parallelizable
+WoofWare.NUnitTestRunner.Parallelizable`1.No [static property]: [read-only] 'scope WoofWare.NUnitTestRunner.Parallelizable
+WoofWare.NUnitTestRunner.Parallelizable`1.Tag [property]: [read-only] int
+WoofWare.NUnitTestRunner.ParallelQueue inherit obj, implements IDisposable
+WoofWare.NUnitTestRunner.ParallelQueue..ctor [constructor]: (int option, WoofWare.NUnitTestRunner.AssemblyParallelScope WoofWare.NUnitTestRunner.Parallelizable option, System.Threading.CancellationToken option)
+WoofWare.NUnitTestRunner.ParallelQueue.EndTestFixture [method]: WoofWare.NUnitTestRunner.TestFixtureTearDownToken -> unit System.Threading.Tasks.Task
+WoofWare.NUnitTestRunner.ParallelQueue.Run [method]: WoofWare.NUnitTestRunner.TestFixtureSetupToken -> unit WoofWare.NUnitTestRunner.Parallelizable option -> (unit -> 'a) -> 'a System.Threading.Tasks.Task
+WoofWare.NUnitTestRunner.ParallelQueue.RunTestSetup [method]: WoofWare.NUnitTestRunner.TestFixtureRunningToken -> (unit -> 'a) -> ('a * WoofWare.NUnitTestRunner.TestFixtureSetupToken) System.Threading.Tasks.Task
+WoofWare.NUnitTestRunner.ParallelQueue.RunTestTearDown [method]: WoofWare.NUnitTestRunner.TestFixtureSetupToken -> (unit -> 'a) -> ('a * WoofWare.NUnitTestRunner.TestFixtureTearDownToken) System.Threading.Tasks.Task
+WoofWare.NUnitTestRunner.ParallelQueue.StartTestFixture [method]: WoofWare.NUnitTestRunner.TestFixture -> WoofWare.NUnitTestRunner.TestFixtureRunningToken System.Threading.Tasks.Task
+WoofWare.NUnitTestRunner.SingleTestMethod inherit obj, implements WoofWare.NUnitTestRunner.SingleTestMethod System.IEquatable, System.Collections.IStructuralEquatable
+WoofWare.NUnitTestRunner.SingleTestMethod..ctor [constructor]: (System.Reflection.MethodInfo, WoofWare.NUnitTestRunner.TestKind, WoofWare.NUnitTestRunner.Modifier list, string list, int option, WoofWare.NUnitTestRunner.Combinatorial option, unit WoofWare.NUnitTestRunner.Parallelizable option)
+WoofWare.NUnitTestRunner.SingleTestMethod.Categories [property]: [read-only] string list
+WoofWare.NUnitTestRunner.SingleTestMethod.Combinatorial [property]: [read-only] WoofWare.NUnitTestRunner.Combinatorial option
+WoofWare.NUnitTestRunner.SingleTestMethod.get_Categories [method]: unit -> string list
+WoofWare.NUnitTestRunner.SingleTestMethod.get_Combinatorial [method]: unit -> WoofWare.NUnitTestRunner.Combinatorial option
+WoofWare.NUnitTestRunner.SingleTestMethod.get_Kind [method]: unit -> WoofWare.NUnitTestRunner.TestKind
+WoofWare.NUnitTestRunner.SingleTestMethod.get_Method [method]: unit -> System.Reflection.MethodInfo
+WoofWare.NUnitTestRunner.SingleTestMethod.get_Modifiers [method]: unit -> WoofWare.NUnitTestRunner.Modifier list
+WoofWare.NUnitTestRunner.SingleTestMethod.get_Name [method]: unit -> string
+WoofWare.NUnitTestRunner.SingleTestMethod.get_Parallelize [method]: unit -> unit WoofWare.NUnitTestRunner.Parallelizable option
+WoofWare.NUnitTestRunner.SingleTestMethod.get_Repeat [method]: unit -> int option
+WoofWare.NUnitTestRunner.SingleTestMethod.Kind [property]: [read-only] WoofWare.NUnitTestRunner.TestKind
+WoofWare.NUnitTestRunner.SingleTestMethod.Method [property]: [read-only] System.Reflection.MethodInfo
+WoofWare.NUnitTestRunner.SingleTestMethod.Modifiers [property]: [read-only] WoofWare.NUnitTestRunner.Modifier list
+WoofWare.NUnitTestRunner.SingleTestMethod.Name [property]: [read-only] string
+WoofWare.NUnitTestRunner.SingleTestMethod.Parallelize [property]: [read-only] unit WoofWare.NUnitTestRunner.Parallelizable option
+WoofWare.NUnitTestRunner.SingleTestMethod.Repeat [property]: [read-only] int option
+WoofWare.NUnitTestRunner.SingleTestMethodModule inherit obj
+WoofWare.NUnitTestRunner.SingleTestMethodModule.parse [static method]: string list -> System.Reflection.MethodInfo -> System.Reflection.CustomAttributeData list -> (WoofWare.NUnitTestRunner.SingleTestMethod option * System.Reflection.CustomAttributeData list)
+WoofWare.NUnitTestRunner.TestContexts inherit obj, implements WoofWare.NUnitTestRunner.TestContexts System.IEquatable, System.Collections.IStructuralEquatable, IDisposable
+WoofWare.NUnitTestRunner.TestContexts.Empty [static method]: unit -> WoofWare.NUnitTestRunner.TestContexts
+WoofWare.NUnitTestRunner.TestFailure inherit obj, implements WoofWare.NUnitTestRunner.TestFailure System.IEquatable, System.Collections.IStructuralEquatable - union type with 3 cases
+WoofWare.NUnitTestRunner.TestFailure+SetUpFailed inherit WoofWare.NUnitTestRunner.TestFailure
+WoofWare.NUnitTestRunner.TestFailure+SetUpFailed.get_Item [method]: unit -> WoofWare.NUnitTestRunner.UserMethodFailure
+WoofWare.NUnitTestRunner.TestFailure+SetUpFailed.Item [property]: [read-only] WoofWare.NUnitTestRunner.UserMethodFailure
+WoofWare.NUnitTestRunner.TestFailure+Tags inherit obj
+WoofWare.NUnitTestRunner.TestFailure+Tags.SetUpFailed [static field]: int = 1
+WoofWare.NUnitTestRunner.TestFailure+Tags.TearDownFailed [static field]: int = 2
+WoofWare.NUnitTestRunner.TestFailure+Tags.TestFailed [static field]: int = 0
+WoofWare.NUnitTestRunner.TestFailure+TearDownFailed inherit WoofWare.NUnitTestRunner.TestFailure
+WoofWare.NUnitTestRunner.TestFailure+TearDownFailed.get_Item [method]: unit -> WoofWare.NUnitTestRunner.UserMethodFailure
+WoofWare.NUnitTestRunner.TestFailure+TearDownFailed.Item [property]: [read-only] WoofWare.NUnitTestRunner.UserMethodFailure
+WoofWare.NUnitTestRunner.TestFailure+TestFailed inherit WoofWare.NUnitTestRunner.TestFailure
+WoofWare.NUnitTestRunner.TestFailure+TestFailed.get_Item [method]: unit -> WoofWare.NUnitTestRunner.UserMethodFailure
+WoofWare.NUnitTestRunner.TestFailure+TestFailed.Item [property]: [read-only] WoofWare.NUnitTestRunner.UserMethodFailure
+WoofWare.NUnitTestRunner.TestFailure.get_IsSetUpFailed [method]: unit -> bool
+WoofWare.NUnitTestRunner.TestFailure.get_IsTearDownFailed [method]: unit -> bool
+WoofWare.NUnitTestRunner.TestFailure.get_IsTestFailed [method]: unit -> bool
+WoofWare.NUnitTestRunner.TestFailure.get_Name [method]: unit -> string
+WoofWare.NUnitTestRunner.TestFailure.get_Tag [method]: unit -> int
+WoofWare.NUnitTestRunner.TestFailure.IsSetUpFailed [property]: [read-only] bool
+WoofWare.NUnitTestRunner.TestFailure.IsTearDownFailed [property]: [read-only] bool
+WoofWare.NUnitTestRunner.TestFailure.IsTestFailed [property]: [read-only] bool
+WoofWare.NUnitTestRunner.TestFailure.Name [property]: [read-only] string
+WoofWare.NUnitTestRunner.TestFailure.NewSetUpFailed [static method]: WoofWare.NUnitTestRunner.UserMethodFailure -> WoofWare.NUnitTestRunner.TestFailure
+WoofWare.NUnitTestRunner.TestFailure.NewTearDownFailed [static method]: WoofWare.NUnitTestRunner.UserMethodFailure -> WoofWare.NUnitTestRunner.TestFailure
+WoofWare.NUnitTestRunner.TestFailure.NewTestFailed [static method]: WoofWare.NUnitTestRunner.UserMethodFailure -> WoofWare.NUnitTestRunner.TestFailure
+WoofWare.NUnitTestRunner.TestFailure.Tag [property]: [read-only] int
+WoofWare.NUnitTestRunner.TestFixture inherit obj, implements WoofWare.NUnitTestRunner.TestFixture System.IEquatable, System.Collections.IStructuralEquatable
+WoofWare.NUnitTestRunner.TestFixture..ctor [constructor]: (System.Reflection.Assembly, string, System.Type, System.Reflection.MethodInfo option, System.Reflection.MethodInfo option, System.Reflection.MethodInfo list, System.Reflection.MethodInfo list, obj list list, WoofWare.NUnitTestRunner.SingleTestMethod list, WoofWare.NUnitTestRunner.ClassParallelScope WoofWare.NUnitTestRunner.Parallelizable option)
+WoofWare.NUnitTestRunner.TestFixture.ContainingAssembly [property]: [read-only] System.Reflection.Assembly
+WoofWare.NUnitTestRunner.TestFixture.Empty [static method]: System.Type -> WoofWare.NUnitTestRunner.ClassParallelScope WoofWare.NUnitTestRunner.Parallelizable option -> obj list list -> WoofWare.NUnitTestRunner.TestFixture
+WoofWare.NUnitTestRunner.TestFixture.get_ContainingAssembly [method]: unit -> System.Reflection.Assembly
+WoofWare.NUnitTestRunner.TestFixture.get_Name [method]: unit -> string
+WoofWare.NUnitTestRunner.TestFixture.get_OneTimeSetUp [method]: unit -> System.Reflection.MethodInfo option
+WoofWare.NUnitTestRunner.TestFixture.get_OneTimeTearDown [method]: unit -> System.Reflection.MethodInfo option
+WoofWare.NUnitTestRunner.TestFixture.get_Parallelize [method]: unit -> WoofWare.NUnitTestRunner.ClassParallelScope WoofWare.NUnitTestRunner.Parallelizable option
+WoofWare.NUnitTestRunner.TestFixture.get_Parameters [method]: unit -> obj list list
+WoofWare.NUnitTestRunner.TestFixture.get_SetUp [method]: unit -> System.Reflection.MethodInfo list
+WoofWare.NUnitTestRunner.TestFixture.get_TearDown [method]: unit -> System.Reflection.MethodInfo list
+WoofWare.NUnitTestRunner.TestFixture.get_Tests [method]: unit -> WoofWare.NUnitTestRunner.SingleTestMethod list
+WoofWare.NUnitTestRunner.TestFixture.get_Type [method]: unit -> System.Type
+WoofWare.NUnitTestRunner.TestFixture.Name [property]: [read-only] string
+WoofWare.NUnitTestRunner.TestFixture.OneTimeSetUp [property]: [read-only] System.Reflection.MethodInfo option
+WoofWare.NUnitTestRunner.TestFixture.OneTimeTearDown [property]: [read-only] System.Reflection.MethodInfo option
+WoofWare.NUnitTestRunner.TestFixture.Parallelize [property]: [read-only] WoofWare.NUnitTestRunner.ClassParallelScope WoofWare.NUnitTestRunner.Parallelizable option
+WoofWare.NUnitTestRunner.TestFixture.Parameters [property]: [read-only] obj list list
+WoofWare.NUnitTestRunner.TestFixture.SetUp [property]: [read-only] System.Reflection.MethodInfo list
+WoofWare.NUnitTestRunner.TestFixture.TearDown [property]: [read-only] System.Reflection.MethodInfo list
+WoofWare.NUnitTestRunner.TestFixture.Tests [property]: [read-only] WoofWare.NUnitTestRunner.SingleTestMethod list
+WoofWare.NUnitTestRunner.TestFixture.Type [property]: [read-only] System.Type
+WoofWare.NUnitTestRunner.TestFixtureModule inherit obj
+WoofWare.NUnitTestRunner.TestFixtureModule.parse [static method]: System.Type -> WoofWare.NUnitTestRunner.TestFixture
+WoofWare.NUnitTestRunner.TestFixtureModule.run [static method]: WoofWare.NUnitTestRunner.TestContexts -> WoofWare.NUnitTestRunner.ParallelQueue -> WoofWare.NUnitTestRunner.ITestProgress -> (WoofWare.NUnitTestRunner.TestFixture -> WoofWare.NUnitTestRunner.SingleTestMethod -> bool) -> WoofWare.NUnitTestRunner.TestFixture -> WoofWare.NUnitTestRunner.FixtureRunResults list System.Threading.Tasks.Task
+WoofWare.NUnitTestRunner.TestFixtureModule.runOneFixture [static method]: WoofWare.NUnitTestRunner.TestContexts -> WoofWare.NUnitTestRunner.ParallelQueue -> WoofWare.NUnitTestRunner.ITestProgress -> (WoofWare.NUnitTestRunner.TestFixture -> WoofWare.NUnitTestRunner.SingleTestMethod -> bool) -> string -> obj -> WoofWare.NUnitTestRunner.TestFixture -> WoofWare.NUnitTestRunner.FixtureRunResults System.Threading.Tasks.Task
+WoofWare.NUnitTestRunner.TestFixtureRunningToken inherit obj, implements WoofWare.NUnitTestRunner.TestFixtureRunningToken System.IEquatable, System.Collections.IStructuralEquatable
+WoofWare.NUnitTestRunner.TestFixtureSetupToken inherit obj, implements WoofWare.NUnitTestRunner.TestFixtureSetupToken System.IEquatable, System.Collections.IStructuralEquatable
+WoofWare.NUnitTestRunner.TestFixtureTearDownToken inherit obj, implements WoofWare.NUnitTestRunner.TestFixtureTearDownToken System.IEquatable, System.Collections.IStructuralEquatable
+WoofWare.NUnitTestRunner.TestKind inherit obj, implements WoofWare.NUnitTestRunner.TestKind System.IEquatable, System.Collections.IStructuralEquatable - union type with 3 cases
+WoofWare.NUnitTestRunner.TestKind+Data inherit WoofWare.NUnitTestRunner.TestKind
+WoofWare.NUnitTestRunner.TestKind+Data.get_Item [method]: unit -> obj list list
+WoofWare.NUnitTestRunner.TestKind+Data.Item [property]: [read-only] obj list list
+WoofWare.NUnitTestRunner.TestKind+Source inherit WoofWare.NUnitTestRunner.TestKind
+WoofWare.NUnitTestRunner.TestKind+Source.get_Item [method]: unit -> string list
+WoofWare.NUnitTestRunner.TestKind+Source.Item [property]: [read-only] string list
+WoofWare.NUnitTestRunner.TestKind+Tags inherit obj
+WoofWare.NUnitTestRunner.TestKind+Tags.Data [static field]: int = 2
+WoofWare.NUnitTestRunner.TestKind+Tags.Single [static field]: int = 0
+WoofWare.NUnitTestRunner.TestKind+Tags.Source [static field]: int = 1
+WoofWare.NUnitTestRunner.TestKind.get_IsData [method]: unit -> bool
+WoofWare.NUnitTestRunner.TestKind.get_IsSingle [method]: unit -> bool
+WoofWare.NUnitTestRunner.TestKind.get_IsSource [method]: unit -> bool
+WoofWare.NUnitTestRunner.TestKind.get_Single [static method]: unit -> WoofWare.NUnitTestRunner.TestKind
+WoofWare.NUnitTestRunner.TestKind.get_Tag [method]: unit -> int
+WoofWare.NUnitTestRunner.TestKind.IsData [property]: [read-only] bool
+WoofWare.NUnitTestRunner.TestKind.IsSingle [property]: [read-only] bool
+WoofWare.NUnitTestRunner.TestKind.IsSource [property]: [read-only] bool
+WoofWare.NUnitTestRunner.TestKind.NewData [static method]: obj list list -> WoofWare.NUnitTestRunner.TestKind
+WoofWare.NUnitTestRunner.TestKind.NewSource [static method]: string list -> WoofWare.NUnitTestRunner.TestKind
+WoofWare.NUnitTestRunner.TestKind.Single [static property]: [read-only] WoofWare.NUnitTestRunner.TestKind
+WoofWare.NUnitTestRunner.TestKind.Tag [property]: [read-only] int
+WoofWare.NUnitTestRunner.TestMemberFailure inherit obj, implements WoofWare.NUnitTestRunner.TestMemberFailure System.IEquatable, System.Collections.IStructuralEquatable - union type with 2 cases
+WoofWare.NUnitTestRunner.TestMemberFailure+Failed inherit WoofWare.NUnitTestRunner.TestMemberFailure
+WoofWare.NUnitTestRunner.TestMemberFailure+Failed.get_Item [method]: unit -> WoofWare.NUnitTestRunner.TestFailure list
+WoofWare.NUnitTestRunner.TestMemberFailure+Failed.Item [property]: [read-only] WoofWare.NUnitTestRunner.TestFailure list
+WoofWare.NUnitTestRunner.TestMemberFailure+Malformed inherit WoofWare.NUnitTestRunner.TestMemberFailure
+WoofWare.NUnitTestRunner.TestMemberFailure+Malformed.get_reasons [method]: unit -> string list
+WoofWare.NUnitTestRunner.TestMemberFailure+Malformed.reasons [property]: [read-only] string list
+WoofWare.NUnitTestRunner.TestMemberFailure+Tags inherit obj
+WoofWare.NUnitTestRunner.TestMemberFailure+Tags.Failed [static field]: int = 1
+WoofWare.NUnitTestRunner.TestMemberFailure+Tags.Malformed [static field]: int = 0
+WoofWare.NUnitTestRunner.TestMemberFailure.get_IsFailed [method]: unit -> bool
+WoofWare.NUnitTestRunner.TestMemberFailure.get_IsMalformed [method]: unit -> bool
+WoofWare.NUnitTestRunner.TestMemberFailure.get_Tag [method]: unit -> int
+WoofWare.NUnitTestRunner.TestMemberFailure.IsFailed [property]: [read-only] bool
+WoofWare.NUnitTestRunner.TestMemberFailure.IsMalformed [property]: [read-only] bool
+WoofWare.NUnitTestRunner.TestMemberFailure.NewFailed [static method]: WoofWare.NUnitTestRunner.TestFailure list -> WoofWare.NUnitTestRunner.TestMemberFailure
+WoofWare.NUnitTestRunner.TestMemberFailure.NewMalformed [static method]: string list -> WoofWare.NUnitTestRunner.TestMemberFailure
+WoofWare.NUnitTestRunner.TestMemberFailure.Tag [property]: [read-only] int
+WoofWare.NUnitTestRunner.TestMemberSuccess inherit obj, implements WoofWare.NUnitTestRunner.TestMemberSuccess System.IEquatable, System.Collections.IStructuralEquatable, WoofWare.NUnitTestRunner.TestMemberSuccess System.IComparable, System.IComparable, System.Collections.IStructuralComparable - union type with 4 cases
+WoofWare.NUnitTestRunner.TestMemberSuccess+Explicit inherit WoofWare.NUnitTestRunner.TestMemberSuccess
+WoofWare.NUnitTestRunner.TestMemberSuccess+Explicit.get_reason [method]: unit -> string option
+WoofWare.NUnitTestRunner.TestMemberSuccess+Explicit.reason [property]: [read-only] string option
+WoofWare.NUnitTestRunner.TestMemberSuccess+Ignored inherit WoofWare.NUnitTestRunner.TestMemberSuccess
+WoofWare.NUnitTestRunner.TestMemberSuccess+Ignored.get_reason [method]: unit -> string option
+WoofWare.NUnitTestRunner.TestMemberSuccess+Ignored.reason [property]: [read-only] string option
+WoofWare.NUnitTestRunner.TestMemberSuccess+Inconclusive inherit WoofWare.NUnitTestRunner.TestMemberSuccess
+WoofWare.NUnitTestRunner.TestMemberSuccess+Inconclusive.get_reason [method]: unit -> string option
+WoofWare.NUnitTestRunner.TestMemberSuccess+Inconclusive.reason [property]: [read-only] string option
+WoofWare.NUnitTestRunner.TestMemberSuccess+Tags inherit obj
+WoofWare.NUnitTestRunner.TestMemberSuccess+Tags.Explicit [static field]: int = 2
+WoofWare.NUnitTestRunner.TestMemberSuccess+Tags.Ignored [static field]: int = 1
+WoofWare.NUnitTestRunner.TestMemberSuccess+Tags.Inconclusive [static field]: int = 3
+WoofWare.NUnitTestRunner.TestMemberSuccess+Tags.Ok [static field]: int = 0
+WoofWare.NUnitTestRunner.TestMemberSuccess.get_IsExplicit [method]: unit -> bool
+WoofWare.NUnitTestRunner.TestMemberSuccess.get_IsIgnored [method]: unit -> bool
+WoofWare.NUnitTestRunner.TestMemberSuccess.get_IsInconclusive [method]: unit -> bool
+WoofWare.NUnitTestRunner.TestMemberSuccess.get_IsOk [method]: unit -> bool
+WoofWare.NUnitTestRunner.TestMemberSuccess.get_Ok [static method]: unit -> WoofWare.NUnitTestRunner.TestMemberSuccess
+WoofWare.NUnitTestRunner.TestMemberSuccess.get_Tag [method]: unit -> int
+WoofWare.NUnitTestRunner.TestMemberSuccess.IsExplicit [property]: [read-only] bool
+WoofWare.NUnitTestRunner.TestMemberSuccess.IsIgnored [property]: [read-only] bool
+WoofWare.NUnitTestRunner.TestMemberSuccess.IsInconclusive [property]: [read-only] bool
+WoofWare.NUnitTestRunner.TestMemberSuccess.IsOk [property]: [read-only] bool
+WoofWare.NUnitTestRunner.TestMemberSuccess.NewExplicit [static method]: string option -> WoofWare.NUnitTestRunner.TestMemberSuccess
+WoofWare.NUnitTestRunner.TestMemberSuccess.NewIgnored [static method]: string option -> WoofWare.NUnitTestRunner.TestMemberSuccess
+WoofWare.NUnitTestRunner.TestMemberSuccess.NewInconclusive [static method]: string option -> WoofWare.NUnitTestRunner.TestMemberSuccess
+WoofWare.NUnitTestRunner.TestMemberSuccess.Ok [static property]: [read-only] WoofWare.NUnitTestRunner.TestMemberSuccess
+WoofWare.NUnitTestRunner.TestMemberSuccess.Tag [property]: [read-only] int
+WoofWare.NUnitTestRunner.TestProgress inherit obj
+WoofWare.NUnitTestRunner.TestProgress.toStderr [static method]: unit -> WoofWare.NUnitTestRunner.ITestProgress
+WoofWare.NUnitTestRunner.TrxCounters inherit obj, implements WoofWare.NUnitTestRunner.TrxCounters System.IEquatable, System.Collections.IStructuralEquatable
+WoofWare.NUnitTestRunner.TrxCounters..ctor [constructor]: (System.UInt32, System.UInt32, System.UInt32, System.UInt32, System.UInt32, System.UInt32, System.UInt32, System.UInt32, System.UInt32, System.UInt32, System.UInt32, System.UInt32, System.UInt32, System.UInt32, System.UInt32, System.UInt32)
+WoofWare.NUnitTestRunner.TrxCounters.Aborted [property]: [read-only] System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.AddFailed [method]: unit -> WoofWare.NUnitTestRunner.TrxCounters
+WoofWare.NUnitTestRunner.TrxCounters.AddInconclusive [method]: unit -> WoofWare.NUnitTestRunner.TrxCounters
+WoofWare.NUnitTestRunner.TrxCounters.AddNotExecuted [method]: unit -> WoofWare.NUnitTestRunner.TrxCounters
+WoofWare.NUnitTestRunner.TrxCounters.AddPassed [method]: unit -> WoofWare.NUnitTestRunner.TrxCounters
+WoofWare.NUnitTestRunner.TrxCounters.Completed [property]: [read-only] System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.Disconnected [property]: [read-only] System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.Errors [property]: [read-only] System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.Executed [property]: [read-only] System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.Failed [property]: [read-only] System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.get_Aborted [method]: unit -> System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.get_Completed [method]: unit -> System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.get_Disconnected [method]: unit -> System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.get_Errors [method]: unit -> System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.get_Executed [method]: unit -> System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.get_Failed [method]: unit -> System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.get_Inconclusive [method]: unit -> System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.get_InProgress [method]: unit -> System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.get_NotExecuted [method]: unit -> System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.get_NotRunnable [method]: unit -> System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.get_Passed [method]: unit -> System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.get_PassedButRunAborted [method]: unit -> System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.get_Pending [method]: unit -> System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.get_Timeout [method]: unit -> System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.get_Total [method]: unit -> System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.get_Warning [method]: unit -> System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.get_Zero [static method]: unit -> WoofWare.NUnitTestRunner.TrxCounters
+WoofWare.NUnitTestRunner.TrxCounters.Inconclusive [property]: [read-only] System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.InProgress [property]: [read-only] System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.NotExecuted [property]: [read-only] System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.NotRunnable [property]: [read-only] System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.Passed [property]: [read-only] System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.PassedButRunAborted [property]: [read-only] System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.Pending [property]: [read-only] System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.Timeout [property]: [read-only] System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.Total [property]: [read-only] System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.Warning [property]: [read-only] System.UInt32
+WoofWare.NUnitTestRunner.TrxCounters.Zero [static property]: [read-only] WoofWare.NUnitTestRunner.TrxCounters
+WoofWare.NUnitTestRunner.TrxDeployment inherit obj, implements WoofWare.NUnitTestRunner.TrxDeployment System.IEquatable, System.Collections.IStructuralEquatable
+WoofWare.NUnitTestRunner.TrxDeployment..ctor [constructor]: string
+WoofWare.NUnitTestRunner.TrxDeployment.get_RunDeploymentRoot [method]: unit -> string
+WoofWare.NUnitTestRunner.TrxDeployment.RunDeploymentRoot [property]: [read-only] string
+WoofWare.NUnitTestRunner.TrxErrorInfo inherit obj, implements WoofWare.NUnitTestRunner.TrxErrorInfo System.IEquatable, System.Collections.IStructuralEquatable
+WoofWare.NUnitTestRunner.TrxErrorInfo..ctor [constructor]: (string option, string option)
+WoofWare.NUnitTestRunner.TrxErrorInfo.get_Message [method]: unit -> string option
+WoofWare.NUnitTestRunner.TrxErrorInfo.get_StackTrace [method]: unit -> string option
+WoofWare.NUnitTestRunner.TrxErrorInfo.Message [property]: [read-only] string option
+WoofWare.NUnitTestRunner.TrxErrorInfo.StackTrace [property]: [read-only] string option
+WoofWare.NUnitTestRunner.TrxExecution inherit obj, implements WoofWare.NUnitTestRunner.TrxExecution System.IEquatable, System.Collections.IStructuralEquatable
+WoofWare.NUnitTestRunner.TrxExecution..ctor [constructor]: System.Guid
+WoofWare.NUnitTestRunner.TrxExecution.get_Id [method]: unit -> System.Guid
+WoofWare.NUnitTestRunner.TrxExecution.Id [property]: [read-only] System.Guid
+WoofWare.NUnitTestRunner.TrxOutcome inherit obj, implements WoofWare.NUnitTestRunner.TrxOutcome System.IEquatable, System.Collections.IStructuralEquatable - union type with 3 cases
+WoofWare.NUnitTestRunner.TrxOutcome+Tags inherit obj
+WoofWare.NUnitTestRunner.TrxOutcome+Tags.Completed [static field]: int = 0
+WoofWare.NUnitTestRunner.TrxOutcome+Tags.Failed [static field]: int = 2
+WoofWare.NUnitTestRunner.TrxOutcome+Tags.Warning [static field]: int = 1
+WoofWare.NUnitTestRunner.TrxOutcome.Completed [static property]: [read-only] WoofWare.NUnitTestRunner.TrxOutcome
+WoofWare.NUnitTestRunner.TrxOutcome.Failed [static property]: [read-only] WoofWare.NUnitTestRunner.TrxOutcome
+WoofWare.NUnitTestRunner.TrxOutcome.get_Completed [static method]: unit -> WoofWare.NUnitTestRunner.TrxOutcome
+WoofWare.NUnitTestRunner.TrxOutcome.get_Failed [static method]: unit -> WoofWare.NUnitTestRunner.TrxOutcome
+WoofWare.NUnitTestRunner.TrxOutcome.get_IsCompleted [method]: unit -> bool
+WoofWare.NUnitTestRunner.TrxOutcome.get_IsFailed [method]: unit -> bool
+WoofWare.NUnitTestRunner.TrxOutcome.get_IsWarning [method]: unit -> bool
+WoofWare.NUnitTestRunner.TrxOutcome.get_Tag [method]: unit -> int
+WoofWare.NUnitTestRunner.TrxOutcome.get_Warning [static method]: unit -> WoofWare.NUnitTestRunner.TrxOutcome
+WoofWare.NUnitTestRunner.TrxOutcome.IsCompleted [property]: [read-only] bool
+WoofWare.NUnitTestRunner.TrxOutcome.IsFailed [property]: [read-only] bool
+WoofWare.NUnitTestRunner.TrxOutcome.IsWarning [property]: [read-only] bool
+WoofWare.NUnitTestRunner.TrxOutcome.Parse [static method]: string -> WoofWare.NUnitTestRunner.TrxOutcome option
+WoofWare.NUnitTestRunner.TrxOutcome.Tag [property]: [read-only] int
+WoofWare.NUnitTestRunner.TrxOutcome.Warning [static property]: [read-only] WoofWare.NUnitTestRunner.TrxOutcome
+WoofWare.NUnitTestRunner.TrxOutput inherit obj, implements WoofWare.NUnitTestRunner.TrxOutput System.IEquatable, System.Collections.IStructuralEquatable
+WoofWare.NUnitTestRunner.TrxOutput..ctor [constructor]: (string option, string option, WoofWare.NUnitTestRunner.TrxErrorInfo option)
+WoofWare.NUnitTestRunner.TrxOutput.ErrorInfo [property]: [read-only] WoofWare.NUnitTestRunner.TrxErrorInfo option
+WoofWare.NUnitTestRunner.TrxOutput.get_ErrorInfo [method]: unit -> WoofWare.NUnitTestRunner.TrxErrorInfo option
+WoofWare.NUnitTestRunner.TrxOutput.get_StdErr [method]: unit -> string option
+WoofWare.NUnitTestRunner.TrxOutput.get_StdOut [method]: unit -> string option
+WoofWare.NUnitTestRunner.TrxOutput.StdErr [property]: [read-only] string option
+WoofWare.NUnitTestRunner.TrxOutput.StdOut [property]: [read-only] string option
+WoofWare.NUnitTestRunner.TrxReport inherit obj, implements WoofWare.NUnitTestRunner.TrxReport System.IEquatable, System.Collections.IStructuralEquatable
+WoofWare.NUnitTestRunner.TrxReport..ctor [constructor]: (System.Guid, string, WoofWare.NUnitTestRunner.TrxReportTimes, WoofWare.NUnitTestRunner.TrxTestSettings, WoofWare.NUnitTestRunner.TrxUnitTestResult list, WoofWare.NUnitTestRunner.TrxUnitTest list, WoofWare.NUnitTestRunner.TrxTestEntry list, WoofWare.NUnitTestRunner.TrxTestListEntry list, WoofWare.NUnitTestRunner.TrxResultsSummary)
+WoofWare.NUnitTestRunner.TrxReport.get_Id [method]: unit -> System.Guid
+WoofWare.NUnitTestRunner.TrxReport.get_Name [method]: unit -> string
+WoofWare.NUnitTestRunner.TrxReport.get_Results [method]: unit -> WoofWare.NUnitTestRunner.TrxUnitTestResult list
+WoofWare.NUnitTestRunner.TrxReport.get_ResultsSummary [method]: unit -> WoofWare.NUnitTestRunner.TrxResultsSummary
+WoofWare.NUnitTestRunner.TrxReport.get_Settings [method]: unit -> WoofWare.NUnitTestRunner.TrxTestSettings
+WoofWare.NUnitTestRunner.TrxReport.get_TestDefinitions [method]: unit -> WoofWare.NUnitTestRunner.TrxUnitTest list
+WoofWare.NUnitTestRunner.TrxReport.get_TestEntries [method]: unit -> WoofWare.NUnitTestRunner.TrxTestEntry list
+WoofWare.NUnitTestRunner.TrxReport.get_TestLists [method]: unit -> WoofWare.NUnitTestRunner.TrxTestListEntry list
+WoofWare.NUnitTestRunner.TrxReport.get_Times [method]: unit -> WoofWare.NUnitTestRunner.TrxReportTimes
+WoofWare.NUnitTestRunner.TrxReport.Id [property]: [read-only] System.Guid
+WoofWare.NUnitTestRunner.TrxReport.Name [property]: [read-only] string
+WoofWare.NUnitTestRunner.TrxReport.Results [property]: [read-only] WoofWare.NUnitTestRunner.TrxUnitTestResult list
+WoofWare.NUnitTestRunner.TrxReport.ResultsSummary [property]: [read-only] WoofWare.NUnitTestRunner.TrxResultsSummary
+WoofWare.NUnitTestRunner.TrxReport.Settings [property]: [read-only] WoofWare.NUnitTestRunner.TrxTestSettings
+WoofWare.NUnitTestRunner.TrxReport.TestDefinitions [property]: [read-only] WoofWare.NUnitTestRunner.TrxUnitTest list
+WoofWare.NUnitTestRunner.TrxReport.TestEntries [property]: [read-only] WoofWare.NUnitTestRunner.TrxTestEntry list
+WoofWare.NUnitTestRunner.TrxReport.TestLists [property]: [read-only] WoofWare.NUnitTestRunner.TrxTestListEntry list
+WoofWare.NUnitTestRunner.TrxReport.Times [property]: [read-only] WoofWare.NUnitTestRunner.TrxReportTimes
+WoofWare.NUnitTestRunner.TrxReportModule inherit obj
+WoofWare.NUnitTestRunner.TrxReportModule.parse [static method]: string -> Microsoft.FSharp.Core.FSharpResult<WoofWare.NUnitTestRunner.TrxReport, string>
+WoofWare.NUnitTestRunner.TrxReportModule.toXml [static method]: WoofWare.NUnitTestRunner.TrxReport -> System.Xml.XmlDocument
+WoofWare.NUnitTestRunner.TrxReportTimes inherit obj, implements WoofWare.NUnitTestRunner.TrxReportTimes System.IEquatable, System.Collections.IStructuralEquatable
+WoofWare.NUnitTestRunner.TrxReportTimes..ctor [constructor]: (System.DateTimeOffset, System.DateTimeOffset, System.DateTimeOffset, System.DateTimeOffset)
+WoofWare.NUnitTestRunner.TrxReportTimes.Creation [property]: [read-only] System.DateTimeOffset
+WoofWare.NUnitTestRunner.TrxReportTimes.Finish [property]: [read-only] System.DateTimeOffset
+WoofWare.NUnitTestRunner.TrxReportTimes.get_Creation [method]: unit -> System.DateTimeOffset
+WoofWare.NUnitTestRunner.TrxReportTimes.get_Finish [method]: unit -> System.DateTimeOffset
+WoofWare.NUnitTestRunner.TrxReportTimes.get_Queuing [method]: unit -> System.DateTimeOffset
+WoofWare.NUnitTestRunner.TrxReportTimes.get_Start [method]: unit -> System.DateTimeOffset
+WoofWare.NUnitTestRunner.TrxReportTimes.Queuing [property]: [read-only] System.DateTimeOffset
+WoofWare.NUnitTestRunner.TrxReportTimes.Start [property]: [read-only] System.DateTimeOffset
+WoofWare.NUnitTestRunner.TrxResultsSummary inherit obj, implements WoofWare.NUnitTestRunner.TrxResultsSummary System.IEquatable, System.Collections.IStructuralEquatable
+WoofWare.NUnitTestRunner.TrxResultsSummary..ctor [constructor]: (WoofWare.NUnitTestRunner.TrxOutcome, WoofWare.NUnitTestRunner.TrxCounters, WoofWare.NUnitTestRunner.TrxOutput, WoofWare.NUnitTestRunner.TrxRunInfo list)
+WoofWare.NUnitTestRunner.TrxResultsSummary.Counters [property]: [read-only] WoofWare.NUnitTestRunner.TrxCounters
+WoofWare.NUnitTestRunner.TrxResultsSummary.get_Counters [method]: unit -> WoofWare.NUnitTestRunner.TrxCounters
+WoofWare.NUnitTestRunner.TrxResultsSummary.get_Outcome [method]: unit -> WoofWare.NUnitTestRunner.TrxOutcome
+WoofWare.NUnitTestRunner.TrxResultsSummary.get_Output [method]: unit -> WoofWare.NUnitTestRunner.TrxOutput
+WoofWare.NUnitTestRunner.TrxResultsSummary.get_RunInfos [method]: unit -> WoofWare.NUnitTestRunner.TrxRunInfo list
+WoofWare.NUnitTestRunner.TrxResultsSummary.Outcome [property]: [read-only] WoofWare.NUnitTestRunner.TrxOutcome
+WoofWare.NUnitTestRunner.TrxResultsSummary.Output [property]: [read-only] WoofWare.NUnitTestRunner.TrxOutput
+WoofWare.NUnitTestRunner.TrxResultsSummary.RunInfos [property]: [read-only] WoofWare.NUnitTestRunner.TrxRunInfo list
+WoofWare.NUnitTestRunner.TrxRunInfo inherit obj, implements WoofWare.NUnitTestRunner.TrxRunInfo System.IEquatable, System.Collections.IStructuralEquatable
+WoofWare.NUnitTestRunner.TrxRunInfo..ctor [constructor]: (string, WoofWare.NUnitTestRunner.TrxOutcome, System.DateTimeOffset, string)
+WoofWare.NUnitTestRunner.TrxRunInfo.ComputerName [property]: [read-only] string
+WoofWare.NUnitTestRunner.TrxRunInfo.get_ComputerName [method]: unit -> string
+WoofWare.NUnitTestRunner.TrxRunInfo.get_Outcome [method]: unit -> WoofWare.NUnitTestRunner.TrxOutcome
+WoofWare.NUnitTestRunner.TrxRunInfo.get_Text [method]: unit -> string
+WoofWare.NUnitTestRunner.TrxRunInfo.get_Timestamp [method]: unit -> System.DateTimeOffset
+WoofWare.NUnitTestRunner.TrxRunInfo.Outcome [property]: [read-only] WoofWare.NUnitTestRunner.TrxOutcome
+WoofWare.NUnitTestRunner.TrxRunInfo.Text [property]: [read-only] string
+WoofWare.NUnitTestRunner.TrxRunInfo.Timestamp [property]: [read-only] System.DateTimeOffset
+WoofWare.NUnitTestRunner.TrxTestEntry inherit obj, implements WoofWare.NUnitTestRunner.TrxTestEntry System.IEquatable, System.Collections.IStructuralEquatable
+WoofWare.NUnitTestRunner.TrxTestEntry..ctor [constructor]: (System.Guid, System.Guid, System.Guid)
+WoofWare.NUnitTestRunner.TrxTestEntry.ExecutionId [property]: [read-only] System.Guid
+WoofWare.NUnitTestRunner.TrxTestEntry.get_ExecutionId [method]: unit -> System.Guid
+WoofWare.NUnitTestRunner.TrxTestEntry.get_TestId [method]: unit -> System.Guid
+WoofWare.NUnitTestRunner.TrxTestEntry.get_TestListId [method]: unit -> System.Guid
+WoofWare.NUnitTestRunner.TrxTestEntry.TestId [property]: [read-only] System.Guid
+WoofWare.NUnitTestRunner.TrxTestEntry.TestListId [property]: [read-only] System.Guid
+WoofWare.NUnitTestRunner.TrxTestListEntry inherit obj, implements WoofWare.NUnitTestRunner.TrxTestListEntry System.IEquatable, System.Collections.IStructuralEquatable
+WoofWare.NUnitTestRunner.TrxTestListEntry..ctor [constructor]: (string, System.Guid)
+WoofWare.NUnitTestRunner.TrxTestListEntry.get_Id [method]: unit -> System.Guid
+WoofWare.NUnitTestRunner.TrxTestListEntry.get_Name [method]: unit -> string
+WoofWare.NUnitTestRunner.TrxTestListEntry.Id [property]: [read-only] System.Guid
+WoofWare.NUnitTestRunner.TrxTestListEntry.Name [property]: [read-only] string
+WoofWare.NUnitTestRunner.TrxTestMethod inherit obj, implements WoofWare.NUnitTestRunner.TrxTestMethod System.IEquatable, System.Collections.IStructuralEquatable
+WoofWare.NUnitTestRunner.TrxTestMethod..ctor [constructor]: (string, System.Uri, string, string)
+WoofWare.NUnitTestRunner.TrxTestMethod.AdapterTypeName [property]: [read-only] System.Uri
+WoofWare.NUnitTestRunner.TrxTestMethod.ClassName [property]: [read-only] string
+WoofWare.NUnitTestRunner.TrxTestMethod.CodeBase [property]: [read-only] string
+WoofWare.NUnitTestRunner.TrxTestMethod.get_AdapterTypeName [method]: unit -> System.Uri
+WoofWare.NUnitTestRunner.TrxTestMethod.get_ClassName [method]: unit -> string
+WoofWare.NUnitTestRunner.TrxTestMethod.get_CodeBase [method]: unit -> string
+WoofWare.NUnitTestRunner.TrxTestMethod.get_Name [method]: unit -> string
+WoofWare.NUnitTestRunner.TrxTestMethod.Name [property]: [read-only] string
+WoofWare.NUnitTestRunner.TrxTestOutcome inherit obj, implements WoofWare.NUnitTestRunner.TrxTestOutcome System.IEquatable, System.Collections.IStructuralEquatable - union type with 4 cases
+WoofWare.NUnitTestRunner.TrxTestOutcome+Tags inherit obj
+WoofWare.NUnitTestRunner.TrxTestOutcome+Tags.Failed [static field]: int = 1
+WoofWare.NUnitTestRunner.TrxTestOutcome+Tags.Inconclusive [static field]: int = 3
+WoofWare.NUnitTestRunner.TrxTestOutcome+Tags.NotExecuted [static field]: int = 2
+WoofWare.NUnitTestRunner.TrxTestOutcome+Tags.Passed [static field]: int = 0
+WoofWare.NUnitTestRunner.TrxTestOutcome.Failed [static property]: [read-only] WoofWare.NUnitTestRunner.TrxTestOutcome
+WoofWare.NUnitTestRunner.TrxTestOutcome.get_Failed [static method]: unit -> WoofWare.NUnitTestRunner.TrxTestOutcome
+WoofWare.NUnitTestRunner.TrxTestOutcome.get_Inconclusive [static method]: unit -> WoofWare.NUnitTestRunner.TrxTestOutcome
+WoofWare.NUnitTestRunner.TrxTestOutcome.get_IsFailed [method]: unit -> bool
+WoofWare.NUnitTestRunner.TrxTestOutcome.get_IsInconclusive [method]: unit -> bool
+WoofWare.NUnitTestRunner.TrxTestOutcome.get_IsNotExecuted [method]: unit -> bool
+WoofWare.NUnitTestRunner.TrxTestOutcome.get_IsPassed [method]: unit -> bool
+WoofWare.NUnitTestRunner.TrxTestOutcome.get_NotExecuted [static method]: unit -> WoofWare.NUnitTestRunner.TrxTestOutcome
+WoofWare.NUnitTestRunner.TrxTestOutcome.get_Passed [static method]: unit -> WoofWare.NUnitTestRunner.TrxTestOutcome
+WoofWare.NUnitTestRunner.TrxTestOutcome.get_Tag [method]: unit -> int
+WoofWare.NUnitTestRunner.TrxTestOutcome.Inconclusive [static property]: [read-only] WoofWare.NUnitTestRunner.TrxTestOutcome
+WoofWare.NUnitTestRunner.TrxTestOutcome.IsFailed [property]: [read-only] bool
+WoofWare.NUnitTestRunner.TrxTestOutcome.IsInconclusive [property]: [read-only] bool
+WoofWare.NUnitTestRunner.TrxTestOutcome.IsNotExecuted [property]: [read-only] bool
+WoofWare.NUnitTestRunner.TrxTestOutcome.IsPassed [property]: [read-only] bool
+WoofWare.NUnitTestRunner.TrxTestOutcome.NotExecuted [static property]: [read-only] WoofWare.NUnitTestRunner.TrxTestOutcome
+WoofWare.NUnitTestRunner.TrxTestOutcome.Parse [static method]: string -> WoofWare.NUnitTestRunner.TrxTestOutcome option
+WoofWare.NUnitTestRunner.TrxTestOutcome.Passed [static property]: [read-only] WoofWare.NUnitTestRunner.TrxTestOutcome
+WoofWare.NUnitTestRunner.TrxTestOutcome.Tag [property]: [read-only] int
+WoofWare.NUnitTestRunner.TrxTestSettings inherit obj, implements WoofWare.NUnitTestRunner.TrxTestSettings System.IEquatable, System.Collections.IStructuralEquatable
+WoofWare.NUnitTestRunner.TrxTestSettings..ctor [constructor]: (string, System.Guid, WoofWare.NUnitTestRunner.TrxDeployment)
+WoofWare.NUnitTestRunner.TrxTestSettings.Deployment [property]: [read-only] WoofWare.NUnitTestRunner.TrxDeployment
+WoofWare.NUnitTestRunner.TrxTestSettings.get_Deployment [method]: unit -> WoofWare.NUnitTestRunner.TrxDeployment
+WoofWare.NUnitTestRunner.TrxTestSettings.get_Id [method]: unit -> System.Guid
+WoofWare.NUnitTestRunner.TrxTestSettings.get_Name [method]: unit -> string
+WoofWare.NUnitTestRunner.TrxTestSettings.Id [property]: [read-only] System.Guid
+WoofWare.NUnitTestRunner.TrxTestSettings.Name [property]: [read-only] string
+WoofWare.NUnitTestRunner.TrxUnitTest inherit obj, implements WoofWare.NUnitTestRunner.TrxUnitTest System.IEquatable, System.Collections.IStructuralEquatable
+WoofWare.NUnitTestRunner.TrxUnitTest..ctor [constructor]: (string, string, System.Guid, WoofWare.NUnitTestRunner.TrxExecution, WoofWare.NUnitTestRunner.TrxTestMethod)
+WoofWare.NUnitTestRunner.TrxUnitTest.Execution [property]: [read-only] WoofWare.NUnitTestRunner.TrxExecution
+WoofWare.NUnitTestRunner.TrxUnitTest.get_Execution [method]: unit -> WoofWare.NUnitTestRunner.TrxExecution
+WoofWare.NUnitTestRunner.TrxUnitTest.get_Id [method]: unit -> System.Guid
+WoofWare.NUnitTestRunner.TrxUnitTest.get_Name [method]: unit -> string
+WoofWare.NUnitTestRunner.TrxUnitTest.get_Storage [method]: unit -> string
+WoofWare.NUnitTestRunner.TrxUnitTest.get_TestMethod [method]: unit -> WoofWare.NUnitTestRunner.TrxTestMethod
+WoofWare.NUnitTestRunner.TrxUnitTest.Id [property]: [read-only] System.Guid
+WoofWare.NUnitTestRunner.TrxUnitTest.Name [property]: [read-only] string
+WoofWare.NUnitTestRunner.TrxUnitTest.Storage [property]: [read-only] string
+WoofWare.NUnitTestRunner.TrxUnitTest.TestMethod [property]: [read-only] WoofWare.NUnitTestRunner.TrxTestMethod
+WoofWare.NUnitTestRunner.TrxUnitTestResult inherit obj, implements WoofWare.NUnitTestRunner.TrxUnitTestResult System.IEquatable, System.Collections.IStructuralEquatable
+WoofWare.NUnitTestRunner.TrxUnitTestResult..ctor [constructor]: (System.Guid, System.Guid, string, string, System.TimeSpan, System.DateTimeOffset, System.DateTimeOffset, System.Guid, WoofWare.NUnitTestRunner.TrxTestOutcome, System.Guid, string, WoofWare.NUnitTestRunner.TrxOutput option)
+WoofWare.NUnitTestRunner.TrxUnitTestResult.ComputerName [property]: [read-only] string
+WoofWare.NUnitTestRunner.TrxUnitTestResult.Duration [property]: [read-only] System.TimeSpan
+WoofWare.NUnitTestRunner.TrxUnitTestResult.EndTime [property]: [read-only] System.DateTimeOffset
+WoofWare.NUnitTestRunner.TrxUnitTestResult.ExecutionId [property]: [read-only] System.Guid
+WoofWare.NUnitTestRunner.TrxUnitTestResult.get_ComputerName [method]: unit -> string
+WoofWare.NUnitTestRunner.TrxUnitTestResult.get_Duration [method]: unit -> System.TimeSpan
+WoofWare.NUnitTestRunner.TrxUnitTestResult.get_EndTime [method]: unit -> System.DateTimeOffset
+WoofWare.NUnitTestRunner.TrxUnitTestResult.get_ExecutionId [method]: unit -> System.Guid
+WoofWare.NUnitTestRunner.TrxUnitTestResult.get_Outcome [method]: unit -> WoofWare.NUnitTestRunner.TrxTestOutcome
+WoofWare.NUnitTestRunner.TrxUnitTestResult.get_Output [method]: unit -> WoofWare.NUnitTestRunner.TrxOutput option
+WoofWare.NUnitTestRunner.TrxUnitTestResult.get_RelativeResultsDirectory [method]: unit -> string
+WoofWare.NUnitTestRunner.TrxUnitTestResult.get_StartTime [method]: unit -> System.DateTimeOffset
+WoofWare.NUnitTestRunner.TrxUnitTestResult.get_TestId [method]: unit -> System.Guid
+WoofWare.NUnitTestRunner.TrxUnitTestResult.get_TestListId [method]: unit -> System.Guid
+WoofWare.NUnitTestRunner.TrxUnitTestResult.get_TestName [method]: unit -> string
+WoofWare.NUnitTestRunner.TrxUnitTestResult.get_TestType [method]: unit -> System.Guid
+WoofWare.NUnitTestRunner.TrxUnitTestResult.Outcome [property]: [read-only] WoofWare.NUnitTestRunner.TrxTestOutcome
+WoofWare.NUnitTestRunner.TrxUnitTestResult.Output [property]: [read-only] WoofWare.NUnitTestRunner.TrxOutput option
+WoofWare.NUnitTestRunner.TrxUnitTestResult.RelativeResultsDirectory [property]: [read-only] string
+WoofWare.NUnitTestRunner.TrxUnitTestResult.StartTime [property]: [read-only] System.DateTimeOffset
+WoofWare.NUnitTestRunner.TrxUnitTestResult.TestId [property]: [read-only] System.Guid
+WoofWare.NUnitTestRunner.TrxUnitTestResult.TestListId [property]: [read-only] System.Guid
+WoofWare.NUnitTestRunner.TrxUnitTestResult.TestName [property]: [read-only] string
+WoofWare.NUnitTestRunner.TrxUnitTestResult.TestType [property]: [read-only] System.Guid
+WoofWare.NUnitTestRunner.UserMethodFailure inherit obj, implements WoofWare.NUnitTestRunner.UserMethodFailure System.IEquatable, System.Collections.IStructuralEquatable - union type with 2 cases
+WoofWare.NUnitTestRunner.UserMethodFailure+ReturnedNonUnit inherit WoofWare.NUnitTestRunner.UserMethodFailure
+WoofWare.NUnitTestRunner.UserMethodFailure+ReturnedNonUnit.get_name [method]: unit -> string
+WoofWare.NUnitTestRunner.UserMethodFailure+ReturnedNonUnit.get_result [method]: unit -> obj
+WoofWare.NUnitTestRunner.UserMethodFailure+ReturnedNonUnit.name [property]: [read-only] string
+WoofWare.NUnitTestRunner.UserMethodFailure+ReturnedNonUnit.result [property]: [read-only] obj
+WoofWare.NUnitTestRunner.UserMethodFailure+Tags inherit obj
+WoofWare.NUnitTestRunner.UserMethodFailure+Tags.ReturnedNonUnit [static field]: int = 0
+WoofWare.NUnitTestRunner.UserMethodFailure+Tags.Threw [static field]: int = 1
+WoofWare.NUnitTestRunner.UserMethodFailure+Threw inherit WoofWare.NUnitTestRunner.UserMethodFailure
+WoofWare.NUnitTestRunner.UserMethodFailure+Threw.get_Item2 [method]: unit -> System.Exception
+WoofWare.NUnitTestRunner.UserMethodFailure+Threw.get_name [method]: unit -> string
+WoofWare.NUnitTestRunner.UserMethodFailure+Threw.Item2 [property]: [read-only] System.Exception
+WoofWare.NUnitTestRunner.UserMethodFailure+Threw.name [property]: [read-only] string
+WoofWare.NUnitTestRunner.UserMethodFailure.get_IsReturnedNonUnit [method]: unit -> bool
+WoofWare.NUnitTestRunner.UserMethodFailure.get_IsThrew [method]: unit -> bool
+WoofWare.NUnitTestRunner.UserMethodFailure.get_Name [method]: unit -> string
+WoofWare.NUnitTestRunner.UserMethodFailure.get_Tag [method]: unit -> int
+WoofWare.NUnitTestRunner.UserMethodFailure.IsReturnedNonUnit [property]: [read-only] bool
+WoofWare.NUnitTestRunner.UserMethodFailure.IsThrew [property]: [read-only] bool
+WoofWare.NUnitTestRunner.UserMethodFailure.Name [property]: [read-only] string
+WoofWare.NUnitTestRunner.UserMethodFailure.NewReturnedNonUnit [static method]: (string, obj) -> WoofWare.NUnitTestRunner.UserMethodFailure
+WoofWare.NUnitTestRunner.UserMethodFailure.NewThrew [static method]: (string, System.Exception) -> WoofWare.NUnitTestRunner.UserMethodFailure
+WoofWare.NUnitTestRunner.UserMethodFailure.Tag [property]: [read-only] int

WoofWare.NUnitTestRunner.Lib/TestFixture.fs

@@ -1,25 +1,14 @@
-namespace TestRunner
+namespace WoofWare.NUnitTestRunner
 
 open System
+open System.Collections
 open System.Diagnostics
 open System.IO
 open System.Reflection
 open System.Threading
+open System.Threading.Tasks
 open Microsoft.FSharp.Core
 
-type private StdoutSetter (newStdout : StreamWriter, newStderr : StreamWriter) =
-    let oldStdout = Console.Out
-    let oldStderr = Console.Error
-
-    do
-        Console.SetOut newStdout
-        Console.SetError newStderr
-
-    interface IDisposable with
-        member _.Dispose () =
-            Console.SetOut oldStdout
-            Console.SetError oldStderr
-
 /// Information about the circumstances of a run of a single test.
 type IndividualTestRunMetadata =
     {
@@ -79,6 +68,8 @@ module TestFixture =
     ///
     /// This function does not throw.
     let private runOne
+        (outputId : OutputStreamId)
+        (contexts : TestContexts)
         (setUp : MethodInfo list)
         (tearDown : MethodInfo list)
         (testId : Guid)
@@ -111,13 +102,6 @@ module TestFixture =
 
         let start = DateTimeOffset.Now
 
-        use stdOutStream = new MemoryStream ()
-        use stdErrStream = new MemoryStream ()
-        use stdOut = new StreamWriter (stdOutStream)
-        use stdErr = new StreamWriter (stdErrStream)
-
-        use _ = new StdoutSetter (stdOut, stdErr)
-
         let sw = Stopwatch.StartNew ()
 
         let metadata () =
@@ -138,13 +122,13 @@ module TestFixture =
                 TestName = name
                 ClassName = test.DeclaringType.FullName
                 StdOut =
-                    match stdOutStream.ToArray () with
-                    | [||] -> None
-                    | arr -> Console.OutputEncoding.GetString arr |> Some
+                    match contexts.DumpStdout outputId with
+                    | "" -> None
+                    | v -> Some v
                 StdErr =
-                    match stdErrStream.ToArray () with
-                    | [||] -> None
-                    | arr -> Console.OutputEncoding.GetString arr |> Some
+                    match contexts.DumpStderr outputId with
+                    | "" -> None
+                    | v -> Some v
             }
 
         let setUpResult = runMethods TestFailure.SetUpFailed setUp [||]
@@ -168,8 +152,6 @@ module TestFixture =
                 | "NUnit.Framework.IgnoreException" -> Ok (Some (TestMemberSuccess.Ignored (Option.ofObj exc.Message)))
                 | "NUnit.Framework.InconclusiveException" ->
                     Ok (Some (TestMemberSuccess.Inconclusive (Option.ofObj exc.Message)))
-                | s when s.StartsWith ("NUnit.Framework.", StringComparison.Ordinal) ->
-                    failwith $"Unrecognised special exception: %s{s}"
                 | _ -> Error orig
             | Error orig -> Error orig
 
@@ -224,12 +206,37 @@ module TestFixture =
     /// This method should never throw: it only throws if there's a critical logic error in the runner.
     /// Exceptions from the units under test are wrapped up and passed out.
     let private runTestsFromMember
+        (contexts : TestContexts)
+        (par : ParallelQueue)
+        (running : TestFixtureSetupToken)
+        (progress : ITestProgress)
         (setUp : MethodInfo list)
         (tearDown : MethodInfo list)
         (containingObject : obj)
         (test : SingleTestMethod)
-        : (Result<TestMemberSuccess, TestMemberFailure> * IndividualTestRunMetadata) list
+        : (Result<TestMemberSuccess, TestMemberFailure> * IndividualTestRunMetadata) Task list
         =
+        if test.Method.ContainsGenericParameters then
+            let failureMetadata =
+                {
+                    Total = TimeSpan.Zero
+                    Start = DateTimeOffset.Now
+                    End = DateTimeOffset.Now
+                    ComputerName = Environment.MachineName
+                    ExecutionId = Guid.NewGuid ()
+                    TestId = Guid.NewGuid ()
+                    TestName = test.Name
+                    ClassName = test.Method.DeclaringType.FullName
+                    StdErr = None
+                    StdOut = None
+                }
+
+            let error =
+                TestMemberFailure.Malformed [ "Test contained generic parameters; generics are not supported." ]
+
+            (Error error, failureMetadata) |> Task.FromResult |> List.singleton
+        else
+
         let resultPreRun =
             (None, test.Modifiers)
             ||> List.fold (fun _result modifier ->
@@ -243,17 +250,12 @@ module TestFixture =
                 | Modifier.Ignored reason -> Some (TestMemberSuccess.Ignored reason)
             )
 
-        let sw = Stopwatch.StartNew ()
-        let startTime = DateTimeOffset.Now
-
         match resultPreRun with
         | Some result ->
-            sw.Stop ()
-
             let failureMetadata =
                 {
-                    Total = sw.Elapsed
-                    Start = startTime
+                    Total = TimeSpan.Zero
+                    Start = DateTimeOffset.Now
                     End = DateTimeOffset.Now
                     ComputerName = Environment.MachineName
                     ExecutionId = Guid.NewGuid ()
@@ -265,7 +267,7 @@ module TestFixture =
                     StdOut = None
                 }
 
-            [ Ok result, failureMetadata ]
+            (Ok result, failureMetadata) |> Task.FromResult |> List.singleton
         | None ->
 
         let individualTests =
@@ -328,10 +330,11 @@ module TestFixture =
 
                             // Might not be an IEnumerable of a reference type.
                             // Concretely, `FSharpList<HttpStatusCode> :> IEnumerable<obj>` fails.
-                            for arg in args.GetValue (null : obj) :?> System.Collections.IEnumerable do
+                            for arg in args.GetValue (null : obj) :?> IEnumerable do
                                 yield
                                     Guid.NewGuid (),
                                     match arg with
+                                    | null -> [| (null : obj) |]
                                     | :? Tuple<obj, obj> as (a, b) -> [| a ; b |]
                                     | :? Tuple<obj, obj, obj> as (a, b, c) -> [| a ; b ; c |]
                                     | :? Tuple<obj, obj, obj, obj> as (a, b, c, d) -> [| a ; b ; c ; d |]
@@ -350,20 +353,19 @@ module TestFixture =
                                             if isNull argsMem then
                                                 failwith "Unexpectedly could not call `.Arguments` on TestCaseData"
 
+                                            // TODO: need to capture this stdout/stderr
                                             (argsMem.Invoke (arg, [||]) |> unbox<obj[]>)
                                         else
                                             [| arg |]
                     ]
                     |> Ok
 
-        sw.Stop ()
-
         match individualTests with
         | Error e ->
             let failureMetadata =
                 {
-                    Total = sw.Elapsed
-                    Start = startTime
+                    Total = TimeSpan.Zero
+                    Start = DateTimeOffset.Now
                     End = DateTimeOffset.Now
                     ComputerName = Environment.MachineName
                     ExecutionId = Guid.NewGuid ()
@@ -376,7 +378,7 @@ module TestFixture =
                     StdOut = None
                 }
 
-            [ Error e, failureMetadata ]
+            (Error e, failureMetadata) |> Task.FromResult |> List.singleton
         | Ok individualTests ->
 
         let count = test.Repeat |> Option.defaultValue 1
@@ -384,149 +386,256 @@ module TestFixture =
         Seq.init count (fun _ -> individualTests)
         |> Seq.concat
         |> Seq.map (fun (testGuid, args) ->
-            let results, summary =
-                runOne setUp tearDown testGuid test.Method containingObject args
+            task {
+                let runMe () =
+                    progress.OnTestMemberStart test.Name
+                    let oldValue = contexts.AsyncLocal.Value
+                    let outputId = contexts.NewOutputs ()
+                    contexts.AsyncLocal.Value <- outputId
 
-            match results with
-            | Ok results -> Ok results, summary
-            | Error e -> Error (TestMemberFailure.Failed e), summary
+                    let result, meta =
+                        runOne outputId contexts setUp tearDown testGuid test.Method containingObject args
+
+                    contexts.AsyncLocal.Value <- oldValue
+                    progress.OnTestMemberFinished test.Name
+
+                    result, meta
+
+                let! results, summary = par.Run running test.Parallelize runMe
+
+                match results with
+                | Ok results -> return Ok results, summary
+                | Error e -> return Error (TestMemberFailure.Failed e), summary
+            }
         )
         |> Seq.toList
 
     /// Run every test (except those which fail the `filter`) in this test fixture, as well as the
     /// appropriate setup and tear-down logic.
-    let run
+    let runOneFixture
+        (contexts : TestContexts)
+        (par : ParallelQueue)
         (progress : ITestProgress)
         (filter : TestFixture -> SingleTestMethod -> bool)
+        (name : string)
+        (containingObject : obj)
         (tests : TestFixture)
-        : FixtureRunResults
+        : FixtureRunResults Task
         =
-        progress.OnTestFixtureStart tests.Name tests.Tests.Length
+        task {
+            let! running = par.StartTestFixture tests
+            progress.OnTestFixtureStart name tests.Tests.Length
 
-        let containingObject =
-            let methods =
-                seq {
-                    match tests.OneTimeSetUp with
-                    | None -> ()
-                    | Some t -> yield t
+            let oldWorkDir = Environment.CurrentDirectory
+            Environment.CurrentDirectory <- FileInfo(tests.ContainingAssembly.Location).Directory.FullName
 
-                    match tests.OneTimeTearDown with
-                    | None -> ()
-                    | Some t -> yield t
+            let sw = Stopwatch.StartNew ()
+            let startTime = DateTimeOffset.UtcNow
 
-                    yield! tests.Tests |> Seq.map (fun t -> t.Method)
+            let endMetadata (outputId : OutputStreamId) =
+                let stdOut = contexts.DumpStdout outputId
+                let stdErr = contexts.DumpStderr outputId
+
+                {
+                    Total = sw.Elapsed
+                    Start = startTime
+                    End = DateTimeOffset.UtcNow
+                    ComputerName = Environment.MachineName
+                    ExecutionId = Guid.NewGuid ()
+                    TestId = Guid.NewGuid ()
+                    // This one is a bit dubious, because we don't actually have a test name at all
+                    TestName = name
+                    ClassName = tests.Name
+                    StdOut = if String.IsNullOrEmpty stdOut then None else Some stdOut
+                    StdErr = if String.IsNullOrEmpty stdErr then None else Some stdErr
                 }
 
-            methods
-            |> Seq.tryPick (fun mi ->
-                if not mi.IsStatic then
-                    Some (Activator.CreateInstance mi.DeclaringType)
-                else
-                    None
-            )
-            |> Option.toObj
+            let! setupResult, running =
+                match tests.OneTimeSetUp with
+                | Some su ->
+                    par.RunTestSetup
+                        running
+                        (fun () ->
+                            let oldValue = contexts.AsyncLocal.Value
+                            let newOutputs = contexts.NewOutputs ()
+                            contexts.AsyncLocal.Value <- newOutputs
 
-        let oldWorkDir = Environment.CurrentDirectory
-        Environment.CurrentDirectory <- FileInfo(tests.ContainingAssembly.Location).Directory.FullName
+                            let result =
+                                try
+                                    match su.Invoke (containingObject, [||]) with
+                                    | :? unit -> None
+                                    | ret ->
+                                        Some (UserMethodFailure.ReturnedNonUnit (su.Name, ret), endMetadata newOutputs)
+                                with :? TargetInvocationException as e ->
+                                    Some (UserMethodFailure.Threw (su.Name, e.InnerException), endMetadata newOutputs)
 
-        let sw = Stopwatch.StartNew ()
-        let startTime = DateTimeOffset.UtcNow
+                            contexts.AsyncLocal.Value <- oldValue
 
-        use stdOutStream = new MemoryStream ()
-        use stdOut = new StreamWriter (stdOutStream)
-        use stdErrStream = new MemoryStream ()
-        use stdErr = new StreamWriter (stdErrStream)
-        use _ = new StdoutSetter (stdOut, stdErr)
+                            match result with
+                            | None -> Ok (Some newOutputs)
+                            | Some err -> Error (err, newOutputs)
+                        )
+                | _ -> Task.FromResult (Ok None, TestFixtureSetupToken.vouchNoSetupRequired running)
 
-        let endMetadata () =
-            let stdOut = stdOutStream.ToArray () |> Console.OutputEncoding.GetString
-            let stdErr = stdErrStream.ToArray () |> Console.OutputEncoding.GetString
+            let testFailures = ResizeArray<TestMemberFailure * IndividualTestRunMetadata> ()
 
-            {
-                Total = sw.Elapsed
-                Start = startTime
-                End = DateTimeOffset.UtcNow
-                ComputerName = Environment.MachineName
-                ExecutionId = Guid.NewGuid ()
-                TestId = Guid.NewGuid ()
-                // This one is a bit dubious, because we don't actually have a test name at all
-                TestName = tests.Name
-                ClassName = tests.Name
-                StdOut = if String.IsNullOrEmpty stdOut then None else Some stdOut
-                StdErr = if String.IsNullOrEmpty stdErr then None else Some stdErr
-            }
+            let successes =
+                ResizeArray<SingleTestMethod * TestMemberSuccess * IndividualTestRunMetadata> ()
 
-        let setupResult =
-            match tests.OneTimeSetUp with
-            | Some su ->
-                try
-                    match su.Invoke (containingObject, [||]) with
-                    | :? unit -> None
-                    | ret -> Some (UserMethodFailure.ReturnedNonUnit (su.Name, ret), endMetadata ())
-                with :? TargetInvocationException as e ->
-                    Some (UserMethodFailure.Threw (su.Name, e.InnerException), endMetadata ())
-            | _ -> None
+            let testsRun =
+                match setupResult with
+                | Error _ ->
+                    // Don't run any tests if setup failed.
+                    Task.FromResult ()
+                | Ok _ ->
+                    tests.Tests
+                    |> Seq.filter (fun test ->
+                        if filter tests test then
+                            true
+                        else
+                            progress.OnTestMemberSkipped test.Name
+                            false
+                    )
+                    |> Seq.map (fun test ->
+                        task {
+                            let testSuccess = ref 0
 
-        let testFailures = ResizeArray<TestMemberFailure * IndividualTestRunMetadata> ()
+                            let results =
+                                runTestsFromMember
+                                    contexts
+                                    par
+                                    running
+                                    progress
+                                    tests.SetUp
+                                    tests.TearDown
+                                    containingObject
+                                    test
 
-        let successes =
-            ResizeArray<SingleTestMethod * TestMemberSuccess * IndividualTestRunMetadata> ()
+                            let! result =
+                                results
+                                |> List.map (fun t ->
+                                    task {
+                                        let! result, report = t
 
-        match setupResult with
-        | Some _ ->
-            // Don't run any tests if setup failed.
-            ()
-        | None ->
-            for test in tests.Tests do
-                if filter tests test then
-                    progress.OnTestMemberStart test.Name
-                    let testSuccess = ref 0
+                                        match result with
+                                        | Error failure ->
+                                            testFailures.Add (failure, report)
+                                            progress.OnTestFailed test.Name failure
+                                        | Ok result ->
+                                            Interlocked.Increment testSuccess |> ignore<int>
+                                            lock successes (fun () -> successes.Add (test, result, report))
+                                    }
+                                )
+                                |> Task.WhenAll
 
-                    let results = runTestsFromMember tests.SetUp tests.TearDown containingObject test
+                            result |> Array.iter id
+                        }
+                    )
+                    |> Task.WhenAll
+                    |> fun t ->
+                        task {
+                            let! t = t
+                            return t |> Array.iter id
+                        }
 
-                    for result, report in results do
-                        match result with
-                        | Error failure ->
-                            testFailures.Add (failure, report)
-                            progress.OnTestFailed test.Name failure
-                        | Ok result ->
-                            Interlocked.Increment testSuccess |> ignore<int>
-                            lock successes (fun () -> successes.Add (test, result, report))
+            do! testsRun
 
-                    progress.OnTestMemberFinished test.Name
-                else
-                    progress.OnTestMemberSkipped test.Name
+            // Unconditionally run OneTimeTearDown if it exists.
+            let! tearDownError, tornDown =
+                match tests.OneTimeTearDown with
+                | Some td ->
+                    par.RunTestTearDown
+                        running
+                        (fun () ->
+                            let oldValue = contexts.AsyncLocal.Value
+                            let outputs = contexts.NewOutputs ()
+                            contexts.AsyncLocal.Value <- outputs
 
-        // Unconditionally run OneTimeTearDown if it exists.
-        let tearDownError =
-            match tests.OneTimeTearDown with
-            | Some td ->
-                try
-                    match td.Invoke (containingObject, [||]) with
-                    | null -> None
-                    | ret -> Some (UserMethodFailure.ReturnedNonUnit (td.Name, ret), endMetadata ())
-                with :? TargetInvocationException as e ->
-                    Some (UserMethodFailure.Threw (td.Name, e), endMetadata ())
-            | _ -> None
+                            let result =
+                                try
+                                    match td.Invoke (containingObject, [||]) with
+                                    | :? unit -> None
+                                    | ret ->
+                                        Some (UserMethodFailure.ReturnedNonUnit (td.Name, ret), endMetadata outputs)
+                                with :? TargetInvocationException as e ->
+                                    Some (UserMethodFailure.Threw (td.Name, e.InnerException), endMetadata outputs)
 
-        Environment.CurrentDirectory <- oldWorkDir
+                            contexts.AsyncLocal.Value <- oldValue
 
-        {
-            Failed = testFailures |> Seq.toList
-            Success = successes |> Seq.toList
-            OtherFailures = [ tearDownError ; setupResult ] |> List.choose id
+                            match result with
+                            | None -> Ok (Some outputs)
+                            | Some err -> Error (err, outputs)
+                        )
+                | _ -> Task.FromResult (Ok None, TestFixtureTearDownToken.vouchNoTearDownRequired running)
+
+            Environment.CurrentDirectory <- oldWorkDir
+
+            do! par.EndTestFixture tornDown
+
+            // TODO: we have access to stdout/err of OneTimeSetUp and OneTimeTearDown here, but we throw them away.
+            return
+                {
+                    Failed = testFailures |> Seq.toList
+                    Success = successes |> Seq.toList
+                    OtherFailures =
+                        [ tearDownError ; setupResult ]
+                        |> List.choose (
+                            function
+                            | Error (e, _) -> Some e
+                            | Ok _ -> None
+                        )
+                }
         }
 
     /// Interpret this type as a [<TestFixture>], extracting the test members from it and annotating them with all
     /// relevant information about how we should run them.
     let parse (parentType : Type) : TestFixture =
-        let categories =
-            parentType.CustomAttributes
-            |> Seq.filter (fun attr -> attr.AttributeType.FullName = "NUnit.Framework.CategoryAttribute")
-            |> Seq.map (fun attr -> attr.ConstructorArguments |> Seq.exactlyOne |> _.Value |> unbox<string>)
-            |> Seq.toList
+        let categories, args, par =
+            (([], [], None), parentType.CustomAttributes)
+            ||> Seq.fold (fun (categories, args, par) attr ->
+                match attr.AttributeType.FullName with
+                | "NUnit.Framework.SetUpFixtureAttribute" ->
+                    failwith "This test runner does not support SetUpFixture. Please shout if you want this."
+                | "NUnit.Framework.CategoryAttribute" ->
+                    let cat = attr.ConstructorArguments |> Seq.exactlyOne |> _.Value |> unbox<string>
+                    cat :: categories, args, par
+                | "NUnit.Framework.TestFixtureAttribute" ->
+                    let newArgs =
+                        match attr.ConstructorArguments |> Seq.map _.Value |> Seq.toList with
+                        | [ :? ICollection as x ] ->
+                            x |> Seq.cast<CustomAttributeTypedArgument> |> Seq.map _.Value |> Seq.toList
+                        | xs -> xs
 
-        (TestFixture.Empty parentType.Assembly parentType.Name, parentType.GetRuntimeMethods ())
+                    categories, newArgs :: args, par
+                | "NUnit.Framework.NonParallelizableAttribute" ->
+                    match par with
+                    | Some _ -> failwith $"Got multiple parallelism attributes on %s{parentType.FullName}"
+                    | None -> categories, args, Some Parallelizable.No
+                | "NUnit.Framework.ParallelizableAttribute" ->
+                    match par with
+                    | Some _ -> failwith $"Got multiple parallelism attributes on %s{parentType.FullName}"
+                    | None ->
+                        match attr.ConstructorArguments |> Seq.toList with
+                        | [] -> categories, args, Some (Parallelizable.Yes ClassParallelScope.Self)
+                        | [ v ] ->
+                            match v.Value with
+                            | :? int as v ->
+                                match v with
+                                | 512 -> categories, args, Some (Parallelizable.Yes ClassParallelScope.Fixtures)
+                                | 256 -> categories, args, Some (Parallelizable.Yes ClassParallelScope.Children)
+                                | 257 -> categories, args, Some (Parallelizable.Yes ClassParallelScope.All)
+                                | 1 -> categories, args, Some (Parallelizable.Yes ClassParallelScope.Self)
+                                | v ->
+                                    failwith
+                                        $"Could not recognise value %i{v} of parallel scope in %s{parentType.FullName}"
+                            | v ->
+                                failwith
+                                    $"Unexpectedly non-int value %O{v} of parallel scope in %s{parentType.FullName}"
+                        | _ -> failwith $"unexpectedly got multiple args to Parallelizable on %s{parentType.FullName}"
+                | _ -> categories, args, par
+            )
+
+        (TestFixture.Empty parentType par args, parentType.GetRuntimeMethods ())
         ||> Seq.fold (fun state mi ->
             ((state, []), mi.CustomAttributes)
             ||> Seq.fold (fun (state, unrecognisedAttrs) attr ->
@@ -596,3 +705,56 @@ module TestFixture =
 
                 state
         )
+
+    /// Run every test (except those which fail the `filter`) in this test fixture, as well as the
+    /// appropriate setup and tear-down logic.
+    let run
+        (contexts : TestContexts)
+        (par : ParallelQueue)
+        (progress : ITestProgress)
+        (filter : TestFixture -> SingleTestMethod -> bool)
+        (tests : TestFixture)
+        : FixtureRunResults list Task
+        =
+        match tests.Parameters with
+        | [] -> [ null ]
+        | args -> args |> List.map List.toArray
+        |> List.map (fun args ->
+            let containingObject =
+                let methods =
+                    seq {
+                        match tests.OneTimeSetUp with
+                        | None -> ()
+                        | Some t -> yield t
+
+                        match tests.OneTimeTearDown with
+                        | None -> ()
+                        | Some t -> yield t
+
+                        yield! tests.Tests |> Seq.map (fun t -> t.Method)
+                    }
+
+                methods
+                |> Seq.tryPick (fun mi ->
+                    if not mi.IsStatic then
+                        Some (Activator.CreateInstance (mi.DeclaringType, args))
+                    else
+                        None
+                )
+                |> Option.toObj
+
+            let name =
+                if isNull args then
+                    tests.Name
+                else
+                    let args = args |> Seq.map (fun o -> o.ToString ()) |> String.concat ","
+                    $"%s{tests.Name}(%s{args})"
+
+            runOneFixture contexts par progress filter name containingObject tests
+        )
+        |> Task.WhenAll
+        |> fun t ->
+            task {
+                let! t = t
+                return Array.toList t
+            }

WoofWare.NUnitTestRunner.Lib/TestProgress.fs

@@ -1,4 +1,4 @@
-namespace TestRunner
+namespace WoofWare.NUnitTestRunner
 
 open System
 

WoofWare.NUnitTestRunner.Lib/TrxReport.fs

@@ -1,8 +1,13 @@
-namespace TestRunner
+namespace WoofWare.NUnitTestRunner
 
 open System
 open System.Xml
 
+[<RequireQualifiedAccess>]
+module private XmlUtil =
+    [<Literal>]
+    let NS = "http://microsoft.com/schemas/VisualStudio/TeamTest/2010"
+
 /// Describes the times at which a complete test run went through state transitions.
 /// These all have semantics specific to the test runner, and I have not rigorously worked out what
 /// semantics NUnit has, so take these with considerable amounts of salt.
@@ -22,8 +27,7 @@ type TrxReportTimes =
     }
 
     member internal this.toXml (doc : XmlDocument) : XmlNode =
-        let node =
-            doc.CreateElement ("Times", "http://microsoft.com/schemas/VisualStudio/TeamTest/2010")
+        let node = doc.CreateElement ("Times", XmlUtil.NS)
 
         do
             let attr = doc.CreateAttribute "creation"
@@ -113,7 +117,7 @@ type TrxDeployment =
     }
 
     member internal this.toXml (doc : XmlDocument) : XmlNode =
-        let node = doc.CreateElement "Deployment"
+        let node = doc.CreateElement ("Deployment", XmlUtil.NS)
 
         do
             let attr = doc.CreateAttribute "runDeploymentRoot"
@@ -149,7 +153,7 @@ type TrxTestSettings =
     }
 
     member internal this.toXml (doc : XmlDocument) : XmlNode =
-        let node = doc.CreateElement "TestSettings"
+        let node = doc.CreateElement ("TestSettings", XmlUtil.NS)
 
         do
             let attr = doc.CreateAttribute "name"
@@ -243,13 +247,13 @@ type TrxErrorInfo =
     }
 
     member internal this.toXml (doc : XmlDocument) : XmlNode =
-        let node = doc.CreateElement "ErrorInfo"
+        let node = doc.CreateElement ("ErrorInfo", XmlUtil.NS)
 
         match this.Message with
         | None -> ()
         | Some message ->
             let child = doc.CreateTextNode message
-            let messageNode = doc.CreateElement "Message"
+            let messageNode = doc.CreateElement ("Message", XmlUtil.NS)
             messageNode.AppendChild child |> ignore<XmlNode>
             node.AppendChild messageNode |> ignore<XmlNode>
 
@@ -257,7 +261,7 @@ type TrxErrorInfo =
         | None -> ()
         | Some stackTrace ->
             let child = doc.CreateTextNode stackTrace
-            let stackTraceNode = doc.CreateElement "StackTrace"
+            let stackTraceNode = doc.CreateElement ("StackTrace", XmlUtil.NS)
             stackTraceNode.AppendChild child |> ignore<XmlNode>
             node.AppendChild stackTraceNode |> ignore<XmlNode>
 
@@ -286,18 +290,28 @@ type TrxOutput =
     {
         /// What the entity printed to standard output.
         StdOut : string option
+        /// What the entity printed to standard error.
+        StdErr : string option
         /// Description of any error the entity encountered.
         ErrorInfo : TrxErrorInfo option
     }
 
     member internal this.toXml (doc : XmlDocument) : XmlNode =
-        let node = doc.CreateElement "Output"
+        let node = doc.CreateElement ("Output", XmlUtil.NS)
 
         match this.StdOut with
         | None -> ()
         | Some stdout ->
             let text = doc.CreateTextNode stdout
-            let childNode = doc.CreateElement "StdOut"
+            let childNode = doc.CreateElement ("StdOut", XmlUtil.NS)
+            childNode.AppendChild text |> ignore<XmlNode>
+            node.AppendChild childNode |> ignore<XmlNode>
+
+        match this.StdErr with
+        | None -> ()
+        | Some stderr ->
+            let text = doc.CreateTextNode stderr
+            let childNode = doc.CreateElement ("StdErr", XmlUtil.NS)
             childNode.AppendChild text |> ignore<XmlNode>
             node.AppendChild childNode |> ignore<XmlNode>
 
@@ -313,6 +327,11 @@ type TrxOutput =
             | NodeWithNamedChild "StdOut" (OneChildNode "StdOut" (NoChildrenNode stdout)) -> Some stdout
             | _ -> None
 
+        let stderr =
+            match node with
+            | NodeWithNamedChild "StdErr" (OneChildNode "StdErr" (NoChildrenNode stdout)) -> Some stdout
+            | _ -> None
+
         let errorInfo =
             match node with
             | NodeWithNamedChild "ErrorInfo" node ->
@@ -326,6 +345,7 @@ type TrxOutput =
         | Ok errorInfo ->
             {
                 StdOut = stdout
+                StdErr = stderr
                 ErrorInfo = errorInfo
             }
             |> Ok
@@ -362,7 +382,7 @@ type TrxUnitTestResult =
     }
 
     member internal this.toXml (doc : XmlDocument) : XmlNode =
-        let node = doc.CreateElement "UnitTestResult"
+        let node = doc.CreateElement ("UnitTestResult", XmlUtil.NS)
 
         do
             let attr = doc.CreateAttribute "executionId"
@@ -582,7 +602,7 @@ type TrxTestMethod =
     }
 
     member internal this.toXml (doc : XmlDocument) : XmlNode =
-        let node = doc.CreateElement "TestMethod"
+        let node = doc.CreateElement ("TestMethod", XmlUtil.NS)
 
         do
             let attr = doc.CreateAttribute "codeBase"
@@ -668,7 +688,7 @@ type TrxExecution =
     }
 
     member internal this.toXml (doc : XmlDocument) : XmlNode =
-        let node = doc.CreateElement "Execution"
+        let node = doc.CreateElement ("Execution", XmlUtil.NS)
 
         do
             let attr = doc.CreateAttribute "id"
@@ -723,7 +743,7 @@ type TrxUnitTest =
     }
 
     member internal this.toXml (doc : XmlDocument) : XmlNode =
-        let node = doc.CreateElement "UnitTest"
+        let node = doc.CreateElement ("UnitTest", XmlUtil.NS)
 
         do
             let attr = doc.CreateAttribute "name"
@@ -821,7 +841,7 @@ type TrxTestEntry =
     }
 
     member internal this.toXml (doc : XmlDocument) : XmlNode =
-        let node = doc.CreateElement "TestEntry"
+        let node = doc.CreateElement ("TestEntry", XmlUtil.NS)
 
         do
             let attr = doc.CreateAttribute "testListId"
@@ -905,7 +925,7 @@ type TrxTestListEntry =
     }
 
     member internal this.toXml (doc : XmlDocument) : XmlNode =
-        let node = doc.CreateElement "TestList"
+        let node = doc.CreateElement ("TestList", XmlUtil.NS)
 
         do
             let attr = doc.CreateAttribute "name"
@@ -998,7 +1018,7 @@ type TrxRunInfo =
     }
 
     member internal this.toXml (doc : XmlDocument) : XmlNode =
-        let node = doc.CreateElement "RunInfo"
+        let node = doc.CreateElement ("RunInfo", XmlUtil.NS)
 
         do
             let attr = doc.CreateAttribute "computerName"
@@ -1015,7 +1035,7 @@ type TrxRunInfo =
             attr.Value <- this.Timestamp.ToString "o"
             node.Attributes.Append attr |> ignore<XmlAttribute>
 
-        let childNode = doc.CreateElement "Text"
+        let childNode = doc.CreateElement ("Text", XmlUtil.NS)
         let textNode = doc.CreateTextNode this.Text
         childNode.AppendChild textNode |> ignore<XmlNode>
         node.AppendChild childNode |> ignore<XmlNode>
@@ -1154,7 +1174,7 @@ type TrxCounters =
         }
 
     member internal this.toXml (doc : XmlDocument) : XmlNode =
-        let node = doc.CreateElement "Counters"
+        let node = doc.CreateElement ("Counters", XmlUtil.NS)
 
         do
             let attr = doc.CreateAttribute "total"
@@ -1475,7 +1495,7 @@ type TrxResultsSummary =
     }
 
     member internal this.toXml (doc : XmlDocument) : XmlNode =
-        let node = doc.CreateElement "ResultSummary"
+        let node = doc.CreateElement ("ResultSummary", XmlUtil.NS)
 
         do
             let attr = doc.CreateAttribute "outcome"
@@ -1486,7 +1506,7 @@ type TrxResultsSummary =
         node.AppendChild (this.Output.toXml doc) |> ignore<XmlNode>
 
         do
-            let runInfosNode = doc.CreateElement "RunInfos"
+            let runInfosNode = doc.CreateElement ("RunInfos", XmlUtil.NS)
 
             for runInfo in this.RunInfos do
                 runInfosNode.AppendChild (runInfo.toXml doc) |> ignore<XmlNode>
@@ -1575,8 +1595,7 @@ type TrxReport =
     }
 
     member internal this.toXml (doc : XmlDocument) : XmlNode =
-        let node =
-            doc.CreateElement ("TestRun", "http://microsoft.com/schemas/VisualStudio/TeamTest/2010")
+        let node = doc.CreateElement ("TestRun", XmlUtil.NS)
 
         do
             let attr = doc.CreateAttribute "id"
@@ -1592,7 +1611,7 @@ type TrxReport =
         node.AppendChild (this.Settings.toXml doc) |> ignore<XmlNode>
 
         do
-            let resultNode = doc.CreateElement "Results"
+            let resultNode = doc.CreateElement ("Results", XmlUtil.NS)
 
             for result in this.Results do
                 resultNode.AppendChild (result.toXml doc) |> ignore<XmlNode>
@@ -1600,7 +1619,7 @@ type TrxReport =
             node.AppendChild resultNode |> ignore<XmlNode>
 
         do
-            let defsNode = doc.CreateElement "TestDefinitions"
+            let defsNode = doc.CreateElement ("TestDefinitions", XmlUtil.NS)
 
             for result in this.TestDefinitions do
                 defsNode.AppendChild (result.toXml doc) |> ignore<XmlNode>
@@ -1608,7 +1627,7 @@ type TrxReport =
             node.AppendChild defsNode |> ignore<XmlNode>
 
         do
-            let testsNode = doc.CreateElement "TestEntries"
+            let testsNode = doc.CreateElement ("TestEntries", XmlUtil.NS)
 
             for result in this.TestEntries do
                 testsNode.AppendChild (result.toXml doc) |> ignore<XmlNode>
@@ -1616,7 +1635,7 @@ type TrxReport =
             node.AppendChild testsNode |> ignore<XmlNode>
 
         do
-            let listsNode = doc.CreateElement "TestLists"
+            let listsNode = doc.CreateElement ("TestLists", XmlUtil.NS)
 
             for result in this.TestLists do
                 listsNode.AppendChild (result.toXml doc) |> ignore<XmlNode>

WoofWare.NUnitTestRunner.Lib/WoofWare.NUnitTestRunner.Lib.fsproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-      <TargetFramework>netstandard2.1</TargetFramework>
+      <TargetFramework>net6.0</TargetFramework>
       <GenerateDocumentationFile>true</GenerateDocumentationFile>
       <Authors>Patrick Stevens</Authors>
       <Copyright>Copyright (c) Patrick Stevens 2024</Copyright>
@@ -14,17 +14,25 @@
       <PackageId>WoofWare.NUnitTestRunner.Lib</PackageId>
       <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
       <WarnOn>FS3559</WarnOn>
+      <WoofWareMyriadPluginVersion>2.1.44</WoofWareMyriadPluginVersion>
     </PropertyGroup>
 
     <ItemGroup>
       <Compile Include="AssemblyInfo.fs" />
+      <Compile Include="RuntimeConfig.fs" />
+      <Compile Include="GeneratedRuntimeConfig.fs">
+        <MyriadFile>RuntimeConfig.fs</MyriadFile>
+      </Compile>
+      <Compile Include="DotnetRuntime.fs" />
       <Compile Include="Array.fs" />
       <Compile Include="List.fs" />
       <Compile Include="Result.fs" />
       <Compile Include="Domain.fs" />
       <Compile Include="Filter.fs" />
+      <Compile Include="ParallelQueue.fs" />
       <Compile Include="SingleTestMethod.fs" />
       <Compile Include="TestProgress.fs" />
+      <Compile Include="Context.fs" />
       <Compile Include="TestFixture.fs" />
       <Compile Include="Xml.fs" />
       <Compile Include="TrxReport.fs" />
@@ -38,6 +46,14 @@
   <ItemGroup>
     <PackageReference Include="WoofWare.PrattParser" Version="0.1.2" />
     <PackageReference Update="FSharp.Core" Version="6.0.0" />
+    <PackageReference Include="WoofWare.DotnetRuntimeLocator" Version="0.1.4" />
+    <PackageReference Include="WoofWare.Myriad.Plugins.Attributes" Version="3.1.6" />
+    <PackageReference Include="Myriad.SDK" Version="0.8.3" />
+    <PackageReference Include="WoofWare.Myriad.Plugins" Version="$(WoofWareMyriadPluginVersion)" PrivateAssets="all" />
+  </ItemGroup>
+  
+  <ItemGroup>
+    <MyriadSdkGenerator Include="$(NuGetPackageRoot)/woofware.myriad.plugins/$(WoofWareMyriadPluginVersion)/lib/net6.0/WoofWare.Myriad.Plugins.dll" />
   </ItemGroup>
 
 </Project>

WoofWare.NUnitTestRunner.Lib/Xml.fs

@@ -1,4 +1,4 @@
-namespace TestRunner
+namespace WoofWare.NUnitTestRunner
 
 open System.Xml
 

WoofWare.NUnitTestRunner.Lib/version.json

@@ -1,6 +1,8 @@
 {
-  "version": "0.7-prerelease",
-  "publicReleaseRefSpec": ["^refs/heads/main$"],
+  "version": "0.13",
+  "publicReleaseRefSpec": [
+    "^refs/heads/main$"
+  ],
   "pathFilters": [
     "./",
     ":/Directory.Build.props",

WoofWare.NUnitTestRunner.sln

@@ -1,12 +1,12 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "TestRunner", "TestRunner\TestRunner.fsproj", "{D4CAE716-79EB-4174-B58C-54E66CF16536}"
-EndProject
-Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "TestRunner.Test", "TestRunner\TestRunner.Test\TestRunner.Test.fsproj", "{E776AC80-CD07-4A3E-9F85-1AEFBB56309D}"
+Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "WoofWare.NUnitTestRunner", "WoofWare.NUnitTestRunner\WoofWare.NUnitTestRunner.fsproj", "{D4CAE716-79EB-4174-B58C-54E66CF16536}"
 EndProject
 Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "Consumer", "Consumer\Consumer.fsproj", "{5C87D399-62EB-4A5F-8F6C-3FD6F1B31684}"
 EndProject
-Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "TestRunner.Lib", "TestRunner.Lib\TestRunner.Lib.fsproj", "{8C32F4B9-4CF3-4204-BD24-B32D7E64F5C4}"
+Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "WoofWare.NUnitTestRunner.Lib", "WoofWare.NUnitTestRunner.Lib\WoofWare.NUnitTestRunner.Lib.fsproj", "{8C32F4B9-4CF3-4204-BD24-B32D7E64F5C4}"
+EndProject
+Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "WoofWare.NUnitTestRunner.Test", "WoofWare.NUnitTestRunner\WoofWare.NUnitTestRunner.Test\WoofWare.NUnitTestRunner.Test.fsproj", "{443B01B3-2A8C-45CF-96D6-1D890EEA0533}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -18,10 +18,6 @@ Global
 		{D4CAE716-79EB-4174-B58C-54E66CF16536}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{D4CAE716-79EB-4174-B58C-54E66CF16536}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{D4CAE716-79EB-4174-B58C-54E66CF16536}.Release|Any CPU.Build.0 = Release|Any CPU
-		{E776AC80-CD07-4A3E-9F85-1AEFBB56309D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{E776AC80-CD07-4A3E-9F85-1AEFBB56309D}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{E776AC80-CD07-4A3E-9F85-1AEFBB56309D}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{E776AC80-CD07-4A3E-9F85-1AEFBB56309D}.Release|Any CPU.Build.0 = Release|Any CPU
 		{5C87D399-62EB-4A5F-8F6C-3FD6F1B31684}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{5C87D399-62EB-4A5F-8F6C-3FD6F1B31684}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{5C87D399-62EB-4A5F-8F6C-3FD6F1B31684}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -30,5 +26,9 @@ Global
 		{8C32F4B9-4CF3-4204-BD24-B32D7E64F5C4}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{8C32F4B9-4CF3-4204-BD24-B32D7E64F5C4}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{8C32F4B9-4CF3-4204-BD24-B32D7E64F5C4}.Release|Any CPU.Build.0 = Release|Any CPU
+		{443B01B3-2A8C-45CF-96D6-1D890EEA0533}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{443B01B3-2A8C-45CF-96D6-1D890EEA0533}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{443B01B3-2A8C-45CF-96D6-1D890EEA0533}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{443B01B3-2A8C-45CF-96D6-1D890EEA0533}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 EndGlobal

WoofWare.NUnitTestRunner/Program.fs

@@ -1,10 +1,9 @@
-namespace TestRunner
+namespace WoofWare.NUnitTestRunner
 
 open System
-open WoofWare.DotnetRuntimeLocator
 open System.IO
-open System.Reflection
-open System.Runtime.Loader
+open System.Threading.Tasks
+open Spectre.Console
 
 // Fix for https://github.com/Smaug123/unofficial-nunit-runner/issues/8
 // Set AppContext.BaseDirectory to where the test DLL is.
@@ -17,157 +16,195 @@ type SetBaseDir (testDll : FileInfo) =
         member _.Dispose () =
             AppContext.SetData ("APP_CONTEXT_BASE_DIRECTORY", oldBaseDir)
 
+[<RequireQualifiedAccess>]
+type LogLevel =
+    | Nothing
+    | Verbose
 
-type Ctx (dll : FileInfo, runtimes : DirectoryInfo list) =
-    inherit AssemblyLoadContext ()
-
-    override this.Load (target : AssemblyName) : Assembly =
-        let path = Path.Combine (dll.Directory.FullName, $"%s{target.Name}.dll")
-
-        if File.Exists path then
-            this.LoadFromAssemblyPath path
+[<AutoOpen>]
+module Patterns =
+    let (|Key|_|) (start : string) (s : string) : string option =
+        if s.StartsWith (start + "=", StringComparison.Ordinal) then
+            s.Substring (start.Length + 1) |> Some
         else
+            None
 
-        runtimes
-        |> List.tryPick (fun di ->
-            let path = Path.Combine (di.FullName, $"%s{target.Name}.dll")
+type Args =
+    {
+        Dll : FileInfo
+        Trx : FileInfo option
+        Filter : Filter option
+        Logging : LogLevel
+        LevelOfParallelism : int option
+        Timeout : TimeSpan option
+    }
 
-            if File.Exists path then
-                this.LoadFromAssemblyPath path |> Some
-            else
-                None
-        )
-        |> Option.defaultValue null
+    static member Parse (args : string list) : Args =
+        match args with
+        | [] -> failwith "The first arg must be a positional arg, the DLL to test."
+        | dll :: args ->
 
+        let rec go
+            (trx : FileInfo option)
+            (filter : Filter option)
+            (logging : LogLevel option)
+            (par : int option)
+            (timeout : TimeSpan option)
+            (args : string list)
+            =
+            match args with
+            | [] ->
+                {
+                    Dll = FileInfo dll
+                    Trx = trx
+                    Filter = filter
+                    Logging = logging |> Option.defaultValue LogLevel.Nothing
+                    LevelOfParallelism = par
+                    Timeout = timeout
+                }
+            | Key "--filter" filterStr :: rest
+            | "--filter" :: filterStr :: rest ->
+                match filter with
+                | Some _ -> failwith "Two conflicting filters; you can only specify --filter once"
+                | None -> go trx (Some (Filter.parse filterStr)) logging par timeout rest
+            | Key "--trx" trxStr :: rest
+            | "--trx" :: trxStr :: rest ->
+                match trx with
+                | Some _ -> failwith "Two conflicting TRX outputs; you can only specify --trx once"
+                | None -> go (Some (FileInfo trxStr)) filter logging par timeout rest
+            | Key "--verbose" verboseStr :: rest
+            | "--verbose" :: verboseStr :: rest ->
+                match logging with
+                | Some _ -> failwith "Two conflicting --verbose outputs; you can only specify --verbose once"
+                | None ->
+                    let verbose =
+                        if Boolean.Parse verboseStr then
+                            LogLevel.Verbose
+                        else
+                            LogLevel.Nothing
+
+                    go trx filter (Some verbose) par timeout rest
+            | Key "--parallelism" parStr :: rest
+            | "--parallelism" :: parStr :: rest ->
+                match par with
+                | Some _ -> failwith "Two conflicting --parallelism outputs; you can only specify --parallelism once"
+                | None -> go trx filter logging (Some (Int32.Parse parStr)) timeout rest
+            | Key "--timeout-seconds" timeoutStr :: rest
+            | "--timeout-seconds" :: timeoutStr :: rest ->
+                match timeout with
+                | Some _ ->
+                    failwith "Two conflicting --timeout-seconds outputs; you can only specify --timeout-seconds once"
+                | None -> go trx filter logging par (Some (TimeSpan.FromSeconds (Int32.Parse timeoutStr |> float))) rest
+            | k :: _rest -> failwith $"Unrecognised arg %s{k}"
+
+        go None None None None None args
 
 module Program =
-    let selectRuntime
-        (config : RuntimeOptions)
-        (f : DotnetEnvironmentInfo)
-        : Choice<DotnetEnvironmentFrameworkInfo, DotnetEnvironmentSdkInfo> option
-        =
-        let rollForward =
-            match Environment.GetEnvironmentVariable "DOTNET_ROLL_FORWARD" with
-            | null ->
-                config.RollForward
-                |> Option.map RollForward.Parse
-                |> Option.defaultValue RollForward.Minor
-            | s -> RollForward.Parse s
-
-        let desiredVersions =
-            match config.Framework with
-            | Some f -> [ Version f.Version, f.Name ]
-            | None ->
-
-            match config.Frameworks with
-            | Some f -> f |> List.map (fun f -> Version f.Version, f.Name)
-            | None ->
-                failwith
-                    "Could not deduce a framework version due to lack of either Framework or Frameworks in runtimeconfig"
-
-        let compatiblyNamedRuntimes =
-            f.Frameworks
-            |> Seq.collect (fun availableFramework ->
-                desiredVersions
-                |> List.choose (fun (desiredVersion, desiredName) ->
-                    if desiredName = availableFramework.Name then
-                        Some
-                            {|
-                                Desired = desiredVersion
-                                Name = desiredName
-                                Installed = availableFramework
-                                InstalledVersion = Version availableFramework.Version
-                            |}
-                    else
-                        None
-                )
-            )
-            |> Seq.toList
-
-        match rollForward with
-        | RollForward.Minor ->
-            let available =
-                compatiblyNamedRuntimes
-                |> Seq.filter (fun data ->
-                    data.InstalledVersion.Major = data.Desired.Major
-                    && data.InstalledVersion.Minor >= data.Desired.Minor
-                )
-                |> Seq.groupBy (fun data -> data.Name)
-                |> Seq.map (fun (name, data) ->
-                    let data =
-                        data
-                        |> Seq.minBy (fun data -> data.InstalledVersion.Minor, data.InstalledVersion.Build)
-
-                    name, data.Installed
-                )
-                // TODO: how do we select between many available frameworks?
-                |> Seq.tryHead
-
-            match available with
-            | Some (_, f) -> Some (Choice1Of2 f)
-            | None ->
-                // TODO: maybe we can ask the SDK. But we keep on trucking: maybe we're self-contained,
-                // and we'll actually find all the runtime next to the DLL.
-                None
-        | _ -> failwith "non-minor RollForward not supported yet; please shout if you want it"
-
-    let locateRuntimes (dll : FileInfo) : DirectoryInfo list =
-        let runtimeConfig =
-            let name =
-                if not (dll.Name.EndsWith (".dll", StringComparison.OrdinalIgnoreCase)) then
-                    failwith $"Expected DLL %s{dll.FullName} to end in .dll"
-
-                dll.Name.Substring (0, dll.Name.Length - 4)
-
-            Path.Combine (dll.Directory.FullName, $"%s{name}.runtimeconfig.json")
-            |> File.ReadAllText
-            |> System.Text.Json.Nodes.JsonNode.Parse
-            |> RuntimeConfig.jsonParse
-            |> fun f -> f.RuntimeOptions
-
-        let availableRuntimes = DotnetEnvironmentInfo.Get ()
-
-        let runtime = selectRuntime runtimeConfig availableRuntimes
-
-        match runtime with
-        | None ->
-            // Keep on trucking: let's be optimistic and hope that we're self-contained.
-            [ dll.Directory ]
-        | Some (Choice1Of2 runtime) -> [ dll.Directory ; DirectoryInfo runtime.Path ]
-        | Some (Choice2Of2 sdk) -> [ dll.Directory ; DirectoryInfo sdk.Path ]
-
     let main argv =
         let startTime = DateTimeOffset.Now
 
-        let testDll, filter, trxPath =
-            match argv |> List.ofSeq with
-            | [ dll ] -> FileInfo dll, None, None
-            | [ dll ; "--trx" ; trxPath ] -> FileInfo dll, None, Some (FileInfo trxPath)
-            | [ dll ; "--filter" ; filter ] -> FileInfo dll, Some (Filter.parse filter), None
-            | [ dll ; "--trx" ; trxPath ; "--filter" ; filter ] ->
-                FileInfo dll, Some (Filter.parse filter), Some (FileInfo trxPath)
-            | [ dll ; "--filter" ; filter ; "--trx" ; trxPath ] ->
-                FileInfo dll, Some (Filter.parse filter), Some (FileInfo trxPath)
-            | _ ->
-                failwith
-                    "provide exactly one arg, a test DLL; then optionally `--filter <filter>` and/or `--trx <output-filename>`."
+        let args = argv |> List.ofArray |> Args.Parse
 
         let filter =
-            match filter with
+            match args.Filter with
             | Some filter -> Filter.shouldRun filter
             | None -> fun _ _ -> true
 
-        let progress = Progress.spectre ()
+        let stderr =
+            let consoleSettings = AnsiConsoleSettings ()
+            consoleSettings.Out <- AnsiConsoleOutput Console.Error
+            AnsiConsole.Create consoleSettings
 
-        use _ = new SetBaseDir (testDll)
+        let progress = Progress.spectre stderr
 
-        let ctx = Ctx (testDll, locateRuntimes testDll)
-        let assy = ctx.LoadFromAssemblyPath testDll.FullName
+        let runtime = DotnetRuntime.locate args.Dll
+
+        match args.Logging with
+        | LogLevel.Nothing -> ()
+        | LogLevel.Verbose ->
+            for d in runtime do
+                stderr.WriteLine $".NET runtime directory: %s{d.FullName}"
+
+        use _ = new SetBaseDir (args.Dll)
+
+        use contexts = TestContexts.Empty ()
+
+        let ctx = LoadContext (args.Dll, runtime, contexts)
+        let assy = ctx.LoadFromAssemblyPath args.Dll.FullName
+
+        let levelOfParallelism, par =
+            ((None, None), assy.CustomAttributes)
+            ||> Seq.fold (fun (levelPar, par) attr ->
+                match attr.AttributeType.FullName with
+                | "NUnit.Framework.LevelOfParallelismAttribute" ->
+                    let arg = attr.ConstructorArguments |> Seq.exactlyOne |> _.Value |> unbox<int>
+
+                    match levelPar with
+                    | None -> (Some arg, par)
+                    | Some existing ->
+                        failwith $"Assembly %s{assy.Location} declares parallelism %i{arg} and also %i{existing}"
+                | "NUnit.Framework.NonParallelizableAttribute" ->
+                    match levelPar with
+                    | None -> (Some 1, par)
+                    | Some existing ->
+                        failwith
+                            $"Assembly %s{assy.Location} declares non-parallelizable and also parallelism %i{existing}"
+                | "NUnit.Framework.ParallelizableAttribute" ->
+                    match par with
+                    | Some _ -> failwith "Got multiple Parallelize attributes in assembly"
+                    | None ->
+                        match attr.ConstructorArguments |> Seq.toList with
+                        | [] -> levelPar, Some (Parallelizable.Yes AssemblyParallelScope.Fixtures)
+                        | [ v ] ->
+                            match v.Value with
+                            | :? int as v ->
+                                match v with
+                                | 512 -> levelPar, Some (Parallelizable.Yes AssemblyParallelScope.Fixtures)
+                                | 256 -> levelPar, Some (Parallelizable.Yes AssemblyParallelScope.Children)
+                                | 257 ->
+                                    failwith "ParallelScope.All is invalid on assemblies; only Fixtures or Children"
+                                | 1 ->
+                                    failwith "ParallelScope.Self is invalid on assemblies; only Fixtures or Children"
+                                | v -> failwith $"Could not recognise value %i{v} of parallel scope on assembly"
+                            | v -> failwith $"Unexpectedly non-int value %O{v} of parallel scope on assembly"
+                        | _ -> failwith "unexpectedly got multiple args to Parallelizable on assembly"
+                | _ -> levelPar, par
+            )
+
+        let levelOfParallelism =
+            match args.LevelOfParallelism, levelOfParallelism with
+            | None, None -> None
+            | Some taken, Some ignored ->
+                match args.Logging with
+                | LogLevel.Nothing -> ()
+                | LogLevel.Verbose ->
+                    stderr.WriteLine
+                        $"Taking parallelism %i{taken} from command line, ignoring value %i{ignored} from assembly"
+
+                Some taken
+            | Some x, None
+            | None, Some x -> Some x
 
         let testFixtures = assy.ExportedTypes |> Seq.map TestFixture.parse |> Seq.toList
 
+        use par = new ParallelQueue (levelOfParallelism, par)
+
         let creationTime = DateTimeOffset.Now
-        let results = testFixtures |> List.map (TestFixture.run progress filter)
+
+        let results =
+            testFixtures
+            |> List.map (TestFixture.run contexts par progress filter)
+            |> Task.WhenAll
+
+        let timeout =
+            match args.Timeout with
+            | None -> TimeSpan.FromHours 2.0
+            | Some t -> t
+
+        if not (results.Wait timeout) then
+            failwith "Tests failed to terminate within two hours"
+
+        let results = results.Result |> Seq.concat |> List.ofSeq
 
         let finishTime = DateTimeOffset.Now
         let finishTimeHumanReadable = finishTime.ToString @"yyyy-MM-dd HH:mm:ss"
@@ -270,6 +307,7 @@ module Program =
                 Output =
                     {
                         StdOut = None
+                        StdErr = None
                         ErrorInfo = None
                     }
                 RunInfos =
@@ -373,11 +411,11 @@ module Program =
                     Output =
                         match i.StdOut, i.StdErr, exc with
                         | None, None, None -> None
-                        // TODO surely stderr can be emitted
-                        | stdout, _stderr, exc ->
+                        | stdout, stderr, exc ->
                             Some
                                 {
                                     TrxOutput.StdOut = stdout
+                                    StdErr = stderr
                                     ErrorInfo = exc
                                 }
                 }
@@ -396,11 +434,12 @@ module Program =
                 ResultsSummary = resultSummary
             }
 
-        match trxPath with
+        match args.Trx with
         | Some trxPath ->
             let contents = TrxReport.toXml report |> fun d -> d.OuterXml
             trxPath.Directory.Create ()
             File.WriteAllText (trxPath.FullName, contents)
+            Console.Error.WriteLine $"Written TRX file: %s{trxPath.FullName}"
         | None -> ()
 
         match outcome with

WoofWare.NUnitTestRunner/Progress.fs

@@ -0,0 +1,24 @@
+namespace WoofWare.NUnitTestRunner
+
+open Spectre.Console
+
+[<RequireQualifiedAccess>]
+module Progress =
+    let spectre (console : IAnsiConsole) : ITestProgress =
+        { new ITestProgress with
+            member _.OnTestFailed name failure =
+                console.MarkupLine
+                    $"[red]Test '%s{Markup.Escape name}' failed: %s{Markup.Escape (failure.ToString ())}[/]"
+
+            member _.OnTestFixtureStart name testCount =
+                console.MarkupLine $"[white]Running tests: %s{Markup.Escape name}[/]"
+
+            member _.OnTestMemberFinished name =
+                console.MarkupLine $"[gray]Finished test: %s{Markup.Escape name}[/]"
+
+            member _.OnTestMemberSkipped name =
+                console.MarkupLine $"[yellow]Skipping test due to filter: %s{Markup.Escape name}[/]"
+
+            member _.OnTestMemberStart name =
+                console.MarkupLine $"[white]Running test: %s{Markup.Escape name}[/]"
+        }

WoofWare.NUnitTestRunner/Seq.fs

@@ -1,4 +1,4 @@
-namespace TestRunner
+namespace WoofWare.NUnitTestRunner
 
 [<RequireQualifiedAccess>]
 module internal Seq =

WoofWare.NUnitTestRunner/WoofWare.NUnitTestRunner.Test/EmbeddedResource.fs

@@ -1,4 +1,4 @@
-namespace TestRunner.Test
+namespace WoofWare.NUnitTestRunner.Test
 
 open System
 open System.IO

WoofWare.NUnitTestRunner/WoofWare.NUnitTestRunner.Test/TestFilter.fs

@@ -1,6 +1,6 @@
-namespace TestRunner.Test
+namespace WoofWare.NUnitTestRunner.Test
 
-open TestRunner
+open WoofWare.NUnitTestRunner
 open NUnit.Framework
 open FsUnitTyped
 

WoofWare.NUnitTestRunner/WoofWare.NUnitTestRunner.Test/TestList.fs

@@ -1,8 +1,8 @@
-namespace TestRunner.Test
+namespace WoofWare.NUnitTestRunner.Test
 
 open FsCheck
 open FsUnitTyped
-open TestRunner
+open WoofWare.NUnitTestRunner
 open NUnit.Framework
 
 [<TestFixture>]
@@ -11,6 +11,8 @@ module TestList =
     [<Test>]
     let ``combinations has right size`` () =
         let property (xs : int list list) =
+            let xs = if xs.Length > 6 then xs |> List.take 6 else xs
+            let xs = xs |> List.map (fun xs -> if xs.Length > 6 then xs |> List.take 6 else xs)
             let combs = List.combinations xs
 
             combs.Length

WoofWare.NUnitTestRunner/WoofWare.NUnitTestRunner.Test/TestSurface.fs

@@ -1,4 +1,4 @@
-namespace TestRunner.Test
+namespace WoofWare.NUnitTestRunner.Test
 
 open NUnit.Framework
 open ApiSurface
@@ -6,7 +6,7 @@ open ApiSurface
 [<TestFixture>]
 module TestSurface =
 
-    let assembly = typeof<TestRunner.Combinatorial>.Assembly
+    let assembly = typeof<WoofWare.NUnitTestRunner.Combinatorial>.Assembly
 
     [<Test>]
     let ``Ensure API surface has not been modified`` () = ApiSurface.assertIdentical assembly
@@ -20,6 +20,6 @@ module TestSurface =
         DocCoverage.assertFullyDocumented assembly
 
     [<Test>]
-    [<Explicit "Not yet published">]
-    let ``Ensure version is monotonic`` () =
-        MonotonicVersion.validate assembly "CHOOSE A NAME"
+    // https://github.com/nunit/nunit3-vs-adapter/issues/876
+    let EnsureVersionIsMonotonic () =
+        MonotonicVersion.validate assembly "WoofWare.NUnitTestRunner.Lib"

WoofWare.NUnitTestRunner/WoofWare.NUnitTestRunner.Test/TestTrx.fs

@@ -1,7 +1,7 @@
-namespace TestRunner.Test
+namespace WoofWare.NUnitTestRunner.Test
 
 open System
-open TestRunner
+open WoofWare.NUnitTestRunner
 open NUnit.Framework
 open FsUnitTyped
 
@@ -197,6 +197,7 @@ Running all tests in /Users/patrick/Documents/GitHub/TestRunner/TestRunner/TestR
 Ensure version is monotonic: Not yet published
 NUnit Adapter 4.5.0.0: Test execution complete
 """
+                        StdErr = None
                         ErrorInfo = None
                     }
                 Outcome = TrxOutcome.Failed

WoofWare.NUnitTestRunner/WoofWare.NUnitTestRunner.Test/WoofWare.NUnitTestRunner.Test.fsproj

@@ -16,7 +16,7 @@
     </ItemGroup>
 
     <ItemGroup>
-        <PackageReference Include="ApiSurface" Version="4.0.40" />
+        <PackageReference Include="ApiSurface" Version="4.0.41" />
         <PackageReference Include="FsCheck" Version="3.0.0-rc3" />
         <PackageReference Include="FsUnit" Version="6.0.0" />
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.10.0" />
@@ -25,7 +25,7 @@
     </ItemGroup>
 
     <ItemGroup>
-      <ProjectReference Include="..\..\TestRunner.Lib\TestRunner.Lib.fsproj" />
+      <ProjectReference Include="..\..\WoofWare.NUnitTestRunner.Lib\WoofWare.NUnitTestRunner.Lib.fsproj" />
     </ItemGroup>
 
 </Project>

WoofWare.NUnitTestRunner/WoofWare.NUnitTestRunner.fsproj

@@ -16,14 +16,9 @@
     <PackageId>WoofWare.NUnitTestRunner</PackageId>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <WarnOn>FS3559</WarnOn>
-    <WoofWareMyriadPluginVersion>2.1.40</WoofWareMyriadPluginVersion>
   </PropertyGroup>
 
   <ItemGroup>
-    <Compile Include="RuntimeConfig.fs" />
-    <Compile Include="GeneratedRuntimeConfig.fs">
-      <MyriadFile>RuntimeConfig.fs</MyriadFile>
-    </Compile>
     <Compile Include="Seq.fs" />
     <Compile Include="Progress.fs" />
     <Compile Include="Program.fs" />
@@ -34,18 +29,14 @@
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\TestRunner.Lib\TestRunner.Lib.fsproj" />
+    <ProjectReference Include="..\WoofWare.NUnitTestRunner.Lib\WoofWare.NUnitTestRunner.Lib.fsproj" />
   </ItemGroup>
 
   <ItemGroup>
     <PackageReference Include="Spectre.Console" Version="0.49.1" />
-    <PackageReference Include="WoofWare.DotnetRuntimeLocator" Version="0.1.3" />
-    <PackageReference Include="WoofWare.Myriad.Plugins.Attributes" Version="3.1.4" />
-    <PackageReference Include="Myriad.SDK" Version="0.8.3" />
-    <PackageReference Include="WoofWare.Myriad.Plugins" Version="$(WoofWareMyriadPluginVersion)" PrivateAssets="all" />
   </ItemGroup>
 
   <ItemGroup>
-    <MyriadSdkGenerator Include="$(NuGetPackageRoot)/woofware.myriad.plugins/$(WoofWareMyriadPluginVersion)/lib/net6.0/WoofWare.Myriad.Plugins.dll" />
+    <EmbeddedResource Include="version.json" />
   </ItemGroup>
 </Project>

WoofWare.NUnitTestRunner/version.json

@@ -0,0 +1,13 @@
+{
+  "version": "0.2",
+  "publicReleaseRefSpec": [
+    "^refs/heads/main$"
+  ],
+  "pathFilters": [
+    "./",
+    "^./WoofWare.NUnitTestRunner.Test",
+    ":/WoofWare.NUnitTestRunner.Lib",
+    ":/Directory.Build.props",
+    ":/README.md"
+  ]
+}

flake.nix

@@ -49,8 +49,9 @@
           inherit pname version dotnet-sdk dotnet-runtime;
           name = "unofficial-nunit-runner";
           src = ./.;
-          projectFile = "./TestRunner/TestRunner.fsproj";
-          testProjectFile = "./TestRunner/TestRunner.Test/TestRunner.Test.fsproj";
+          projectFile = "./WoofWare.NUnitTestRunner/WoofWare.NUnitTestRunner.fsproj";
+          testProjectFile = "./WoofWare.NUnitTestRunner/WoofWare.NUnitTestRunner.Test/WoofWare.NUnitTestRunner.Test.fsproj";
+          disabledTests = ["WoofWare.NUnitTestRunner.Test.TestSurface.EnsureVersionIsMonotonic"];
           nugetDeps = ./nix/deps.nix; # `nix build .#default.passthru.fetch-deps && ./result` and put the result here
           doCheck = true;
         };

nix/deps.nix

@@ -3,13 +3,13 @@
 {fetchNuGet}: [
   (fetchNuGet {
     pname = "ApiSurface";
-    version = "4.0.40";
-    sha256 = "1c9z0b6minlripwrjmv4yd5w8zj4lcpak4x41izh7ygx8kgmbvx0";
+    version = "4.0.41";
+    sha256 = "03kfa5ngmgkik9lc58sp8s9rrh9g40hhgjnrv662ks0d0y2i9i89";
   })
   (fetchNuGet {
     pname = "fantomas";
-    version = "6.3.7";
-    sha256 = "1z1a5bw7vwz6g8nvfgkvx66jnm4hmvn62vbyq0as60nw0jlvaidl";
+    version = "6.3.9";
+    sha256 = "1b34iiiff02bbzjv03zyna8xmrgs6y87zdvp5i5k58fcqpjw44sx";
   })
   (fetchNuGet {
     pname = "FsCheck";
@@ -36,6 +36,31 @@
     version = "6.0.0";
     sha256 = "18q3p0z155znwj1l0qq3vq9nh9wl2i4mlfx4pmrnia4czr0xdkmb";
   })
+  (fetchNuGet {
+    pname = "Microsoft.AspNetCore.App.Ref";
+    version = "6.0.30";
+    sha256 = "17k3l8xd5bsyk69bm5q4nxbpb4i0izw1kzmzi7j3p8pmm9prgrpy";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.AspNetCore.App.Runtime.linux-arm64";
+    version = "6.0.30";
+    sha256 = "1n4v5przbrjhzj01b6qijpdc2jbsxr66ijvd0483qxh4s0b4jppr";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.AspNetCore.App.Runtime.linux-x64";
+    version = "6.0.30";
+    sha256 = "18v0l07q74m5xxaf6y6dkmr6and8ivya0nslffnr4djrxcbiygdr";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.AspNetCore.App.Runtime.osx-arm64";
+    version = "6.0.30";
+    sha256 = "0p53lyqmr5n2ym202pbgmsd9b9aa6jar7ic04dcq86h2g77r5jqk";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.AspNetCore.App.Runtime.osx-x64";
+    version = "6.0.30";
+    sha256 = "009srl8vazkjnd93xr6k1m353spbki9gn1yzp4zgazgbrini6rqc";
+  })
   (fetchNuGet {
     pname = "Microsoft.CodeCoverage";
     version = "17.10.0";
@@ -46,6 +71,51 @@
     version = "17.10.0";
     sha256 = "13g8fwl09li8fc71nk13dgkb7gahd4qhamyg2xby7am63nlchhdf";
   })
+  (fetchNuGet {
+    pname = "Microsoft.NETCore.App.Host.linux-arm64";
+    version = "6.0.30";
+    sha256 = "0l3gjhmnjd5n67w83smqyhmfcwzszafjgcbq8kdwxiwwh2m6nh2i";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.NETCore.App.Host.linux-x64";
+    version = "6.0.30";
+    sha256 = "0ss3108c2h7afypvliyqixv4dll60sq9iwqy90k1p132znpszrmb";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.NETCore.App.Host.osx-arm64";
+    version = "6.0.30";
+    sha256 = "08k5v35mvcs712kb0vcfjd1dsas5rgwrmv8rn87mzjb2p6ajl3n3";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.NETCore.App.Host.osx-x64";
+    version = "6.0.30";
+    sha256 = "02x38c68xan8hlr59mindcl4rcx49bbh4bibh6fw1l4rrijb38lw";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.NETCore.App.Ref";
+    version = "6.0.30";
+    sha256 = "1wqqjhhlqz4dmijcx3kg3hnwq0s0jzqsddaksskzhq8avr4ziy18";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.NETCore.App.Runtime.linux-arm64";
+    version = "6.0.30";
+    sha256 = "0xfhcig3gj3986rxp3dhnd8hvnj4nvyhz1fz7kpx342d3g53wb37";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.NETCore.App.Runtime.linux-x64";
+    version = "6.0.30";
+    sha256 = "1s81sj8lnb8szqawxh3vc8wi815ln12cyhrl3f7hwcpay57xgswx";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.NETCore.App.Runtime.osx-arm64";
+    version = "6.0.30";
+    sha256 = "0s71k92daakzwish65gmn4nniy6bf2hv34c0sb6m1hv3criqxmp4";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.NETCore.App.Runtime.osx-x64";
+    version = "6.0.30";
+    sha256 = "0xybqg2wd240r1nm2vrbn2qbfqfnqsmxn1012zzwjn17wa2si9a1";
+  })
   (fetchNuGet {
     pname = "Microsoft.NETCore.Platforms";
     version = "2.0.0";
@@ -71,11 +141,6 @@
     version = "3.6.139";
     sha256 = "0npcryhq3r0c2zi940jk39h13mzc4hyg7z8gm6jdmxi1aqv1vh8c";
   })
-  (fetchNuGet {
-    pname = "NETStandard.Library.Ref";
-    version = "2.1.0";
-    sha256 = "12n76gymxq715lkrw841vi5r84kx746cxxssp22pd08as75jzsj6";
-  })
   (fetchNuGet {
     pname = "Newtonsoft.Json";
     version = "13.0.1";
@@ -183,18 +248,18 @@
   })
   (fetchNuGet {
     pname = "WoofWare.DotnetRuntimeLocator";
-    version = "0.1.3";
-    sha256 = "0qw41mcvx4qy012pj1dlpdfwsz036qrx7xnzsirk5fz715f1a45m";
+    version = "0.1.4";
+    sha256 = "19pp4qlyf18g704ppbcsm1rhjqjpi84py18yljj9nx70331m8bpg";
   })
   (fetchNuGet {
     pname = "WoofWare.Myriad.Plugins";
-    version = "2.1.40";
-    sha256 = "025lv42zjvqpr2di0iaqhqpricqary3l2a3cxgjjl0zxzflfbmx2";
+    version = "2.1.44";
+    sha256 = "0rp9hpkah60gd9x0ba2izr9ff1g7yhzv5a4pkhi5fbrwf5rpqpwx";
   })
   (fetchNuGet {
     pname = "WoofWare.Myriad.Plugins.Attributes";
-    version = "3.1.4";
-    sha256 = "06yw013f2qs2r8bxvja2c5kzbqc5knd3sc3pf6w5gaz4fbzwc2c3";
+    version = "3.1.6";
+    sha256 = "0786pr1p0nq0854mqi2cddmh185j3jihwn6azz9wiy6nxawjbrd2";
   })
   (fetchNuGet {
     pname = "WoofWare.PrattParser";