anchor.diff:      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 x.Replay with get() = match replay with None -> String.Empty | Some (Random.StdGen (x,y)) -> sprintf "%A" (x,y)
  -                    and set(v:string) =
  +    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)
  -    member internal x.ReplayStdGen = replay
  +    member internal __.ReplayStdGen = replay //interestingly, although this member is unused, if you remove it tests will fail...?
       ///The maximum number of tests that are run.
  -    member x.MaxTest with get() = maxTest and set(v) = maxTest <- v
  +    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 x.MaxFail with get() = maxFail and set(v) = maxFail <- v
  +    member __.MaxFail with get() = maxFail and set(v) = maxFail <- v
       ///The size to use for the first test.
  -    member x.StartSize with get() = startSize and set(v) = startSize <- v
  +    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 x.EndSize with get() = endSize and set(v) = endSize <- v
  +    member __.EndSize with get() = endSize and set(v) = endSize <- v
       ///Output all generated arguments.
  -    member x.Verbose with get() = verbose and set(v) = verbose <- v
  +    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 x.Arbitrary with get() = arbitrary and set(v) = arbitrary <- v
  +    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 x.QuietOnSuccess with get() = quietOnSuccess and set(v) = quietOnSuccess <- v
  +    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 []) =
  
positive.code: //can not be an anonymous type because of let mutable.
  type XunitRunner() =
      let mutable result = None
      member x.Result = result.Value
      interface IRunner with
          override x.OnStartFixture t = ()
          override x.OnArguments (ntest,args, every) =
              printf "%s" (every ntest args)
          override x.OnShrink(args, everyShrink) =
              printf "%s" (everyShrink args)
          override x.OnFinished(name,testResult) =
              result <- Some testResult
  
  ///Override Arbitrary instances for FsCheck tests within the attributed class
  
negative.code: type ArbitraryAttribute(types:Type[]) =
      inherit Attribute()
      new(typ:Type) = ArbitraryAttribute([|typ|])
      member __.Arbitrary = types
  
  ///Run this method as an FsCheck test.
  [<AttributeUsage(AttributeTargets.Method ||| AttributeTargets.Property, AllowMultiple = false)>]
  