anchor.diff:      type testFunc = unit -> unit
       type Test = {Name: string; Test: unit -> unit}
       type T = {
  -        Tests: Test list
  +        Tests: Test list;
  +        Setups: testFunc list;
           }
   
  +    let create () = { 
  +        Tests = [];
  +        Setups = [];
  +    }
       let addTest ctx test = { ctx with Tests = test::ctx.Tests }
  -
  -    let create () = { Tests = [] }
  +    let addSetup ctx setup = { ctx with Setups = setup::ctx.Setups }
       
   type TestCollection(parent, name) =
       let mutable context = TestContext.create ()
  -    let mutable setups = []
       let mutable tearDowns = []
       let mutable contexts = []
       let mutable current = None
  
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: 
      member self.before (f: unit -> unit) =
          match current with
          | None    -> context <- TestContext.addSetup context f
          | Some(v) -> v.before f
  
      member self.after (f: unit -> unit) =
  