Permit async ParallelQueue (#279)

* Bump WoofWare.Myriad.Plugins from 8.0.4 to 8.0.5

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

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

* Deps

---------

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

.config/dotnet-tools.json

@@ -3,13 +3,13 @@
   "isRoot": true,
   "tools": {
     "fantomas": {
-      "version": "7.0.0",
+      "version": "7.0.3",
       "commands": [
         "fantomas"
       ]
     },
     "fsharp-analyzers": {
-      "version": "0.28.0",
+      "version": "0.32.0",
       "commands": [
         "fsharp-analyzers"
       ]

.github/workflows/dotnet.yaml

@@ -29,7 +29,7 @@ jobs:
       with:
         fetch-depth: 0 # so that NerdBank.GitVersioning has access to history
     - name: Install Nix
-      uses: cachix/install-nix-action@v30
+      uses: cachix/install-nix-action@v31
       with:
         extra_nix_config: |
           access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -48,7 +48,7 @@ jobs:
       with:
         fetch-depth: 0 # so that NerdBank.GitVersioning has access to history
     - name: Install Nix
-      uses: cachix/install-nix-action@v30
+      uses: cachix/install-nix-action@v31
       with:
         extra_nix_config: |
           access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -85,7 +85,7 @@ jobs:
       with:
         fetch-depth: 0 # so that NerdBank.GitVersioning has access to history
     - name: Install Nix
-      uses: cachix/install-nix-action@v30
+      uses: cachix/install-nix-action@v31
       with:
         extra_nix_config: |
           access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -113,7 +113,7 @@ jobs:
         with:
           fetch-depth: 0 # so that NerdBank.GitVersioning has access to history
       - name: Install Nix
-        uses: cachix/install-nix-action@v30
+        uses: cachix/install-nix-action@v31
         with:
           extra_nix_config: |
             access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -130,7 +130,7 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
       - name: Install Nix
-        uses: cachix/install-nix-action@v30
+        uses: cachix/install-nix-action@v31
         with:
           extra_nix_config: |
             access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -145,7 +145,7 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
       - name: Install Nix
-        uses: cachix/install-nix-action@v30
+        uses: cachix/install-nix-action@v31
         with:
           extra_nix_config: |
             access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -158,7 +158,7 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
       - name: Install Nix
-        uses: cachix/install-nix-action@v30
+        uses: cachix/install-nix-action@v31
         with:
           extra_nix_config: |
             access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -171,7 +171,7 @@ jobs:
     steps:
       - uses: actions/checkout@master
       - name: Install Nix
-        uses: cachix/install-nix-action@v30
+        uses: cachix/install-nix-action@v31
         with:
           extra_nix_config: |
             access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -184,7 +184,7 @@ jobs:
     steps:
       - uses: actions/checkout@master
       - name: Install Nix
-        uses: cachix/install-nix-action@v30
+        uses: cachix/install-nix-action@v31
         with:
           extra_nix_config: |
             access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -198,7 +198,7 @@ jobs:
       with:
         fetch-depth: 0 # so that NerdBank.GitVersioning has access to history
     - name: Install Nix
-      uses: cachix/install-nix-action@v30
+      uses: cachix/install-nix-action@v31
       with:
         extra_nix_config: |
           access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -264,7 +264,7 @@ jobs:
           name: nuget-package-lib
           path: packed
       - name: Attest Build Provenance
-        uses: actions/attest-build-provenance@7668571508540a607bdfd90a87a560489fe372eb # v2.1.0
+        uses: actions/attest-build-provenance@e8998f949152b193b063cb0ec769d69d929409be # v2.4.0
         with:
           subject-path: "packed/*.nupkg"
 
@@ -283,7 +283,7 @@ jobs:
           name: nuget-package-tool
           path: packed
       - name: Attest Build Provenance
-        uses: actions/attest-build-provenance@7668571508540a607bdfd90a87a560489fe372eb # v2.1.0
+        uses: actions/attest-build-provenance@e8998f949152b193b063cb0ec769d69d929409be # v2.4.0
         with:
           subject-path: "packed/*.nupkg"
 
@@ -299,7 +299,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Install Nix
-        uses: cachix/install-nix-action@v30
+        uses: cachix/install-nix-action@v31
         with:
           extra_nix_config: |
             access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -331,7 +331,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Install Nix
-        uses: cachix/install-nix-action@v30
+        uses: cachix/install-nix-action@v31
         with:
           extra_nix_config: |
             access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}

.github/workflows/flake_update.yaml

@@ -32,7 +32,7 @@ jobs:
 
       - name: Create token
         id: generate-token
-        uses: actions/create-github-app-token@v1
+        uses: actions/create-github-app-token@v2
         with:
           # https://github.com/actions/create-github-app-token/issues/136
           app-id: ${{ secrets.APP_ID }}

Consumer/Consumer.fsproj

@@ -10,6 +10,7 @@
         <Compile Include="NoAttribute.fs" />
         <Compile Include="Inconclusive.fs" />
         <Compile Include="RunSubProcess.fs" />
+        <Compile Include="TestExplicit.fs" />
         <Compile Include="TestNonParallel.fs" />
         <Compile Include="TestParallel.fs" />
         <Compile Include="TestParallelIndividualTest.fs" />
@@ -26,10 +27,10 @@
     </ItemGroup>
 
     <ItemGroup>
-      <PackageReference Include="FsUnit" Version="7.0.1" />
-      <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.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="4.6.0"/>
+      <PackageReference Include="NUnit3TestAdapter" Version="5.0.0"/>
     </ItemGroup>
 
 </Project>

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"

Directory.Build.props

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

FailingConsumer/FailingConsumer.fsproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
       <TargetFramework>net8.0</TargetFramework>
@@ -11,10 +11,10 @@
     </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="FsUnit" Version="7.0.1" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.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="4.6.0"/>
+    <PackageReference Include="NUnit3TestAdapter" Version="5.0.0"/>
   </ItemGroup>
 
 </Project>

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,16 +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>
@@ -77,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

WoofWare.NUnitTestRunner.Lib/Domain.fs

@@ -138,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
@@ -153,6 +160,7 @@ type TestFixture =
             Parameters = args
             Tests = []
             Parallelize = par
+            Modifiers = modifiers
         }
 
 /// User code in the unit under test has failed somehow.

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/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 =
+                    { new AsyncThunkEvaluator<_> with
+                        member _.Eval<'b> (t : unit -> Async<'b>) rc =
                             let tcs = TaskCompletionSource TaskCreationOptions.RunContinuationsAsynchronously
-                            use ec = ExecutionContext.Capture ()
 
                             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/RuntimeConfig.fs

@@ -1,16 +1,15 @@
 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
@@ -21,7 +20,7 @@ type internal RuntimeOptions =
         RollForward : string option
     }
 
