Switch to trusted publishing (#301)

* Bump WoofWare.Myriad.Plugins from 8.0.5 to 8.1.1

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

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

* Deps

---------

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

.config/dotnet-tools.json

@@ -3,13 +3,13 @@
   "isRoot": true,
   "tools": {
     "fantomas": {
-      "version": "6.3.9",
+      "version": "7.0.3",
       "commands": [
         "fantomas"
       ]
     },
     "fsharp-analyzers": {
-      "version": "0.26.0",
+      "version": "0.32.1",
       "commands": [
         "fsharp-analyzers"
       ]

.editorconfig

@@ -1,40 +1,40 @@
-root=true
+root = true
 
 [*]
-charset=utf-8
-trim_trailing_whitespace=true
-insert_final_newline=true
-indent_style=space
-indent_size=4
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+indent_style = space
+indent_size = 4
 
 # ReSharper properties
-resharper_xml_indent_size=2
-resharper_xml_max_line_length=100
-resharper_xml_tab_width=2
+resharper_xml_indent_size = 2
+resharper_xml_max_line_length = 100
+resharper_xml_tab_width = 2
 
 [*.{csproj,fsproj,sqlproj,targets,props,ts,tsx,css,json}]
-indent_style=space
-indent_size=2
+indent_style = space
+indent_size = 2
 
 [*.{fs,fsi}]
-fsharp_bar_before_discriminated_union_declaration=true
-fsharp_space_before_uppercase_invocation=true
-fsharp_space_before_class_constructor=true
-fsharp_space_before_member=true
-fsharp_space_before_colon=true
-fsharp_space_before_semicolon=true
-fsharp_multiline_bracket_style=aligned
-fsharp_newline_between_type_definition_and_members=true
-fsharp_align_function_signature_to_indentation=true
-fsharp_alternative_long_member_definitions=true
-fsharp_multi_line_lambda_closing_newline=true
-fsharp_experimental_keep_indent_in_branch=true
-fsharp_max_value_binding_width=80
-fsharp_max_record_width=0
-max_line_length=120
-end_of_line=lf
+fsharp_bar_before_discriminated_union_declaration = true
+fsharp_space_before_uppercase_invocation = true
+fsharp_space_before_class_constructor = true
+fsharp_space_before_member = true
+fsharp_space_before_colon = true
+fsharp_space_before_semicolon = true
+fsharp_multiline_bracket_style = aligned
+fsharp_newline_between_type_definition_and_members = true
+fsharp_align_function_signature_to_indentation = true
+fsharp_alternative_long_member_definitions = true
+fsharp_multi_line_lambda_closing_newline = true
+fsharp_experimental_keep_indent_in_branch = true
+fsharp_max_value_binding_width = 80
+fsharp_max_record_width = 0
+max_line_length = 120
+end_of_line = lf
 
 [*.{appxmanifest,build,dtd,nuspec,xaml,xamlx,xoml,xsd}]
-indent_style=space
-indent_size=2
-tab_width=2
+indent_style = space
+indent_size = 2
+tab_width = 2

.envrc

@@ -0,0 +1,23 @@
+use flake
+DOTNET_PATH=$(readlink "$(which dotnet)")
+SETTINGS_FILE=$(find . -maxdepth 1 -type f -name '*.sln.DotSettings.user')
+MSBUILD=$(realpath "$(find "$(dirname "$DOTNET_PATH")/../share/dotnet/sdk" -maxdepth 2 -type f -name MSBuild.dll)")
+if [ -f "$SETTINGS_FILE" ] ; then
+    xmlstarlet ed --inplace \
+    -N wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation" \
+    -N x="http://schemas.microsoft.com/winfx/2006/xaml" \
+    -N s="clr-namespace:System;assembly=mscorlib" \
+    -N ss="urn:shemas-jetbrains-com:settings-storage-xaml" \
+    --update "//s:String[@x:Key='/Default/Environment/Hierarchy/Build/BuildTool/DotNetCliExePath/@EntryValue']" \
+    --value "$(realpath "$(dirname "$DOTNET_PATH")/../share/dotnet/dotnet")" \
+    "$SETTINGS_FILE"
+
+    xmlstarlet ed --inplace \
+    -N wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation" \
+    -N x="http://schemas.microsoft.com/winfx/2006/xaml" \
+    -N s="clr-namespace:System;assembly=mscorlib" \
+    -N ss="urn:shemas-jetbrains-com:settings-storage-xaml" \
+    --update "//s:String[@x:Key='/Default/Environment/Hierarchy/Build/BuildTool/CustomBuildToolPath/@EntryValue']" \
+    --value "$MSBUILD" \
+    "$SETTINGS_FILE"
+fi

.fantomasignore

@@ -0,0 +1 @@
+.direnv/

.github/workflows/dotnet.yaml

@@ -25,11 +25,11 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
       with:
         fetch-depth: 0 # so that NerdBank.GitVersioning has access to history
     - name: Install Nix
-      uses: cachix/install-nix-action@V27
+      uses: cachix/install-nix-action@v31
       with:
         extra_nix_config: |
           access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -38,7 +38,30 @@ jobs:
     - name: Build
       run: 'nix develop --command dotnet build --no-restore --configuration ${{matrix.config}}'
     - name: Test
-      run: 'nix develop --command dotnet test --no-build --verbosity normal --configuration ${{matrix.config}}'
+      run: |
+          nix develop --command dotnet test --no-build --verbosity normal --configuration ${{matrix.config}} --filter 'FullyQualifiedName !~ FailingConsumer'
+
+  selftest-intended-failures:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v5
+      with:
+        fetch-depth: 0 # so that NerdBank.GitVersioning has access to history
+    - name: Install Nix
+      uses: cachix/install-nix-action@v31
+      with:
+        extra_nix_config: |
+          access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
+    - name: Restore dependencies
+      run: nix develop --command dotnet restore
+    - name: Build
+      run: 'nix develop --command dotnet build --no-restore --configuration Release'
+    - name: Test using self
+      run: 'nix develop --command dotnet exec ./WoofWare.NUnitTestRunner/bin/Release/net9.0/WoofWare.NUnitTestRunner.dll ./FailingConsumer/bin/Release/net9.0/FailingConsumer.dll --trx TrxOut/out.trx || true'
+    - name: Munge output
+      run: 'nix develop --command xmlstarlet sel -N x="http://microsoft.com/schemas/VisualStudio/TeamTest/2010" -t -m "//x:UnitTestResult" -v "@testName" -o ": " -v ".//x:ErrorInfo/x:Message" -n TrxOut/out.trx > snapshot.txt'
+    - name: Check output matches expected
+      run: 'actual=$(cat snapshot.txt | sort) expected=$(cat FailingConsumer/expected.txt | sort) [ "$expected" == "$actual" ]'
 
   selftest:
     runs-on: ubuntu-latest
@@ -58,11 +81,11 @@ jobs:
       statuses: read
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
       with:
         fetch-depth: 0 # so that NerdBank.GitVersioning has access to history
     - name: Install Nix
-      uses: cachix/install-nix-action@V27
+      uses: cachix/install-nix-action@v31
       with:
         extra_nix_config: |
           access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -71,10 +94,10 @@ jobs:
     - name: Build
       run: 'nix develop --command dotnet build --no-restore --configuration Release'
     - name: Test using self
-      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'
+      run: 'nix develop --command dotnet exec ./WoofWare.NUnitTestRunner/bin/Release/net9.0/WoofWare.NUnitTestRunner.dll ./Consumer/bin/Release/net9.0/Consumer.dll --trx TrxOut/out.trx'
     - name: Parse Trx files
-      uses: NasAmin/trx-parser@v0.6.0
-      if: always()
+      uses: NasAmin/trx-parser@v0.7.0
+      if: always() && github.ref_name != 'main'
       id: trx-parser
       with:
         TRX_PATH: ${{ github.workspace }}/TrxOut
@@ -86,11 +109,11 @@ jobs:
       security-events: write
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
         with:
           fetch-depth: 0 # so that NerdBank.GitVersioning has access to history
       - name: Install Nix
-        uses: cachix/install-nix-action@V27
+        uses: cachix/install-nix-action@v31
         with:
           extra_nix_config: |
             access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -105,22 +128,24 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
       - name: Install Nix
-        uses: cachix/install-nix-action@V27
+        uses: cachix/install-nix-action@v31
         with:
           extra_nix_config: |
             access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
       - name: Build
         run: nix build
+      - name: Reproducibility check
+        run: nix build --rebuild
 
   check-dotnet-format:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
       - name: Install Nix
-        uses: cachix/install-nix-action@V27
+        uses: cachix/install-nix-action@v31
         with:
           extra_nix_config: |
             access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -131,9 +156,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
       - name: Install Nix
-        uses: cachix/install-nix-action@V27
+        uses: cachix/install-nix-action@v31
         with:
           extra_nix_config: |
             access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -146,7 +171,7 @@ jobs:
     steps:
       - uses: actions/checkout@master
       - name: Install Nix
-        uses: cachix/install-nix-action@V27
+        uses: cachix/install-nix-action@v31
         with:
           extra_nix_config: |
             access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -159,7 +184,7 @@ jobs:
     steps:
       - uses: actions/checkout@master
       - name: Install Nix
-        uses: cachix/install-nix-action@V27
+        uses: cachix/install-nix-action@v31
         with:
           extra_nix_config: |
             access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -169,11 +194,11 @@ jobs:
   nuget-pack:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
       with:
         fetch-depth: 0 # so that NerdBank.GitVersioning has access to history
     - name: Install Nix
-      uses: cachix/install-nix-action@V27
+      uses: cachix/install-nix-action@v31
       with:
         extra_nix_config: |
           access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -199,7 +224,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Download NuGet artifact (lib)
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v5
         with:
           name: nuget-package-lib
           path: packed-lib
@@ -207,7 +232,7 @@ jobs:
         # Verify that there is exactly one nupkg in the artifact that would be NuGet published
         run: if [[ $(find packed-lib -maxdepth 1 -name 'WoofWare.NUnitTestRunner.Lib.*.nupkg' -printf c | wc -c) -ne "1" ]]; then exit 1; fi
       - name: Download NuGet artifact (tool)
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v5
         with:
           name: nuget-package-tool
           path: packed-tool
@@ -215,59 +240,165 @@ jobs:
         # Verify that there is exactly one nupkg in the artifact that would be NuGet published
         run: if [[ $(find packed-tool -maxdepth 1 -name 'WoofWare.NUnitTestRunner.*.nupkg' -printf c | wc -c) -ne "1" ]]; then exit 1; fi
 
-  github-release-tool-dry-run:
-    needs: [nuget-pack]
+  all-required-checks-complete:
+    if: ${{ always() }}
+    needs: [github-release-dry-run, check-dotnet-format, check-nix-format, build, build-nix, linkcheck, flake-check, analyzers, nuget-pack, expected-pack, selftest-intended-failures, selftest]
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - name: Download NuGet artifact (lib)
-        uses: actions/download-artifact@v4
+      - uses: G-Research/common-actions/check-required-lite@2b7dc49cb14f3344fbe6019c14a31165e258c059
+        with:
+          needs-context: ${{ toJSON(needs) }}
+
+  attestation-lib:
+    runs-on: ubuntu-latest
+    needs: [all-required-checks-complete]
+    if: ${{ !github.event.repository.fork && github.ref == 'refs/heads/main' }}
+    permissions:
+      id-token: write
+      attestations: write
+      contents: read
+    steps:
+      - name: Download NuGet artifact
+        uses: actions/download-artifact@v5
         with:
           name: nuget-package-lib
-      - name: Download NuGet artifact (tool)
-        uses: actions/download-artifact@v4
+          path: packed
+      - name: Attest Build Provenance
+        uses: actions/attest-build-provenance@977bb373ede98d70efdf65b84cb5f73e068dcc2a # v3.0.0
+        with:
+          subject-path: "packed/*.nupkg"
+
+  attestation-tool:
+    runs-on: ubuntu-latest
+    needs: [all-required-checks-complete]
+    if: ${{ !github.event.repository.fork && github.ref == 'refs/heads/main' }}
+    permissions:
+      id-token: write
+      attestations: write
+      contents: read
+    steps:
+      - name: Download NuGet artifact
+        uses: actions/download-artifact@v5
         with:
           name: nuget-package-tool
-      - name: Tag and release tool
-        env:
-          DRY_RUN: 1
-          GITHUB_TOKEN: mock-token
-        run: sh .github/workflows/tag.sh
+          path: packed
+      - name: Attest Build Provenance
+        uses: actions/attest-build-provenance@977bb373ede98d70efdf65b84cb5f73e068dcc2a # v3.0.0
+        with:
+          subject-path: "packed/*.nupkg"
 
-  all-required-checks-complete:
-    needs: [check-dotnet-format, check-nix-format, build, build-nix, linkcheck, flake-check, analyzers, nuget-pack, expected-pack, github-release-tool-dry-run]
-    runs-on: ubuntu-latest
-    steps:
-      - run: echo "All required checks complete."
-
-  nuget-publish:
+  nuget-publish-lib:
     runs-on: ubuntu-latest
     if: ${{ !github.event.repository.fork && github.ref == 'refs/heads/main' }}
     needs: [all-required-checks-complete]
     environment: main-deploy
+    permissions:
+      id-token: write
+      attestations: write
+      contents: read
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - name: Install Nix
-        uses: cachix/install-nix-action@V27
+        uses: cachix/install-nix-action@v31
         with:
           extra_nix_config: |
             access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
-      - name: Download NuGet artifact (lib)
-        uses: actions/download-artifact@v4
+      - name: Download NuGet artifact
+        uses: actions/download-artifact@v5
         with:
           name: nuget-package-lib
-          path: packed-lib
-      - name: Publish to NuGet (lib)
-        run: nix develop --command dotnet nuget push "packed-lib/WoofWare.NUnitTestRunner.Lib.*.nupkg" --api-key ${{ secrets.NUGET_API_KEY }} --source https://api.nuget.org/v3/index.json --skip-duplicate
-      - name: Download NuGet artifact (tool)
-        uses: actions/download-artifact@v4
+          path: packed
+      - name: Identify .NET
+        id: identify-dotnet
+        run: nix develop --command bash -c "echo dotnet=$(which dotnet) >> $GITHUB_OUTPUT"
+      - name: Obtain NuGet key
+        uses: NuGet/login@d22cc5f58ff5b88bf9bd452535b4335137e24544
+        id: login
+        with:
+            user: ${{ secrets.NUGET_USER }}
+      - name: Publish NuGet package
+        uses: G-Research/common-actions/publish-nuget@2b7dc49cb14f3344fbe6019c14a31165e258c059
+        with:
+          package-name: WoofWare.NUnitTestRunner.Lib
+          nuget-key: ${{ steps.login.outputs.NUGET_API_KEY }}
+          nupkg-dir: packed/
+          dotnet: ${{ steps.identify-dotnet.outputs.dotnet }}
+
+  nuget-publish-tool:
+    runs-on: ubuntu-latest
+    if: ${{ !github.event.repository.fork && github.ref == 'refs/heads/main' }}
+    needs: [all-required-checks-complete]
+    environment: main-deploy
+    permissions:
+      id-token: write
+      attestations: write
+      contents: read
+    steps:
+      - uses: actions/checkout@v5
+      - name: Install Nix
+        uses: cachix/install-nix-action@v31
+        with:
+          extra_nix_config: |
+            access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
+      - name: Download NuGet artifact
+        uses: actions/download-artifact@v5
         with:
           name: nuget-package-tool
-          path: packed-tool
-      - name: Publish to NuGet (tool)
-        run: nix develop --command dotnet nuget push "packed-tool/WoofWare.NUnitTestRunner.*.nupkg" --api-key ${{ secrets.NUGET_API_KEY }} --source https://api.nuget.org/v3/index.json --skip-duplicate
+          path: packed
+      - name: Identify .NET
+        id: identify-dotnet
+        run: nix develop --command bash -c "echo dotnet=$(which dotnet) >> $GITHUB_OUTPUT"
+      - name: Obtain NuGet key
+        uses: NuGet/login@d22cc5f58ff5b88bf9bd452535b4335137e24544
+        id: login
+        with:
+            user: ${{ secrets.NUGET_USER }}
+      - name: Publish NuGet package
+        uses: G-Research/common-actions/publish-nuget@2b7dc49cb14f3344fbe6019c14a31165e258c059
+        with:
+          package-name: WoofWare.NUnitTestRunner
+          nuget-key: ${{ steps.login.outputs.NUGET_API_KEY }}
+          nupkg-dir: packed/
+          dotnet: ${{ steps.identify-dotnet.outputs.dotnet }}
 
-  github-release-tool:
+  github-release-dry-run:
+    strategy:
+      matrix:
+        artifact:
+        - nuget-package-tool
+        - nuget-package-lib
+    runs-on: ubuntu-latest
+    needs: [nuget-pack]
+    steps:
+      - uses: actions/checkout@v5
+      - name: Download NuGet artifact (tool)
+        uses: actions/download-artifact@v5
+        with:
+          name: ${{ matrix.artifact }}
+      - name: Compute package path
+        id: compute-path
+        run: |
+          find . -maxdepth 1 -type f -name 'WoofWare.NUnitTestRunner.*.nupkg' -exec sh -c 'echo "output=$(basename "$1")" >> $GITHUB_OUTPUT' shell {} \;
+      - name: Compute tag name
+        id: compute-tag
+        env:
+          NUPKG_PATH: ${{ steps.compute-path.outputs.output }}
+        run: echo "output=$(basename "$NUPKG_PATH" .nupkg)" >> $GITHUB_OUTPUT
+      - name: Tag and release
+        uses: G-Research/common-actions/github-release@19d7281a0f9f83e13c78f99a610dbc80fc59ba3b
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          target-commitish: ${{ github.sha }}
+          tag: ${{ steps.compute-tag.outputs.output }}
+          binary-contents: ${{ steps.compute-path.outputs.output }}
+          dry-run: true
+
+  github-release:
+    strategy:
+      matrix:
+        artifact:
+        - nuget-package-tool
+        - nuget-package-lib
     runs-on: ubuntu-latest
     if: ${{ !github.event.repository.fork && github.ref == 'refs/heads/main' }}
     needs: [all-required-checks-complete]
@@ -275,16 +406,24 @@ jobs:
     permissions:
       contents: write
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - name: Download NuGet artifact (tool)
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v5
         with:
-          name: nuget-package-tool
-      - name: Download NuGet artifact (lib)
-        uses: actions/download-artifact@v4
-        with:
-          name: nuget-package-lib
-      - name: Tag and release plugin
+          name: ${{ matrix.artifact }}
+      - name: Compute package path
+        id: compute-path
+        run: |
+          find . -maxdepth 1 -type f -name 'WoofWare.NUnitTestRunner.*.nupkg' -exec sh -c 'echo "output=$(basename "$1")" >> $GITHUB_OUTPUT' shell {} \;
+      - name: Compute tag name
+        id: compute-tag
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: sh .github/workflows/tag.sh
+          NUPKG_PATH: ${{ steps.compute-path.outputs.output }}
+        run: echo "output=$(basename "$NUPKG_PATH" .nupkg)" >> $GITHUB_OUTPUT
+      - name: Tag and release
+        uses: G-Research/common-actions/github-release@19d7281a0f9f83e13c78f99a610dbc80fc59ba3b
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          target-commitish: ${{ github.sha }}
+          tag: ${{ steps.compute-tag.outputs.output }}
+          binary-contents: ${{ steps.compute-path.outputs.output }}

.github/workflows/flake_update.yaml

@@ -0,0 +1,54 @@
+# yaml-language-server: $schema=https://raw.githubusercontent.com/SchemaStore/schemastore/master/src/schemas/json/github-workflow.json
+name: Weekly Nix Flake Update
+
+on:
+  schedule:
+    - cron: '0 0 * * 0'  # Runs at 00:00 every Sunday
+  workflow_dispatch:  # Allows manual triggering
+
+jobs:
+  update-nix-flake:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v5
+
+      - name: Install Nix
+        uses: DeterminateSystems/nix-installer-action@main
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Update Nix flake
+        run: 'nix flake update'
+
+      - name: Build fetch-deps
+        run: 'nix build ".#default.fetch-deps"'
+
+      - name: Run fetch-deps
+        run: ./result nix/deps.json
+
+      - name: Format
+        run: 'nix develop --command alejandra .'
+
+      - name: Create token
+        id: generate-token
+        uses: actions/create-github-app-token@v2
+        with:
+          # https://github.com/actions/create-github-app-token/issues/136
+          app-id: ${{ secrets.APP_ID }}
+          private-key: ${{ secrets.APP_PRIVATE_KEY }}
+
+      - name: Raise pull request
+        uses: Smaug123/commit-action@cc25e6d80a796c49669dda4a0aa36c54c573983d
+        id: cpr
+        with:
+            bearer-token: ${{ steps.generate-token.outputs.token }}
+            pr-title: "Upgrade Nix flake and deps"
+
+      - name: Enable Pull Request Automerge
+        if: ${{ steps.cpr.outputs.pull-request-number }}
+        uses: peter-evans/enable-pull-request-automerge@v3
+        with:
+          token: ${{ steps.generate-token.outputs.token }}
+          pull-request-number: ${{ steps.cpr.outputs.pull-request-number }}
+          merge-method: squash

.github/workflows/tag.sh

@@ -1,124 +0,0 @@
-#!/bin/bash
-
-echo "Dry-run? $DRY_RUN!"
-
-find . -maxdepth 1 -type f ! -name "$(printf "*\n*")" -name '*.nupkg' | while IFS= read -r file
-do
-    tag=$(basename "$file" .nupkg)
-    git tag "$tag"
-    ${DRY_RUN:+echo} git push origin "$tag"
-done
-
-export TAG
-TAG=$(find . -maxdepth 1 -type f -name 'WoofWare.NUnitTestRunner.*.nupkg' -exec sh -c 'basename "$1" .nupkg' shell {} \; | grep -v Lib)
-
-case "$TAG" in
-  *"
-"*)
-    echo "Error: TAG contains a newline; multiple tools found."
-    exit 1
-    ;;
-esac
-
-# target_commitish empty indicates the repo default branch
-IS_PRERELEASE="false"
-if [ "${TAG#*prerelease}" != "$TAG" ]; then
-    IS_PRERELEASE="true"
-fi
-curl_body='{"tag_name":"'"$TAG"'","target_commitish":"","name":"'"$TAG"'","draft":false,"prerelease":'"$IS_PRERELEASE"',"generate_release_notes":false}'
-
-echo "cURL body: $curl_body"
-
-failed_output=$(cat <<'EOF'
-{
-  "message": "Validation Failed",
-  "errors": [
-    {
-      "resource": "Release",
-      "code": "already_exists",
-      "field": "tag_name"
-    }
-  ],
-  "documentation_url": "https://docs.github.com/rest/releases/releases#create-a-release"
-}
-EOF
-)
-
-success_output=$(cat <<'EOF'
-{
-  "url": "https://api.github.com/repos/Smaug123/unofficial-nunit-runner/releases/158152116",
-  "assets_url": "https://api.github.com/repos/Smaug123/unofficial-nunit-runner/releases/158152116/assets",
-  "upload_url": "https://uploads.github.com/repos/Smaug123/unofficial-nunit-runner/releases/158152116/assets{?name,label}",
-  "html_url": "https://github.com/Smaug123/unofficial-nunit-runner/releases/tag/WoofWare.NUnitTestRunner.2.1.30",
-  "id": 158152116,
-  "author": {
-    "login": "github-actions[bot]",
-    "id": 41898282,
-    "node_id": "MDM6Qm90NDE4OTgyODI=",
-    "avatar_url": "https://avatars.githubusercontent.com/in/15368?v=4",
-    "gravatar_id": "",
-    "url": "https://api.github.com/users/github-actions%5Bbot%5D",
-    "html_url": "https://github.com/apps/github-actions",
-    "followers_url": "https://api.github.com/users/github-actions%5Bbot%5D/followers",
-    "following_url": "https://api.github.com/users/github-actions%5Bbot%5D/following{/other_user}",
-    "gists_url": "https://api.github.com/users/github-actions%5Bbot%5D/gists{/gist_id}",
-    "starred_url": "https://api.github.com/users/github-actions%5Bbot%5D/starred{/owner}{/repo}",
-    "subscriptions_url": "https://api.github.com/users/github-actions%5Bbot%5D/subscriptions",
-    "organizations_url": "https://api.github.com/users/github-actions%5Bbot%5D/orgs",
-    "repos_url": "https://api.github.com/users/github-actions%5Bbot%5D/repos",
-    "events_url": "https://api.github.com/users/github-actions%5Bbot%5D/events{/privacy}",
-    "received_events_url": "https://api.github.com/users/github-actions%5Bbot%5D/received_events",
-    "type": "Bot",
-    "site_admin": false
-  },
-  "node_id": "RE_kwDOJfksgc4JbTW0",
-  "tag_name": "WoofWare.NUnitTestRunner.2.1.30",
-  "target_commitish": "main",
-  "name": "WoofWare.NUnitTestRunner.2.1.30",
-  "draft": false,
-  "prerelease": false,
-  "created_at": "2024-05-30T11:00:55Z",
-  "published_at": "2024-05-30T11:03:02Z",
-  "assets": [
-
-  ],
-  "tarball_url": "https://api.github.com/repos/Smaug123/unofficial-nunit-runner/tarball/WoofWare.NUnitTestRunner.2.1.30",
-  "zipball_url": "https://api.github.com/repos/Smaug123/unofficial-nunit-runner/zipball/WoofWare.NUnitTestRunner.2.1.30",
-  "body": null
-}
-EOF
-)
-
-HANDLE_OUTPUT=''
-handle_error() {
-    ERROR_OUTPUT="$1"
-    exit_message=$(echo "$ERROR_OUTPUT" | jq -r --exit-status 'if .errors | length == 1 then .errors[0].code else null end')
-    if [ "$exit_message" = "already_exists" ] ; then
-        HANDLE_OUTPUT="Did not create GitHub release because it already exists at this version."
-    else
-        echo "Unexpected error output from curl: $(cat curl_output.json)"
-        echo "JQ output: $(exit_message)"
-        exit 2
-    fi
-}
-
-run_tests() {
-    handle_error "$failed_output"
-    if [ "$HANDLE_OUTPUT" != "Did not create GitHub release because it already exists at this version." ]; then
-        echo "Bad output from handler: $HANDLE_OUTPUT"
-        exit 3
-    fi
-    HANDLE_OUTPUT=''
-    echo "Tests passed."
-}
-
-run_tests
-
-if [ "$DRY_RUN" != 1 ] ; then
-    if curl --fail-with-body -L -X POST -H "Accept: application/vnd.github+json" -H "Authorization: Bearer $GITHUB_TOKEN" -H "X-GitHub-Api-Version: 2022-11-28" https://api.github.com/repos/Smaug123/unofficial-nunit-runner/releases -d "$curl_body" > curl_output.json; then
-        echo "Curl succeeded."
-    else
-        handle_error "$(cat curl_output.json)"
-        echo "$HANDLE_OUTPUT"
-    fi
-fi

Consumer/Consumer.fsproj

@@ -1,8 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>net8.0</TargetFramework>
-
+        <TargetFrameworks>net9.0</TargetFrameworks>
         <IsPackable>false</IsPackable>
         <IsTestProject>true</IsTestProject>
     </PropertyGroup>
@@ -10,8 +9,12 @@
     <ItemGroup>
         <Compile Include="NoAttribute.fs" />
         <Compile Include="Inconclusive.fs" />
+        <Compile Include="RunSubProcess.fs" />
+        <Compile Include="TestAsync.fs" />
+        <Compile Include="TestExplicit.fs" />
         <Compile Include="TestNonParallel.fs" />
         <Compile Include="TestParallel.fs" />
+        <Compile Include="TestParallelIndividualTest.fs" />
         <Compile Include="TestStdout.fs" />
         <Compile Include="TestParameterisedFixture.fs" />
         <Compile Include="TestSetUp.fs" />
@@ -25,10 +28,10 @@
     </ItemGroup>
 
     <ItemGroup>
-      <PackageReference Include="FsUnit" Version="6.0.0" />
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.10.0"/>
-        <PackageReference Include="NUnit" Version="4.1.0"/>
-        <PackageReference Include="NUnit3TestAdapter" Version="4.5.0"/>
+      <PackageReference Include="FsUnit" Version="7.1.1" />
+      <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1"/>
+      <PackageReference Include="NUnit" Version="4.3.2"/>
+      <PackageReference Include="NUnit3TestAdapter" Version="5.0.0"/>
     </ItemGroup>
 
 </Project>

Consumer/RunSubProcess.fs

@@ -0,0 +1,45 @@
+namespace Consumer
+
+open System
+open System.Diagnostics
+open System.IO
+open System.IO.Compression
+open System.Text
+open NUnit.Framework
+open FsUnitTyped
+
+[<TestFixture>]
+module RunSubProcess =
+    [<Test>]
+    let ``Run a subprocess`` () =
+        let exe = "/bin/bash"
+        let args = [ "-c" ; "echo hi >&2 && echo bye" ]
+        let workingDir = None
+
+        let psi =
+            ProcessStartInfo (
+                exe,
+                UseShellExecute = false,
+                RedirectStandardError = true,
+                RedirectStandardOutput = true,
+                WorkingDirectory = Option.toObj workingDir
+            )
+
+        for arg in args do
+            psi.ArgumentList.Add arg
+
+        psi.EnvironmentVariables.Add ("THING", Path.Combine (AppDomain.CurrentDomain.BaseDirectory, "hi"))
+        let stderr = StringBuilder ()
+        use proc = new Process (StartInfo = psi)
+        proc.OutputDataReceived.Add (fun e -> printfn $"%s{e.Data}")
+
+        proc.ErrorDataReceived.Add (fun e ->
+            eprintfn $"%s{e.Data}"
+            stderr.AppendLine e.Data |> ignore
+        )
+
+        proc.Start () |> shouldEqual true
+        proc.BeginOutputReadLine ()
+        proc.BeginErrorReadLine ()
+
+        proc.WaitForExit ()

Consumer/TestAsync.fs

@@ -0,0 +1,23 @@
+namespace Consumer
+
+open System
+open System.Threading.Tasks
+open FsUnitTyped
+open NUnit.Framework
+
+[<TestFixture>]
+module TestAsync =
+
+    [<Test>]
+    let ``an async test`` () =
+        async {
+            do! Async.Sleep (TimeSpan.FromMilliseconds 20.0)
+            1 |> shouldEqual 1
+        }
+
+    [<Test>]
+    let ``an async test, task-based`` () =
+        task {
+            do! Task.Delay (TimeSpan.FromMilliseconds 20.0)
+            1 |> shouldEqual 1
+        }

Consumer/TestExplicit.fs

@@ -0,0 +1,24 @@
+namespace Consumer
+
+open NUnit.Framework
+
+[<TestFixture>]
+module TestExplicitIndividual =
+
+    [<Explicit>]
+    [<Test>]
+    let ``This test should not be run`` () = failwith<unit> "should not call"
+
+[<Explicit>]
+[<TestFixture>]
+module TestExplicitModule =
+
+    [<OneTimeSetUp>]
+    let setUp () = failwith<unit> "should not call: setup"
+
+    [<OneTimeTearDown>]
+    let tearDown () =
+        failwith<unit> "should not call: teardown"
+
+    [<Test>]
+    let ``This test should not be run because its module is explicit`` () = failwith<unit> "should not call: test"

Consumer/TestParallelIndividualTest.fs

@@ -0,0 +1,59 @@
+namespace Consumer
+
+open System
+open System.Collections.Concurrent
+open System.Threading
+open NUnit.Framework
+open FsUnitTyped
+
+// These tests are flaky if the bug https://github.com/Smaug123/unofficial-nunit-runner/issues/168 is unfixed.
+[<TestFixture>]
+module TestParallelIndividualTest =
+
+    type private Transitions =
+        | Started of int
+        | LockAcquired of int
+        | Exited of int
+
+    let locker = obj ()
+    let private sequence = ConcurrentQueue<Transitions> ()
+
+    [<Test>]
+    [<Parallelizable(ParallelScope.None)>]
+    let ``does not run in parallel`` () =
+        sequence.Enqueue (Transitions.Started 0)
+        let entered = Monitor.TryEnter (locker, TimeSpan.Zero)
+
+        if entered then
+            sequence.Enqueue (Transitions.LockAcquired 0)
+            Monitor.Exit locker
+            sequence.Enqueue (Transitions.Exited 0)
+        else
+            sequence.Enqueue (Transitions.Exited 0)
+            failwith "failed to acquire the lock"
+
+    [<Test>]
+    let ``unrestricted parallelism`` () =
+        sequence.Enqueue (Transitions.Started 1)
+        let entered = Monitor.TryEnter (locker, TimeSpan.Zero)
+
+        if entered then
+            sequence.Enqueue (Transitions.LockAcquired 1)
+            Monitor.Exit locker
+            sequence.Enqueue (Transitions.Exited 1)
+        else
+            sequence.Enqueue (Transitions.Exited 1)
+            failwith "failed to acquire the lock"
+
+    [<OneTimeTearDown>]
+    let ``It worked`` () =
+        let sequence = sequence |> Seq.toList
+
+        let allowed n =
+            [ Transitions.Started n ; Transitions.LockAcquired n ; Transitions.Exited n ]
+
+        if sequence <> allowed 0 @ allowed 1 && sequence <> allowed 1 @ allowed 0 then
+            let s = sequence |> Seq.map string<Transitions> |> String.concat "\n"
+            failwith $"Unexpected sequence!\n%s{s}"
+
+        ()

Directory.Build.props

@@ -10,7 +10,7 @@
     <WarnOn>FS3388,FS3559</WarnOn>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="Nerdbank.GitVersioning" Version="3.6.139" PrivateAssets="all"/>
+    <PackageReference Include="Nerdbank.GitVersioning" Version="3.8.118" PrivateAssets="all" />
   </ItemGroup>
   <PropertyGroup Condition="'$(GITHUB_ACTION)' != ''">
     <ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>

FailingConsumer/FailingConsumer.fsproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+      <TargetFramework>net9.0</TargetFramework>
+      <IsPackable>false</IsPackable>
+      <IsTestProject>true</IsTestProject>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <Compile Include="TestInsufficientArgs.fs" />
+    </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="FsUnit" Version="7.1.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1"/>
+    <PackageReference Include="NUnit" Version="4.3.2"/>
+    <PackageReference Include="NUnit3TestAdapter" Version="5.0.0"/>
+  </ItemGroup>
+
+</Project>

FailingConsumer/TestInsufficientArgs.fs

@@ -0,0 +1,9 @@
+namespace FailingConsumer
+
+open NUnit.Framework
+
+[<TestFixture>]
+module TestInsufficientArgs =
+
+    [<Test>]
+    let foo (_ : int) = ()

FailingConsumer/expected.txt

@@ -0,0 +1 @@
+foo: had parameter count mismatch: expected 1, actual 0

README.md

@@ -12,5 +12,8 @@ However, we would recommend phrasing some of them differently, for maximum peace
 ## 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).
+By default, we run tests in parallel, taking half the available processors; we may or may not respect the NUnit parallelism attributes to any given extent that they tell us to be *more* parallel (but we will never incorrectly run tests in parallel).
+
+# Licence
+
+WoofWare.NUnitTestRunner is licensed to you under the MIT licence, a copy of which can be found at [LICENSE](./LICENSE).

WoofWare.NUnitTestRunner.Lib/Args.fs

@@ -0,0 +1,99 @@
+namespace WoofWare.NUnitTestRunner
+
+open System
+open System.IO
+
+[<AutoOpen>]
+module internal Patterns =
+    let (|Key|_|) (start : string) (s : string) : string option =
+        if s.StartsWith (start + "=", StringComparison.Ordinal) then
+            s.Substring (start.Length + 1) |> Some
+        else
+            None
+
+/// Represents how verbose the test runner's logging should be.
+[<RequireQualifiedAccess>]
+type LogLevel =
+    /// Don't log any information about the test run.
+    | Nothing
+    /// Log as much information as is available about the test run.
+    | Verbose
+
+/// Arguments controlling the test runner itself (not the tests therein).
+type Args =
+    {
+        /// The DLL containing the tests we'll reflectively discover and invoke.
+        Dll : FileInfo
+        /// If set, the output file into which we will write a TRX report. (We'll create parent directories as necessary.)
+        Trx : FileInfo option
+        /// Also contains the original string which specified the filter.
+        Filter : (string * Filter) option
+        /// How verbose to be with the test runner's own logging.
+        Logging : LogLevel
+        /// Maximum number of tests which can run concurrently. This setting overrides any LevelOfParallelism reflectively
+        /// extracted from the assembly under test.
+        LevelOfParallelism : int option
+        /// Abort if the test runner is running for longer than this timeout.
+        Timeout : TimeSpan option
+    }
+
+    /// Parse `argv` into a structured Args.
+    static member Parse (args : string list) : Args =
+        match args with
+        | [] -> failwith "The first arg must be a positional arg, the DLL to test."
+        | dll :: args ->
+
+        let rec go
+            (trx : FileInfo option)
+            (filter : (string * Filter) option)
+            (logging : LogLevel option)
+            (par : int option)
+            (timeout : TimeSpan option)
+            (args : string list)
+            =
+            match args with
+            | [] ->
+                {
+                    Dll = FileInfo dll
+                    Trx = trx
+                    Filter = filter
+                    Logging = logging |> Option.defaultValue LogLevel.Nothing
+                    LevelOfParallelism = par
+                    Timeout = timeout
+                }
+            | Key "--filter" filterStr :: rest
+            | "--filter" :: filterStr :: rest ->
+                match filter with
+                | Some _ -> failwith "Two conflicting filters; you can only specify --filter once"
+                | None -> go trx (Some (filterStr, Filter.parse filterStr)) logging par timeout rest
+            | Key "--trx" trxStr :: rest
+            | "--trx" :: trxStr :: rest ->
+                match trx with
+                | Some _ -> failwith "Two conflicting TRX outputs; you can only specify --trx once"
+                | None -> go (Some (FileInfo trxStr)) filter logging par timeout rest
+            | Key "--verbose" verboseStr :: rest
+            | "--verbose" :: verboseStr :: rest ->
+                match logging with
+                | Some _ -> failwith "Two conflicting --verbose outputs; you can only specify --verbose once"
+                | None ->
+                    let verbose =
+                        if Boolean.Parse verboseStr then
+                            LogLevel.Verbose
+                        else
+                            LogLevel.Nothing
+
+                    go trx filter (Some verbose) par timeout rest
+            | Key "--parallelism" parStr :: rest
+            | "--parallelism" :: parStr :: rest ->
+                match par with
+                | Some _ -> failwith "Two conflicting --parallelism outputs; you can only specify --parallelism once"
+                | None -> go trx filter logging (Some (Int32.Parse parStr)) timeout rest
+            | Key "--timeout-seconds" timeoutStr :: rest
+            | "--timeout-seconds" :: timeoutStr :: rest ->
+                match timeout with
+                | Some _ ->
+                    failwith "Two conflicting --timeout-seconds outputs; you can only specify --timeout-seconds once"
+                | None -> go trx filter logging par (Some (TimeSpan.FromSeconds (Int32.Parse timeoutStr |> float))) rest
+            | k :: _rest -> failwith $"Unrecognised arg %s{k}"
+
+        go None None None None None args

WoofWare.NUnitTestRunner.Lib/AssemblyLevelAttributes.fs

@@ -0,0 +1,62 @@
+namespace WoofWare.NUnitTestRunner
+
+open System.Reflection
+
+/// Attributes at the assembly level which control the behaviour of NUnit.
+type AssemblyLevelAttributes =
+    {
+        /// How many tests can be running at once, if anything's running in parallel.
+        Parallelism : int option
+        /// Whether the tests in this assembly can be parallelised at all.
+        Parallelizable : Parallelizable<AssemblyParallelScope> option
+    }
+
+[<RequireQualifiedAccess>]
+module AssemblyLevelAttributes =
+
+    /// Reflectively obtain the values of any relevant assembly attributes.
+    let get (assy : Assembly) : AssemblyLevelAttributes =
+        ((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 ParallelScope.ofInt v with
+                            | ParallelScope.Fixtures ->
+                                levelPar, Some (Parallelizable.Yes AssemblyParallelScope.Fixtures)
+                            | ParallelScope.Children ->
+                                levelPar, Some (Parallelizable.Yes AssemblyParallelScope.Children)
+                            | ParallelScope.None -> levelPar, Some Parallelizable.No
+                            | ParallelScope.All ->
+                                failwith "ParallelScope.All is invalid on assemblies; only Fixtures or Children"
+                            | ParallelScope.Self ->
+                                failwith "ParallelScope.Self is invalid on assemblies; only Fixtures or Children"
+                        | v -> failwith $"Unexpectedly non-int value %O{v} of parallel scope on assembly"
+                    | _ -> failwith "unexpectedly got multiple args to Parallelizable on assembly"
+            | _ -> levelPar, par
+        )
+        |> fun (par, canPar) ->
+            {
+                Parallelizable = canPar
+                Parallelism = par
+            }

WoofWare.NUnitTestRunner.Lib/Context.fs

@@ -10,20 +10,14 @@ open System.Threading
 
 type internal OutputStreamId = | OutputStreamId of Guid
 
-type private ThreadAwareWriter
-    (
-        local : AsyncLocal<OutputStreamId>,
-        underlying : Dictionary<OutputStreamId, TextWriter>,
-        mem : Dictionary<OutputStreamId, MemoryStream>
-    )
+type private ThreadAwareWriter (local : AsyncLocal<OutputStreamId>, underlying : Dictionary<OutputStreamId, TextWriter>)
     =
     inherit TextWriter ()
     override _.get_Encoding () = Encoding.Default
 
     override this.Write (v : char) : unit =
-        use prev = ExecutionContext.Capture ()
-
-        (fun _ ->
+        lock
+            underlying
             (fun () ->
                 match underlying.TryGetValue local.Value with
                 | true, output -> output.Write v
@@ -31,16 +25,12 @@ type private ThreadAwareWriter
                     let wanted =
                         underlying |> Seq.map (fun (KeyValue (a, b)) -> $"%O{a}") |> String.concat "\n"
 
-                    failwith $"no such context: %O{local.Value}\nwanted:\n"
+                    failwith $"no such context: %O{local.Value}\nwanted:\n{wanted}"
             )
-            |> lock underlying
-        )
-        |> fun action -> ExecutionContext.Run (prev, action, ())
 
     override this.WriteLine (v : string) : unit =
-        use prev = ExecutionContext.Capture ()
-
-        (fun _ ->
+        lock
+            underlying
             (fun () ->
                 match underlying.TryGetValue local.Value with
                 | true, output -> output.WriteLine v
@@ -48,15 +38,13 @@ type private ThreadAwareWriter
                     let wanted =
                         underlying |> Seq.map (fun (KeyValue (a, b)) -> $"%O{a}") |> String.concat "\n"
 
-                    failwith $"no such context: %O{local.Value}\nwanted:\n"
+                    failwith $"no such context: %O{local.Value}\nwanted:\n{wanted}"
             )
-            |> lock underlying
-        )
-        |> fun action -> ExecutionContext.Run (prev, action, ())
 
 /// Wraps up the necessary context to intercept global state.
+[<NoEquality ; NoComparison>]
 type TestContexts =
-    private
+    internal
         {
             /// Accesses to this must be locked on StdOutWriters.
             StdOuts : Dictionary<OutputStreamId, MemoryStream>
@@ -76,8 +64,8 @@ type TestContexts =
         let stdoutWriters = Dictionary ()
         let stderrWriters = Dictionary ()
         let local = AsyncLocal ()
-        let stdoutWriter = new ThreadAwareWriter (local, stdoutWriters, stdouts)
-        let stderrWriter = new ThreadAwareWriter (local, stderrWriters, stderrs)
+        let stdoutWriter = new ThreadAwareWriter (local, stdoutWriters)
+        let stderrWriter = new ThreadAwareWriter (local, stderrWriters)
 
         {
             StdOuts = stdouts
@@ -89,8 +77,13 @@ type TestContexts =
             AsyncLocal = local
         }
 
-    member internal this.Stdout : TextWriter = this.StdOutWriter
-    member internal this.Stderr : TextWriter = this.StdErrWriter
+    /// An output stream which will identify the ExecutionContext it's being written to from,
+    /// and will separate that output into its own stream internally.
+    member this.Stdout : TextWriter = this.StdOutWriter
+
+    /// An output stream which will identify the ExecutionContext it's being written to from,
+    /// and will separate that output into its own stream internally.
+    member this.Stderr : TextWriter = this.StdErrWriter
 
     member internal this.DumpStdout (id : OutputStreamId) : string =
         lock

WoofWare.NUnitTestRunner.Lib/CreateTrxReport.fs

@@ -0,0 +1,263 @@
+namespace WoofWare.NUnitTestRunner
+
+open System
+open System.Reflection
+
+/// Methods for constructing TRX reports.
+[<RequireQualifiedAccess>]
+module BuildTrxReport =
+
+    /// Build a TRX report from the given results.
+    let build
+        (assy : Assembly)
+        (creationTime : DateTimeOffset)
+        (startTime : DateTimeOffset)
+        (results : FixtureRunResults list)
+        : TrxReport
+        =
+        let finishTime = DateTimeOffset.Now
+        let finishTimeHumanReadable = finishTime.ToString @"yyyy-MM-dd HH:mm:ss"
+        let nowMachine = finishTime.ToString @"yyyy-MM-dd_HH_mm_ss"
+
+        let testListId = Guid.NewGuid ()
+
+        let testDefinitions, testEntries =
+            results
+            |> List.collect (fun results -> results.IndividualTestRunMetadata)
+            |> List.map (fun (data, _) ->
+                let defn =
+                    {
+                        Name = data.TestName
+                        Storage = assy.Location.ToLowerInvariant ()
+                        Id = data.TestId
+                        Execution =
+                            {
+                                Id = data.ExecutionId
+                            }
+                        TestMethod =
+                            {
+                                CodeBase = assy.Location
+                                AdapterTypeName = Uri "executor://woofware/"
+                                ClassName = data.ClassName
+                                Name = data.TestName
+                            }
+                    }
+
+                let entry : TrxTestEntry =
+                    {
+                        TestListId = testListId
+                        ExecutionId = data.ExecutionId
+                        TestId = data.TestId
+
+                    }
+
+                defn, entry
+            )
+            |> List.unzip
+
+        let hostname = Environment.MachineName
+
+        let settings =
+            {
+                Name = "default"
+                Id = Guid.NewGuid ()
+                Deployment =
+                    {
+                        RunDeploymentRoot = $"_%s{hostname}_%s{nowMachine}"
+                    }
+            }
+
+        let testList : TrxTestListEntry =
+            {
+                Id = testListId
+                Name = "All"
+            }
+
+        let counters =
+            (TrxCounters.Zero, results)
+            // TODO: this is woefully inefficient
+            ||> List.fold (fun counters results ->
+                let counters =
+                    (counters, results.Failed)
+                    ||> List.fold (fun counters (_, _) ->
+                        // TODO: the counters can be more specific about the failure mode
+                        counters.AddFailed ()
+                    )
+
+                let counters =
+                    (counters, results.OtherFailures)
+                    ||> List.fold (fun counters _ ->
+                        // TODO: the counters can be more specific about the failure mode
+                        counters.AddFailed ()
+                    )
+
+                (counters, results.Success)
+                ||> List.fold (fun counters (_, success, _) ->
+                    match success with
+                    | TestMemberSuccess.Ok -> counters.AddPassed ()
+                    | TestMemberSuccess.Ignored _
+                    | TestMemberSuccess.Explicit _ -> counters.AddNotExecuted ()
+                    | TestMemberSuccess.Inconclusive _ -> counters.AddInconclusive ()
+                )
+            )
+
+        // TODO: I'm sure we can do better than this; there's a whole range of possible
+        // states!
+        let outcome =
+            if counters.Failed > 0u then
+                TrxOutcome.Failed
+            else
+                TrxOutcome.Completed
+
+        let resultSummary : TrxResultsSummary =
+            {
+                Outcome = outcome
+                Counters = counters
+                Output =
+                    {
+                        StdOut = None
+                        StdErr = None
+                        ErrorInfo = None
+                    }
+                RunInfos =
+                    [
+                    // TODO: capture stdout
+                    ]
+            }
+
+        let times : TrxReportTimes =
+            {
+                Creation = creationTime
+                Queuing = startTime
+                Start = startTime
+                Finish = finishTime
+
+            }
+
+        let magicGuid = Guid.Parse "13cdc9d9-ddb5-4fa4-a97d-d965ccfc6d4b"
+
+        let results =
+            results
+            |> List.collect (fun results -> results.IndividualTestRunMetadata)
+            |> List.map (fun (i, cause) ->
+                let exc =
+                    match cause with
+                    | Choice2Of3 _ -> None
+                    | Choice1Of3 (TestMemberFailure.Malformed reasons) ->
+                        {
+                            StackTrace = None
+                            Message = reasons |> String.concat "\n" |> Some
+                        }
+                        |> Some
+                    | Choice1Of3 (TestMemberFailure.Failed fail)
+                    | Choice1Of3 (TestMemberFailure.Failed fail)
+                    | Choice1Of3 (TestMemberFailure.Failed fail) ->
+                        ((None, None), fail)
+                        ||> List.fold (fun (stackTrace, message) tf ->
+                            match tf with
+                            | TestFailure.TestFailed (UserMethodFailure.Threw (_, exc))
+                            | TestFailure.SetUpFailed (UserMethodFailure.Threw (_, exc))
+                            | TestFailure.TearDownFailed (UserMethodFailure.Threw (_, exc)) ->
+                                let stackTrace =
+                                    match stackTrace with
+                                    | None -> (exc : Exception).ToString ()
+                                    | Some s -> s
+
+                                (Some stackTrace, message)
+                            | TestFailure.TestFailed (UserMethodFailure.BadParameters (_, expected, actual))
+                            | TestFailure.SetUpFailed (UserMethodFailure.BadParameters (_, expected, actual))
+                            | TestFailure.TearDownFailed (UserMethodFailure.BadParameters (_, expected, actual)) ->
+                                let newMessage =
+                                    $"had parameter count mismatch: expected %i{expected.Length}, actual %i{actual.Length}"
+
+                                let message =
+                                    match message with
+                                    | None -> newMessage
+                                    | Some message -> $"%s{message}\n%s{newMessage}"
+
+                                (stackTrace, Some message)
+                            | TestFailure.TestFailed (UserMethodFailure.ReturnedNonUnit (_, ret))
+                            | TestFailure.SetUpFailed (UserMethodFailure.ReturnedNonUnit (_, ret))
+                            | TestFailure.TearDownFailed (UserMethodFailure.ReturnedNonUnit (_, ret)) ->
+                                let newMessage = $"returned non-unit value %O{ret}"
+
+                                let message =
+                                    match message with
+                                    | None -> newMessage
+                                    | Some message -> $"%s{message}\n%s{newMessage}"
+
+                                (stackTrace, Some message)
+                        )
+                        |> fun (stackTrace, message) ->
+                            {
+                                StackTrace = stackTrace
+                                Message = message
+                            }
+                            |> Some
+                    | Choice3Of3 (UserMethodFailure.Threw (_, exc)) ->
+                        {
+                            StackTrace = (exc : Exception).ToString () |> Some
+                            Message = None
+                        }
+                        |> Some
+                    | Choice3Of3 (UserMethodFailure.BadParameters (_, expected, actual)) ->
+                        {
+                            StackTrace = None
+                            Message =
+                                $"parameter count mismatch, expected %i{expected.Length}, actual %i{actual.Length}"
+                                |> Some
+                        }
+                        |> Some
+                    | Choice3Of3 (UserMethodFailure.ReturnedNonUnit (_, ret)) ->
+                        {
+                            Message = $"returned non-unit value %O{ret}" |> Some
+                            StackTrace = None
+                        }
+                        |> Some
+
+                let outcome =
+                    match cause with
+                    | Choice1Of3 _ -> TrxTestOutcome.Failed
+                    | Choice2Of3 TestMemberSuccess.Ok -> TrxTestOutcome.Passed
+                    | Choice2Of3 (TestMemberSuccess.Inconclusive _) -> TrxTestOutcome.Inconclusive
+                    | Choice2Of3 (TestMemberSuccess.Ignored _)
+                    | Choice2Of3 (TestMemberSuccess.Explicit _) -> TrxTestOutcome.NotExecuted
+                    // TODO: we can totally do better here, more fine-grained classification
+                    | Choice3Of3 _ -> TrxTestOutcome.Failed
+
+                {
+                    ExecutionId = i.ExecutionId
+                    TestId = i.TestId
+                    TestName = i.TestName
+                    ComputerName = i.ComputerName
+                    Duration = i.End - i.Start
+                    StartTime = i.Start
+                    EndTime = i.End
+                    TestType = magicGuid
+                    Outcome = outcome
+                    TestListId = testListId
+                    RelativeResultsDirectory = i.ExecutionId.ToString () // for some reason
+                    Output =
+                        match i.StdOut, i.StdErr, exc with
+                        | None, None, None -> None
+                        | stdout, stderr, exc ->
+                            Some
+                                {
+                                    TrxOutput.StdOut = stdout
+                                    StdErr = stderr
+                                    ErrorInfo = exc
+                                }
+                }
+            )
+
+        {
+            Id = Guid.NewGuid ()
+            Name = $"@%s{hostname} %s{finishTimeHumanReadable}"
+            Times = times
+            Settings = settings
+            Results = results
+            TestDefinitions = testDefinitions
+            TestEntries = testEntries
+            TestLists = [ testList ]
+            ResultsSummary = resultSummary
+        }

WoofWare.NUnitTestRunner.Lib/Domain.fs

@@ -61,6 +61,24 @@ type Parallelizable<'scope> =
     /// This test must always be run on its own.
     | No
 
+[<RequireQualifiedAccess>]
+module Parallelizable =
+    /// Functorial map.
+    let inline map<'a, 'b> ([<InlineIfLambda>] f : 'a -> 'b) (p : Parallelizable<'a>) : Parallelizable<'b> =
+        match p with
+        | Parallelizable.No -> Parallelizable.No
+        | Parallelizable.Yes a -> Parallelizable.Yes (f a)
+
+    /// Functorial bind.
+    let inline bind<'a, 'b>
+        ([<InlineIfLambda>] f : 'a -> Parallelizable<'b>)
+        (p : Parallelizable<'a>)
+        : Parallelizable<'b>
+        =
+        match p with
+        | Parallelizable.No -> Parallelizable.No
+        | Parallelizable.Yes a -> f a
+
 /// 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 =
@@ -120,10 +138,17 @@ type TestFixture =
         Tests : SingleTestMethod list
         /// If this fixture has declared a parallelisability, that goes here.
         Parallelize : Parallelizable<ClassParallelScope> option
+        /// It is possible to mark a fixture as "Explicit" or "Ignored", for example.
+        Modifiers : Modifier list
     }
 
     /// A test fixture about which we know nothing. No tests, no setup/teardown.
-    static member Empty (ty : Type) (par : Parallelizable<ClassParallelScope> option) (args : obj list list) =
+    static member Empty
+        (ty : Type)
+        (par : Parallelizable<ClassParallelScope> option)
+        (modifiers : Modifier list)
+        (args : obj list list)
+        =
         {
             ContainingAssembly = ty.Assembly
             Type = ty
@@ -135,6 +160,7 @@ type TestFixture =
             Parameters = args
             Tests = []
             Parallelize = par
+            Modifiers = modifiers
         }
 
 /// User code in the unit under test has failed somehow.
@@ -144,6 +170,8 @@ type UserMethodFailure =
     | ReturnedNonUnit of name : string * result : obj
     /// A method threw.
     | Threw of name : string * exn
+    /// Parameter count mismatch.
+    | BadParameters of name : string * expected : Type[] * actual : obj[]
 
     /// Human-readable representation of the user failure.
     override this.ToString () =
@@ -152,12 +180,22 @@ type UserMethodFailure =
             $"User-defined method '%s{method}' returned a non-unit: %O{ret}"
         | UserMethodFailure.Threw (method, exc) ->
             $"User-defined method '%s{method}' threw: %s{exc.Message}\n  %s{exc.StackTrace}"
+        | UserMethodFailure.BadParameters (method, expected, actual) ->
+            let expectedStr = expected |> Seq.map (fun t -> t.Name) |> String.concat ", "
+
+            let actualStr =
+                actual
+                |> Seq.map (fun s -> if isNull s then "null" else s.ToString ())
+                |> String.concat ", "
+
+            $"User-defined method '%s{method}' had parameter count mismatch. Expected: (%s{expectedStr}) (%i{expected.Length} params). Actual: (%s{actualStr}) (%i{actual.Length} params)"
 
     /// Name (not fully-qualified) of the method which failed.
     member this.Name =
         match this with
         | UserMethodFailure.Threw (name, _)
         | UserMethodFailure.ReturnedNonUnit (name, _) -> name
+        | UserMethodFailure.BadParameters (name, _, _) -> name
 
 /// Represents the failure of a single run of one test. An error signalled this way is a user error: the unit under
 /// test has misbehaved.

WoofWare.NUnitTestRunner.Lib/DotnetRuntime.fs

@@ -7,11 +7,7 @@ open WoofWare.DotnetRuntimeLocator
 /// Functions for locating .NET runtimes.
 [<RequireQualifiedAccess>]
 module DotnetRuntime =
-    let private selectRuntime
-        (config : RuntimeOptions)
-        (f : DotnetEnvironmentInfo)
-        : Choice<DotnetEnvironmentFrameworkInfo, DotnetEnvironmentSdkInfo> option
-        =
+    let private selectRuntime (config : RuntimeOptions) (f : DotnetEnvironmentInfo) : DirectoryInfo list =
         let rollForward =
             match Environment.GetEnvironmentVariable "DOTNET_ROLL_FORWARD" with
             | null ->
@@ -20,6 +16,14 @@ module DotnetRuntime =
                 |> Option.defaultValue RollForward.Minor
             | s -> RollForward.Parse s
 
+        if
+            Option.isSome config.IncludedFramework
+            || Option.isSome config.IncludedFrameworks
+        then
+            // No need for a framework that's anywhere other than the given DLL.
+            []
+        else
+
         let desiredVersions =
             match config.Framework with
             | Some f -> [ Version f.Version, f.Name ]
@@ -66,15 +70,13 @@ module DotnetRuntime =
 
                     name, data.Installed
                 )
-                // TODO: how do we select between many available frameworks?
-                |> Seq.tryHead
+                |> Seq.toList
 
-            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
+            // TODO: maybe we can ask the SDK if we don't have any runtimes.
+            // But we keep on trucking: maybe we're self-contained, and we'll actually find all the runtime next to the
+            // DLL.
+            available
+            |> List.map (fun (_name, runtime) -> DirectoryInfo $"%s{runtime.Path}/%s{runtime.Version}")
         | _ -> failwith "non-minor RollForward not supported yet; please shout if you want it"
 
     /// Given an executable DLL, locate the .NET runtime that can best run it.
@@ -96,9 +98,4 @@ module DotnetRuntime =
 
         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 ]
+        dll.Directory :: runtime

WoofWare.NUnitTestRunner.Lib/Exception.fs

@@ -0,0 +1,10 @@
+namespace WoofWare.NUnitTestRunner
+
+open System.Runtime.ExceptionServices
+
+[<RequireQualifiedAccess>]
+module internal Exception =
+    let reraiseWithOriginalStackTrace<'a> (e : exn) : 'a =
+        let edi = ExceptionDispatchInfo.Capture e
+        edi.Throw ()
+        failwith "unreachable"

WoofWare.NUnitTestRunner.Lib/Filter.fs

@@ -2,7 +2,7 @@ namespace WoofWare.NUnitTestRunner
 
 open System
 open System.IO
-open PrattParser
+open WoofWare.PrattParser
 
 // Documentation:
 // https://learn.microsoft.com/en-us/dotnet/core/testing/selective-unit-tests?pivots=mstest
@@ -155,9 +155,7 @@ module internal Lexer =
 [<RequireQualifiedAccess>]
 module internal ParsedFilter =
     let private unescape (s : string) : string =
-        System.Xml.XmlReader
-            .Create(new StringReader ("<r>" + s + "</r>"))
-            .ReadElementString ()
+        System.Xml.XmlReader.Create(new StringReader ("<r>" + s + "</r>")).ReadElementString ()
 
     let private atom (inputString : string) (token : Token) : ParsedFilter option =
         let start, len = token.Trivia

WoofWare.NUnitTestRunner.Lib/ParallelQueue.fs

@@ -4,16 +4,16 @@ open System
 open System.Threading
 open System.Threading.Tasks
 
-type private ThunkEvaluator<'ret> =
-    abstract Eval<'a> : (unit -> 'a) -> AsyncReplyChannel<'a> -> 'ret
+type private AsyncThunkEvaluator<'ret> =
+    abstract Eval<'a> : (unit -> Async<'a>) -> AsyncReplyChannel<Result<'a, exn>> -> 'ret
 
-type private ThunkCrate =
-    abstract Apply<'ret> : ThunkEvaluator<'ret> -> 'ret
+type private AsyncThunkCrate =
+    abstract Apply<'ret> : AsyncThunkEvaluator<'ret> -> 'ret
 
 [<RequireQualifiedAccess>]
-module private ThunkCrate =
-    let make<'a> (t : unit -> 'a) (rc : AsyncReplyChannel<'a>) : ThunkCrate =
-        { new ThunkCrate with
+module private AsyncThunkCrate =
+    let make<'a> (t : unit -> Async<'a>) (rc : AsyncReplyChannel<Result<'a, exn>>) : AsyncThunkCrate =
+        { new AsyncThunkCrate with
             member _.Apply e = e.Eval t rc
         }
 
@@ -41,7 +41,11 @@ type private MailboxMessage =
     | Quit of AsyncReplyChannel<unit>
     /// Check current state, see if we need to start more tests, etc.
     | Reconcile
-    | RunTest of within : TestFixture * Parallelizable<unit> option * test : ThunkCrate
+    | RunTestAsync of
+        within : TestFixture *
+        Parallelizable<unit> option *
+        test : AsyncThunkCrate *
+        context : ExecutionContext
     | BeginTestFixture of TestFixture * AsyncReplyChannel<TestFixtureRunningToken>
     | EndTestFixture of TestFixtureTearDownToken * AsyncReplyChannel<unit>
 
@@ -310,21 +314,31 @@ type ParallelQueue
                     rc.Reply ()
                     m.Post MailboxMessage.Reconcile
                     return! processTask (Running state) m
-            | MailboxMessage.RunTest (withinFixture, par, message) ->
+            | MailboxMessage.RunTestAsync (withinFixture, par, message, capturedContext) ->
                 let t () =
-                    { new ThunkEvaluator<_> with
-                        member _.Eval<'b> (t : unit -> 'b) rc =
-                            let tcs = TaskCompletionSource ()
-                            use ec = ExecutionContext.Capture ()
+                    { new AsyncThunkEvaluator<_> with
+                        member _.Eval<'b> (t : unit -> Async<'b>) rc =
+                            let tcs = TaskCompletionSource TaskCreationOptions.RunContinuationsAsynchronously
 
                             fun () ->
                                 ExecutionContext.Run (
-                                    ec,
+                                    capturedContext,
                                     (fun _ ->
-                                        let result = t ()
-                                        tcs.SetResult ()
-                                        m.Post MailboxMessage.Reconcile
-                                        rc.Reply result
+                                        async {
+                                            let! result =
+                                                async {
+                                                    try
+                                                        let! r = t ()
+                                                        return Ok r
+                                                    with e ->
+                                                        return Error e
+                                                }
+
+                                            tcs.SetResult ()
+                                            m.Post MailboxMessage.Reconcile
+                                            rc.Reply result
+                                        }
+                                        |> Async.StartImmediate
                                     ),
                                     ()
                                 )
@@ -348,17 +362,36 @@ type ParallelQueue
     let mb = new MailboxProcessor<_> (processTask MailboxState.Idle)
     do mb.Start ()
 
+    /// Request to run the given async action, freely in parallel with other running tests.
+    /// The resulting Task will return when the action has completed.
+    member _.RunAsync<'a>
+        (TestFixtureSetupToken parent)
+        (scope : Parallelizable<unit> option)
+        (action : unit -> Async<'a>)
+        : 'a Task
+        =
+        let ec = ExecutionContext.Capture ()
+
+        task {
+            let! result =
+                (fun rc -> MailboxMessage.RunTestAsync (parent, scope, AsyncThunkCrate.make action rc, ec))
+                |> mb.PostAndAsyncReply
+                |> Async.StartAsTask
+
+            match result with
+            | Ok o -> return o
+            | Error e -> return Exception.reraiseWithOriginalStackTrace e
+        }
+
     /// Request to run the given action, freely in parallel with other running tests.
     /// The resulting Task will return when the action has completed.
-    member _.Run<'a>
-        (TestFixtureSetupToken parent)
+    member this.Run<'a>
+        (parent : TestFixtureSetupToken)
         (scope : Parallelizable<unit> option)
         (action : unit -> 'a)
         : 'a Task
         =
-        (fun rc -> MailboxMessage.RunTest (parent, scope, ThunkCrate.make action rc))
-        |> mb.PostAndAsyncReply
-        |> Async.StartAsTask
+        this.RunAsync parent scope (fun () -> async.Return (action ()))
 
     /// Declare that we wish to start the given test fixture. The resulting Task will return
     /// when you are allowed to start running tests from that fixture.
@@ -379,11 +412,22 @@ type ParallelQueue
                     | Parallelizable.Yes _ -> Parallelizable.Yes ()
                 )
 
+            let ec = ExecutionContext.Capture ()
+
             let! response =
-                (fun rc -> MailboxMessage.RunTest (parent, par, ThunkCrate.make action rc))
+                (fun rc ->
+                    MailboxMessage.RunTestAsync (
+                        parent,
+                        par,
+                        AsyncThunkCrate.make (fun () -> async.Return (action ())) rc,
+                        ec
+                    )
+                )
                 |> mb.PostAndAsyncReply
 
-            return response, TestFixtureSetupToken parent
+            match response with
+            | Ok response -> return response, TestFixtureSetupToken parent
+            | Error e -> return Exception.reraiseWithOriginalStackTrace e
         }
 
     /// Run the given one-time tear-down for the test fixture.
@@ -401,11 +445,22 @@ type ParallelQueue
                     | Parallelizable.Yes _ -> Parallelizable.Yes ()
                 )
 
+            let ec = ExecutionContext.Capture ()
+
             let! response =
-                (fun rc -> MailboxMessage.RunTest (parent, par, ThunkCrate.make action rc))
+                (fun rc ->
+                    MailboxMessage.RunTestAsync (
+                        parent,
+                        par,
+                        AsyncThunkCrate.make (fun () -> async.Return (action ())) rc,
+                        ec
+                    )
+                )
                 |> mb.PostAndAsyncReply
 
-            return response, TestFixtureTearDownToken parent
+            match response with
+            | Ok response -> return response, TestFixtureTearDownToken parent
+            | Error e -> return Exception.reraiseWithOriginalStackTrace e
         }
 
     /// Declare that we have finished submitting requests to run in the given test fixture.

WoofWare.NUnitTestRunner.Lib/ParallelScope.fs

@@ -0,0 +1,29 @@
+namespace WoofWare.NUnitTestRunner
+
+/// Our own strongly-typed rendering of the NUnit ParallelScope enum.
+/// This is more tightly modelled by ClassParallelScope and AssemblyParallelScope in our own domain; this type exists
+/// for the initial interop.
+[<RequireQualifiedAccess>]
+type ParallelScope =
+    /// Corresponds to NUnit's ParallelScope.Fixtures.
+    | Fixtures
+    /// Corresponds to NUnit's ParallelScope.Children.
+    | Children
+    /// Corresponds to NUnit's ParallelScope.All.
+    | All
+    /// Corresponds to NUnit's ParallelScope.Self.
+    | Self
+    /// Corresponds to NUnit's ParallelScope.None.
+    | None
+
+[<RequireQualifiedAccess>]
+module ParallelScope =
+    /// Convert the weakly-typed C# enum that is NUnit's `ParallelScope` to a strongly-typed representation.
+    let ofInt (n : int) =
+        match n with
+        | 512 -> ParallelScope.Fixtures
+        | 256 -> ParallelScope.Children
+        | 257 -> ParallelScope.All
+        | 1 -> ParallelScope.Self
+        | 2 -> ParallelScope.None
+        | _ -> failwith $"Unrecognised ParallelScope enum: %i{n}"

WoofWare.NUnitTestRunner.Lib/RuntimeConfig.fs

@@ -1,25 +1,26 @@
 namespace WoofWare.NUnitTestRunner
 
 open System
-open WoofWare.Myriad.Plugins
 
-[<JsonParse>]
+// Myriad runs the JsonParse generator on this
 type internal FrameworkDescription =
     {
         Name : string
         Version : string
     }
 
-[<JsonParse>]
+// Myriad runs the JsonParse generator on this
 type internal RuntimeOptions =
     {
         Tfm : string
         Framework : FrameworkDescription option
         Frameworks : FrameworkDescription list option
+        IncludedFramework : FrameworkDescription option
+        IncludedFrameworks : FrameworkDescription list option
         RollForward : string option
     }
 
-[<JsonParse>]
+// Myriad runs the JsonParse generator on this
 type internal RuntimeConfig =
     {
         RuntimeOptions : RuntimeOptions

WoofWare.NUnitTestRunner.Lib/SingleTestMethod.fs

@@ -94,7 +94,27 @@ module SingleTestMethod =
                     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 ()))
