anchor.diff:      |> should equal (
           IntMap.ofList [(5, "5:a"); (3, "3:b")])
   
  -
  -
  -
  -
  -
  -
  +//[<TestCase>]
  +//let filter () : unit =
  +//    Assert.Fail ()
  +//
  +//[<TestCase>]
  +//let choose () : unit =
  +//    Assert.Fail ()
  +//
  +//[<TestCase>]
  +//let iter () : unit =
  +//    Assert.Fail ()
  +//
  +//[<TestCase>]
  +//let iterBack () : unit =
  +//    Assert.Fail ()
  +//
  +//[<TestCase>]
  +//let fold () : unit =
  +//    Assert.Fail ()
  +//
  +//[<TestCase>]
  +//let foldBack () : unit =
  +//    Assert.Fail ()
  +//
  +//[<TestCase>]
  +//let exists () : unit =
  +//    Assert.Fail ()
  +//
  +//[<TestCase>]
  +//let forall () : unit =
  +//    Assert.Fail ()
  +//
  +//[<TestCase>]
  +//let partition () : unit =
  +//    Assert.Fail ()
  +//
  +//[<TestCase>]
  +//let mapPartition () : unit =
  +//    Assert.Fail ()
   
   
   
  
positive.code: 
  [<TestCase>]
  let remove () : unit =
      [(5, "a"); (3, "b")]
      |> IntMap.ofList
      |> IntMap.remove 5
      |> should equal (
          IntMap.singleton 3 "b")
  
      [(5, "a"); (3, "b")]
      |> IntMap.ofList
      |> IntMap.remove 7
      |> should equal (
          IntMap.ofList [(5, "a"); (3, "b")])
  
      (IntMap.empty : IntMap<string>)
      |> IntMap.remove 5
      |> should equal (IntMap.empty : IntMap<string>)
  
  [<TestCase>]
  let map () : unit =
      [(5, "a"); (3, "b")]
  
negative.code:     |> IntMap.count
      |> should equal 1
  
      [| (5, 'a'); (3, 'b'); (11, 'f'); (2, 'd');
          (17, 'a'); (4, 'g'); (12, 'b'); (14, 'c'); |]
      |> IntMap.ofArray
      |> IntMap.count
      |> should equal 8
  
  [<TestCase>]
  let singleton () : unit =
      IntMap.singleton 1 'a'
      |> should equal (
          IntMap.add 1 'a' IntMap.empty)
  
      IntMap.singleton 1 'a'
      |> IntMap.count
      |> should equal 1
  
  [<TestCase>]
  let containsKey () : unit =
      [| (5, 'a'); (3, 'b'); (11, 'f'); (2, 'd');
          (17, 'a'); (4, 'g'); (12, 'b'); (14, 'c'); |]
      |> IntMap.ofArray
      |> IntMap.containsKey 5
      |> should be True
  
      [| (5, 'a'); (3, 'b'); (11, 'f'); (2, 'd');
          (17, 'a'); (4, 'g'); (12, 'b'); (14, 'c'); |]
      |> IntMap.ofArray
      |> IntMap.containsKey 1
      |> should be False
  
  [<TestCase>]
  let tryFind () : unit =
      [(5, 'a'); (3, 'b')]
      |> IntMap.ofList
      |> IntMap.tryFind 5
      |> should equal (Some 'a')
  
      [(5, 'a'); (3, 'b')]
      |> IntMap.ofList
      |> IntMap.tryFind 7
      |> should equal None
  
  [<TestCase>]
  let find () : unit =
      [(5, 'a'); (3, 'b')]
      |> IntMap.ofList
      |> IntMap.find 5
      |> should equal 'a'
  
  [<TestCase>]
  let findOrDefault () : unit =
      [(5, 'a'); (3, 'b')]
      |> IntMap.ofList
      |> IntMap.findOrDefault 'z' 5
      |> should equal 'a'
  
      [(5, 'a'); (3, 'b')]
      |> IntMap.ofList
      |> IntMap.findOrDefault 'z' 7
      |> should equal 'z'
  
  [<TestCase>]
  let tryFindKey () : unit =
      (IntMap.empty : IntMap<string>)
      |> IntMap.tryFindKey (fun k v ->
          k % 2 = 0)
      |> should equal None
  
      [| (5, 'a'); (3, 'b'); (11, 'f'); (2, 'd');
          (17, 'a'); (4, 'g'); (12, 'b'); (14, 'c'); |]
      |> IntMap.ofArray
      |> IntMap.tryFindKey (fun k v ->
          (k + int v) % 11 = 0)
      |> should equal (Some 12)
  
      [| (5, 'a'); (3, 'b'); (11, 'f'); (2, 'd');
          (17, 'a'); (4, 'g'); (12, 'b'); (14, 'c'); |]
      |> IntMap.ofArray
      |> IntMap.tryFindKey (fun k v ->
          (k + int v) % 289 = 0)
      |> should equal None
  
  [<TestCase>]
  let add () : unit =
      [| (5, 'a'); (3, 'b'); (11, 'f'); (2, 'd');
          (17, 'a'); (4, 'g'); (12, 'b'); (14, 'c'); |]
      |> IntMap.ofArray
      |> IntMap.add 5 'x'
      |> should equal (IntMap.ofArray
         [| (5, 'x'); (3, 'b'); (11, 'f'); (2, 'd');
            (17, 'a'); (4, 'g'); (12, 'b'); (14, 'c'); |])
  
      [| (5, 'a'); (3, 'b'); (11, 'f'); (2, 'd');
          (17, 'a'); (4, 'g'); (12, 'b'); (14, 'c'); |]
      |> IntMap.ofArray
      |> IntMap.add 13 'x'
      |> should equal (IntMap.ofArray
         [| (5, 'x'); (3, 'b'); (11, 'f'); (2, 'd');
            (17, 'a'); (4, 'g'); (12, 'b'); (14, 'c'); (13, 'x'); |])
  
      IntMap.empty
      |> IntMap.add 5 'x'
  