-[<JsonParse>]
+// Myriad runs the JsonParse generator on this
 type internal RuntimeConfig =
     {
         RuntimeOptions : RuntimeOptions

WoofWare.NUnitTestRunner.Lib/SurfaceBaseline.txt

@@ -170,8 +170,9 @@ 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
@@ -255,6 +256,7 @@ 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
@@ -346,11 +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
@@ -360,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

WoofWare.NUnitTestRunner.Lib/TestFixture.fs

@@ -597,15 +597,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
@@ -613,38 +613,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 ParallelScope.ofInt v with
                                 | ParallelScope.Fixtures ->
-                                    categories, args, Some (Parallelizable.Yes ClassParallelScope.Fixtures)
+                                    categories, args, mods, Some (Parallelizable.Yes ClassParallelScope.Fixtures)
                                 | ParallelScope.Children ->
-                                    categories, args, Some (Parallelizable.Yes ClassParallelScope.Children)
+                                    categories, args, mods, Some (Parallelizable.Yes ClassParallelScope.Children)
                                 | ParallelScope.All ->
-                                    categories, args, Some (Parallelizable.Yes ClassParallelScope.All)
+                                    categories, args, mods, Some (Parallelizable.Yes ClassParallelScope.All)
                                 | ParallelScope.Self ->
-                                    categories, args, Some (Parallelizable.Yes ClassParallelScope.Self)
-                                | ParallelScope.None -> categories, args, Some Parallelizable.No
+                                    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 ->
@@ -717,6 +731,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)
@@ -725,6 +741,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