+                        let arg =
+                            match Seq.toList attr.ConstructorArguments with
+                            | [] -> Parallelizable.Yes ()
+                            | [ x ] ->
+                                if x.ArgumentType.Name <> "ParallelScope" then
+                                    failwith
+                                        $"Got argument %O{x.Value} of unrecognised type %s{x.ArgumentType.Name} on [<Parallelizable>] attribute; expected ParallelScope"
+
+                                match ParallelScope.ofInt (unbox<int> x.Value) with
+                                | ParallelScope.Children ->
+                                    failwith
+                                        $"Unexpected ParallelScope.Children on test %s{method.Name}; this is not valid on individual tests"
+                                | ParallelScope.Fixtures ->
+                                    failwith
+                                        $"Unexpected ParallelScope.Children on test %s{method.Name}; this is not valid on individual tests"
+                                | ParallelScope.All
+                                | ParallelScope.Self -> Parallelizable.Yes ()
+                                | ParallelScope.None -> Parallelizable.No
+                            | s -> failwith $"Got multiple arguments on a [<Parallelizable>] attribute: %O{s}"
+
+                        (remaining, isTest, sources, hasData, mods, cats, repeat, comb, Some arg)
                 | 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, par)

WoofWare.NUnitTestRunner.Lib/SurfaceBaseline.txt

