anchor.diff:                  head.TearDowns |> List.iter (fun y -> y())
                   perform_teardown tail
       
  -    let rec run contexts (results : TestReport) =
  -        let context = contexts |> List.head
  +    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
   
  -        context.Tests |> List.rev |> List.iter (fun x -> 
  -            let nameStack = x.Name :: (contexts |> List.map (fun x -> x.Name) |> List.filter (fun x -> x <> null))
  +        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 contexts
  +                    perform_setup exampleGroups
                       x.Test()
                   finally
  -                    perform_teardown contexts
  +                    perform_teardown exampleGroups
                   results.reportTestName name Success
               with
               | PendingError -> results.reportTestName name Pending
  
positive.code:                 results.reportTestName name (Error(ex))
          )
  
          context.ChildContexts |> List.rev |> List.iter (fun x ->
              run (x::contexts) results
          )
  
  type TestCollection() =
      let mutable context = TestContext.create null
      let mutateContext f = context <- f context
  
      member self.init (f: unit -> 'a) : (unit -> 'a) =
          let value = ref None
  
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
  