anchor.diff:              (dict : ObservableDictionaryBase<obj, obj>, keys : NonNull<obj> array, values : obj array) =
           // The generator doesn't generate empty dictionaries, which can throw
           // off the checking logic
  -        dict.Clear ()
  -
  -        // Process the keys as .Add can't handle 
  +        //dict.Clear ()
  +
  +        // Remove duplicate keys as .Add can't handle replacement
           let grouped =
               keys
               |> Seq.map (fun k -> k.Get)
               |> Seq.groupBy id
  +            |> Seq.map fst
   
           // Number of unique keys in the list
           let groups = grouped |> Seq.length
   
  -        // Generate a random value for each key
  -        Gen.sample 4 groups Arb.generate<obj>
  +        // Be sure there are at least as many values as there are keys
  +        match Seq.length grouped, Array.length values with
  +        | k, 0            -> Array.zeroCreate k
  +        | k, v when k < v -> values
  +        | k, v            -> Array.create (k / v + 1) values
  +                             |> Array.collect id
           // Additionally, randomly switch between methods of adding values
  -        |> List.zip <| Gen.sample 2 groups Arb.generate<bool>
  -        |> Seq.iter2 (fun k (v, b) -> if b then dict.[k] <- v else dict.Add (k, v)) (grouped |> Seq.map fst)
  +        |> Seq.zip <| Gen.sample 2 groups Arb.generate<bool>
  +        |> Seq.iter2 (fun k (v, b) -> if b then dict.[k] <- v else dict.Add (k, v)) grouped
   
           groups > 0 ==> lazy
             // Compare the returned keys to what was put in
  -        ( grouped |> Seq.map fst
  +        ( grouped
             |> Seq.map (fun k -> dict.Keys |> Seq.exists ((=) k))
             |> Seq.reduce (&&)
             // If the length isn't greater than the number of groups, there
  
positive.code:             (dict : ObservableDictionaryBase<obj, obj>, keys : NonNull<obj> array) =
          // The generator doesn't generate empty dictionaries, which can throw
          // off the isAddition/isReplace logic
          dict.Clear ()
  
          // Add event tracker *after* the preprocessing
          let counts = Observer dict
  
negative.code: let equalProperty s v w =
      (v = w) |@ sprintf "%s: %d (want %d)" s v w
  
  //BUG: Not being run
  type ObservableDictionaryBaseFixture () =
      do
          Arb.register<Generators.DictionaryGenerator> () |> ignore
  [<CollectionDefinition("ObservableDictionaryBase")>]
  type ObservableDictionaryBaseCollection () =
      interface ICollectionFixture<ObservableDictionaryBaseFixture>
  
  [<Collection("ObservableDictionaryBase")>]
  type Item =
      [<Property>]
      static member ``Set and retrieval returns the same item``
  