@@ -1,8 +1,34 @@
+WoofWare.NUnitTestRunner.Args inherit obj, implements WoofWare.NUnitTestRunner.Args System.IEquatable, System.Collections.IStructuralEquatable
+WoofWare.NUnitTestRunner.Args..ctor [constructor]: (System.IO.FileInfo, System.IO.FileInfo option, (string * WoofWare.NUnitTestRunner.Filter) option, WoofWare.NUnitTestRunner.LogLevel, int option, System.TimeSpan option)
+WoofWare.NUnitTestRunner.Args.Dll [property]: [read-only] System.IO.FileInfo
+WoofWare.NUnitTestRunner.Args.Equals [method]: (WoofWare.NUnitTestRunner.Args, System.Collections.IEqualityComparer) -> bool
+WoofWare.NUnitTestRunner.Args.Filter [property]: [read-only] (string * WoofWare.NUnitTestRunner.Filter) option
+WoofWare.NUnitTestRunner.Args.get_Dll [method]: unit -> System.IO.FileInfo
+WoofWare.NUnitTestRunner.Args.get_Filter [method]: unit -> (string * WoofWare.NUnitTestRunner.Filter) option
+WoofWare.NUnitTestRunner.Args.get_LevelOfParallelism [method]: unit -> int option
+WoofWare.NUnitTestRunner.Args.get_Logging [method]: unit -> WoofWare.NUnitTestRunner.LogLevel
+WoofWare.NUnitTestRunner.Args.get_Timeout [method]: unit -> System.TimeSpan option
+WoofWare.NUnitTestRunner.Args.get_Trx [method]: unit -> System.IO.FileInfo option
+WoofWare.NUnitTestRunner.Args.LevelOfParallelism [property]: [read-only] int option
+WoofWare.NUnitTestRunner.Args.Logging [property]: [read-only] WoofWare.NUnitTestRunner.LogLevel
+WoofWare.NUnitTestRunner.Args.Parse [static method]: string list -> WoofWare.NUnitTestRunner.Args
+WoofWare.NUnitTestRunner.Args.Timeout [property]: [read-only] System.TimeSpan option
+WoofWare.NUnitTestRunner.Args.Trx [property]: [read-only] System.IO.FileInfo option
+WoofWare.NUnitTestRunner.AssemblyLevelAttributes inherit obj, implements WoofWare.NUnitTestRunner.AssemblyLevelAttributes System.IEquatable, System.Collections.IStructuralEquatable, WoofWare.NUnitTestRunner.AssemblyLevelAttributes System.IComparable, System.IComparable, System.Collections.IStructuralComparable
+WoofWare.NUnitTestRunner.AssemblyLevelAttributes..ctor [constructor]: (int option, WoofWare.NUnitTestRunner.AssemblyParallelScope WoofWare.NUnitTestRunner.Parallelizable option)
+WoofWare.NUnitTestRunner.AssemblyLevelAttributes.Equals [method]: (WoofWare.NUnitTestRunner.AssemblyLevelAttributes, System.Collections.IEqualityComparer) -> bool
+WoofWare.NUnitTestRunner.AssemblyLevelAttributes.get_Parallelism [method]: unit -> int option
+WoofWare.NUnitTestRunner.AssemblyLevelAttributes.get_Parallelizable [method]: unit -> WoofWare.NUnitTestRunner.AssemblyParallelScope WoofWare.NUnitTestRunner.Parallelizable option
+WoofWare.NUnitTestRunner.AssemblyLevelAttributes.Parallelism [property]: [read-only] int option
+WoofWare.NUnitTestRunner.AssemblyLevelAttributes.Parallelizable [property]: [read-only] WoofWare.NUnitTestRunner.AssemblyParallelScope WoofWare.NUnitTestRunner.Parallelizable option
+WoofWare.NUnitTestRunner.AssemblyLevelAttributesModule inherit obj
+WoofWare.NUnitTestRunner.AssemblyLevelAttributesModule.get [static method]: System.Reflection.Assembly -> WoofWare.NUnitTestRunner.AssemblyLevelAttributes
 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.Equals [method]: (WoofWare.NUnitTestRunner.AssemblyParallelScope, System.Collections.IEqualityComparer) -> bool
 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