@@ -10,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
@@ -32,6 +34,9 @@ module TestProgress =
                 let plural = if testCount = 1 then "" else "s"
                 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 =
                 writer.WriteLine $"Running test: %s{name}"
 

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

@@ -14,7 +14,7 @@
       <PackageId>WoofWare.NUnitTestRunner.Lib</PackageId>
       <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
       <WarnOn>FS3559</WarnOn>
-      <WoofWareMyriadPluginVersion>4.0.11</WoofWareMyriadPluginVersion>
+      <WoofWareMyriadPluginVersion>8.0.5</WoofWareMyriadPluginVersion>
     </PropertyGroup>
 
     <ItemGroup>
@@ -22,10 +22,16 @@
       <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" />
@@ -48,10 +54,9 @@
       <EmbeddedResource Include="version.json" />
     </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="WoofWare.PrattParser" Version="0.2.3" />
+    <PackageReference Include="WoofWare.PrattParser" Version="0.2.4" />
     <PackageReference Update="FSharp.Core" Version="6.0.1" />
-    <PackageReference Include="WoofWare.DotnetRuntimeLocator" Version="0.1.11" />
-    <PackageReference Include="WoofWare.Myriad.Plugins.Attributes" Version="3.6.7" />
+    <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>

WoofWare.NUnitTestRunner.Lib/version.json

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

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/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

@@ -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.1.16" />
-        <PackageReference Include="FsCheck" Version="3.0.0" />
-        <PackageReference Include="FsUnit" Version="7.0.1" />
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+        <PackageReference Include="ApiSurface" Version="4.1.22" />
+        <PackageReference Include="FsCheck" Version="3.3.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="4.6.0"/>
+        <PackageReference Include="NUnit3TestAdapter" Version="5.0.0"/>
     </ItemGroup>
 
     <ItemGroup>

WoofWare.NUnitTestRunner/WoofWare.NUnitTestRunner.fsproj

@@ -35,7 +35,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Spectre.Console" Version="0.49.1" />
+    <PackageReference Include="Spectre.Console" Version="0.50.0" />
   </ItemGroup>
 
   <ItemGroup>

analyzers/analyzers.fsproj

@@ -10,7 +10,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageDownload Include="G-Research.FSharp.Analyzers" Version="[0.12.0]" />
+    <PackageDownload Include="G-Research.FSharp.Analyzers" Version="[0.17.0]" />
   </ItemGroup>
 
 </Project>

flake.lock

