Generalise Spectre to arbitrary console (#78 )

Add test for stdout/stderr redirection (#77 )
Recognise parallelism attributes (#76 )
2025-10-06 09:48:40 +00:00 · 2024-06-15 23:57:48 +01:00 · 2024-06-15 23:32:31 +01:00 · 2024-06-15 23:26:19 +01:00 · 2024-06-15 23:06:11 +01:00 · 2024-06-15 22:55:30 +01:00
45 changed files with 1297 additions and 834 deletions
--- a/.config/dotnet-tools.json
+++ b/.config/dotnet-tools.json
@@ -3,7 +3,7 @@
  "isRoot": true,
  "tools": {
    "fantomas": {
-      "version": "6.3.7",
+      "version": "6.3.9",
      "commands": [
        "fantomas"
      ]
--- a/.github/workflows/dotnet.yaml
+++ b/.github/workflows/dotnet.yaml
@@ -71,7 +71,7 @@ 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()
@@ -97,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
@@ -187,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]
--- a/Consumer/Consumer.fsproj
+++ b/Consumer/Consumer.fsproj
@@ -10,6 +10,9 @@
    <ItemGroup>
        <Compile Include="NoAttribute.fs" />
        <Compile Include="Inconclusive.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">
--- a/Consumer/TestCaseData.fs
+++ b/Consumer/TestCaseData.fs
@@ -35,6 +35,13 @@ module TestCaseData =
    [<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 () =
        testCasesSeen
--- a/Consumer/TestParallel.fs
+++ b/Consumer/TestParallel.fs
@@ -0,0 +1,49 @@
+namespace Consumer
+
+open NUnit.Framework
+open FsUnitTyped
+
+[<TestFixture>]
+[<Parallelizable>]
+module TestParallelDefault =
+
+    let defaults = List.init 100 id
+
+    [<TestCaseSource(nameof defaults)>]
+    let ``Default thing`` (i : int) = i |> shouldEqual i
+
+[<TestFixture>]
+[<Parallelizable(ParallelScope.All)>]
+module TestParallelAllScope =
+
+    let defaults = List.init 100 id
+
+    [<TestCaseSource(nameof defaults)>]
+    let ``Default thing`` (i : int) = i |> shouldEqual i
+
+[<TestFixture>]
+[<Parallelizable(ParallelScope.Self)>]
+module TestParallelSelfScope =
+
+    let defaults = List.init 100 id
+
+    [<TestCaseSource(nameof defaults)>]
+    let ``Default thing`` (i : int) = i |> shouldEqual i
+
+[<TestFixture>]
+[<Parallelizable(ParallelScope.Children)>]
+module TestParallelChildrenScope =
+
+    let defaults = List.init 100 id
+
+    [<TestCaseSource(nameof defaults)>]
+    let ``Default thing`` (i : int) = i |> shouldEqual i
+
+[<TestFixture>]
+[<Parallelizable(ParallelScope.Fixtures)>]
+module TestParallelFixturesScope =
+
+    let defaults = List.init 100 id
+
+    [<TestCaseSource(nameof defaults)>]
+    let ``Default thing`` (i : int) = i |> shouldEqual i
--- a/Consumer/TestParameterisedFixture.fs
+++ b/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
--- a/Consumer/TestStdout.fs
+++ b/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!"
--- a/README.md
+++ b/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).
--- a/TestRunner.Lib/AssemblyInfo.fs
+++ b/TestRunner.Lib/AssemblyInfo.fs
@@ -1,7 +0,0 @@
-namespace TestRunner.AssemblyInfo
-
-open System.Runtime.CompilerServices
-
-[<assembly : InternalsVisibleTo("TestRunner.Test")>]
-
-do ()
--- a/TestRunner.Lib/SurfaceBaseline.txt
+++ b/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
--- a/TestRunner/Progress.fs
+++ b/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}[/]"
-        }
--- a/TestRunner/version.json
+++ b/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"
-  ]
-}
--- a/WoofWare.NUnitTestRunner.Lib/Array.fs
+++ b/WoofWare.NUnitTestRunner.Lib/Array.fs
@@ -1,4 +1,4 @@
-namespace TestRunner
+namespace WoofWare.NUnitTestRunner

 [<RequireQualifiedAccess>]
 module internal Array =
