anchor.diff:        }
       loop [] [] None)
   
  +(*
  +   Function
  +   Take in the max degree of parallelism and pass that to the manager.
  +   Wait for the run to finish and return the number of tests that failed
  +   which can be used as an exit code.
  +*)
   let run maxDOP =
     let manager = newManager maxDOP
     manager.Post(Manager.Initialize(suites))
  
positive.code: open System.Collections.Generic
  open prunner
  
  let newReporter () : actor<Reporter> =
    let messages = new Dictionary<Guid, (color * string) list>()
    let printMessages id = messages.[id] |> List.rev |> List.iter (fun (color, message) -> colorWriteReset color message)
  
negative.code:       }
      loop ())
  
  (*
     Function as constructor and Pattern Matching
     The most complex of the actors, and where the majority of
     real logic is.
     Manager.Initialize:
       Create a list of workers for each suite/test
       Creata a list of workers for each suite/wip
       Loop with workers for regular test if there are no wips, otherwise with wips.
     Manager.Start:
       Take in a replyChannel for future use and pass it as part of the loop.
       Make a post to self with maxDOP which says how many workers should be
       working at the same time.  With 1 it will act like a traditional test runner
       but with more it will pull X workers off the list and tell them to Run.
     Manager.Run:
       If told to run 0 then no-op.
       Otherwise look at the workers list, and there are none left then no-op.
       If there are some, take the head and tell him to work.
       Call Run on self again, incase there are more workers who need to work
       to satisfy maxDOP.
       Add the worker you told to work to the pendingWorkers list so we know it is busy.
     Manager.WorkerDone:
       Called from a worker once it is done with its work.
       Create a new pendingWorkers list, removing the one that just finished.
       Check to see if there are any pendingWorkers or other workers for this suite.
       If there are not, tell the reporter that the suite is done.
       If there are no workers and no pending workers then all the tests have been run
       and we can notify the reporter and retrieve the number of tests and return it.
  *)
  let newManager maxDOP : actor<Manager> =
    let sw = System.Diagnostics.Stopwatch.StartNew()
    let contexts = new HashSet<string>()
  