@@ -20,11 +20,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1737003892,
-        "narHash": "sha256-RCzJE9wKByLCXmRBp+z8LK9EgdW+K+W/DXnJS4S/NVo=",
+        "lastModified": 1753432016,
+        "narHash": "sha256-cnL5WWn/xkZoyH/03NNUS7QgW5vI7D1i74g48qplCvg=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "ae06b9c2d83cb5c8b12d7d0e32692e93d1379713",
+        "rev": "6027c30c8e9810896b92429f0092f624f7b1aace",
         "type": "github"
       },
       "original": {

nix/deps.json

@@ -1,13 +1,13 @@
 [
   {
     "pname": "ApiSurface",
-    "version": "4.1.16",
-    "hash": "sha256-3F+dY2nZMFukUjIGrvB/h3ZsZYdLJ9jvQKRxX33qk2E="
+    "version": "4.1.22",
+    "hash": "sha256-voj9m3YmyJ95FAMLV4sWzQMod3Em0mTjzf0LBUUFOso="
   },
   {
     "pname": "fantomas",
-    "version": "7.0.0",
-    "hash": "sha256-v4bXmvjZOYxl5RSIHuqVfDzBQdRz5SrmzZtD6SeEYTY="
+    "version": "7.0.3",
+    "hash": "sha256-0XlfV7SxXPDnk/CjkUesJSaH0cxlNHJ+Jj86zNUhkNA="
   },
   {
     "pname": "Fantomas.Core",
@@ -21,13 +21,13 @@
   },
   {
     "pname": "FsCheck",
-    "version": "3.0.0",
-    "hash": "sha256-/5FqiNeTVFairRtInS0cjQ3uGlqVfVJG2FsKIo8mdZ4="
+    "version": "3.3.0",
+    "hash": "sha256-TFDR/uAGv4OqrMX8/reQ4faaAhH9hxTHr1T/YkNPCCU="
   },
   {
     "pname": "fsharp-analyzers",
-    "version": "0.28.0",
-    "hash": "sha256-BqGk9MzHHA3oRPNfWuANcM1YELsdhzWI+kLF4mUDUx8="
+    "version": "0.32.0",
+    "hash": "sha256-MnhsK5tOeexL6uQhsV4nTRz8CGbz2o8VyHwAK8x91pE="
   },
   {
     "pname": "FSharp.Core",
@@ -41,8 +41,13 @@
   },
   {
     "pname": "FsUnit",
-    "version": "7.0.1",
-    "hash": "sha256-K85CIdxMeFSHEKZk6heIXp/oFjWAn7dBILKrw49pJUY="
+    "version": "7.1.1",
+    "hash": "sha256-UMCEGKxQ4ytjmPuVpiNaAPbi3RQH9gqa61JJIUS/6hg="
+  },
+  {
+    "pname": "Microsoft.ApplicationInsights",
+    "version": "2.22.0",
+    "hash": "sha256-mUQ63atpT00r49ca50uZu2YCiLg3yd6r3HzTryqcuEA="
   },
   {
     "pname": "Microsoft.AspNetCore.App.Ref",
@@ -71,13 +76,13 @@
   },
   {
     "pname": "Microsoft.CodeCoverage",
-    "version": "17.12.0",
-    "hash": "sha256-lGjifppD0OBMBp28pjUfPipaeXg739n8cPhtHWoo5RE="
+    "version": "17.14.1",
+    "hash": "sha256-f8QytG8GvRoP47rO2KEmnDLxIpyesaq26TFjDdW40Gs="
   },
   {
     "pname": "Microsoft.NET.Test.Sdk",
-    "version": "17.12.0",
-    "hash": "sha256-DKFEbhh2wPzahNeHdEoFig8tZh/LEVrFc5+zpT43Btg="
+    "version": "17.14.1",
+    "hash": "sha256-mZUzDFvFp7x1nKrcnRd0hhbNu5g8EQYt8SKnRgdhT/A="
   },
   {
     "pname": "Microsoft.NETCore.App.Host.linux-arm64",
@@ -139,15 +144,45 @@
     "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.12.0",
-    "hash": "sha256-rf8Sh0fQq44Sneuvs64unkkIHg8kOjDGWE35j9iLx5I="
+    "version": "17.14.1",
+    "hash": "sha256-1cxHWcvHRD7orQ3EEEPPxVGEkTpxom1/zoICC9SInJs="
   },
   {
     "pname": "Myriad.Core",
@@ -161,13 +196,8 @@
   },
   {
     "pname": "Nerdbank.GitVersioning",
-    "version": "3.7.115",
-    "hash": "sha256-sqn+i7vvBgBUtm7j82mH+SpApgI2hsmL5DYfLm1Z7gw="
-  },
-  {
-    "pname": "Newtonsoft.Json",
-    "version": "13.0.1",
-    "hash": "sha256-K2tSVW4n4beRPzPu3rlVaBEMdGvWSv/3Q1fxaDh4Mjo="
+    "version": "3.8.38-alpha",
+    "hash": "sha256-gPMrVbjOZxXoofczF/pn6eVkLhjVSJIyQrLO2oljrDc="
   },
   {
     "pname": "Newtonsoft.Json",
@@ -176,33 +206,33 @@
   },
   {
     "pname": "NuGet.Common",
-    "version": "6.12.1",
-    "hash": "sha256-k6JAFqHFinTakwNuW666aXYPhR7TpI/rb+KbHm1S2TM="
+    "version": "6.14.0",
+    "hash": "sha256-jDOwt3veI1GSG8CfBnf2+dJxD3E/Nmlc+vHtD4J76Ms="
   },
   {
     "pname": "NuGet.Configuration",
-    "version": "6.12.1",
-    "hash": "sha256-e/4lvyl7o7g4aWTAtr9S2yiGgk7V0E9p6DXpsy7GgVw="
+    "version": "6.14.0",
+    "hash": "sha256-1PN9s6fhCw3wd2260U6hQ4vG3jIvcG8GIn1oQgxMXA0="
   },
   {
     "pname": "NuGet.Frameworks",
-    "version": "6.12.1",
-    "hash": "sha256-GGpkbas+PNLx35vvr3nyAVz5lY/aeoMx6qjmT368Lpg="
+    "version": "6.14.0",
+    "hash": "sha256-3ViM3R1ucQMEL2hQYsivT86kI6veMQK2xDsiAcFcVQk="
   },
   {
     "pname": "NuGet.Packaging",
-    "version": "6.12.1",
-    "hash": "sha256-3h8Nmjpt383+dCg9GJ1BJ26UirwEQsWCPcTiT0+wGeI="
+    "version": "6.14.0",
+    "hash": "sha256-Yafbnxs3maj55bJ1oKQiZ0QkntFUzXdhorL94YEUOhY="
   },
   {
     "pname": "NuGet.Protocol",
-    "version": "6.12.1",
-    "hash": "sha256-l+CHnAcit6Y9OjBxereRP5JzOuWbuZZQYkFOKsUkdQ8="
+    "version": "6.14.0",
+    "hash": "sha256-uLDKfs+QN1MdnuQtTES8qfNzzsmYKM6XB9pwJc4G+eo="
   },
   {
     "pname": "NuGet.Versioning",
-    "version": "6.12.1",
-    "hash": "sha256-f/ejCuzCAwKs4N4Ec6yf2RovrhBT0nj0hRDP+03/Iy4="
+    "version": "6.14.0",
+    "hash": "sha256-DqdOJgsphKxSvqB8b60zNPCaiLfbiu3WnUJ/90feLrY="
   },
   {
     "pname": "NUnit",
@@ -211,8 +241,8 @@
   },
   {
     "pname": "NUnit3TestAdapter",
-    "version": "4.6.0",
-    "hash": "sha256-9Yav2fYhC4w0OgsyUwU4/5rDy4FVDTpKnWHuwl/uKJQ="
+    "version": "5.0.0",
+    "hash": "sha256-7jZM4qAbIzne3AcdFfMbvbgogqpxvVe6q2S7Ls8xQy0="
   },
   {
     "pname": "runtime.any.System.Runtime",
@@ -231,8 +261,18 @@
   },
   {
     "pname": "Spectre.Console",
-    "version": "0.49.1",
-    "hash": "sha256-tqSVojyuQjuB34lXo759NOcyLgNIw815mKXJPq5JFDo="
+    "version": "0.50.0",
+    "hash": "sha256-3MNgumQSXzuXVGj7kLb5FMkTH/LoFohMvUjAZ7nyHfo="
+  },
+  {
+    "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",
@@ -241,8 +281,8 @@
   },
   {
     "pname": "System.Formats.Asn1",
-    "version": "8.0.1",
-    "hash": "sha256-may/Wg+esmm1N14kQTG4ESMBi+GQKPp0ZrrBo/o6OXM="
+    "version": "6.0.0",
+    "hash": "sha256-KaMHgIRBF7Nf3VwOo+gJS1DcD+41cJDPWFh+TDQ8ee8="
   },
   {
     "pname": "System.IO.Abstractions",
@@ -259,6 +299,11 @@
     "version": "4.5.5",
     "hash": "sha256-EPQ9o1Kin7KzGI5O3U3PUQAZTItSbk9h/i4rViN3WiI="
   },
+  {
+    "pname": "System.Memory",
+    "version": "4.6.3",
+    "hash": "sha256-JgeK63WMmumF6L+FH5cwJgYdpqXrSDcgTQwtIgTHKVU="
+  },
   {
     "pname": "System.Private.Uri",
     "version": "4.3.0",
@@ -269,6 +314,11 @@
     "version": "1.6.0",
     "hash": "sha256-JJfgaPav7UfEh4yRAQdGhLZF1brr0tUWPl6qmfNWq/E="
   },
+  {
+    "pname": "System.Reflection.Metadata",
+    "version": "8.0.0",
+    "hash": "sha256-dQGC30JauIDWNWXMrSNOJncVa1umR1sijazYwUDdSIE="
+  },
   {
     "pname": "System.Runtime",
     "version": "4.3.1",
@@ -299,15 +349,10 @@
     "version": "4.5.0",
     "hash": "sha256-BkUYNguz0e4NJp1kkW7aJBn3dyH9STwB5N8XqnlCsmY="
   },
-  {
-    "pname": "System.Text.Encodings.Web",
-    "version": "8.0.0",
-    "hash": "sha256-IUQkQkV9po1LC0QsqrilqwNzPvnc+4eVvq+hCvq8fvE="
-  },
   {
     "pname": "System.Text.Json",
-    "version": "8.0.4",
-    "hash": "sha256-g5oT7fbXxQ9Iah1nMCr4UUX/a2l+EVjJyTrw3FTbIaI="
+    "version": "8.0.5",
+    "hash": "sha256-yKxo54w5odWT6nPruUVsaX53oPRe+gKzGvLnnxtwP68="
   },
   {
     "pname": "TypeEquality",
@@ -316,27 +361,27 @@
   },
   {
     "pname": "WoofWare.DotnetRuntimeLocator",
-    "version": "0.1.11",
-    "hash": "sha256-btWYnXxZzAnEcAE3Ufvz+Z3cJqtW7EGXs5OZMEHIWr8="
+    "version": "0.1.12",
+    "hash": "sha256-6pNZs0/R2LnLKSODq9DyHhGo2C+SDyz9k7D/13/78so="
   },
   {
     "pname": "WoofWare.Myriad.Plugins",
-    "version": "4.0.11",
-    "hash": "sha256-fHwMb391JiJI2/4aq0YBVdHiBwFHvgKkYboHyy3TB/g="
+    "version": "8.0.5",
+    "hash": "sha256-IfTT2GM9ktUW5BQoKQGFKK39BAKeziJJnrOIL7Vs19o="
   },
   {
     "pname": "WoofWare.Myriad.Plugins.Attributes",
-    "version": "3.6.7",
-    "hash": "sha256-YvrXS2ZMoMZkWgGxxcumyoqQkg4cSjGQzCrMbBCCtXM="
+    "version": "3.6.12",
+    "hash": "sha256-90uiVtc5exCbkcdS8DgTmlEZZT8/AdrY0QuFzy+FHUo="
   },
   {
     "pname": "WoofWare.PrattParser",
-    "version": "0.2.3",
-    "hash": "sha256-PsfU33BFsaA8LwlZMkSwmoA4hLb7Vkm2gYm48MglqxY="
+    "version": "0.2.4",
+    "hash": "sha256-aNTa2C300jUCsQ+iVSoothbCvBWdg7OzCJknwG5HV6g="
   },
   {
     "pname": "WoofWare.Whippet.Fantomas",
-    "version": "0.3.1",
-    "hash": "sha256-i5oiqcrxzM90Ocuq5MIu2Ha5lV0aYu5nCvuwmFqp6NA="
+    "version": "0.6.3",
+    "hash": "sha256-FkW/HtVp8/HE2k6d7yFpnJcnP3FNNe9kGlkoIWmNgDw="
   }
 ]