--- a/WoofWare.NUnitTestRunner.Lib/AssemblyInfo.fs
+++ b/WoofWare.NUnitTestRunner.Lib/AssemblyInfo.fs
@@ -0,0 +1,7 @@
+namespace WoofWare.NUnitTestRunner.AssemblyInfo
+
+open System.Runtime.CompilerServices
+
+[<assembly : InternalsVisibleTo("WoofWare.NUnitTestRunner.Test")>]
+
+do ()
--- a/WoofWare.NUnitTestRunner.Lib/Domain.fs
+++ b/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.
@@ -62,6 +95,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 +112,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.
--- a/WoofWare.NUnitTestRunner.Lib/DotnetRuntime.fs
+++ b/WoofWare.NUnitTestRunner.Lib/DotnetRuntime.fs
@@ -0,0 +1,104 @@
+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)
+        : 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"
+
+    /// 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
+
+        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 $"%s{runtime.Path}/%s{runtime.Version}" ]
+        | Some (Choice2Of2 sdk) -> [ dll.Directory ; DirectoryInfo sdk.Path ]
--- a/WoofWare.NUnitTestRunner.Lib/Filter.fs
+++ b/WoofWare.NUnitTestRunner.Lib/Filter.fs
@@ -1,4 +1,4 @@
-namespace TestRunner
+namespace WoofWare.NUnitTestRunner

 open System
 open System.IO
--- a/WoofWare.NUnitTestRunner.Lib/List.fs
+++ b/WoofWare.NUnitTestRunner.Lib/List.fs
@@ -1,4 +1,4 @@
-namespace TestRunner
+namespace WoofWare.NUnitTestRunner

 [<RequireQualifiedAccess>]
 module internal List =
--- a/WoofWare.NUnitTestRunner.Lib/Result.fs
+++ b/WoofWare.NUnitTestRunner.Lib/Result.fs
@@ -1,4 +1,4 @@
-namespace TestRunner
+namespace WoofWare.NUnitTestRunner

 [<RequireQualifiedAccess>]
 module internal Result =
--- a/WoofWare.NUnitTestRunner.Lib/RuntimeConfig.fs
+++ b/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
--- a/WoofWare.NUnitTestRunner.Lib/SingleTestMethod.fs
+++ b/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."

--- a/WoofWare.NUnitTestRunner.Lib/SurfaceBaseline.txt
+++ b/WoofWare.NUnitTestRunner.Lib/SurfaceBaseline.txt
@@ -0,0 +1,597 @@
+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.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.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.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.ITestProgress -> (WoofWare.NUnitTestRunner.TestFixture -> WoofWare.NUnitTestRunner.SingleTestMethod -> bool) -> WoofWare.NUnitTestRunner.TestFixture -> WoofWare.NUnitTestRunner.FixtureRunResults list
+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
--- a/WoofWare.NUnitTestRunner.Lib/TestFixture.fs
+++ b/WoofWare.NUnitTestRunner.Lib/TestFixture.fs
@@ -1,6 +1,7 @@
-namespace TestRunner
+namespace WoofWare.NUnitTestRunner

 open System
+open System.Collections
 open System.Diagnostics
 open System.IO
 open System.Reflection
@@ -168,8 +169,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

@@ -230,6 +229,27 @@ module TestFixture =
        (test : SingleTestMethod)
        : (Result<TestMemberSuccess, TestMemberFailure> * IndividualTestRunMetadata) 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) |> List.singleton
+        else
+
        let resultPreRun =
            (None, test.Modifiers)
            ||> List.fold (fun _result modifier ->
@@ -396,36 +416,15 @@ module TestFixture =

    /// 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 private runOneFixture
        (progress : ITestProgress)
        (filter : TestFixture -> SingleTestMethod -> bool)
+        (name : string)
+        (containingObject : obj)
        (tests : TestFixture)
        : FixtureRunResults
        =
-        progress.OnTestFixtureStart tests.Name tests.Tests.Length
-
-        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)
-                else
-                    None
-            )
-            |> Option.toObj
+        progress.OnTestFixtureStart name tests.Tests.Length

        let oldWorkDir = Environment.CurrentDirectory
        Environment.CurrentDirectory <- FileInfo(tests.ContainingAssembly.Location).Directory.FullName
