anchor.diff:  
           static member (?) (self:TestContext,name) = self.Get name 
           static member (?<-) (self:TestContext,name,value) = self.Set name value 
  -        static member create metaData = { 
  -            MetaData = metaData
  -            Data = metaData
  -            Disposables = []
  -            WrappedSubject = None }
  +        static member create metaData = 
  +            let data = { 
  +                MetaData = metaData
  +                Data = metaData
  +                Disposables = []
  +                WrappedSubject = None }
  +            TestContext(data)
   
   type TestFunc = TestContext -> unit
   
  
positive.code:             if self.Instance = null then self.Instance <- self.Initializer ctx
              self.Instance
  
  type TestContext =
      { 
          MetaData: TestDataMap.T
          mutable Disposables: System.IDisposable list
          mutable WrappedSubject: SubjectWrapper<TestContext> option
          mutable Data: TestDataMap.T }
  
  type TestContext
      with
          static member cleanup ctx =
              ctx.Disposables |> List.iter (fun x -> x.Dispose())
  
          member internal ctx.RegisterDisposable x =
              match (x :> obj) with
              | :? System.IDisposable as d -> 
                  ctx.Disposables <- d::ctx.Disposables
                  x
              | _ -> x
              
          member ctx.Set name value =
              ctx.Data <- ctx.Data.Add name value
              ctx.RegisterDisposable value |> ignore
          member ctx.Get<'T> name = ctx.Data.Get<'T> name
  
          member ctx.TryGet<'T> name = ctx.Data |> TestDataMap.tryGet<'T> name
          member ctx.GetOrDefault<'T> name (initializer : TestContext -> 'T) =
              match ctx.TryGet<'T> name with
              | Some x -> x
  
negative.code:                 result
  
          member ctx.SetSubject f = 
              data.WrappedSubject <- Some (SubjectWrapper.create f data.WrappedSubject)
  
          member ctx.WithSubject s f =
              let tmp = data.WrappedSubject
              try
                  data.WrappedSubject <- s
                  f ctx
              finally
                  data.WrappedSubject <- tmp
  
          member ctx.MetaData
              with get () = data.MetaData
  
          member ctx.Subject
              with get () : obj =
                  match data.WrappedSubject with
                  | None -> null
                  | Some subject -> 
                      ctx.WithSubject     
  