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:                 head.TearDowns |> List.iter (fun y -> y())
                  perform_teardown tail
      
      let rec run exampleGroups (results : TestReport) =
          let exampleGroup = exampleGroups |> List.head
          let rec printNameStack(stack) : string =
              match stack with
              | []    -> ""
              | head::[] -> head
              | head::tail ->sprintf "%s %s" (printNameStack(tail)) head
  
          exampleGroup.Examples |> List.rev |> List.iter (fun x -> 
              let nameStack = x.Name :: (exampleGroups |> List.map (fun x -> x.Name) |> List.filter (fun x -> x <> null))
              let name = printNameStack(nameStack)
              try
                  try
                      perform_setup exampleGroups
                      x.Test()
                  finally
                      perform_teardown exampleGroups
                  results.reportTestName name Success
              with
              | PendingError -> results.reportTestName name Pending
  