anchor.diff:      yield testCaseAsync "sequenced group" <| async {
         let config =
           { defaultConfig with
  -            parallelWorkers = 32
  +            parallelWorkers = 8
               stress = TimeSpan.FromMilliseconds 10000.0 |> Some
               stressTimeout = TimeSpan.FromMilliseconds 10000.0
               printer = TestPrinters.silent
  
positive.code:       ]
  
      let deadlockTest() =
        let waitOne = new ManualResetEventSlim()
        let waitTwo = new ManualResetEventSlim()
        let lockOne = new obj()
        let lockTwo = new obj()
        testList "deadlock" [
          testCaseAsync "case A" <| async {
            lock lockOne (fun () ->
              waitOne.Set()
              waitTwo.Wait 300 |> ignore
              lock lockTwo (fun () ->
                ()
              )
            )
            waitOne.Reset()
          }
          testCaseAsync "case B" <| async {
            lock lockTwo (fun () ->
              waitTwo.Set()
              waitOne.Wait 300 |> ignore
              lock lockOne (fun () ->
                ()
              )
            )
            waitTwo.Reset()
          }
        ]
  
      let sequencedGroup() =
        testList "with other" [
          singleTest
  
negative.code:     yield testCaseAsync "memory" <| async {
        let config =
          { defaultConfig with
              parallelWorkers = 8
              stress = TimeSpan.FromMilliseconds 100.0 |> Some
              stressMemoryLimit = 0.001
              printer = TestPrinters.silent
  