anchor.diff:  //can not be an anonymous type because of let mutable.
   type XunitRunner() =
       let mutable result = None
  -    member __.Result = result.Value
  +    member x.Result = result.Value
       interface IRunner with
  -        override __.OnStartFixture _ = ()
  -        override __.OnArguments (ntest,args, every) =
  +        override x.OnStartFixture t = ()
  +        override x.OnArguments (ntest,args, every) =
               printf "%s" (every ntest args)
  -        override __.OnShrink(args, everyShrink) =
  +        override x.OnShrink(args, everyShrink) =
               printf "%s" (everyShrink args)
  -        override __.OnFinished(_ ,testResult) =
  +        override x.OnFinished(name,testResult) =
               result <- Some testResult
   
   ///Override Arbitrary instances for FsCheck tests within the attributed class
  
positive.code:     let mutable arbitrary = Config.Default.Arbitrary |> List.toArray
      ///If set, the seed to use to start testing. Allows reproduction of previous runs. You can just paste
      ///the tuple from the output window, e.g. 12344,12312 or (123,123).
      member __.Replay with get() = match replay with None -> String.Empty | Some (Random.StdGen (x,y)) -> sprintf "%A" (x,y)
                       and set(v:string) =
                          //if someone sets this, we want it to throw if it fails
                          let split = v.Trim('(',')').Split([|","|], StringSplitOptions.RemoveEmptyEntries)
                          let elem1 = Int32.Parse(split.[0])
                          let elem2 = Int32.Parse(split.[1])
                          replay <- Some <| Random.StdGen (elem1,elem2)
      ///The maximum number of tests that are run.
      member __.MaxTest with get() = maxTest and set(v) = maxTest <- v
      ///The maximum number of tests where values are rejected, e.g. as the result of ==>
      member __.MaxFail with get() = maxFail and set(v) = maxFail <- v
      ///The size to use for the first test.
      member __.StartSize with get() = startSize and set(v) = startSize <- v
      ///The size to use for the last test, when all the tests are passing. The size increases linearly between Start- and EndSize.
      member __.EndSize with get() = endSize and set(v) = endSize <- v
      ///Output all generated arguments.
      member __.Verbose with get() = verbose and set(v) = verbose <- v
      ///The Arbitrary instances to use for this test method. The Arbitrary instances
      ///are merged in back to front order i.e. instances for the same generated type
      ///at the front of the array will override those at the back.
      member __.Arbitrary with get() = arbitrary and set(v) = arbitrary <- v
      ///If set, suppresses the output from the test if the test is successful. This can be useful when running tests
      ///with TestDriven.net, because TestDriven.net pops up the Output window in Visual Studio if a test fails; thus,
      ///when conditioned to that behaviour, it's always a bit jarring to receive output from passing tests.
      ///The default is false, which means that FsCheck will also output test results on success, but if set to true,
      ///FsCheck will suppress output in the case of a passing test. This setting doesn't affect the behaviour in case of
      ///test failures.
      member __.QuietOnSuccess with get() = quietOnSuccess and set(v) = quietOnSuccess <- v
  
  /// The xUnit2 test runner for the PropertyAttribute that executes the test via FsCheck
  type PropertyTestCase(diagnosticMessageSink:IMessageSink, defaultMethodDisplay:TestMethodDisplay, testMethod:ITestMethod, ?testMethodArguments:obj []) =
  
negative.code: 
      new () = PropertyDiscoverer(null)
  
      member x.MessageSink = messageSink
  
      interface IXunitTestCaseDiscoverer with
          override this.Discover(discoveryOptions:ITestFrameworkDiscoveryOptions, testMethod:ITestMethod, factAttribute:IAttributeInfo)=
              let ptc = new PropertyTestCase(this.MessageSink, discoveryOptions.MethodDisplayOrDefault(), testMethod)
              Seq.singleton (ptc :> IXunitTestCase)