anchor.diff:  
       member self.before (f: unit -> unit) =
           match current with
  -        | None    -> setups <- f::setups
  +        | None    -> context <- TestContext.addSetup context f
           | Some(v) -> v.before f
   
       member self.after (f: unit -> unit) =
  
positive.code:         match parent with
          | None    -> ()
          | Some(x) -> x.perform_setup()
          setups |> List.iter (fun y -> y())
  
      member self.performTearDown() =
          tearDowns |> List.iter (fun y -> y())
  
negative.code:     type testFunc = unit -> unit
      type Test = {Name: string; Test: unit -> unit}
      type T = {
          Tests: Test list;
          Setups: testFunc list;
          }
  
      let create () = { 
          Tests = [];
          Setups = [];
      }
      let addTest ctx test = { ctx with Tests = test::ctx.Tests }
      let addSetup ctx setup = { ctx with Setups = setup::ctx.Setups }
      
  type TestCollection(parent, name) =
      let mutable context = TestContext.create ()
      let mutable tearDowns = []
      let mutable contexts = []
      let mutable current = None
  