@@ -12,6 +38,8 @@ 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.BuildTrxReport inherit obj
+WoofWare.NUnitTestRunner.BuildTrxReport.build [static method]: System.Reflection.Assembly -> System.DateTimeOffset -> System.DateTimeOffset -> WoofWare.NUnitTestRunner.FixtureRunResults list -> WoofWare.NUnitTestRunner.TrxReport
 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
@@ -20,6 +48,7 @@ WoofWare.NUnitTestRunner.ClassParallelScope+Tags.Fixtures [static field]: int =
 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.Equals [method]: (WoofWare.NUnitTestRunner.ClassParallelScope, System.Collections.IEqualityComparer) -> bool
 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
@@ -41,6 +70,7 @@ 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.Equals [method]: (WoofWare.NUnitTestRunner.Combinatorial, System.Collections.IEqualityComparer) -> bool
 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
@@ -82,6 +112,7 @@ 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.Equals [method]: (WoofWare.NUnitTestRunner.Filter, System.Collections.IEqualityComparer) -> bool
 WoofWare.NUnitTestRunner.Filter.get_IsAnd [method]: unit -> bool
 WoofWare.NUnitTestRunner.Filter.get_IsFullyQualifiedName [method]: unit -> bool
 WoofWare.NUnitTestRunner.Filter.get_IsName [method]: unit -> bool
@@ -107,6 +138,7 @@ WoofWare.NUnitTestRunner.FilterModule.parse [static method]: string -> WoofWare.
 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.Equals [method]: (WoofWare.NUnitTestRunner.FixtureRunResults, System.Collections.IEqualityComparer) -> bool
 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
