anchor.diff:                  results.reportTestName name (Error(ex))
           )
   
  -        context.ChildContexts |> List.rev |> List.iter (fun x ->
  -            run (x::contexts) results
  +        exampleGroup.ChildGroups |> List.rev |> List.iter (fun x ->
  +            run (x::exampleGroups) results
           )
   
   type TestCollection() =
  -    let mutable context = TestContext.create null
  -    let mutateContext f = context <- f context
  +    let mutable exampleGroup = ExampleGroup.create null
  +    let mutateGroup f = exampleGroup <- f exampleGroup
   
       member self.init (f: unit -> 'a) : (unit -> 'a) =
           let value = ref None
  
positive.code:         r
  
      member self.describe (name: string) (f: unit -> unit) = 
          let oldContext = context
          context <- TestContext.create name
          f()
          context <- TestContext.addChildContext context oldContext
  
      member self.before f = TestContext.addSetup f |> mutateContext
      member self.after f = TestContext.addTearDown f |> mutateContext
      member self.it name f = TestContext.addTest { Name = name; Test = f} |> mutateContext
      member self.run(results) = TestContext.run [context] results
      member self.run() = self.run(TestReport())
  
  let c = TestCollection()
  
negative.code: 
  let pending () = raise PendingError
  
  module Example =
      type T = {Name: string; Test: unit -> unit}
      let create name test = { Name = name; Test = test }
  
  module ExampleGroup =
      type TestFunc = unit -> unit
      type T = {
          Name: string
          Examples: Example.T list;
          Setups: TestFunc list;
          TearDowns: TestFunc list;
          ChildGroups : T list;
          }
  
      let create name = { 
          Name = name;
          Examples = [];
          Setups = [];
          TearDowns = [];
          ChildGroups = [];
      }
      let addExample test ctx = { ctx with Examples = test::ctx.Examples }
      let addSetup setup ctx = { ctx with Setups = setup::ctx.Setups }
      let addTearDown tearDown ctx = { ctx with TearDowns = tearDown::ctx.TearDowns }
      let addChildContext child ctx = { ctx with ChildGroups = child::ctx.ChildGroups }
  
      let rec perform_setup contexts =
          match contexts with
  