@@ -451,7 +450,7 @@ module TestFixture =
                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
+                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
@@ -521,13 +520,52 @@ module TestFixture =
    /// 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 ->
@@ -597,3 +635,48 @@ 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
+        (progress : ITestProgress)
+        (filter : TestFixture -> SingleTestMethod -> bool)
+        (tests : TestFixture)
+        : FixtureRunResults list
+        =
+        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 progress filter name containingObject tests
+        )
--- a/WoofWare.NUnitTestRunner.Lib/TestProgress.fs
+++ b/WoofWare.NUnitTestRunner.Lib/TestProgress.fs
@@ -1,4 +1,4 @@
-namespace TestRunner
+namespace WoofWare.NUnitTestRunner

 open System

--- a/WoofWare.NUnitTestRunner.Lib/TrxReport.fs
+++ b/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>
--- a/WoofWare.NUnitTestRunner.Lib/WoofWare.NUnitTestRunner.Lib.fsproj
+++ b/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,10 +14,16 @@
      <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" />
@@ -38,6 +44,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>
--- a/WoofWare.NUnitTestRunner.Lib/Xml.fs
+++ b/WoofWare.NUnitTestRunner.Lib/Xml.fs
@@ -1,4 +1,4 @@
-namespace TestRunner
+namespace WoofWare.NUnitTestRunner

 open System.Xml

--- a/WoofWare.NUnitTestRunner.Lib/myriad.toml
+++ b/WoofWare.NUnitTestRunner.Lib/myriad.toml
--- a/WoofWare.NUnitTestRunner.Lib/version.json
+++ b/WoofWare.NUnitTestRunner.Lib/version.json
@@ -1,6 +1,8 @@
 {
-  "version": "0.7-prerelease",
-  "publicReleaseRefSpec": ["^refs/heads/main$"],
+  "version": "0.12",
+  "publicReleaseRefSpec": [
+    "^refs/heads/main$"
+  ],
  "pathFilters": [
    "./",
    ":/Directory.Build.props",
--- a/WoofWare.NUnitTestRunner.sln
+++ b/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
--- a/WoofWare.NUnitTestRunner/Program.fs
+++ b/WoofWare.NUnitTestRunner/Program.fs
@@ -1,10 +1,10 @@
-namespace TestRunner
+namespace WoofWare.NUnitTestRunner

 open System
-open WoofWare.DotnetRuntimeLocator
 open System.IO
 open System.Reflection
 open System.Runtime.Loader
+open Spectre.Console

 // Fix for https://github.com/Smaug123/unofficial-nunit-runner/issues/8
 // Set AppContext.BaseDirectory to where the test DLL is.
@@ -41,101 +41,6 @@ type Ctx (dll : FileInfo, runtimes : DirectoryInfo list) =


 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 $"%s{runtime.Path}/%s{runtime.Version}" ]
-        | Some (Choice2Of2 sdk) -> [ dll.Directory ; DirectoryInfo sdk.Path ]
-
    let main argv =
        let startTime = DateTimeOffset.Now

@@ -157,17 +62,61 @@ module Program =
            | 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
+
+        let progress = Progress.spectre stderr

        use _ = new SetBaseDir (testDll)

-        let ctx = Ctx (testDll, locateRuntimes testDll)
+        let ctx = Ctx (testDll, DotnetRuntime.locate testDll)
        let assy = ctx.LoadFromAssemblyPath testDll.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 testFixtures = assy.ExportedTypes |> Seq.map TestFixture.parse |> Seq.toList

        let creationTime = DateTimeOffset.Now
-        let results = testFixtures |> List.map (TestFixture.run progress filter)
+        let results = testFixtures |> List.collect (TestFixture.run progress filter)

        let finishTime = DateTimeOffset.Now
        let finishTimeHumanReadable = finishTime.ToString @"yyyy-MM-dd HH:mm:ss"
@@ -270,6 +219,7 @@ module Program =
                Output =
                    {
                        StdOut = None
+                        StdErr = None
                        ErrorInfo = None
                    }
                RunInfos =
@@ -373,11 +323,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
                                }
                }
@@ -401,6 +351,7 @@ module Program =
            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
