anchor.diff:  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``
  
positive.code:         )
      
      [<Property>]
      static member ``Replacing values doesn't change the set of keys``
              (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 ()
  
          // Prep the dictionary to have all elements at all unique keys 
          let grouped =
              keys
              |> Array.map (fun k -> k.Get)
              |> Seq.groupBy id
          let len = Seq.length grouped
  
          grouped
          |> Seq.iter2 (fun k v -> dict.[fst k] <- v) <| Gen.sample len len Arb.generate<obj>
  
          len > 0 ==> lazy (
              // Assign to some keys multiple times and others not at all
              Gen.elements keys |> Gen.sample len len
              |> Seq.iter2 (fun k v -> dict.[k.Get] <- v) <| values
  
              // Compare the returned keys to what was put in
              grouped
              |> Seq.map (fun k -> dict.Keys |> Seq.exists ((=) (fst k)))
              |> Seq.reduce (&&)
          )
          // If the length isn't greater than the number of groups, there
          // can't be extra keys beyond what we started with
          .&. (Seq.length grouped = Seq.length dict.Keys)
  
negative.code:             (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 ()
  
          // 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
  
          // 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
          |> 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 (fun k -> dict.Keys |> Seq.exists ((=) k))
            |> Seq.reduce (&&)
            // If the length isn't greater than the number of groups, there
  