anchor.diff:  
   //************* TESTS *****************
   //Only tested the functions on the SkewBinomialHeap module for now, later I could test the remaining functions and methods
  +//TODO: Test ofSeq
   
   [<Test>]
   let ``toSeq returns all the elements`` () =
  
positive.code:         return {Heap = heap; Items = list; Desc = desc}}
      
      static member private Mixed<'T when 'T: comparison> (): Gen<HeapData<'T, 'T>> =
          Gen.frequency [200, SkewBinomialHeapGenerators.EmptyOnly<'T> (); 800, SkewBinomialHeapGenerators.NonemptyOnly<'T> ()]
  
      static member private TwoMixed<'T when 'T: comparison> (): Gen<HeapData<'T, 'T> * HeapData<'T, 'T>> =
          Gen.frequency [
              200, SkewBinomialHeapGenerators.EmptyOnly<'T> () |> Gen.two; 
              400, SkewBinomialHeapGenerators.NonemptyOnly<'T> () |> Gen.two;
              200, gen{ 
                  let! e = SkewBinomialHeapGenerators.EmptyOnly<'T>()
                  let! n = SkewBinomialHeapGenerators.EmptyOnly<'T>()
                  return (e, n)}
              200, gen{ 
                  let! e = SkewBinomialHeapGenerators.EmptyOnly<'T>()
                  let! n = SkewBinomialHeapGenerators.EmptyOnly<'T>()
                  return (n, e)}]
  
      static member ComparableAndComparable() = SkewBinomialHeapGenerators.Mixed<IComparable> () |> Arb.fromGen
  
  
negative.code: 
  [<Test>]
  let ``Cons pattern return the same as uncons`` () =
      fsCheck <| fun { Heap = heap } ->
          heap |> SkewBinomialHeap.isEmpty |> not ==>
          match heap with
          | SkewBinomialHeap.Cons (h, t) ->
              let (h', t') = heap |> SkewBinomialHeap.uncons
              h = h' && t = t'
          | _ -> false
  
  [<Test>]
  let ``GetHashCode is the same for equal heaps`` () =
      fsCheck <| fun { Heap = heap } item ->
          let heap1 = heap |> SkewBinomialHeap.insert item |> SkewBinomialHeap.tail
          let heap2 = heap |> SkewBinomialHeap.insert item |> SkewBinomialHeap.tail
          Unchecked.hash heap1 = Unchecked.hash heap2
  
  //Maybe the distribution of the hash should be checked
  //to avoid bad hashes, I don't know if that should be done as part of unit testing
  
  [<Test>]
  let ``Equality reflexivity`` () =
      fsCheck <| fun { Heap = heap } ->
          heap = heap
  
  [<Test>]
  let ``Equality symmetry`` () =
      fsCheck <| fun {Heap = heap } item ->
          let heap1 = heap |> SkewBinomialHeap.insert item |> SkewBinomialHeap.tail
          let heap2 = heap |> SkewBinomialHeap.insert item |> SkewBinomialHeap.tail
          heap1 = heap2 ==> (heap2 = heap1)
  
  [<Test>]
  let ``Equality transitivity`` () = //maybe this is too much, I guess It would be hard to write an Equals that violates this property and not the others
      fsCheck <| fun {Heap = heap } item ->
          let heap1 = heap |> SkewBinomialHeap.insert item |> SkewBinomialHeap.tail
          let heap2 = heap |> SkewBinomialHeap.insert item |> SkewBinomialHeap.tail
          let heap3 = heap |> SkewBinomialHeap.insert item |> SkewBinomialHeap.tail
          (heap1 = heap2 && heap2 = heap3) ==> (heap1 = heap3)