--- a/WoofWare.NUnitTestRunner/Progress.fs
+++ b/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}[/]"
+        }
--- a/WoofWare.NUnitTestRunner/Seq.fs
+++ b/WoofWare.NUnitTestRunner/Seq.fs
@@ -1,4 +1,4 @@
-namespace TestRunner
+namespace WoofWare.NUnitTestRunner

 [<RequireQualifiedAccess>]
 module internal Seq =
--- a/WoofWare.NUnitTestRunner/WoofWare.NUnitTestRunner.Test/EmbeddedResource.fs
+++ b/WoofWare.NUnitTestRunner/WoofWare.NUnitTestRunner.Test/EmbeddedResource.fs
@@ -1,4 +1,4 @@
-namespace TestRunner.Test
+namespace WoofWare.NUnitTestRunner.Test

 open System
 open System.IO
--- a/WoofWare.NUnitTestRunner/WoofWare.NUnitTestRunner.Test/Example1.trx
+++ b/WoofWare.NUnitTestRunner/WoofWare.NUnitTestRunner.Test/Example1.trx
--- a/WoofWare.NUnitTestRunner/WoofWare.NUnitTestRunner.Test/TestFilter.fs
+++ b/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

--- a/WoofWare.NUnitTestRunner/WoofWare.NUnitTestRunner.Test/TestList.fs
+++ b/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
--- a/WoofWare.NUnitTestRunner/WoofWare.NUnitTestRunner.Test/TestSurface.fs
+++ b/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"
--- a/WoofWare.NUnitTestRunner/WoofWare.NUnitTestRunner.Test/TestTrx.fs
+++ b/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
--- a/WoofWare.NUnitTestRunner/WoofWare.NUnitTestRunner.Test/WoofWare.NUnitTestRunner.Test.fsproj
+++ b/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>
--- a/WoofWare.NUnitTestRunner/WoofWare.NUnitTestRunner.fsproj
+++ b/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>
--- a/WoofWare.NUnitTestRunner/myriad.toml
+++ b/WoofWare.NUnitTestRunner/myriad.toml
--- a/WoofWare.NUnitTestRunner/version.json
+++ b/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"
+  ]
+}
--- a/flake.nix
+++ b/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;
        };
--- a/nix/deps.nix
+++ b/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";
Author	SHA1	Message	Date
Patrick Stevens	e0b2d52812	Generalise Spectre to arbitrary console (#78 )	2024-06-15 23:57:48 +01:00
Patrick Stevens	2ed4a04f70	Add test for stdout/stderr redirection (#77 )	2024-06-15 23:32:31 +01:00
Patrick Stevens	2e066a1a9a	Recognise parallelism attributes (#76 )	2024-06-15 23:26:19 +01:00
Patrick Stevens	6468a301b9	Capture stderr too (#75 )	2024-06-15 23:06:11 +01:00
Patrick Stevens	13f636df3d	Promote runtime stuff to lib (#74 )	2024-06-15 22:55:30 +01:00
Patrick Stevens	eed076cad5	Cap runtime of test (#73 )	2024-06-15 22:50:15 +01:00
Patrick Stevens	df64e46079	Cope with parameterised fixtures (#70 )	2024-06-11 23:28:13 +01:00
Patrick Stevens	b3bc0aa4c0	Fix param count error with TestCase (#68 )	2024-06-11 22:41:43 +01:00
Patrick Stevens	d3f9ee6b02	Throw on SetUpFixture (#63 )	2024-06-10 23:45:03 +01:00
Patrick Stevens	3e6fff27d6	Stop throwing on unrecognised exceptions (#62 )	2024-06-10 23:28:49 +01:00
Patrick Stevens	ebcf0ed589	Rename from the rather bland "TestRunner" (#61 )	2024-06-10 23:25:33 +01:00
dependabot[bot]	181063afcd	Bump fantomas from 6.3.7 to 6.3.9 (#58 ) * 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>	2024-06-10 18:42:15 +01:00
Patrick Stevens	41a39ca159	No empty namespaces in TRX reports (#60 )	2024-06-10 18:08:16 +01:00
Patrick Stevens	eb4dfae8f4	Forbid generics (#55 )	2024-06-10 12:18:33 +01:00
Patrick Stevens	78f51d127c	Print path to TRX file (#54 )	2024-06-10 12:16:16 +01:00