anchor.diff:      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 }
  +
  +    let rec perform_setup context =
  +        match context.ParentContext with
  +            | None    -> ()
  +            | Some(x) -> perform_setup x
  +        context.Setups |> List.iter (fun y -> y())
       
  -type TestCollection(parent, name) =
  -    let mutable context = TestContext.create ()
  +    let rec perform_teardown context =
  +        context.TearDowns |> List.iter (fun y -> y())
  +        match context.ParentContext with
  +        | None    -> ()
  +        | Some(x) -> perform_teardown x
  +    
  +    let rec name_stack context =
  +        match context.ParentContext with
  +        | None    -> []
  +        | Some(x) -> (context.Name)::(name_stack x)
  +
  +type TestCollection(_parent : TestCollection option, _name) =
  +    let parentContext = match _parent with
  +                        | None -> None
  +                        | Some(x) -> Some(x.getContext())
  +    let mutable context = TestContext.create _name parentContext
       let mutable contexts = []
       let mutable current = None
  +
  +    member self.getContext() = context
  +
       new () = TestCollection(None, null)
   
       member self.init (f: unit -> 'a) : (unit -> 'a) =
  
positive.code:         | None    -> context <- TestContext.addTest context { Name = name; Test = f}
          | Some(v) -> v.it name f
  
      member self.perform_setup() =
          match parent with
          | None    -> ()
          | Some(x) -> x.perform_setup()
          context.Setups |> List.iter (fun y -> y())
  
      member self.performTearDown() =
          context.TearDowns |> List.iter (fun y -> y())
          match parent with
          | None    -> ()
          | Some(x) -> x.performTearDown()
  
      member self.nameStack () =
          match parent with
          | None    -> []
          | Some(x) -> name::x.nameStack()
  
      member self.run(results : TestReport) =
          let rec printNameStack(stack) : string =
              match stack with
  
negative.code:             | ex -> 
                  results.reportFailure()
                  results.reportTestName name Error
              TestContext.perform_teardown context
          )
  
          contexts |> List.rev |> List.iter (fun x ->
  