anchor.diff:  
               if contextFailed = true then failedContexts <- s.Context::failedContexts
               if s.Context <> null then reporter.contextEnd s.Context
  -    )
  +
  +    if browserSuccess then List.iter runSuite prioritisedSuites
  +    ()
  +
  +let private runForBrowsers (browsers: Browsers option) =
  +    let wipsExist = suites |> List.exists (fun s -> not s.Wips.IsEmpty)
  +
  +    if wipsExist && failIfAnyWipTests then
  +       raise <| Exception "Wip tests found and failIfAnyWipTests is true"
  +
  +    reporter.suiteBegin()
  +    let stopWatch = Diagnostics.Stopwatch()
  +    stopWatch.Start()
  +
  +    //if there are wips, run only wip and always tests
  +    let filteredSuites =
  +        if wipsExist
  +        then suites |> List.filter (fun s -> not (s.Wips.IsEmpty && s.Always.IsEmpty))
  +        else suites
  +    let failedContexts = canopy.history.get()
  +
  +    match browsers with
  +    | Some (BrowserStartModes browsers) ->
  +        for browser in browsers do
  +            runSuitesForBrowser (Some (toString browser)) (fun () -> start browser) filteredSuites
  +    | Some (WebDrivers browsers) ->
  +        for browser in browsers do
  +            runSuitesForBrowser (Some (browser.ToString())) (fun () -> switchTo browser) filteredSuites
  +    | None ->
  +        runSuitesForBrowser None id filteredSuites
   
       canopy.history.save failedContexts
   
  
positive.code:         failureMessage <- null
          FailFast
  
  (* documented/testing *)
  let run () =
  
      let wipsExist = suites |> List.exists (fun s -> s.Wips.IsEmpty = false)
  
      if wipsExist && canopy.configuration.failIfAnyWipTests then
         raise <| Exception "Wip tests found and failIfAnyWipTests is true"
  
      reporter.suiteBegin()
      let stopWatch = new Diagnostics.Stopwatch()
      stopWatch.Start()
  
      // suites list is in reverse order and have to be reversed before running the tests
      suites <- List.rev suites
  
      //run all the suites
      if runFailedContextsFirst = true then
          let failedContexts = canopy.history.get()
          //reorder so failed contexts are first
          let fc, pc = suites |> List.partition (fun s -> failedContexts |> List.exists (fun fc -> fc = s.Context))
          suites <- fc @ pc
  
      //run only wips if there are any
      if wipsExist then
          suites <- suites |> List.filter (fun s -> s.Wips.IsEmpty = false || s.Always.IsEmpty = false)
  
      suites
      |> List.iter (fun s ->
          if skipRemainingTestsInContextOnFailure = true && skipAllTestsOnFailure = false then skipNextTest <- false
          if failed = false then
              contextFailed <- false
  
negative.code:     reporter.suiteEnd()
  
  (* documented/testing *)
  let run () =
      runForBrowsers None
  
  (* documented/testing *)
  let runFor browsers =
      runForBrowsers (Some browsers)
  