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