@@ -120,6 +152,7 @@ WoofWare.NUnitTestRunner.IndividualTestRunMetadata..ctor [constructor]: (System.
 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.Equals [method]: (WoofWare.NUnitTestRunner.IndividualTestRunMetadata, System.Collections.IEqualityComparer) -> bool
 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
@@ -137,14 +170,30 @@ WoofWare.NUnitTestRunner.IndividualTestRunMetadata.StdOut [property]: [read-only
 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 - interface with 6 member(s)
 WoofWare.NUnitTestRunner.ITestProgress.OnTestFailed [method]: string -> WoofWare.NUnitTestRunner.TestMemberFailure -> unit
+WoofWare.NUnitTestRunner.ITestProgress.OnTestFixtureSkipped [method]: string -> string -> unit
 WoofWare.NUnitTestRunner.ITestProgress.OnTestFixtureStart [method]: string -> int -> unit
 WoofWare.NUnitTestRunner.ITestProgress.OnTestMemberFinished [method]: string -> unit
 WoofWare.NUnitTestRunner.ITestProgress.OnTestMemberSkipped [method]: string -> unit
 WoofWare.NUnitTestRunner.ITestProgress.OnTestMemberStart [method]: string -> unit
 WoofWare.NUnitTestRunner.LoadContext inherit System.Runtime.Loader.AssemblyLoadContext
 WoofWare.NUnitTestRunner.LoadContext..ctor [constructor]: (System.IO.FileInfo, System.IO.DirectoryInfo list, WoofWare.NUnitTestRunner.TestContexts)
+WoofWare.NUnitTestRunner.LogLevel inherit obj, implements WoofWare.NUnitTestRunner.LogLevel System.IEquatable, System.Collections.IStructuralEquatable, WoofWare.NUnitTestRunner.LogLevel System.IComparable, System.IComparable, System.Collections.IStructuralComparable - union type with 2 cases
+WoofWare.NUnitTestRunner.LogLevel+Tags inherit obj
+WoofWare.NUnitTestRunner.LogLevel+Tags.Nothing [static field]: int = 0
+WoofWare.NUnitTestRunner.LogLevel+Tags.Verbose [static field]: int = 1
+WoofWare.NUnitTestRunner.LogLevel.Equals [method]: (WoofWare.NUnitTestRunner.LogLevel, System.Collections.IEqualityComparer) -> bool
+WoofWare.NUnitTestRunner.LogLevel.get_IsNothing [method]: unit -> bool
+WoofWare.NUnitTestRunner.LogLevel.get_IsVerbose [method]: unit -> bool
+WoofWare.NUnitTestRunner.LogLevel.get_Nothing [static method]: unit -> WoofWare.NUnitTestRunner.LogLevel
+WoofWare.NUnitTestRunner.LogLevel.get_Tag [method]: unit -> int
+WoofWare.NUnitTestRunner.LogLevel.get_Verbose [static method]: unit -> WoofWare.NUnitTestRunner.LogLevel
+WoofWare.NUnitTestRunner.LogLevel.IsNothing [property]: [read-only] bool
+WoofWare.NUnitTestRunner.LogLevel.IsVerbose [property]: [read-only] bool
+WoofWare.NUnitTestRunner.LogLevel.Nothing [static property]: [read-only] WoofWare.NUnitTestRunner.LogLevel
+WoofWare.NUnitTestRunner.LogLevel.Tag [property]: [read-only] int
+WoofWare.NUnitTestRunner.LogLevel.Verbose [static property]: [read-only] WoofWare.NUnitTestRunner.LogLevel
 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
@@ -155,6 +204,7 @@ 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.Equals [method]: (WoofWare.NUnitTestRunner.Match, System.Collections.IEqualityComparer) -> bool
 WoofWare.NUnitTestRunner.Match.get_IsContains [method]: unit -> bool
 WoofWare.NUnitTestRunner.Match.get_IsExact [method]: unit -> bool
 WoofWare.NUnitTestRunner.Match.get_Tag [method]: unit -> int
@@ -173,6 +223,7 @@ WoofWare.NUnitTestRunner.Modifier+Ignored.reason [property]: [read-only] string
 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.Equals [method]: (WoofWare.NUnitTestRunner.Modifier, System.Collections.IEqualityComparer) -> bool
 WoofWare.NUnitTestRunner.Modifier.get_IsExplicit [method]: unit -> bool
 WoofWare.NUnitTestRunner.Modifier.get_IsIgnored [method]: unit -> bool
 WoofWare.NUnitTestRunner.Modifier.get_Tag [method]: unit -> int
@@ -181,6 +232,9 @@ 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 inherit obj
+WoofWare.NUnitTestRunner.Parallelizable.bind [static method]: ('a -> 'b WoofWare.NUnitTestRunner.Parallelizable) -> 'a WoofWare.NUnitTestRunner.Parallelizable -> 'b WoofWare.NUnitTestRunner.Parallelizable
+WoofWare.NUnitTestRunner.Parallelizable.map [static method]: ('a -> 'b) -> 'a WoofWare.NUnitTestRunner.Parallelizable -> 'b WoofWare.NUnitTestRunner.Parallelizable
 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
@@ -188,6 +242,7 @@ 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.Equals [method]: ('scope WoofWare.NUnitTestRunner.Parallelizable, System.Collections.IEqualityComparer) -> bool
 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
@@ -201,13 +256,47 @@ WoofWare.NUnitTestRunner.ParallelQueue inherit obj, implements IDisposable
 WoofWare.NUnitTestRunner.ParallelQueue..ctor [constructor]: (int option, WoofWare.NUnitTestRunner.AssemblyParallelScope WoofWare.NUnitTestRunner.Parallelizable option, System.Threading.CancellationToken option)
 WoofWare.NUnitTestRunner.ParallelQueue.EndTestFixture [method]: WoofWare.NUnitTestRunner.TestFixtureTearDownToken -> unit System.Threading.Tasks.Task
 WoofWare.NUnitTestRunner.ParallelQueue.Run [method]: WoofWare.NUnitTestRunner.TestFixtureSetupToken -> unit WoofWare.NUnitTestRunner.Parallelizable option -> (unit -> 'a) -> 'a System.Threading.Tasks.Task
+WoofWare.NUnitTestRunner.ParallelQueue.RunAsync [method]: WoofWare.NUnitTestRunner.TestFixtureSetupToken -> unit WoofWare.NUnitTestRunner.Parallelizable option -> (unit -> 'a Microsoft.FSharp.Control.FSharpAsync) -> 'a System.Threading.Tasks.Task
 WoofWare.NUnitTestRunner.ParallelQueue.RunTestSetup [method]: WoofWare.NUnitTestRunner.TestFixtureRunningToken -> (unit -> 'a) -> ('a * WoofWare.NUnitTestRunner.TestFixtureSetupToken) System.Threading.Tasks.Task
 WoofWare.NUnitTestRunner.ParallelQueue.RunTestTearDown [method]: WoofWare.NUnitTestRunner.TestFixtureSetupToken -> (unit -> 'a) -> ('a * WoofWare.NUnitTestRunner.TestFixtureTearDownToken) System.Threading.Tasks.Task
 WoofWare.NUnitTestRunner.ParallelQueue.StartTestFixture [method]: WoofWare.NUnitTestRunner.TestFixture -> WoofWare.NUnitTestRunner.TestFixtureRunningToken System.Threading.Tasks.Task
+WoofWare.NUnitTestRunner.ParallelScope inherit obj, implements WoofWare.NUnitTestRunner.ParallelScope System.IEquatable, System.Collections.IStructuralEquatable, WoofWare.NUnitTestRunner.ParallelScope System.IComparable, System.IComparable, System.Collections.IStructuralComparable - union type with 5 cases
+WoofWare.NUnitTestRunner.ParallelScope+Tags inherit obj
+WoofWare.NUnitTestRunner.ParallelScope+Tags.All [static field]: int = 2
+WoofWare.NUnitTestRunner.ParallelScope+Tags.Children [static field]: int = 1
+WoofWare.NUnitTestRunner.ParallelScope+Tags.Fixtures [static field]: int = 0
+WoofWare.NUnitTestRunner.ParallelScope+Tags.None [static field]: int = 4
+WoofWare.NUnitTestRunner.ParallelScope+Tags.Self [static field]: int = 3
+WoofWare.NUnitTestRunner.ParallelScope.All [static property]: [read-only] WoofWare.NUnitTestRunner.ParallelScope
+WoofWare.NUnitTestRunner.ParallelScope.Children [static property]: [read-only] WoofWare.NUnitTestRunner.ParallelScope
+WoofWare.NUnitTestRunner.ParallelScope.Equals [method]: (WoofWare.NUnitTestRunner.ParallelScope, System.Collections.IEqualityComparer) -> bool
+WoofWare.NUnitTestRunner.ParallelScope.Fixtures [static property]: [read-only] WoofWare.NUnitTestRunner.ParallelScope
+WoofWare.NUnitTestRunner.ParallelScope.get_All [static method]: unit -> WoofWare.NUnitTestRunner.ParallelScope
+WoofWare.NUnitTestRunner.ParallelScope.get_Children [static method]: unit -> WoofWare.NUnitTestRunner.ParallelScope
+WoofWare.NUnitTestRunner.ParallelScope.get_Fixtures [static method]: unit -> WoofWare.NUnitTestRunner.ParallelScope
+WoofWare.NUnitTestRunner.ParallelScope.get_IsAll [method]: unit -> bool
+WoofWare.NUnitTestRunner.ParallelScope.get_IsChildren [method]: unit -> bool
+WoofWare.NUnitTestRunner.ParallelScope.get_IsFixtures [method]: unit -> bool
+WoofWare.NUnitTestRunner.ParallelScope.get_IsNone [method]: unit -> bool
+WoofWare.NUnitTestRunner.ParallelScope.get_IsSelf [method]: unit -> bool
+WoofWare.NUnitTestRunner.ParallelScope.get_None [static method]: unit -> WoofWare.NUnitTestRunner.ParallelScope
+WoofWare.NUnitTestRunner.ParallelScope.get_Self [static method]: unit -> WoofWare.NUnitTestRunner.ParallelScope
+WoofWare.NUnitTestRunner.ParallelScope.get_Tag [method]: unit -> int
+WoofWare.NUnitTestRunner.ParallelScope.IsAll [property]: [read-only] bool
+WoofWare.NUnitTestRunner.ParallelScope.IsChildren [property]: [read-only] bool
+WoofWare.NUnitTestRunner.ParallelScope.IsFixtures [property]: [read-only] bool
+WoofWare.NUnitTestRunner.ParallelScope.IsNone [property]: [read-only] bool
+WoofWare.NUnitTestRunner.ParallelScope.IsSelf [property]: [read-only] bool
+WoofWare.NUnitTestRunner.ParallelScope.None [static property]: [read-only] WoofWare.NUnitTestRunner.ParallelScope
+WoofWare.NUnitTestRunner.ParallelScope.Self [static property]: [read-only] WoofWare.NUnitTestRunner.ParallelScope
+WoofWare.NUnitTestRunner.ParallelScope.Tag [property]: [read-only] int
+WoofWare.NUnitTestRunner.ParallelScopeModule inherit obj
+WoofWare.NUnitTestRunner.ParallelScopeModule.ofInt [static method]: int -> WoofWare.NUnitTestRunner.ParallelScope
 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.Equals [method]: (WoofWare.NUnitTestRunner.SingleTestMethod, System.Collections.IEqualityComparer) -> bool
 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
@@ -224,8 +313,12 @@ WoofWare.NUnitTestRunner.SingleTestMethod.Parallelize [property]: [read-only] un
 WoofWare.NUnitTestRunner.SingleTestMethod.Repeat [property]: [read-only] int option
 WoofWare.NUnitTestRunner.SingleTestMethodModule inherit obj
 WoofWare.NUnitTestRunner.SingleTestMethodModule.parse [static method]: string list -> System.Reflection.MethodInfo -> System.Reflection.CustomAttributeData list -> (WoofWare.NUnitTestRunner.SingleTestMethod option * System.Reflection.CustomAttributeData list)
-WoofWare.NUnitTestRunner.TestContexts inherit obj, implements WoofWare.NUnitTestRunner.TestContexts System.IEquatable, System.Collections.IStructuralEquatable, IDisposable
+WoofWare.NUnitTestRunner.TestContexts inherit obj, implements IDisposable
 WoofWare.NUnitTestRunner.TestContexts.Empty [static method]: unit -> WoofWare.NUnitTestRunner.TestContexts
+WoofWare.NUnitTestRunner.TestContexts.get_Stderr [method]: unit -> System.IO.TextWriter
+WoofWare.NUnitTestRunner.TestContexts.get_Stdout [method]: unit -> System.IO.TextWriter
+WoofWare.NUnitTestRunner.TestContexts.Stderr [property]: [read-only] System.IO.TextWriter
+WoofWare.NUnitTestRunner.TestContexts.Stdout [property]: [read-only] System.IO.TextWriter
 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
@@ -240,6 +333,7 @@ WoofWare.NUnitTestRunner.TestFailure+TearDownFailed.Item [property]: [read-only]
 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.Equals [method]: (WoofWare.NUnitTestRunner.TestFailure, System.Collections.IEqualityComparer) -> bool
 WoofWare.NUnitTestRunner.TestFailure.get_IsSetUpFailed [method]: unit -> bool
 WoofWare.NUnitTestRunner.TestFailure.get_IsTearDownFailed [method]: unit -> bool
 WoofWare.NUnitTestRunner.TestFailure.get_IsTestFailed [method]: unit -> bool
@@ -254,10 +348,12 @@ WoofWare.NUnitTestRunner.TestFailure.NewTearDownFailed [static method]: WoofWare
 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..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.Modifier list)
 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.Empty [static method]: System.Type -> WoofWare.NUnitTestRunner.ClassParallelScope WoofWare.NUnitTestRunner.Parallelizable option -> WoofWare.NUnitTestRunner.Modifier list -> obj list list -> WoofWare.NUnitTestRunner.TestFixture
+WoofWare.NUnitTestRunner.TestFixture.Equals [method]: (WoofWare.NUnitTestRunner.TestFixture, System.Collections.IEqualityComparer) -> bool
 WoofWare.NUnitTestRunner.TestFixture.get_ContainingAssembly [method]: unit -> System.Reflection.Assembly
+WoofWare.NUnitTestRunner.TestFixture.get_Modifiers [method]: unit -> WoofWare.NUnitTestRunner.Modifier list
 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
@@ -267,6 +363,7 @@ WoofWare.NUnitTestRunner.TestFixture.get_SetUp [method]: unit -> System.Reflecti
 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.Modifiers [property]: [read-only] WoofWare.NUnitTestRunner.Modifier list
 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
@@ -281,8 +378,11 @@ WoofWare.NUnitTestRunner.TestFixtureModule.parse [static method]: System.Type ->
 WoofWare.NUnitTestRunner.TestFixtureModule.run [static method]: WoofWare.NUnitTestRunner.TestContexts -> WoofWare.NUnitTestRunner.ParallelQueue -> WoofWare.NUnitTestRunner.ITestProgress -> (WoofWare.NUnitTestRunner.TestFixture -> WoofWare.NUnitTestRunner.SingleTestMethod -> bool) -> WoofWare.NUnitTestRunner.TestFixture -> WoofWare.NUnitTestRunner.FixtureRunResults list System.Threading.Tasks.Task
 WoofWare.NUnitTestRunner.TestFixtureModule.runOneFixture [static method]: WoofWare.NUnitTestRunner.TestContexts -> WoofWare.NUnitTestRunner.ParallelQueue -> WoofWare.NUnitTestRunner.ITestProgress -> (WoofWare.NUnitTestRunner.TestFixture -> WoofWare.NUnitTestRunner.SingleTestMethod -> bool) -> string -> obj -> WoofWare.NUnitTestRunner.TestFixture -> WoofWare.NUnitTestRunner.FixtureRunResults System.Threading.Tasks.Task
 WoofWare.NUnitTestRunner.TestFixtureRunningToken inherit obj, implements WoofWare.NUnitTestRunner.TestFixtureRunningToken System.IEquatable, System.Collections.IStructuralEquatable
+WoofWare.NUnitTestRunner.TestFixtureRunningToken.Equals [method]: (WoofWare.NUnitTestRunner.TestFixtureRunningToken, System.Collections.IEqualityComparer) -> bool
 WoofWare.NUnitTestRunner.TestFixtureSetupToken inherit obj, implements WoofWare.NUnitTestRunner.TestFixtureSetupToken System.IEquatable, System.Collections.IStructuralEquatable
+WoofWare.NUnitTestRunner.TestFixtureSetupToken.Equals [method]: (WoofWare.NUnitTestRunner.TestFixtureSetupToken, System.Collections.IEqualityComparer) -> bool
 WoofWare.NUnitTestRunner.TestFixtureTearDownToken inherit obj, implements WoofWare.NUnitTestRunner.TestFixtureTearDownToken System.IEquatable, System.Collections.IStructuralEquatable
+WoofWare.NUnitTestRunner.TestFixtureTearDownToken.Equals [method]: (WoofWare.NUnitTestRunner.TestFixtureTearDownToken, System.Collections.IEqualityComparer) -> bool
 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
@@ -294,6 +394,7 @@ 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.Equals [method]: (WoofWare.NUnitTestRunner.TestKind, System.Collections.IEqualityComparer) -> bool
 WoofWare.NUnitTestRunner.TestKind.get_IsData [method]: unit -> bool
 WoofWare.NUnitTestRunner.TestKind.get_IsSingle [method]: unit -> bool
 WoofWare.NUnitTestRunner.TestKind.get_IsSource [method]: unit -> bool
@@ -316,6 +417,7 @@ WoofWare.NUnitTestRunner.TestMemberFailure+Malformed.reasons [property]: [read-o
 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.Equals [method]: (WoofWare.NUnitTestRunner.TestMemberFailure, System.Collections.IEqualityComparer) -> bool
 WoofWare.NUnitTestRunner.TestMemberFailure.get_IsFailed [method]: unit -> bool
 WoofWare.NUnitTestRunner.TestMemberFailure.get_IsMalformed [method]: unit -> bool
 WoofWare.NUnitTestRunner.TestMemberFailure.get_Tag [method]: unit -> int
@@ -339,6 +441,7 @@ 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.Equals [method]: (WoofWare.NUnitTestRunner.TestMemberSuccess, System.Collections.IEqualityComparer) -> bool
 WoofWare.NUnitTestRunner.TestMemberSuccess.get_IsExplicit [method]: unit -> bool
 WoofWare.NUnitTestRunner.TestMemberSuccess.get_IsIgnored [method]: unit -> bool
 WoofWare.NUnitTestRunner.TestMemberSuccess.get_IsInconclusive [method]: unit -> bool
@@ -356,6 +459,7 @@ WoofWare.NUnitTestRunner.TestMemberSuccess.Ok [static property]: [read-only] Woo
 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.TestProgress.toWriter [static method]: System.IO.TextWriter -> 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
@@ -365,6 +469,7 @@ WoofWare.NUnitTestRunner.TrxCounters.AddNotExecuted [method]: unit -> WoofWare.N
 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.Equals [method]: (WoofWare.NUnitTestRunner.TrxCounters, System.Collections.IEqualityComparer) -> bool
 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
@@ -398,16 +503,19 @@ WoofWare.NUnitTestRunner.TrxCounters.Warning [property]: [read-only] System.UInt
 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.Equals [method]: (WoofWare.NUnitTestRunner.TrxDeployment, System.Collections.IEqualityComparer) -> bool
 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.Equals [method]: (WoofWare.NUnitTestRunner.TrxErrorInfo, System.Collections.IEqualityComparer) -> bool
 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.Equals [method]: (WoofWare.NUnitTestRunner.TrxExecution, System.Collections.IEqualityComparer) -> bool
 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
@@ -416,6 +524,7 @@ 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.Equals [method]: (WoofWare.NUnitTestRunner.TrxOutcome, System.Collections.IEqualityComparer) -> bool
 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
@@ -432,6 +541,7 @@ 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.Equals [method]: (WoofWare.NUnitTestRunner.TrxOutput, System.Collections.IEqualityComparer) -> bool
 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
@@ -440,6 +550,7 @@ 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.Equals [method]: (WoofWare.NUnitTestRunner.TrxReport, System.Collections.IEqualityComparer) -> bool
 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
@@ -464,6 +575,7 @@ WoofWare.NUnitTestRunner.TrxReportModule.toXml [static method]: WoofWare.NUnitTe
 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.Equals [method]: (WoofWare.NUnitTestRunner.TrxReportTimes, System.Collections.IEqualityComparer) -> bool
 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
@@ -474,6 +586,7 @@ WoofWare.NUnitTestRunner.TrxReportTimes.Start [property]: [read-only] System.Dat
 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.Equals [method]: (WoofWare.NUnitTestRunner.TrxResultsSummary, System.Collections.IEqualityComparer) -> bool
 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
@@ -484,6 +597,7 @@ WoofWare.NUnitTestRunner.TrxResultsSummary.RunInfos [property]: [read-only] Woof
 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.Equals [method]: (WoofWare.NUnitTestRunner.TrxRunInfo, System.Collections.IEqualityComparer) -> bool
 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
@@ -493,6 +607,7 @@ 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.Equals [method]: (WoofWare.NUnitTestRunner.TrxTestEntry, System.Collections.IEqualityComparer) -> bool
 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
@@ -501,6 +616,7 @@ 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.Equals [method]: (WoofWare.NUnitTestRunner.TrxTestListEntry, System.Collections.IEqualityComparer) -> bool
 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
@@ -510,6 +626,7 @@ WoofWare.NUnitTestRunner.TrxTestMethod..ctor [constructor]: (string, System.Uri,
 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.Equals [method]: (WoofWare.NUnitTestRunner.TrxTestMethod, System.Collections.IEqualityComparer) -> bool
 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
@@ -521,6 +638,7 @@ 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.Equals [method]: (WoofWare.NUnitTestRunner.TrxTestOutcome, System.Collections.IEqualityComparer) -> bool
 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
@@ -543,6 +661,7 @@ 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.Equals [method]: (WoofWare.NUnitTestRunner.TrxTestSettings, System.Collections.IEqualityComparer) -> bool
 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
@@ -550,6 +669,7 @@ 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.Equals [method]: (WoofWare.NUnitTestRunner.TrxUnitTest, System.Collections.IEqualityComparer) -> bool
 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
@@ -565,6 +685,7 @@ WoofWare.NUnitTestRunner.TrxUnitTestResult..ctor [constructor]: (System.Guid, Sy
 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.Equals [method]: (WoofWare.NUnitTestRunner.TrxUnitTestResult, System.Collections.IEqualityComparer) -> bool
 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
@@ -586,13 +707,21 @@ WoofWare.NUnitTestRunner.TrxUnitTestResult.TestId [property]: [read-only] System
 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 inherit obj, implements WoofWare.NUnitTestRunner.UserMethodFailure System.IEquatable, System.Collections.IStructuralEquatable - union type with 3 cases
+WoofWare.NUnitTestRunner.UserMethodFailure+BadParameters inherit WoofWare.NUnitTestRunner.UserMethodFailure
+WoofWare.NUnitTestRunner.UserMethodFailure+BadParameters.actual [property]: [read-only] obj []
+WoofWare.NUnitTestRunner.UserMethodFailure+BadParameters.expected [property]: [read-only] System.Type []
+WoofWare.NUnitTestRunner.UserMethodFailure+BadParameters.get_actual [method]: unit -> obj []
+WoofWare.NUnitTestRunner.UserMethodFailure+BadParameters.get_expected [method]: unit -> System.Type []
+WoofWare.NUnitTestRunner.UserMethodFailure+BadParameters.get_name [method]: unit -> string
+WoofWare.NUnitTestRunner.UserMethodFailure+BadParameters.name [property]: [read-only] string
 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.BadParameters [static field]: int = 2
 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
@@ -600,13 +729,17 @@ WoofWare.NUnitTestRunner.UserMethodFailure+Threw.get_Item2 [method]: unit -> Sys
 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.Equals [method]: (WoofWare.NUnitTestRunner.UserMethodFailure, System.Collections.IEqualityComparer) -> bool
+WoofWare.NUnitTestRunner.UserMethodFailure.get_IsBadParameters [method]: unit -> bool
 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.IsBadParameters [property]: [read-only] bool
 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.NewBadParameters [static method]: (string, System.Type [], obj []) -> WoofWare.NUnitTestRunner.UserMethodFailure
 WoofWare.NUnitTestRunner.UserMethodFailure.NewReturnedNonUnit [static method]: (string, obj) -> WoofWare.NUnitTestRunner.UserMethodFailure
 WoofWare.NUnitTestRunner.UserMethodFailure.NewThrew [static method]: (string, System.Exception) -> WoofWare.NUnitTestRunner.UserMethodFailure
 WoofWare.NUnitTestRunner.UserMethodFailure.Tag [property]: [read-only] int

WoofWare.NUnitTestRunner.Lib/TestFixture.fs

@@ -76,98 +76,168 @@ module TestFixture =
         (test : MethodInfo)
         (containingObject : obj)
         (args : obj[])
-        : Result<TestMemberSuccess, TestFailure list> * IndividualTestRunMetadata
+        : Async<Result<TestMemberSuccess, TestFailure list> * IndividualTestRunMetadata>
         =
         let rec runMethods
             (wrap : UserMethodFailure -> TestFailure)
             (toRun : MethodInfo list)
             (args : obj[])
-            : Result<unit, _>
+            : Result<unit, TestFailure> Async
             =
             match toRun with
-            | [] -> Ok ()
+            | [] -> async.Return (Ok ())
             | head :: rest ->
-                let result =
-                    try
-                        head.Invoke (containingObject, args) |> Ok
-                    with :? TargetInvocationException as e ->
-                        Error (UserMethodFailure.Threw (head.Name, e.InnerException))
+                async {
+                    let result =
+                        try
+                            head.Invoke (containingObject, args) |> Ok
+                        with
+                        | :? TargetInvocationException as e ->
+                            Error (UserMethodFailure.Threw (head.Name, e.InnerException))
+                        | :? TargetParameterCountException ->
+                            UserMethodFailure.BadParameters (
+                                head.Name,
+                                head.GetParameters () |> Array.map (fun pm -> pm.ParameterType),
+                                args
+                            )
+                            |> Error
 
-                match result with
-                | Error e -> Error (wrap e)
-                | Ok result ->
-                    match result with
-                    | :? unit -> runMethods wrap rest args
-                    | ret -> UserMethodFailure.ReturnedNonUnit (head.Name, ret) |> wrap |> Error
+                    let! ct = Async.CancellationToken
 
-        let start = DateTimeOffset.Now
+                    let! result =
+                        match result with
+                        | Error e -> async.Return (Error (wrap e))
+                        | Ok result ->
+                            match result with
+                            | :? unit -> runMethods wrap rest args
+                            | :? Task as result ->
+                                async {
+                                    let mutable exc = None
 
-        let sw = Stopwatch.StartNew ()
+                                    try
+                                        do! Async.AwaitTask result
+                                    with e ->
+                                        exc <- Some e
 
-        let metadata () =
-            let name =
-                if args.Length = 0 then
-                    test.Name
-                else
-                    let argsStr = args |> Seq.map string<obj> |> String.concat ","
-                    $"%s{test.Name}(%s{argsStr})"
+                                    match exc with
+                                    | None -> return! runMethods wrap rest args
+                                    | Some e -> return Error (UserMethodFailure.Threw (head.Name, e) |> wrap)
+                                }
+                            // We'd like to do this type-test:
+                            // | :? Async<unit> as result ->
+                            // but instead we have to do all this reflective nonsense, because FSharpAsync is not part
+                            // of the .NET runtime, so is instead in a different AssemblyLoadContext to us!
+                            // It's in the user-code context, not ours.
+                            | ret ->
+                                let ty = ret.GetType ()
 
-            {
-                End = DateTimeOffset.Now
-                Start = start
-                Total = sw.Elapsed
-                ComputerName = Environment.MachineName
-                ExecutionId = Guid.NewGuid ()
-                TestId = testId
-                TestName = name
-                ClassName = test.DeclaringType.FullName
-                StdOut =
-                    match contexts.DumpStdout outputId with
-                    | "" -> None
-                    | v -> Some v
-                StdErr =
-                    match contexts.DumpStderr outputId with
-                    | "" -> None
-                    | v -> Some v
-            }
+                                if ty.Namespace = "Microsoft.FSharp.Control" && ty.Name = "FSharpAsync`1" then
+                                    match ty.GenericTypeArguments |> Array.map (fun t -> t.FullName) with
+                                    | [| "Microsoft.FSharp.Core.Unit" |] ->
+                                        let asyncModule = ty.Assembly.GetType ("Microsoft.FSharp.Control.FSharpAsync")
+                                        // let catch = asyncModule.GetMethod("Catch").MakeGenericMethod [| ty.GenericTypeArguments.[0] |]
+                                        // let caught = catch.Invoke ((null: obj), [| ret |])
+                                        let startAsTask =
+                                            asyncModule.GetMethod("StartAsTask").MakeGenericMethod
+                                                [| ty.GenericTypeArguments.[0] |]
 
-        let setUpResult = runMethods TestFailure.SetUpFailed setUp [||]
-        sw.Stop ()
+                                        let started =
+                                            startAsTask.Invoke ((null : obj), [| ret ; (null : obj) ; (null : obj) |])
+                                            |> unbox<Task>
 
-        match setUpResult with
-        | Error e -> Error [ e ], metadata ()
-        | Ok () ->
+                                        async {
+                                            let! res = Async.AwaitTask started |> Async.Catch
 
-        sw.Start ()
+                                            match res with
+                                            | Choice1Of2 () -> return! runMethods wrap rest args
+                                            | Choice2Of2 e ->
+                                                return
+                                                    Error (
+                                                        UserMethodFailure.Threw (head.Name, started.Exception) |> wrap
+                                                    )
+                                        }
+                                    | _ ->
+                                        UserMethodFailure.ReturnedNonUnit (head.Name, ret)
+                                        |> wrap
+                                        |> Error
+                                        |> async.Return
+                                else
+                                    async.Return (UserMethodFailure.ReturnedNonUnit (head.Name, ret) |> wrap |> Error)
 
-        let result =
-            let result = runMethods TestFailure.TestFailed [ test ] args
+                    return result
+                }
+
+        async {
+            let start = DateTimeOffset.Now
+
+            let sw = Stopwatch.StartNew ()
+
+            let metadata () =
+                let name =
+                    if args.Length = 0 then
+                        test.Name
+                    else
+                        let argsStr = args |> Seq.map string<obj> |> String.concat ","
+                        $"%s{test.Name}(%s{argsStr})"
+
+                {
+                    End = DateTimeOffset.Now
+                    Start = start
+                    Total = sw.Elapsed
+                    ComputerName = Environment.MachineName
+                    ExecutionId = Guid.NewGuid ()
+                    TestId = testId
+                    TestName = name
+                    ClassName = test.DeclaringType.FullName
+                    StdOut =
+                        match contexts.DumpStdout outputId with
+                        | "" -> None
+                        | v -> Some v
+                    StdErr =
+                        match contexts.DumpStderr outputId with
+                        | "" -> None
+                        | v -> Some v
+                }
+
+            let! setUpResult = runMethods TestFailure.SetUpFailed setUp [||]
             sw.Stop ()
 
-            match result with
-            | Ok () -> Ok None
-            | Error (TestFailure.TestFailed (UserMethodFailure.Threw (_, exc)) as orig) ->
-                match exc.GetType().FullName with
-                | "NUnit.Framework.SuccessException" -> Ok None
-                | "NUnit.Framework.IgnoreException" -> Ok (Some (TestMemberSuccess.Ignored (Option.ofObj exc.Message)))
-                | "NUnit.Framework.InconclusiveException" ->
-                    Ok (Some (TestMemberSuccess.Inconclusive (Option.ofObj exc.Message)))
-                | _ -> Error orig
-            | Error orig -> Error orig
+            match setUpResult with
+            | Error e -> return Error [ e ], metadata ()
+            | Ok () ->
 
-        // Unconditionally run TearDown after tests, even if tests failed.
-        sw.Start ()
-        let tearDownResult = runMethods TestFailure.TearDownFailed tearDown [||]
-        sw.Stop ()
+            sw.Start ()
+            let! result = runMethods TestFailure.TestFailed [ test ] args
+            sw.Stop ()
 
-        let metadata = metadata ()
+            let result =
+                match result with
+                | Ok () -> Ok None
+                | Error (TestFailure.TestFailed (UserMethodFailure.Threw (_, exc)) as orig) ->
+                    match exc.GetType().FullName with
+                    | "NUnit.Framework.SuccessException" -> Ok None
+                    | "NUnit.Framework.IgnoreException" ->
+                        Ok (Some (TestMemberSuccess.Ignored (Option.ofObj exc.Message)))
+                    | "NUnit.Framework.InconclusiveException" ->
+                        Ok (Some (TestMemberSuccess.Inconclusive (Option.ofObj exc.Message)))
+                    | _ -> Error orig
+                | Error orig -> Error orig
 
-        match result, tearDownResult with
-        | Ok None, Ok () -> Ok TestMemberSuccess.Ok, metadata
-        | Ok (Some s), Ok () -> Ok s, metadata
-        | Error e, Ok ()
-        | Ok _, Error e -> Error [ e ], metadata
-        | Error e1, Error e2 -> Error [ e1 ; e2 ], metadata
+            // Unconditionally run TearDown after tests, even if tests failed.
+            sw.Start ()
+            let! tearDownResult = runMethods TestFailure.TearDownFailed tearDown [||]
+            sw.Stop ()
+
+            let metadata = metadata ()
+
+            return
+                match result, tearDownResult with
+                | Ok None, Ok () -> Ok TestMemberSuccess.Ok, metadata
+                | Ok (Some s), Ok () -> Ok s, metadata
+                | Error e, Ok ()
+                | Ok _, Error e -> Error [ e ], metadata
+                | Error e1, Error e2 -> Error [ e1 ; e2 ], metadata
+        }
 
     let private getValues (test : SingleTestMethod) =
         let valuesAttrs =
@@ -388,20 +458,22 @@ module TestFixture =
         |> Seq.map (fun (testGuid, args) ->
             task {
                 let runMe () =
-                    progress.OnTestMemberStart test.Name
-                    let oldValue = contexts.AsyncLocal.Value
-                    let outputId = contexts.NewOutputs ()
-                    contexts.AsyncLocal.Value <- outputId
+                    async {
+                        progress.OnTestMemberStart test.Name
+                        let oldValue = contexts.AsyncLocal.Value
+                        let outputId = contexts.NewOutputs ()
+                        contexts.AsyncLocal.Value <- outputId
 
-                    let result, meta =
-                        runOne outputId contexts setUp tearDown testGuid test.Method containingObject args
+                        let! result, meta =
+                            runOne outputId contexts setUp tearDown testGuid test.Method containingObject args
 
-                    contexts.AsyncLocal.Value <- oldValue
-                    progress.OnTestMemberFinished test.Name
+                        contexts.AsyncLocal.Value <- oldValue
+                        progress.OnTestMemberFinished test.Name
 
-                    result, meta
+                        return result, meta
+                    }
 
-                let! results, summary = par.Run running test.Parallelize runMe
+                let! results, summary = par.RunAsync running test.Parallelize runMe
 
                 match results with
                 | Ok results -> return Ok results, summary
@@ -590,15 +662,15 @@ 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, args, par =
-            (([], [], None), parentType.CustomAttributes)
-            ||> Seq.fold (fun (categories, args, par) attr ->
+        let categories, args, mods, par =
+            (([], [], [], None), parentType.CustomAttributes)
+            ||> Seq.fold (fun (categories, args, mods, 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
+                    cat :: categories, args, mods, par
                 | "NUnit.Framework.TestFixtureAttribute" ->
                     let newArgs =
                         match attr.ConstructorArguments |> Seq.map _.Value |> Seq.toList with
@@ -606,36 +678,52 @@ module TestFixture =
                             x |> Seq.cast<CustomAttributeTypedArgument> |> Seq.map _.Value |> Seq.toList
                         | xs -> xs
 
-                    categories, newArgs :: args, par
+                    categories, newArgs :: args, mods, par
                 | "NUnit.Framework.NonParallelizableAttribute" ->
                     match par with
                     | Some _ -> failwith $"Got multiple parallelism attributes on %s{parentType.FullName}"
-                    | None -> categories, args, Some Parallelizable.No
+                    | None -> categories, args, mods, 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)
+                        | [] -> categories, args, mods, 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}"
+                                match ParallelScope.ofInt v with
+                                | ParallelScope.Fixtures ->
+                                    categories, args, mods, Some (Parallelizable.Yes ClassParallelScope.Fixtures)
+                                | ParallelScope.Children ->
+                                    categories, args, mods, Some (Parallelizable.Yes ClassParallelScope.Children)
+                                | ParallelScope.All ->
+                                    categories, args, mods, Some (Parallelizable.Yes ClassParallelScope.All)
+                                | ParallelScope.Self ->
+                                    categories, args, mods, Some (Parallelizable.Yes ClassParallelScope.Self)
+                                | ParallelScope.None -> categories, args, mods, Some Parallelizable.No
                             | 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
+                | "NUnit.Framework.ExplicitAttribute" ->
+                    let reason =
+                        attr.ConstructorArguments
+                        |> Seq.tryHead
+                        |> Option.map (_.Value >> unbox<string>)
+
+                    categories, args, Modifier.Explicit reason :: mods, par
+                | "NUnit.Framework.IgnoreAttribute" ->
+                    let reason =
+                        attr.ConstructorArguments
+                        |> Seq.tryHead
+                        |> Option.map (_.Value >> unbox<string>)
+
+                    categories, args, Modifier.Ignored reason :: mods, par
+                | _ -> categories, args, mods, par
             )
 
-        (TestFixture.Empty parentType par args, parentType.GetRuntimeMethods ())
+        (TestFixture.Empty parentType par mods args, parentType.GetRuntimeMethods ())
         ||> Seq.fold (fun state mi ->
             ((state, []), mi.CustomAttributes)
             ||> Seq.fold (fun (state, unrecognisedAttrs) attr ->
@@ -708,6 +796,8 @@ 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.
+    ///
+    /// If the TestFixture has modifiers that specify no tests should be run, we don't run any tests.
     let run
         (contexts : TestContexts)
         (par : ParallelQueue)
@@ -716,6 +806,26 @@ module TestFixture =
         (tests : TestFixture)
         : FixtureRunResults list Task
         =
+        match
+            tests.Modifiers
+            |> List.tryFind (
+                function
+                | Modifier.Explicit _
+                | Modifier.Ignored _ -> true
+            )
+        with
+        | Some modifier ->
+            let reason =
+                match modifier with
+                | Modifier.Explicit (Some reason) -> reason
+                | Modifier.Ignored (Some reason) -> reason
+                | Modifier.Ignored None -> "test fixture marked Ignore"
+                | Modifier.Explicit None -> "test fixture marked Explicit"
+
+            progress.OnTestFixtureSkipped tests.Name reason
+            Task.FromResult []
+        | None ->
+
         match tests.Parameters with
         | [] -> [ null ]
         | args -> args |> List.map List.toArray

WoofWare.NUnitTestRunner.Lib/TestProgress.fs

@@ -1,6 +1,7 @@
 namespace WoofWare.NUnitTestRunner
 
 open System
+open System.IO
 
 /// Represents something which knows how to report progress through a test suite.
 /// Note that we don't guarantee anything about parallelism; you must make sure
@@ -9,6 +10,8 @@ type ITestProgress =
     /// Called just before we start executing the setup logic for the given test fixture.
     /// We tell you how many test methods there are in the fixture.
     abstract OnTestFixtureStart : name : string -> testCount : int -> unit
+    /// Called when skipping the test fixture with the given name, e.g. because it's `[<Explicit>]`.
+    abstract OnTestFixtureSkipped : name : string -> reason : string -> unit
     /// Called just before we start executing the test(s) indicated by a particular method.
     abstract OnTestMemberStart : name : string -> unit
     /// Called when a test fails. (This may be called repeatedly with the same `name`, e.g. if the test
@@ -24,22 +27,28 @@ type ITestProgress =
 /// Methods for constructing specific ITestProgress objects.
 [<RequireQualifiedAccess>]
 module TestProgress =
-    /// An ITestProgress which logs to stderr.
-    let toStderr () : ITestProgress =
+    /// An ITestProgress which logs to the given writer.
+    let toWriter (writer : TextWriter) : ITestProgress =
         { new ITestProgress with
             member _.OnTestFixtureStart name testCount =
                 let plural = if testCount = 1 then "" else "s"
-                Console.Error.WriteLine $"Running test fixture: %s{name} (%i{testCount} test%s{plural} to run)"
+                writer.WriteLine $"Running test fixture: %s{name} (%i{testCount} test%s{plural} to run)"
+
+            member _.OnTestFixtureSkipped name reason =
+                writer.WriteLine $"Skipping test fixture (%s{reason}): %s{name}"
 
             member _.OnTestMemberStart name =
-                Console.Error.WriteLine $"Running test: %s{name}"
+                writer.WriteLine $"Running test: %s{name}"
 
             member _.OnTestFailed name failure =
-                Console.Error.WriteLine $"Test failed: %O{failure}"
+                writer.WriteLine $"Test failed: %O{failure}"
 
             member _.OnTestMemberFinished name =
-                Console.Error.WriteLine $"Finished test %s{name}"
+                writer.WriteLine $"Finished test %s{name}"
 
             member _.OnTestMemberSkipped name =
-                Console.Error.WriteLine $"Skipping test due to filter: %s{name}"
+                writer.WriteLine $"Skipping test due to filter: %s{name}"
         }
+
+    /// An ITestProgress which logs to stderr.
+    let toStderr () : ITestProgress = toWriter Console.Error

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

@@ -14,7 +14,7 @@
       <PackageId>WoofWare.NUnitTestRunner.Lib</PackageId>
       <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
       <WarnOn>FS3559</WarnOn>
-      <WoofWareMyriadPluginVersion>2.1.44</WoofWareMyriadPluginVersion>
+      <WoofWareMyriadPluginVersion>8.1.1</WoofWareMyriadPluginVersion>
     </PropertyGroup>
 
     <ItemGroup>
@@ -22,13 +22,21 @@
       <Compile Include="RuntimeConfig.fs" />
       <Compile Include="GeneratedRuntimeConfig.fs">
         <MyriadFile>RuntimeConfig.fs</MyriadFile>
+        <MyriadParams>
+          <RuntimeOptions>JsonParse</RuntimeOptions>
+          <RuntimeConfig>JsonParse</RuntimeConfig>
+          <FrameworkDescription>JsonParse</FrameworkDescription>
+        </MyriadParams>
       </Compile>
+      <Compile Include="ParallelScope.fs" />
       <Compile Include="DotnetRuntime.fs" />
       <Compile Include="Array.fs" />
+      <Compile Include="Exception.fs" />
       <Compile Include="List.fs" />
       <Compile Include="Result.fs" />
       <Compile Include="Domain.fs" />
       <Compile Include="Filter.fs" />
+      <Compile Include="Args.fs" />
       <Compile Include="ParallelQueue.fs" />
       <Compile Include="SingleTestMethod.fs" />
       <Compile Include="TestProgress.fs" />
@@ -36,6 +44,8 @@
       <Compile Include="TestFixture.fs" />
       <Compile Include="Xml.fs" />
       <Compile Include="TrxReport.fs" />
+      <Compile Include="CreateTrxReport.fs" />
+      <Compile Include="AssemblyLevelAttributes.fs" />
       <None Include="..\README.md">
         <Pack>True</Pack>
         <PackagePath>\</PackagePath>
@@ -44,14 +54,13 @@
       <EmbeddedResource Include="version.json" />
     </ItemGroup>
   <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.PrattParser" Version="0.2.4" />
+    <PackageReference Update="FSharp.Core" Version="6.0.1" />
+    <PackageReference Include="WoofWare.DotnetRuntimeLocator" Version="0.1.12" />
+    <PackageReference Include="Myriad.SDK" Version="0.8.3" PrivateAssets="all" />
     <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>

WoofWare.NUnitTestRunner.Lib/version.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.13",
+  "version": "0.22",
   "publicReleaseRefSpec": [
     "^refs/heads/main$"
   ],
@@ -8,4 +8,4 @@
     ":/Directory.Build.props",
     ":/README.md"
   ]
-}
+}

WoofWare.NUnitTestRunner.StartupHook/StartupHook.cs

@@ -0,0 +1,35 @@
+using System.Linq;
+using System.Reflection;
+using System.Runtime.Loader;
+using WoofWare.NUnitTestRunner.StartupHook;
+
+namespace WoofWare.NUnitTestRunner.StartupHook
+{
+    internal class StartupAssemblyLoadContext : AssemblyLoadContext
+    {
+        private readonly AssemblyDependencyResolver _resolver;
+
+        public StartupAssemblyLoadContext()
+        {
+            _resolver = new AssemblyDependencyResolver(Assembly.GetExecutingAssembly().Location);
+        }
+
+        protected override Assembly Load(AssemblyName assemblyName)
+        {
+            var assemblyPath = _resolver.ResolveAssemblyToPath(assemblyName);
+
+            return assemblyPath != null ? LoadFromAssemblyPath(assemblyPath) : null;
+        }
+    }
+}
+
+// Must be internal and called `StartupHook`
+internal class StartupHook
+{
+    public static void Initialize()
+    {
+        var loadContext = new StartupAssemblyLoadContext();
+        var assembly = loadContext.LoadFromAssemblyName(new AssemblyName("WoofWare.NUnitTestRunner.StartupHookLogic"));
+        assembly.DefinedTypes.First(x => x.Name == "StartupHookLogic").GetDeclaredMethod("DoIt")!.Invoke(null, null);
+    }
+}

WoofWare.NUnitTestRunner.StartupHook/WoofWare.NUnitTestRunner.StartupHook.csproj

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\WoofWare.NUnitTestRunner.StartupHookLogic\WoofWare.NUnitTestRunner.StartupHookLogic.csproj" />
+    <ProjectReference Include="..\WoofWare.NUnitTestRunner.Lib\WoofWare.NUnitTestRunner.Lib.fsproj"/>
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Include="StartupHook.cs"/>
+  </ItemGroup>
+
+</Project>

WoofWare.NUnitTestRunner.StartupHookLogic/StartupHookLogic.cs

@@ -0,0 +1,102 @@
+using System.Reflection;
+using Microsoft.FSharp.Collections;
+using Microsoft.FSharp.Core;
+
+namespace WoofWare.NUnitTestRunner.StartupHookLogic;
+
+public class StartupHookLogic
+{
+    private static void DoIt()
+    {
+        // Load test runner lib
+        var nunitLib = Environment.GetEnvironmentVariable("WOOFWARE_NUNIT_LIB");
+        if (string.IsNullOrEmpty(nunitLib))
+        {
+            throw new ArgumentException("WoofWare.NUnitTestRunner hook expects to run with WOOFWARE_NUNIT_LIB set to WoofWare.NUnitTestRunner.Lib.dll");
+        }
+        Assembly.LoadFrom(nunitLib);
+
+        var startTime = DateTimeOffset.Now;
+
+        // Arg parsing
+
+        var filterVar = Environment.GetEnvironmentVariable("WOOFWARE_NUNIT_FILTER");
+        static bool NoFilter(TestFixture f, SingleTestMethod g)
+        {
+            return true;
+        }
+
+        FSharpFunc<TestFixture, FSharpFunc<SingleTestMethod, bool>> filter;
+        if (string.IsNullOrEmpty(filterVar))
+        {
+            filter = FuncConvert.FromFunc<TestFixture, SingleTestMethod, bool>(NoFilter);
+        }
+        else
+        {
+            filter = FilterModule.shouldRun(FilterModule.parse(filterVar));
+        }
+
+        var assy = Assembly.GetEntryAssembly()!;
+
+        var attrs = AssemblyLevelAttributesModule.get(assy);
+
+        FSharpOption<int> levelOfParallelism;
+        var parallelismVar = Environment.GetEnvironmentVariable("WOOFWARE_NUNIT_PARALLELISM_LEVEL");
+        if (string.IsNullOrEmpty(parallelismVar))
+        {
+            levelOfParallelism = attrs.Parallelism;
+        }
+        else
+        {
+            levelOfParallelism = FSharpOption<int>.Some(Int32.Parse(parallelismVar));
+        }
+
+        var testFixtures = assy.ExportedTypes.Select(TestFixtureModule.parse);
+        using var par =
+            new ParallelQueue(levelOfParallelism, attrs.Parallelizable, FSharpOption<CancellationToken>.None);
+        var creationTime = DateTimeOffset.Now;
+
+        var timeoutVar = Environment.GetEnvironmentVariable("WOOFWARE_NUNIT_TIMEOUT_SECS");
+        TimeSpan timeout;
+        if (string.IsNullOrEmpty(timeoutVar))
+        {
+            timeout = TimeSpan.FromHours(2.0);
+        }
+        else
+        {
+            timeout = TimeSpan.FromSeconds(Int32.Parse(timeoutVar));
+        }
+
+        var normalErr = Console.Error;
+        using var contexts = TestContexts.Empty();
+        Console.SetOut(contexts.Stdout);
+        Console.SetError(contexts.Stderr);
+        var results =
+            Task.WhenAll(testFixtures.Select(x =>
+                TestFixtureModule.run(contexts, par, TestProgress.toWriter(normalErr), filter, x)));
+
+        if (!results.Wait(timeout))
+        {
+            throw new Exception($"Tests failed to terminate within timeout of {timeout}");
+        }
+
+        var sorted =
+            results.Result.SelectMany(x => x);
+        var report = BuildTrxReport.build(assy, creationTime, startTime, ListModule.OfSeq(sorted));
+
+        var trxFile = Environment.GetEnvironmentVariable("WOOFWARE_NUNIT_GENERATE_TRX");
+        if (!string.IsNullOrEmpty(trxFile))
+        {
+            var contents = TrxReportModule.toXml(report).OuterXml;
+            var trxPath = new FileInfo(trxFile);
+            trxPath.Directory!.Create();
+            File.WriteAllText(trxPath.FullName, contents);
+            normalErr.WriteLine($"Written TRX file: {trxPath.FullName}");
+        }
+
+        if (report.ResultsSummary.Outcome.Equals(TrxOutcome.Completed))
+            Environment.Exit(0);
+        else
+            Environment.Exit(1);
+    }
+}

WoofWare.NUnitTestRunner.StartupHookLogic/WoofWare.NUnitTestRunner.StartupHookLogic.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\WoofWare.NUnitTestRunner.Lib\WoofWare.NUnitTestRunner.Lib.fsproj"/>
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Include="StartupHookLogic.cs"/>
+  </ItemGroup>
+
+</Project>

WoofWare.NUnitTestRunner.sln

@@ -8,6 +8,12 @@ Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "WoofWare.NUnitTestRunner.Li
 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
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WoofWare.NUnitTestRunner.StartupHook", "WoofWare.NUnitTestRunner.StartupHook\WoofWare.NUnitTestRunner.StartupHook.csproj", "{E2C73D96-570C-4E3C-B997-707AF8BB0E6A}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WoofWare.NUnitTestRunner.StartupHookLogic", "WoofWare.NUnitTestRunner.StartupHookLogic\WoofWare.NUnitTestRunner.StartupHookLogic.csproj", "{A70627C8-9D19-42C2-AFEB-CFBDDDCE045D}"
+EndProject
+Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "FailingConsumer", "FailingConsumer\FailingConsumer.fsproj", "{DA7160F5-4C3C-4D2E-918B-7DCBA3F4272E}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -30,5 +36,17 @@ Global
 		{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
+		{E2C73D96-570C-4E3C-B997-707AF8BB0E6A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E2C73D96-570C-4E3C-B997-707AF8BB0E6A}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E2C73D96-570C-4E3C-B997-707AF8BB0E6A}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E2C73D96-570C-4E3C-B997-707AF8BB0E6A}.Release|Any CPU.Build.0 = Release|Any CPU
+		{A70627C8-9D19-42C2-AFEB-CFBDDDCE045D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{A70627C8-9D19-42C2-AFEB-CFBDDDCE045D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{A70627C8-9D19-42C2-AFEB-CFBDDDCE045D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{A70627C8-9D19-42C2-AFEB-CFBDDDCE045D}.Release|Any CPU.Build.0 = Release|Any CPU
+		{DA7160F5-4C3C-4D2E-918B-7DCBA3F4272E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{DA7160F5-4C3C-4D2E-918B-7DCBA3F4272E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{DA7160F5-4C3C-4D2E-918B-7DCBA3F4272E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{DA7160F5-4C3C-4D2E-918B-7DCBA3F4272E}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 EndGlobal

WoofWare.NUnitTestRunner/Program.fs

@@ -1,42 +1,22 @@
 namespace WoofWare.NUnitTestRunner
 
 open System
+open System.Diagnostics
 open System.IO
+open System.Reflection
 open System.Threading.Tasks
 open Spectre.Console
 
-// Fix for https://github.com/Smaug123/unofficial-nunit-runner/issues/8
-// Set AppContext.BaseDirectory to where the test DLL is.
-// (This tells the DLL loader to look next to the test DLL for dependencies.)
-type SetBaseDir (testDll : FileInfo) =
-    let oldBaseDir = AppContext.BaseDirectory
-    do AppContext.SetData ("APP_CONTEXT_BASE_DIRECTORY", testDll.Directory.FullName)
-
-    interface IDisposable with
-        member _.Dispose () =
-            AppContext.SetData ("APP_CONTEXT_BASE_DIRECTORY", oldBaseDir)
-
-
 module Program =
-    let main argv =
+    // This is actually transcribed into C# in WoofWare.NUnitTestRunner.StartupHookLogic.
+    let execute argv =
         let startTime = DateTimeOffset.Now
 
-        let testDll, filter, trxPath =
-            match argv |> List.ofSeq with
-            | [ dll ] -> FileInfo dll, None, None
-            | [ dll ; "--trx" ; trxPath ] -> FileInfo dll, None, Some (FileInfo trxPath)
-            | [ dll ; "--filter" ; filter ] -> FileInfo dll, Some (Filter.parse filter), None
-            | [ dll ; "--trx" ; trxPath ; "--filter" ; filter ] ->
-                FileInfo dll, Some (Filter.parse filter), Some (FileInfo trxPath)
-            | [ dll ; "--filter" ; filter ; "--trx" ; trxPath ] ->
-                FileInfo dll, Some (Filter.parse filter), Some (FileInfo trxPath)
-            | _ ->
-                failwith
-                    "provide exactly one arg, a test DLL; then optionally `--filter <filter>` and/or `--trx <output-filename>`."
+        let args = argv |> List.ofArray |> Args.Parse
 
         let filter =
-            match filter with
-            | Some filter -> Filter.shouldRun filter
+            match args.Filter with
+            | Some (_, filter) -> Filter.shouldRun filter
             | None -> fun _ _ -> true
 
         let stderr =
@@ -46,55 +26,38 @@ module Program =
 
         let progress = Progress.spectre stderr
 
-        use _ = new SetBaseDir (testDll)
+        let runtime = DotnetRuntime.locate args.Dll
+
+        match args.Logging with
+        | LogLevel.Nothing -> ()
+        | LogLevel.Verbose ->
+            for d in runtime do
+                stderr.WriteLine $".NET runtime directory: %s{d.FullName}"
 
         use contexts = TestContexts.Empty ()
 
-        let ctx = LoadContext (testDll, DotnetRuntime.locate testDll, contexts)
-        let assy = ctx.LoadFromAssemblyPath testDll.FullName
+        let ctx = LoadContext (args.Dll, runtime, contexts)
+        let assy = ctx.LoadFromAssemblyPath args.Dll.FullName
 
-        let levelOfParallelism, par =
-            ((None, None), assy.CustomAttributes)
-            ||> Seq.fold (fun (levelPar, par) attr ->
-                match attr.AttributeType.FullName with
-                | "NUnit.Framework.LevelOfParallelismAttribute" ->
-                    let arg = attr.ConstructorArguments |> Seq.exactlyOne |> _.Value |> unbox<int>
+        let attrs = AssemblyLevelAttributes.get assy
 
-                    match levelPar with
-                    | None -> (Some arg, par)
-                    | Some existing ->
-                        failwith $"Assembly %s{assy.Location} declares parallelism %i{arg} and also %i{existing}"
-                | "NUnit.Framework.NonParallelizableAttribute" ->
-                    match levelPar with
-                    | None -> (Some 1, par)
-                    | Some existing ->
-                        failwith
-                            $"Assembly %s{assy.Location} declares non-parallelizable and also parallelism %i{existing}"
-                | "NUnit.Framework.ParallelizableAttribute" ->
-                    match par with
-                    | Some _ -> failwith "Got multiple Parallelize attributes in assembly"
-                    | None ->
-                        match attr.ConstructorArguments |> Seq.toList with
-                        | [] -> levelPar, Some (Parallelizable.Yes AssemblyParallelScope.Fixtures)
-                        | [ v ] ->
-                            match v.Value with
-                            | :? int as v ->
-                                match v with
-                                | 512 -> levelPar, Some (Parallelizable.Yes AssemblyParallelScope.Fixtures)
-                                | 256 -> levelPar, Some (Parallelizable.Yes AssemblyParallelScope.Children)
-                                | 257 ->
-                                    failwith "ParallelScope.All is invalid on assemblies; only Fixtures or Children"
-                                | 1 ->
-                                    failwith "ParallelScope.Self is invalid on assemblies; only Fixtures or Children"
-                                | v -> failwith $"Could not recognise value %i{v} of parallel scope on assembly"
-                            | v -> failwith $"Unexpectedly non-int value %O{v} of parallel scope on assembly"
-                        | _ -> failwith "unexpectedly got multiple args to Parallelizable on assembly"
-                | _ -> levelPar, par
-            )
+        let levelOfParallelism =
+            match args.LevelOfParallelism, attrs.Parallelism with
+            | None, None -> None
+            | Some taken, Some ignored ->
+                match args.Logging with
+                | LogLevel.Nothing -> ()
+                | LogLevel.Verbose ->
+                    stderr.WriteLine
+                        $"Taking parallelism %i{taken} from command line, ignoring value %i{ignored} from assembly"
+
+                Some taken
+            | Some x, None
+            | None, Some x -> Some x
 
         let testFixtures = assy.ExportedTypes |> Seq.map TestFixture.parse |> Seq.toList
 
-        use par = new ParallelQueue (levelOfParallelism, par)
+        use par = new ParallelQueue (levelOfParallelism, attrs.Parallelizable)
 
         let creationTime = DateTimeOffset.Now
 
@@ -103,240 +66,19 @@ module Program =
             |> List.map (TestFixture.run contexts par progress filter)
             |> Task.WhenAll
 
-        if not (results.Wait (TimeSpan.FromHours 2.0)) then
+        let timeout =
+            match args.Timeout with
+            | None -> TimeSpan.FromHours 2.0
+            | Some t -> t
+
+        if not (results.Wait timeout) then
             failwith "Tests failed to terminate within two hours"
 
         let results = results.Result |> Seq.concat |> List.ofSeq
 
-        let finishTime = DateTimeOffset.Now
-        let finishTimeHumanReadable = finishTime.ToString @"yyyy-MM-dd HH:mm:ss"
-        let nowMachine = finishTime.ToString @"yyyy-MM-dd_HH_mm_ss"
+        let report = BuildTrxReport.build assy creationTime startTime results
 
-        let testListId = Guid.NewGuid ()
-
-        let testDefinitions, testEntries =
-            results
-            |> List.collect (fun results -> results.IndividualTestRunMetadata)
-            |> List.map (fun (data, _) ->
-                let defn =
-                    {
-                        Name = data.TestName
-                        Storage = assy.Location.ToLowerInvariant ()
-                        Id = data.TestId
-                        Execution =
-                            {
-                                Id = data.ExecutionId
-                            }
-                        TestMethod =
-                            {
-                                CodeBase = assy.Location
-                                AdapterTypeName = Uri "executor://woofware/"
-                                ClassName = data.ClassName
-                                Name = data.TestName
-                            }
-                    }
-
-                let entry : TrxTestEntry =
-                    {
-                        TestListId = testListId
-                        ExecutionId = data.ExecutionId
-                        TestId = data.TestId
-
-                    }
-
-                defn, entry
-            )
-            |> List.unzip
-
-        let hostname = Environment.MachineName
-
-        let settings =
-            {
-                Name = "default"
-                Id = Guid.NewGuid ()
-                Deployment =
-                    {
-                        RunDeploymentRoot = $"_%s{hostname}_%s{nowMachine}"
-                    }
-            }
-
-        let testList : TrxTestListEntry =
-            {
-                Id = testListId
-                Name = "All"
-            }
-
-        let counters =
-            (TrxCounters.Zero, results)
-            // TODO: this is woefully inefficient
-            ||> List.fold (fun counters results ->
-                let counters =
-                    (counters, results.Failed)
-                    ||> List.fold (fun counters (_, _) ->
-                        // TODO: the counters can be more specific about the failure mode
-                        counters.AddFailed ()
-                    )
-
-                let counters =
-                    (counters, results.OtherFailures)
-                    ||> List.fold (fun counters _ ->
-                        // TODO: the counters can be more specific about the failure mode
-                        counters.AddFailed ()
-                    )
-
-                (counters, results.Success)
-                ||> List.fold (fun counters (_, success, _) ->
-                    match success with
-                    | TestMemberSuccess.Ok -> counters.AddPassed ()
-                    | TestMemberSuccess.Ignored _
-                    | TestMemberSuccess.Explicit _ -> counters.AddNotExecuted ()
-                    | TestMemberSuccess.Inconclusive _ -> counters.AddInconclusive ()
-                )
-            )
-
-        // TODO: I'm sure we can do better than this; there's a whole range of possible
-        // states!
-        let outcome =
-            if counters.Failed > 0u then
-                TrxOutcome.Failed
-            else
-                TrxOutcome.Completed
-
-        let resultSummary : TrxResultsSummary =
-            {
-                Outcome = outcome
-                Counters = counters
-                Output =
-                    {
-                        StdOut = None
-                        StdErr = None
-                        ErrorInfo = None
-                    }
-                RunInfos =
-                    [
-                    // TODO: capture stdout
-                    ]
-            }
-
-        let times : TrxReportTimes =
-            {
-                Creation = creationTime
-                Queuing = startTime
-                Start = startTime
-                Finish = finishTime
-
-            }
-
-        let magicGuid = Guid.Parse "13cdc9d9-ddb5-4fa4-a97d-d965ccfc6d4b"
-
-        let results =
-            results
-            |> List.collect (fun results -> results.IndividualTestRunMetadata)
-            |> List.map (fun (i, cause) ->
-                let exc =
-                    match cause with
-                    | Choice2Of3 _ -> None
-                    | Choice1Of3 (TestMemberFailure.Malformed reasons) ->
-                        {
-                            StackTrace = None
-                            Message = reasons |> String.concat "\n" |> Some
-                        }
-                        |> Some
-                    | Choice1Of3 (TestMemberFailure.Failed fail)
-                    | Choice1Of3 (TestMemberFailure.Failed fail)
-                    | Choice1Of3 (TestMemberFailure.Failed fail) ->
-                        ((None, None), fail)
-                        ||> List.fold (fun (stackTrace, message) tf ->
-                            match tf with
-                            | TestFailure.TestFailed (UserMethodFailure.Threw (_, exc))
-                            | TestFailure.SetUpFailed (UserMethodFailure.Threw (_, exc))
-                            | TestFailure.TearDownFailed (UserMethodFailure.Threw (_, exc)) ->
-                                let stackTrace =
-                                    match stackTrace with
-                                    | None -> (exc : Exception).ToString ()
-                                    | Some s -> s
-
-                                (Some stackTrace, message)
-                            | TestFailure.TestFailed (UserMethodFailure.ReturnedNonUnit (_, ret))
-                            | TestFailure.SetUpFailed (UserMethodFailure.ReturnedNonUnit (_, ret))
-                            | TestFailure.TearDownFailed (UserMethodFailure.ReturnedNonUnit (_, ret)) ->
-                                let newMessage = $"returned non-unit value %O{ret}"
-
-                                let message =
-                                    match message with
-                                    | None -> newMessage
-                                    | Some message -> $"%s{message}\n%s{newMessage}"
-
-                                (stackTrace, Some message)
-                        )
-                        |> fun (stackTrace, message) ->
-                            {
-                                StackTrace = stackTrace
-                                Message = message
-                            }
-                            |> Some
-                    | Choice3Of3 (UserMethodFailure.Threw (_, exc)) ->
-                        {
-                            StackTrace = (exc : Exception).ToString () |> Some
-                            Message = None
-                        }
-                        |> Some
-                    | Choice3Of3 (UserMethodFailure.ReturnedNonUnit (_, ret)) ->
-                        {
-                            Message = $"returned non-unit value %O{ret}" |> Some
-                            StackTrace = None
-                        }
-                        |> Some
-
-                let outcome =
-                    match cause with
-                    | Choice1Of3 _ -> TrxTestOutcome.Failed
-                    | Choice2Of3 TestMemberSuccess.Ok -> TrxTestOutcome.Passed
-                    | Choice2Of3 (TestMemberSuccess.Inconclusive _) -> TrxTestOutcome.Inconclusive
-                    | Choice2Of3 (TestMemberSuccess.Ignored _)
-                    | Choice2Of3 (TestMemberSuccess.Explicit _) -> TrxTestOutcome.NotExecuted
-                    // TODO: we can totally do better here, more fine-grained classification
-                    | Choice3Of3 _ -> TrxTestOutcome.Failed
-
-                {
-                    ExecutionId = i.ExecutionId
-                    TestId = i.TestId
-                    TestName = i.TestName
-                    ComputerName = i.ComputerName
-                    Duration = i.End - i.Start
-                    StartTime = i.Start
-                    EndTime = i.End
-                    TestType = magicGuid
-                    Outcome = outcome
-                    TestListId = testListId
-                    RelativeResultsDirectory = i.ExecutionId.ToString () // for some reason
-                    Output =
-                        match i.StdOut, i.StdErr, exc with
-                        | None, None, None -> None
-                        | stdout, stderr, exc ->
-                            Some
-                                {
-                                    TrxOutput.StdOut = stdout
-                                    StdErr = stderr
-                                    ErrorInfo = exc
-                                }
-                }
-            )
-
-        let report : TrxReport =
-            {
-                Id = Guid.NewGuid ()
-                Name = $"@%s{hostname} %s{finishTimeHumanReadable}"
-                Times = times
-                Settings = settings
-                Results = results
-                TestDefinitions = testDefinitions
-                TestEntries = testEntries
-                TestLists = [ testList ]
-                ResultsSummary = resultSummary
-            }
-
-        match trxPath with
+        match args.Trx with
         | Some trxPath ->
             let contents = TrxReport.toXml report |> fun d -> d.OuterXml
             trxPath.Directory.Create ()
@@ -344,10 +86,56 @@ module Program =
             Console.Error.WriteLine $"Written TRX file: %s{trxPath.FullName}"
         | None -> ()
 
-        match outcome with
+        match report.ResultsSummary.Outcome with
         | TrxOutcome.Completed -> 0
         | _ -> 1
 
+    let main argv =
+        let args = argv |> List.ofArray |> Args.Parse
+
+        let psi = ProcessStartInfo "dotnet"
+
+        match args.Trx with
+        | None -> ()
+        | Some trx -> psi.EnvironmentVariables.Add ("WOOFWARE_NUNIT_GENERATE_TRX", trx.FullName)
+
+        match args.LevelOfParallelism with
+        | None -> ()
+        | Some par -> psi.EnvironmentVariables.Add ("WOOFWARE_NUNIT_PARALLELISM_LEVEL", string<int> par)
+
+        match args.Filter with
+        | None -> ()
+        | Some (filter, _) -> psi.EnvironmentVariables.Add ("WOOFWARE_NUNIT_FILTER", filter)
+
+        match args.Timeout with
+        | None -> ()
+        | Some timeout ->
+            psi.EnvironmentVariables.Add ("WOOFWARE_NUNIT_TIMEOUT_SECS", string<int> (int<float> timeout.TotalSeconds))
+
+        psi.ArgumentList.Add "exec"
+        psi.ArgumentList.Add args.Dll.FullName
+
+        let us = Assembly.GetExecutingAssembly().Location |> FileInfo
+
+        let startupHook =
+            Path.Combine (us.Directory.FullName, "WoofWare.NUnitTestRunner.StartupHook.dll")
+
+        psi.EnvironmentVariables.Add ("DOTNET_STARTUP_HOOKS", startupHook)
+
+        psi.EnvironmentVariables.Add (
+            "WOOFWARE_NUNIT_LIB",
+            Path.Combine (us.Directory.FullName, "WoofWare.NUnitTestRunner.Lib.dll")
+        )
+
+        use proc = new Process ()
+        proc.StartInfo <- psi
+
+        if not (proc.Start ()) then
+            failwith "Failed to start dotnet"
+
+        proc.WaitForExit ()
+        proc.ExitCode
+
     [<EntryPoint>]
     let reallyMain argv =
         // Hack to make sure `finally`s get run.

WoofWare.NUnitTestRunner/Progress.fs

@@ -13,6 +13,10 @@ module Progress =
             member _.OnTestFixtureStart name testCount =
                 console.MarkupLine $"[white]Running tests: %s{Markup.Escape name}[/]"
 
+            member _.OnTestFixtureSkipped name reason =
+                console.MarkupLine
+                    $"[yellow]Skipping test fixture (%s{Markup.Escape reason}): %s{Markup.Escape name}[/]"
+
             member _.OnTestMemberFinished name =
                 console.MarkupLine $"[gray]Finished test: %s{Markup.Escape name}[/]"
 

WoofWare.NUnitTestRunner/Seq.fs

@@ -1,22 +0,0 @@
-namespace WoofWare.NUnitTestRunner
-
-[<RequireQualifiedAccess>]
-module internal Seq =
-
-    let tryMinBy (f : 'a -> 'b) (s : 'a seq) : 'a option =
-        use enum = s.GetEnumerator ()
-
-        if not (enum.MoveNext ()) then
-            None
-        else
-
-        let mutable answer = enum.Current
-        let mutable fAnswer = f enum.Current
-
-        while enum.MoveNext () do
-            let fNext = f enum.Current
-
-            if fNext < fAnswer then
-                answer <- enum.Current
-
-        Some answer

WoofWare.NUnitTestRunner/WoofWare.NUnitTestRunner.Test/TestSynchronizationContext.fs

@@ -0,0 +1,396 @@
+namespace WoofWare.NUnitTestRunner.Test
+
+open System
+open System.Text
+open System.Threading
+open System.Threading.Tasks
+open NUnit.Framework
+open FsUnitTyped
+open WoofWare.NUnitTestRunner
+
+[<TestFixture>]
+module TestSynchronizationContext =
+
+    [<Test>]
+    let ``ExecutionContext flows correctly through synchronous operations`` () =
+        task {
+            let dummyFixture =
+                TestFixture.Empty typeof<obj> (Some (Parallelizable.Yes ClassParallelScope.All)) [] []
+
+            use contexts = TestContexts.Empty ()
+            use queue = new ParallelQueue (Some 4, None)
+
+            // Track which context values we see during execution
+            let contextValues = System.Collections.Concurrent.ConcurrentBag<Guid * Guid> ()
+
+            // Start the fixture
+            let! running = queue.StartTestFixture dummyFixture
+            let! _, setup = queue.RunTestSetup running (fun () -> ())
+
+            // Create several synchronous operations with different context values
+            let tasks =
+                [ 1..10 ]
+                |> List.map (fun _ ->
+                    task {
+                        do! Task.Yield ()
+                        // Set a unique context value
+                        let outputId = contexts.NewOutputs ()
+                        let (OutputStreamId expectedId) = outputId
+                        contexts.AsyncLocal.Value <- outputId
+
+                        // Run a synchronous operation that checks the context
+                        let! actualId =
+                            queue.Run
+                                setup
+                                None
+                                (fun () ->
+                                    // Check context immediately
+                                    let immediate = contexts.AsyncLocal.Value
+                                    let (OutputStreamId immediateGuid) = immediate
+                                    contextValues.Add (expectedId, immediateGuid)
+
+                                    // Do some work that might cause context issues
+                                    Thread.Sleep 10
+
+                                    // Check context after work
+                                    let afterWork = contexts.AsyncLocal.Value
+                                    let (OutputStreamId afterWorkGuid) = afterWork
+                                    contextValues.Add (expectedId, afterWorkGuid)
+
+                                    // Simulate calling into framework code that might use ExecutionContext
+                                    let mutable capturedValue = Guid.Empty
+
+                                    ExecutionContext.Run (
+                                        ExecutionContext.Capture (),
+                                        (fun _ ->
+                                            let current = contexts.AsyncLocal.Value
+                                            let (OutputStreamId currentGuid) = current
+                                            capturedValue <- currentGuid
+                                        ),
+                                        ()
+                                    )
+
+                                    contextValues.Add (expectedId, capturedValue)
+
+                                    afterWorkGuid
+                                )
+
+                        // Verify the returned value matches what we set
+                        actualId |> shouldEqual expectedId
+                    }
+                )
+
+            // Wait for all tasks
+            let! results = Task.WhenAll tasks
+            results |> Array.iter id
+
+            // Verify all context values were correct
+            let allValues = contextValues |> Seq.toList
+            allValues |> shouldHaveLength 30 // 3 checks per operation * 10 operations
+
+            // Every captured value should match its expected value
+            allValues
+            |> List.iter (fun (expected, actual) -> actual |> shouldEqual expected)
+
+            // Clean up
+            let! _, teardown = queue.RunTestTearDown setup (fun () -> ())
+            do! queue.EndTestFixture teardown
+        }
+
+    [<Test>]
+    let ``ExecutionContext isolation between concurrent synchronous operations`` () =
+        task {
+            let dummyFixture =
+                TestFixture.Empty typeof<obj> (Some (Parallelizable.Yes ClassParallelScope.All)) [] []
+
+            use contexts = TestContexts.Empty ()
+            use queue = new ParallelQueue (Some 4, None)
+
+            let! running = queue.StartTestFixture dummyFixture
+            let! _, setup = queue.RunTestSetup running (fun () -> ())
+
+            // Use a barrier to ensure operations run concurrently
+            let barrier = new Barrier (3)
+            let seenValues = System.Collections.Concurrent.ConcurrentBag<int * Guid> ()
+            let outputIds = System.Collections.Concurrent.ConcurrentBag<OutputStreamId> ()
+
+            // Create operations that will definitely run concurrently
+            let tasks =
+                [ 1..3 ]
+                |> List.map (fun i ->
+                    task {
+                        // Each task sets its own context value
+                        let outputId = contexts.NewOutputs ()
+                        let (OutputStreamId myId) = outputId
+                        contexts.AsyncLocal.Value <- outputId
+                        outputIds.Add outputId
+
+                        let! result =
+                            queue.Run
+                                setup
+                                (Some (Parallelizable.Yes ()))
+                                (fun () ->
+                                    // Wait for all tasks to reach this point
+                                    barrier.SignalAndWait ()
+
+                                    // Now check what value we see
+                                    let currentValue = contexts.AsyncLocal.Value
+
+                                    match currentValue with
+                                    | OutputStreamId guid -> seenValues.Add (i, guid)
+
+                                    // Do some synchronous work
+                                    Thread.Sleep 5
+
+                                    // Check again after work
+                                    let afterWork = contexts.AsyncLocal.Value
+
+                                    match afterWork with
+                                    | OutputStreamId guid ->
+                                        // Also verify we can write to the correct streams
+                                        contexts.Stdout.WriteLine $"Task %i{i} sees context %O{guid}"
+                                        guid
+                                )
+
+                        // Each task should see its own value
+                        result |> shouldEqual myId
+                    }
+                )
+
+            let! results = Task.WhenAll tasks
+            results |> Array.iter id
+
+            // Verify we saw 3 different values (one per task)
+            let values = seenValues |> Seq.toList
+            values |> shouldHaveLength 3
+
+            // All seen values should be different (no context bleeding)
+            let uniqueValues = values |> List.map snd |> List.distinct
+            uniqueValues |> shouldHaveLength 3
+
+            let! _, teardown = queue.RunTestTearDown setup (fun () -> ())
+            do! queue.EndTestFixture teardown
+
+            // Verify stdout content for each task
+            let collectedOutputs = outputIds |> Seq.toList
+            collectedOutputs |> shouldHaveLength 3
+
+            for outputId in collectedOutputs do
+                let content = contexts.DumpStdout outputId
+                content |> shouldNotEqual ""
+                let (OutputStreamId guid) = outputId
+                content |> shouldContainText (guid.ToString ())
+        }
+
+    [<Test>]
+    let ``ExecutionContext flows correctly through nested synchronous operations`` () =
+        task {
+            let dummyFixture =
+                TestFixture.Empty typeof<obj> (Some (Parallelizable.Yes ClassParallelScope.All)) [] []
+
+            use contexts = TestContexts.Empty ()
+            use queue = new ParallelQueue (Some 4, None)
+
+            let! running = queue.StartTestFixture dummyFixture
+            let! _, setup = queue.RunTestSetup running (fun () -> ())
+
+            // Set an initial context
+            let outputId = contexts.NewOutputs ()
+            let (OutputStreamId outerGuid) = outputId
+            contexts.AsyncLocal.Value <- outputId
+
+            let! result =
+                queue.Run
+                    setup
+                    None
+                    (fun () ->
+                        // Check we have the outer context
+                        let outer = contexts.AsyncLocal.Value
+                        let (OutputStreamId outerSeen) = outer
+                        outerSeen |> shouldEqual outerGuid
+
+                        // Now change the context for a nested operation
+                        let innerOutputId = contexts.NewOutputs ()
+                        let (OutputStreamId innerGuid) = innerOutputId
+                        contexts.AsyncLocal.Value <- innerOutputId
+
+                        // Use Task.Run to potentially hop threads
+                        let innerResult =
+                            Task
+                                .Run(fun () ->
+                                    let inner = contexts.AsyncLocal.Value
+                                    let (OutputStreamId innerSeen) = inner
+                                    innerSeen |> shouldEqual innerGuid
+                                    innerSeen
+                                )
+                                .Result
+
+                        // After the nested operation, we should still have our inner context
+                        let afterNested = contexts.AsyncLocal.Value
+                        let (OutputStreamId afterNestedGuid) = afterNested
+                        afterNestedGuid |> shouldEqual innerGuid
+
+                        (outerSeen, innerResult, afterNestedGuid)
+                    )
+
+            // Unpack results
+            let seenOuter, seenInner, seenAfter = result
+            seenOuter |> shouldEqual outerGuid
+            seenInner |> shouldNotEqual outerGuid
+            seenAfter |> shouldEqual seenInner
+
+            let! _, teardown = queue.RunTestTearDown setup (fun () -> ())
+            do! queue.EndTestFixture teardown
+        }
+
+    [<Test>]
+    let ``ExecutionContext flows correctly through async operations`` () =
+        task {
+            // Create a test fixture
+            let dummyFixture =
+                TestFixture.Empty typeof<obj> (Some (Parallelizable.Yes ClassParallelScope.All)) [] []
+
+            use contexts = TestContexts.Empty ()
+            use queue = new ParallelQueue (Some 4, None)
+
+            // Track which context values we see during execution
+            let contextValues = System.Collections.Concurrent.ConcurrentBag<Guid * Guid> ()
+
+            // Start the fixture
+            let! running = queue.StartTestFixture dummyFixture
+            let! _, setup = queue.RunTestSetup running (fun () -> ())
+
+            // Create several async operations with different context values
+            let tasks =
+                [ 1..10 ]
+                |> List.map (fun i ->
+                    task {
+                        // Set a unique context value
+                        let expectedId = Guid.NewGuid ()
+                        let outputId = OutputStreamId expectedId
+                        contexts.AsyncLocal.Value <- outputId
+
+                        // Run an async operation that checks the context at multiple points
+                        let! actualId =
+                            queue.RunAsync
+                                setup
+                                None
+                                (fun () ->
+                                    async {
+                                        // Check context immediately
+                                        let immediate = contexts.AsyncLocal.Value
+                                        let (OutputStreamId immediateGuid) = immediate
+                                        contextValues.Add (expectedId, immediateGuid)
+
+                                        // Yield to allow potential context loss
+                                        do! Async.Sleep 10
+
+                                        // Check context after yield
+                                        let afterYield = contexts.AsyncLocal.Value
+                                        let (OutputStreamId afterYieldGuid) = afterYield
+                                        contextValues.Add (expectedId, afterYieldGuid)
+
+                                        // Do some actual async work
+                                        do! Task.Delay (10) |> Async.AwaitTask
+
+                                        // Check context after task
+                                        let afterTask = contexts.AsyncLocal.Value
+                                        let (OutputStreamId afterTaskGuid) = afterTask
+                                        contextValues.Add (expectedId, afterTaskGuid)
+
+                                        return afterTaskGuid
+                                    }
+                                )
+
+                        // Verify the returned value matches what we set
+                        actualId |> shouldEqual expectedId
+                    }
+                )
+
+            // Wait for all tasks
+            let! results = Task.WhenAll (tasks)
+            results |> Array.iter id
+
+            // Verify all context values were correct
+            let allValues = contextValues |> Seq.toList
+            allValues |> shouldHaveLength 30 // 3 checks per operation * 10 operations
+
+            // Every captured value should match its expected value
+            allValues
+            |> List.iter (fun (expected, actual) -> actual |> shouldEqual expected)
+
+            // Clean up
+            let! _, teardown = queue.RunTestTearDown setup (fun () -> ())
+            do! queue.EndTestFixture teardown
+        }
+
+    [<Test>]
+    let ``ExecutionContext isolation between concurrent operations`` () =
+        task {
+            let dummyFixture =
+                TestFixture.Empty typeof<obj> (Some (Parallelizable.Yes ClassParallelScope.All)) [] []
+
+            use contexts = TestContexts.Empty ()
+            use queue = new ParallelQueue (Some 4, None)
+
+            let! running = queue.StartTestFixture dummyFixture
+            let! _, setup = queue.RunTestSetup running (fun () -> ())
+
+            // Use a barrier to ensure operations run concurrently
+            let barrier = new Barrier (3)
+            let seenValues = System.Collections.Concurrent.ConcurrentBag<int * Guid> ()
+
+            // Create operations that will definitely run concurrently
+            let tasks =
+                [ 1..3 ]
+                |> List.map (fun i ->
+                    task {
+                        // Each task sets its own context value
+                        let myId = Guid.NewGuid ()
+                        contexts.AsyncLocal.Value <- OutputStreamId myId
+
+                        let! result =
+                            queue.RunAsync
+                                setup
+                                (Some (Parallelizable.Yes ()))
+                                (fun () ->
+                                    async {
+                                        // Wait for all tasks to reach this point
+                                        barrier.SignalAndWait () |> ignore
+
+                                        // Now check what value we see
+                                        let currentValue = contexts.AsyncLocal.Value
+
+                                        match currentValue with
+                                        | OutputStreamId guid -> seenValues.Add (i, guid)
+
+                                        // Do some async work
+                                        do! Async.Sleep 5
+
+                                        // Check again after async work
+                                        let afterAsync = contexts.AsyncLocal.Value
+
+                                        match afterAsync with
+                                        | OutputStreamId guid -> return guid
+                                    }
+                                )
+
+                        // Each task should see its own value
+                        result |> shouldEqual myId
+                    }
+                )
+
+            let! results = Task.WhenAll (tasks)
+            results |> Array.iter id
+
+            // Verify we saw 3 different values (one per task)
+            let values = seenValues |> Seq.toList
+            values |> shouldHaveLength 3
+
+            // All seen values should be different (no context bleeding)
+            let uniqueValues = values |> List.map snd |> List.distinct
+            uniqueValues |> shouldHaveLength 3
+
+            let! _, teardown = queue.RunTestTearDown setup (fun () -> ())
+            do! queue.EndTestFixture teardown
+        }

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

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>net8.0</TargetFramework>
+        <TargetFramework>net9.0</TargetFramework>
         <IsPackable>false</IsPackable>
         <IsTestProject>true</IsTestProject>
     </PropertyGroup>
@@ -11,17 +11,18 @@
         <Compile Include="TestFilter.fs" />
         <Compile Include="TestList.fs" />
         <Compile Include="TestSurface.fs" />
+        <Compile Include="TestSynchronizationContext.fs" />
         <Compile Include="TestTrx.fs" />
         <EmbeddedResource Include="Example1.trx" />
     </ItemGroup>
 
     <ItemGroup>
-        <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" />
-        <PackageReference Include="NUnit" Version="4.1.0" />
-        <PackageReference Include="NUnit3TestAdapter" Version="4.5.0"/>
+        <PackageReference Include="ApiSurface" Version="5.0.2" />
+        <PackageReference Include="FsCheck" Version="3.3.1" />
+        <PackageReference Include="FsUnit" Version="7.1.1" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
+        <PackageReference Include="NUnit" Version="4.3.2" />
+        <PackageReference Include="NUnit3TestAdapter" Version="5.0.0"/>
     </ItemGroup>
 
     <ItemGroup>

WoofWare.NUnitTestRunner/WoofWare.NUnitTestRunner.fsproj

@@ -2,7 +2,8 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
+    <RollForward>Major</RollForward>
     <PackAsTool>true</PackAsTool>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <Authors>Patrick Stevens</Authors>
@@ -19,7 +20,6 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <Compile Include="Seq.fs" />
     <Compile Include="Progress.fs" />
     <Compile Include="Program.fs" />
     <None Include="..\README.md">
@@ -30,10 +30,12 @@
 
   <ItemGroup>
     <ProjectReference Include="..\WoofWare.NUnitTestRunner.Lib\WoofWare.NUnitTestRunner.Lib.fsproj" />
+    <ProjectReference Include="..\WoofWare.NUnitTestRunner.StartupHookLogic\WoofWare.NUnitTestRunner.StartupHookLogic.csproj" />
+    <ProjectReference Include="..\WoofWare.NUnitTestRunner.StartupHook\WoofWare.NUnitTestRunner.StartupHook.csproj" />
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Spectre.Console" Version="0.49.1" />
+    <PackageReference Include="Spectre.Console" Version="0.51.1" />
   </ItemGroup>
 
   <ItemGroup>

WoofWare.NUnitTestRunner/version.json

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

analyzers/analyzers.fsproj

@@ -4,13 +4,13 @@
     <IsPackable>false</IsPackable>
     <IsPublishable>false</IsPublishable>
     <RestorePackagesPath>../.analyzerpackages/</RestorePackagesPath>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <DisableImplicitNuGetFallbackFolder>true</DisableImplicitNuGetFallbackFolder>
     <AutomaticallyUseReferenceAssemblyPackages>false</AutomaticallyUseReferenceAssemblyPackages> <!-- We don't want to build this project, so we do not need the reference assemblies for the framework we chose.-->
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageDownload Include="G-Research.FSharp.Analyzers" Version="[0.10.0]" />
+    <PackageDownload Include="G-Research.FSharp.Analyzers" Version="[0.17.0]" />
   </ItemGroup>
 
 </Project>

flake.lock

@@ -5,11 +5,11 @@
         "systems": "systems"
       },
       "locked": {
-        "lastModified": 1710146030,
-        "narHash": "sha256-SZ5L6eA7HJ/nmkzGG7/ISclqe6oZdOZTNoesiInkXPQ=",
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
         "owner": "numtide",
         "repo": "flake-utils",
-        "rev": "b1d9ab70662946ef0850d488da1c9019f3a9752a",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
         "type": "github"
       },
       "original": {
@@ -20,11 +20,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1717399147,
-        "narHash": "sha256-eCWaE/q1VItpFAxxLVt171MdtDcjEnwi6QB/yuF73JU=",
+        "lastModified": 1758262103,
+        "narHash": "sha256-aBGl3XEOsjWw6W3AHiKibN7FeoG73dutQQEqnd/etR8=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "4a4ecb0ab415c9fccfb005567a215e6a9564cdf5",
+        "rev": "12bd230118a1901a4a5d393f9f56b6ad7e571d01",
         "type": "github"
       },
       "original": {

flake.nix

@@ -14,10 +14,10 @@
     flake-utils.lib.eachDefaultSystem (system: let
       pkgs = nixpkgs.legacyPackages.${system};
       pname = "unofficial-nunit-runner";
-      dotnet-sdk = pkgs.dotnet-sdk_8;
-      dotnet-runtime = pkgs.dotnetCorePackages.runtime_8_0;
+      dotnet-sdk = pkgs.dotnetCorePackages.sdk_9_0;
+      dotnet-runtime = pkgs.dotnetCorePackages.runtime_9_0;
       version = "0.1";
-      dotnetTool = dllOverride: toolName: toolVersion: sha256:
+      dotnetTool = dllOverride: toolName: toolVersion: hash:
         pkgs.stdenvNoCC.mkDerivation rec {
           name = toolName;
           version = toolVersion;
@@ -25,8 +25,8 @@
           src = pkgs.fetchNuGet {
             pname = name;
             version = version;
-            sha256 = sha256;
-            installPhase = ''mkdir -p $out/bin && cp -r tools/net6.0/any/* $out/bin'';
+            hash = hash;
+            installPhase = ''mkdir -p $out/bin && cp -r tools/net*/any/* $out/bin'';
           };
           installPhase = let
             dll =
@@ -42,9 +42,11 @@
           '';
         };
     in {
-      packages = {
-        fantomas = dotnetTool null "fantomas" (builtins.fromJSON (builtins.readFile ./.config/dotnet-tools.json)).tools.fantomas.version (builtins.head (builtins.filter (elem: elem.pname == "fantomas") ((import ./nix/deps.nix) {fetchNuGet = x: x;}))).sha256;
-        fsharp-analyzers = dotnetTool "FSharp.Analyzers.Cli" "fsharp-analyzers" (builtins.fromJSON (builtins.readFile ./.config/dotnet-tools.json)).tools.fsharp-analyzers.version (builtins.head (builtins.filter (elem: elem.pname == "fsharp-analyzers") ((import ./nix/deps.nix) {fetchNuGet = x: x;}))).sha256;
+      packages = let
+        deps = builtins.fromJSON (builtins.readFile ./nix/deps.json);
+      in {
+        fantomas = dotnetTool null "fantomas" (builtins.fromJSON (builtins.readFile ./.config/dotnet-tools.json)).tools.fantomas.version (builtins.head (builtins.filter (elem: elem.pname == "fantomas") deps)).hash;
+        fsharp-analyzers = dotnetTool "FSharp.Analyzers.Cli" "fsharp-analyzers" (builtins.fromJSON (builtins.readFile ./.config/dotnet-tools.json)).tools.fsharp-analyzers.version (builtins.head (builtins.filter (elem: elem.pname == "fsharp-analyzers") deps)).hash;
         default = pkgs.buildDotnetModule {
           inherit pname version dotnet-sdk dotnet-runtime;
           name = "unofficial-nunit-runner";
@@ -52,17 +54,20 @@
           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
+          nugetDeps = ./nix/deps.json; # `nix build .#default.fetch-deps && ./result nix/deps.json`
           doCheck = true;
         };
       };
-      devShell = pkgs.mkShell {
-        buildInputs = [dotnet-sdk];
-        packages = [
-          pkgs.alejandra
-          pkgs.nodePackages.markdown-link-check
-          pkgs.shellcheck
-        ];
+      devShells = {
+        default = pkgs.mkShell {
+          packages = [
+            dotnet-sdk
+            pkgs.alejandra
+            pkgs.nodePackages.markdown-link-check
+            pkgs.shellcheck
+            pkgs.xmlstarlet
+          ];
+        };
       };
     });
 }

nix/deps.json

@@ -0,0 +1,367 @@
+[
+  {
+    "pname": "ApiSurface",
+    "version": "5.0.2",
+    "hash": "sha256-zcq1H1ccQzsZQf4kolzoOBSbyz07skihgPAvQ9Jri+E="
+  },
+  {
+    "pname": "fantomas",
+    "version": "7.0.3",
+    "hash": "sha256-0XlfV7SxXPDnk/CjkUesJSaH0cxlNHJ+Jj86zNUhkNA="
+  },
+  {
+    "pname": "Fantomas.Core",
+    "version": "6.1.1",
+    "hash": "sha256-FcTLHQFvKkQY/kV08jhhy/St/+FmXpp3epp/R3zUXMA="
+  },
+  {
+    "pname": "Fantomas.FCS",
+    "version": "6.1.1",
+    "hash": "sha256-NuZ8msPEHYA8T3EYREB28F1RcNgUU8V54eg2+UttYxw="
+  },
+  {
+    "pname": "FsCheck",
+    "version": "3.3.1",
+    "hash": "sha256-k65ksdOSOGz+meRUUND+yuqJtm5ChaKuaxmRIdKzx2Y="
+  },
+  {
+    "pname": "fsharp-analyzers",
+    "version": "0.32.1",
+    "hash": "sha256-le6rPnAF7cKGBZ2w8H2u9glK+6rT2ZjiAVnrkH2IhrM="
+  },
+  {
+    "pname": "FSharp.Core",
+    "version": "4.3.4",
+    "hash": "sha256-styyo+6mJy+yxE0NZG/b1hxkAjPOnJfMgd9zWzCJ5uk="
+  },
+  {
+    "pname": "FSharp.Core",
+    "version": "6.0.1",
+    "hash": "sha256-Ehsgt3nCJijpaVuJguC1TPVEKSkJd6PSc07D2ZQSemI="
+  },
+  {
+    "pname": "FSharp.Core",
+    "version": "9.0.303",
+    "hash": "sha256-AxR6wqodeU23KOTgkUfIgbavgbcSuzD4UBP+tiFydgA="
+  },
+  {
+    "pname": "FsUnit",
+    "version": "7.1.1",
+    "hash": "sha256-UMCEGKxQ4ytjmPuVpiNaAPbi3RQH9gqa61JJIUS/6hg="
+  },
+  {
+    "pname": "Microsoft.ApplicationInsights",
+    "version": "2.22.0",
+    "hash": "sha256-mUQ63atpT00r49ca50uZu2YCiLg3yd6r3HzTryqcuEA="
+  },
+  {
+    "pname": "Microsoft.AspNetCore.App.Ref",
+    "version": "6.0.36",
+    "hash": "sha256-9jDkWbjw/nd8yqdzVTagCuqr6owJ/DUMi4BlUZT4hWU="
+  },
+  {
+    "pname": "Microsoft.AspNetCore.App.Runtime.linux-arm64",
+    "version": "6.0.36",
+    "hash": "sha256-JQULJyF0ivLoUU1JaFfK/HHg+/qzpN7V2RR2Cc+WlQ4="
+  },
+  {
+    "pname": "Microsoft.AspNetCore.App.Runtime.linux-x64",
+    "version": "6.0.36",
+    "hash": "sha256-zUsVIpV481vMLAXaLEEUpEMA9/f1HGOnvaQnaWdzlyY="
+  },
+  {
+    "pname": "Microsoft.AspNetCore.App.Runtime.osx-arm64",
+    "version": "6.0.36",
+    "hash": "sha256-2seqZcz0JeUjkzh3QcGa9TcJ4LUafpFjTRk+Nm8T6T0="
+  },
+  {
+    "pname": "Microsoft.AspNetCore.App.Runtime.osx-x64",
+    "version": "6.0.36",
+    "hash": "sha256-yxLafxiBKkvfkDggPk0P9YZIHBkDJOsFTO7/V9mEHuU="
+  },
+  {
+    "pname": "Microsoft.CodeCoverage",
+    "version": "17.14.1",
+    "hash": "sha256-f8QytG8GvRoP47rO2KEmnDLxIpyesaq26TFjDdW40Gs="
+  },
+  {
+    "pname": "Microsoft.NET.Test.Sdk",
+    "version": "17.14.1",
+    "hash": "sha256-mZUzDFvFp7x1nKrcnRd0hhbNu5g8EQYt8SKnRgdhT/A="
+  },
+  {
+    "pname": "Microsoft.NETCore.App.Host.linux-arm64",
+    "version": "6.0.36",
+    "hash": "sha256-9lC/LYnthYhjkWWz2kkFCvlA5LJOv11jdt59SDnpdy0="
+  },
+  {
+    "pname": "Microsoft.NETCore.App.Host.linux-x64",
+    "version": "6.0.36",
+    "hash": "sha256-VFRDzx7LJuvI5yzKdGmw/31NYVbwHWPKQvueQt5xc10="
+  },
+  {
+    "pname": "Microsoft.NETCore.App.Host.osx-arm64",
+    "version": "6.0.36",
+    "hash": "sha256-DaSWwYACJGolEBuMhzDVCj/rQTdDt061xCVi+gyQnuo="
+  },
+  {
+    "pname": "Microsoft.NETCore.App.Host.osx-x64",
+    "version": "6.0.36",
+    "hash": "sha256-FrRny9EI6HKCKQbu6mcLj5w4ooSRrODD4Vj2ZMGnMd4="
+  },
+  {
+    "pname": "Microsoft.NETCore.App.Ref",
+    "version": "6.0.36",
+    "hash": "sha256-9LZgVoIFF8qNyUu8kdJrYGLutMF/cL2K82HN2ywwlx8="
+  },
+  {
+    "pname": "Microsoft.NETCore.App.Runtime.linux-arm64",
+    "version": "6.0.36",
+    "hash": "sha256-k3rxvUhCEU0pVH8KgEMtkPiSOibn+nBh+0zT2xIfId8="
+  },
+  {
+    "pname": "Microsoft.NETCore.App.Runtime.linux-x64",
+    "version": "6.0.36",
+    "hash": "sha256-U8wJ2snSDFqeAgDVLXjnniidC7Cr5aJ1/h/BMSlyu0c="
+  },
+  {
+    "pname": "Microsoft.NETCore.App.Runtime.osx-arm64",
+    "version": "6.0.36",
+    "hash": "sha256-UfLcrL2Gj/OLz0s92Oo+OCJeDpZFAcQLPLiSNND8D5Y="
+  },
+  {
+    "pname": "Microsoft.NETCore.App.Runtime.osx-x64",
+    "version": "6.0.36",
+    "hash": "sha256-0xIJYFzxdMcnCj3wzkFRQZSnQcPHzPHMzePRIOA3oJs="
+  },
+  {
+    "pname": "Microsoft.NETCore.Platforms",
+    "version": "1.1.0",
+    "hash": "sha256-FeM40ktcObQJk4nMYShB61H/E8B7tIKfl9ObJ0IOcCM="
+  },
+  {
+    "pname": "Microsoft.NETCore.Platforms",
+    "version": "1.1.1",
+    "hash": "sha256-8hLiUKvy/YirCWlFwzdejD2Db3DaXhHxT7GSZx/znJg="
+  },
+  {
+    "pname": "Microsoft.NETCore.Targets",
+    "version": "1.1.0",
+    "hash": "sha256-0AqQ2gMS8iNlYkrD+BxtIg7cXMnr9xZHtKAuN4bjfaQ="
+  },
+  {
+    "pname": "Microsoft.NETCore.Targets",
+    "version": "1.1.3",
+    "hash": "sha256-WLsf1NuUfRWyr7C7Rl9jiua9jximnVvzy6nk2D2bVRc="
+  },
+  {
+    "pname": "Microsoft.Testing.Extensions.Telemetry",
+    "version": "1.5.3",
+    "hash": "sha256-bIXwPSa3jkr2b6xINOqMUs6/uj/r4oVFM7xq3uVIZDU="
+  },
+  {
+    "pname": "Microsoft.Testing.Extensions.TrxReport.Abstractions",
+    "version": "1.5.3",
+    "hash": "sha256-IfMRfcyaIKEMRtx326ICKtinDBEfGw/Sv8ZHawJ96Yc="
+  },
+  {
+    "pname": "Microsoft.Testing.Extensions.VSTestBridge",
+    "version": "1.5.3",
+    "hash": "sha256-XpM/yFjhLSsuzyDV+xKubs4V1zVVYiV05E0+N4S1h0g="
+  },
+  {
+    "pname": "Microsoft.Testing.Platform",
+    "version": "1.5.3",
+    "hash": "sha256-y61Iih6w5D79dmrj2V675mcaeIiHoj1HSa1FRit2BLM="
+  },
+  {
+    "pname": "Microsoft.Testing.Platform.MSBuild",
+    "version": "1.5.3",
+    "hash": "sha256-YspvjE5Jfi587TAfsvfDVJXNrFOkx1B3y1CKV6m7YLY="
+  },
+  {
+    "pname": "Microsoft.TestPlatform.ObjectModel",
+    "version": "17.12.0",
+    "hash": "sha256-3XBHBSuCxggAIlHXmKNQNlPqMqwFlM952Av6RrLw1/w="
+  },
+  {
+    "pname": "Microsoft.TestPlatform.ObjectModel",
+    "version": "17.14.1",
+    "hash": "sha256-QMf6O+w0IT+16Mrzo7wn+N20f3L1/mDhs/qjmEo1rYs="
+  },
+  {
+    "pname": "Microsoft.TestPlatform.TestHost",
+    "version": "17.14.1",
+    "hash": "sha256-1cxHWcvHRD7orQ3EEEPPxVGEkTpxom1/zoICC9SInJs="
+  },
+  {
+    "pname": "Myriad.Core",
+    "version": "0.8.3",
+    "hash": "sha256-vBOxfq8QriX/yUtaXN69rEQaY/psRNJWxqATLidrt2g="
+  },
+  {
+    "pname": "Myriad.Sdk",
+    "version": "0.8.3",
+    "hash": "sha256-7O397WKhskKOvE3MkJT37BvxorDWngDR6gTUogtDZ2M="
+  },
+  {
+    "pname": "Nerdbank.GitVersioning",
+    "version": "3.8.118",
+    "hash": "sha256-Hmyy0ZKOmwN4zIhI4+MqoN8geZNc1sd033aZJ6APrO8="
+  },
+  {
+    "pname": "Newtonsoft.Json",
+    "version": "13.0.3",
+    "hash": "sha256-hy/BieY4qxBWVVsDqqOPaLy1QobiIapkbrESm6v2PHc="
+  },
+  {
+    "pname": "NuGet.Common",
+    "version": "6.14.0",
+    "hash": "sha256-jDOwt3veI1GSG8CfBnf2+dJxD3E/Nmlc+vHtD4J76Ms="
+  },
+  {
+    "pname": "NuGet.Configuration",
+    "version": "6.14.0",
+    "hash": "sha256-1PN9s6fhCw3wd2260U6hQ4vG3jIvcG8GIn1oQgxMXA0="
+  },
+  {
+    "pname": "NuGet.Frameworks",
+    "version": "6.14.0",
+    "hash": "sha256-3ViM3R1ucQMEL2hQYsivT86kI6veMQK2xDsiAcFcVQk="
+  },
+  {
+    "pname": "NuGet.Packaging",
+    "version": "6.14.0",
+    "hash": "sha256-Yafbnxs3maj55bJ1oKQiZ0QkntFUzXdhorL94YEUOhY="
+  },
+  {
+    "pname": "NuGet.Protocol",
+    "version": "6.14.0",
+    "hash": "sha256-uLDKfs+QN1MdnuQtTES8qfNzzsmYKM6XB9pwJc4G+eo="
+  },
+  {
+    "pname": "NuGet.Versioning",
+    "version": "6.14.0",
+    "hash": "sha256-DqdOJgsphKxSvqB8b60zNPCaiLfbiu3WnUJ/90feLrY="
+  },
+  {
+    "pname": "NUnit",
+    "version": "4.3.2",
+    "hash": "sha256-0RWe8uFoxYp6qhPlDDEghOMcKJgyw2ybvEoAqBLebeE="
+  },
+  {
+    "pname": "NUnit3TestAdapter",
+    "version": "5.0.0",
+    "hash": "sha256-7jZM4qAbIzne3AcdFfMbvbgogqpxvVe6q2S7Ls8xQy0="
+  },
+  {
+    "pname": "runtime.any.System.Runtime",
+    "version": "4.3.0",
+    "hash": "sha256-qwhNXBaJ1DtDkuRacgHwnZmOZ1u9q7N8j0cWOLYOELM="
+  },
+  {
+    "pname": "runtime.native.System",
+    "version": "4.3.0",
+    "hash": "sha256-ZBZaodnjvLXATWpXXakFgcy6P+gjhshFXmglrL5xD5Y="
+  },
+  {
+    "pname": "runtime.unix.System.Private.Uri",
+    "version": "4.3.0",
+    "hash": "sha256-c5tXWhE/fYbJVl9rXs0uHh3pTsg44YD1dJvyOA0WoMs="
+  },
+  {
+    "pname": "Spectre.Console",
+    "version": "0.51.1",
+    "hash": "sha256-FQAK07dEwEsNYVI1T3S488LHv8AXJ+ZeA9N2hPpWBoo="
+  },
+  {
+    "pname": "System.Collections.Immutable",
+    "version": "8.0.0",
+    "hash": "sha256-F7OVjKNwpqbUh8lTidbqJWYi476nsq9n+6k0+QVRo3w="
+  },
+  {
+    "pname": "System.Diagnostics.DiagnosticSource",
+    "version": "5.0.0",
+    "hash": "sha256-6mW3N6FvcdNH/pB58pl+pFSCGWgyaP4hfVtC/SMWDV4="
+  },
+  {
+    "pname": "System.Diagnostics.DiagnosticSource",
+    "version": "7.0.0",
+    "hash": "sha256-9Wk8cHSkjKtqkN6xW7KnXoQVtF/VNbKeBq79WqDesMs="
+  },
+  {
+    "pname": "System.Formats.Asn1",
+    "version": "6.0.0",
+    "hash": "sha256-KaMHgIRBF7Nf3VwOo+gJS1DcD+41cJDPWFh+TDQ8ee8="
+  },
+  {
+    "pname": "System.Memory",
+    "version": "4.5.5",
+    "hash": "sha256-EPQ9o1Kin7KzGI5O3U3PUQAZTItSbk9h/i4rViN3WiI="
+  },
+  {
+    "pname": "System.Private.Uri",
+    "version": "4.3.0",
+    "hash": "sha256-fVfgcoP4AVN1E5wHZbKBIOPYZ/xBeSIdsNF+bdukIRM="
+  },
+  {
+    "pname": "System.Reflection.Metadata",
+    "version": "8.0.0",
+    "hash": "sha256-dQGC30JauIDWNWXMrSNOJncVa1umR1sijazYwUDdSIE="
+  },
+  {
+    "pname": "System.Runtime",
+    "version": "4.3.1",
+    "hash": "sha256-R9T68AzS1PJJ7v6ARz9vo88pKL1dWqLOANg4pkQjkA0="
+  },
+  {
+    "pname": "System.Runtime.CompilerServices.Unsafe",
+    "version": "6.0.0",
+    "hash": "sha256-bEG1PnDp7uKYz/OgLOWs3RWwQSVYm+AnPwVmAmcgp2I="
+  },
+  {
+    "pname": "System.Security.Cryptography.Pkcs",
+    "version": "6.0.4",
+    "hash": "sha256-2e0aRybote+OR66bHaNiYpF//4fCiaO3zbR2e9GABUI="
+  },
+  {
+    "pname": "System.Security.Cryptography.ProtectedData",
+    "version": "4.4.0",
+    "hash": "sha256-Ri53QmFX8I8UH0x4PikQ1ZA07ZSnBUXStd5rBfGWFOE="
+  },
+  {
+    "pname": "System.Text.Json",
+    "version": "8.0.5",
+    "hash": "sha256-yKxo54w5odWT6nPruUVsaX53oPRe+gKzGvLnnxtwP68="
+  },
+  {
+    "pname": "TypeEquality",
+    "version": "0.3.0",
+    "hash": "sha256-V50xAOzzyUJrY+MYPRxtnqW5MVeATXCes89wPprv1r4="
+  },
+  {
+    "pname": "WoofWare.DotnetRuntimeLocator",
+    "version": "0.1.12",
+    "hash": "sha256-6pNZs0/R2LnLKSODq9DyHhGo2C+SDyz9k7D/13/78so="
+  },
+  {
+    "pname": "WoofWare.Myriad.Plugins",
+    "version": "8.1.1",
+    "hash": "sha256-Cx7/+5+qc8lhxb0On/OW58PrabadMfbcNP1TvLZGHrY="
+  },
+  {
+    "pname": "WoofWare.Myriad.Plugins.Attributes",
+    "version": "3.7.1",
+    "hash": "sha256-Mn0OVvC/AwTYg6+3MCKLkNKGGSdzLfBOaLapxHsUDCw="
+  },
+  {
+    "pname": "WoofWare.PrattParser",
+    "version": "0.2.4",
+    "hash": "sha256-aNTa2C300jUCsQ+iVSoothbCvBWdg7OzCJknwG5HV6g="
+  },
+  {
+    "pname": "WoofWare.Whippet.Fantomas",
+    "version": "0.6.3",
+    "hash": "sha256-FkW/HtVp8/HE2k6d7yFpnJcnP3FNNe9kGlkoIWmNgDw="
+  }
+]

nix/deps.nix

@@ -1,269 +0,0 @@
-# This file was automatically generated by passthru.fetch-deps.
-# Please dont edit it manually, your changes might get overwritten!
-{fetchNuGet}: [
-  (fetchNuGet {
-    pname = "ApiSurface";
-    version = "4.0.41";
-    sha256 = "03kfa5ngmgkik9lc58sp8s9rrh9g40hhgjnrv662ks0d0y2i9i89";
-  })
-  (fetchNuGet {
-    pname = "fantomas";
-    version = "6.3.9";
-    sha256 = "1b34iiiff02bbzjv03zyna8xmrgs6y87zdvp5i5k58fcqpjw44sx";
-  })
-  (fetchNuGet {
-    pname = "FsCheck";
-    version = "3.0.0-rc3";
-    sha256 = "1rn4x9qh479927viwww3dy0mikcdcq3pfqv1hzbbawnwxfzm17z1";
-  })
-  (fetchNuGet {
-    pname = "fsharp-analyzers";
-    version = "0.26.0";
-    sha256 = "0xgv5kvbwfdvcp6s8x7xagbbi4s3mqa4ixni6pazqvyflbgnah7b";
-  })
-  (fetchNuGet {
-    pname = "FSharp.Core";
-    version = "6.0.0";
-    sha256 = "1hjhvr39c1vpgrdmf8xln5q86424fqkvy9nirkr29vl2461d2039";
-  })
-  (fetchNuGet {
-    pname = "FSharp.Core";
-    version = "8.0.300";
-    sha256 = "158xxr9hnhz2ibyzzp2d249angvxfc58ifflm4g3hz8qx9zxaq04";
-  })
-  (fetchNuGet {
-    pname = "FsUnit";
-    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";
-    sha256 = "0s0v7jmrq85n356xv7zixvwa4z94fszjcr5vll8x4im1a2lp00f9";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.NET.Test.Sdk";
-    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";
-    sha256 = "1fk2fk2639i7nzy58m9dvpdnzql4vb8yl8vr19r2fp8lmj9w2jr0";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.TestPlatform.ObjectModel";
-    version = "17.10.0";
-    sha256 = "07j69cw8r39533w4p39mnj00kahazz38760in3jfc45kmlcdb26x";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.TestPlatform.TestHost";
-    version = "17.10.0";
-    sha256 = "1bl471s7fx9jycr0cc8rylwf34mrvlg9qn1an6l86nisavfcyb7v";
-  })
-  (fetchNuGet {
-    pname = "Myriad.Sdk";
-    version = "0.8.3";
-    sha256 = "0qv78c5s5m04xb8h17nnn2ig26zcyya91k2dpj745cm1cbnzvvgc";
-  })
-  (fetchNuGet {
-    pname = "Nerdbank.GitVersioning";
-    version = "3.6.139";
-    sha256 = "0npcryhq3r0c2zi940jk39h13mzc4hyg7z8gm6jdmxi1aqv1vh8c";
-  })
-  (fetchNuGet {
-    pname = "Newtonsoft.Json";
-    version = "13.0.1";
-    sha256 = "0fijg0w6iwap8gvzyjnndds0q4b8anwxxvik7y8vgq97dram4srb";
-  })
-  (fetchNuGet {
-    pname = "Newtonsoft.Json";
-    version = "13.0.3";
-    sha256 = "0xrwysmrn4midrjal8g2hr1bbg38iyisl0svamb11arqws4w2bw7";
-  })
-  (fetchNuGet {
-    pname = "NuGet.Common";
-    version = "6.10.0";
-    sha256 = "0nizrnilmlcqbm945293h8q3wfqfchb4xi8g50x4kjn0rbpd1kbh";
-  })
-  (fetchNuGet {
-    pname = "NuGet.Configuration";
-    version = "6.10.0";
-    sha256 = "1aqaknaawnqx4mnvx9qw73wvj48jjzv0d78dzwl7m9zjlrl9myhz";
-  })
-  (fetchNuGet {
-    pname = "NuGet.Frameworks";
-    version = "6.10.0";
-    sha256 = "0hrd8y31zx9a0wps49czw0qgbrakb49zn3abfgylc9xrq990zkqk";
-  })
-  (fetchNuGet {
-    pname = "NuGet.Packaging";
-    version = "6.10.0";
-    sha256 = "18s53cvrf51lihmaqqdf48p2qi6ky1l48jv0hvbp76cxwdg7rba4";
-  })
-  (fetchNuGet {
-    pname = "NuGet.Protocol";
-    version = "6.10.0";
-    sha256 = "0hmv4q0ks9i34mfgpb13l01la9v3jjllfh1qd3aqv105xrqrdxac";
-  })
-  (fetchNuGet {
-    pname = "NuGet.Versioning";
-    version = "6.10.0";
-    sha256 = "1x19njx4x0sw9fz8y5fibi15xfsrw5avir0cx0599yd7p3ykik5g";
-  })
-  (fetchNuGet {
-    pname = "NUnit";
-    version = "4.1.0";
-    sha256 = "0fj6xwgqaxq3mrai86bklclfmjkzf038mrslwfqf4ignaz9f7g5j";
-  })
-  (fetchNuGet {
-    pname = "NUnit3TestAdapter";
-    version = "4.5.0";
-    sha256 = "1srx1629s0k1kmf02nmz251q07vj6pv58mdafcr5dr0bbn1fh78i";
-  })
-  (fetchNuGet {
-    pname = "Spectre.Console";
-    version = "0.49.1";
-    sha256 = "0fhl96p3xjd5k1wwvhs80cp35rrlgnza6mw9vy0knhmf7ji9b95n";
-  })
-  (fetchNuGet {
-    pname = "System.Formats.Asn1";
-    version = "6.0.0";
-    sha256 = "1vvr7hs4qzjqb37r0w1mxq7xql2b17la63jwvmgv65s1hj00g8r9";
-  })
-  (fetchNuGet {
-    pname = "System.IO.Abstractions";
-    version = "4.2.13";
-    sha256 = "0s784iphsmj4vhkrzq9q3w39vsn76w44zclx3hsygsw458zbyh4y";
-  })
-  (fetchNuGet {
-    pname = "System.IO.FileSystem.AccessControl";
-    version = "4.5.0";
-    sha256 = "1gq4s8w7ds1sp8f9wqzf8nrzal40q5cd2w4pkf4fscrl2ih3hkkj";
-  })
-  (fetchNuGet {
-    pname = "System.Reflection.Metadata";
-    version = "1.6.0";
-    sha256 = "1wdbavrrkajy7qbdblpbpbalbdl48q3h34cchz24gvdgyrlf15r4";
-  })
-  (fetchNuGet {
-    pname = "System.Security.AccessControl";
-    version = "4.5.0";
-    sha256 = "1wvwanz33fzzbnd2jalar0p0z3x0ba53vzx1kazlskp7pwyhlnq0";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Cryptography.Pkcs";
-    version = "6.0.4";
-    sha256 = "0hh5h38pnxmlrnvs72f2hzzpz4b2caiiv6xf8y7fzdg84r3imvfr";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Cryptography.ProtectedData";
-    version = "4.4.0";
-    sha256 = "1q8ljvqhasyynp94a1d7jknk946m20lkwy2c3wa8zw2pc517fbj6";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Principal.Windows";
-    version = "4.5.0";
-    sha256 = "0rmj89wsl5yzwh0kqjgx45vzf694v9p92r4x4q6yxldk1cv1hi86";
-  })
-  (fetchNuGet {
-    pname = "System.Text.Encodings.Web";
-    version = "7.0.0";
-    sha256 = "1151hbyrcf8kyg1jz8k9awpbic98lwz9x129rg7zk1wrs6vjlpxl";
-  })
-  (fetchNuGet {
-    pname = "System.Text.Json";
-    version = "7.0.3";
-    sha256 = "0zjrnc9lshagm6kdb9bdh45dmlnkpwcpyssa896sda93ngbmj8k9";
-  })
-  (fetchNuGet {
-    pname = "WoofWare.DotnetRuntimeLocator";
-    version = "0.1.4";
-    sha256 = "19pp4qlyf18g704ppbcsm1rhjqjpi84py18yljj9nx70331m8bpg";
-  })
-  (fetchNuGet {
-    pname = "WoofWare.Myriad.Plugins";
-    version = "2.1.44";
-    sha256 = "0rp9hpkah60gd9x0ba2izr9ff1g7yhzv5a4pkhi5fbrwf5rpqpwx";
-  })
-  (fetchNuGet {
-    pname = "WoofWare.Myriad.Plugins.Attributes";
-    version = "3.1.6";
-    sha256 = "0786pr1p0nq0854mqi2cddmh185j3jihwn6azz9wiy6nxawjbrd2";
-  })
-  (fetchNuGet {
-    pname = "WoofWare.PrattParser";
-    version = "0.1.2";
-    sha256 = "0spypcwsbn805yrs6grjj68ccva902lhkq93mxy32rdply1xs34q";
-  })
-]