anchor.diff:      |> LazyList.head
       |> assertEqual 'M'
   
  +// TODO : Remove this ASAP, replacing any uses with direct calls to Assert.IsTrue or 'assertTrue'.
  +let private test msg condition =
  +    Assert.IsTrue (condition, sprintf "MiniTest '%s'" msg)
  +
   [<Test>]
   let se () : unit =
       test "se1" (LazyList.isEmpty LazyList.empty)
  
positive.code: (* Tests which check for tail-recursion. *)
  
  [<Test>]
  let ``length is tail-recursive`` () : unit =
      assertEqual 100 <| (LazyList.ofSeq (Seq.init 100 id) |> LazyList.length)
      assertEqual 1000000 <| (LazyList.ofSeq (Seq.init 1000000 id) |> LazyList.length)
      assertEqual 0 <| (LazyList.ofSeq (Seq.init 0 id) |> LazyList.length)
  
  [<Test>]
  let ``map is tail-recursive`` () : unit =
      assertEqual 1000000 <| (LazyList.map (fun x -> x + 1) (LazyList.ofSeq (Seq.init 1000000 id)) |> Seq.length)
  
  [<Test>]
  let ``filter is tail-recursive`` () : unit =
      assertEqual 500000 <| (LazyList.filter (fun x -> x % 2 = 0) (LazyList.ofSeq (Seq.init 1000000 id)) |> Seq.length)
  
  [<Test>]
  let ``iter is tail-recursive`` () : unit =
      assertEqual 0 <| (let count = ref 0 in LazyList.iter (fun x -> incr count) (LazyList.ofSeq (Seq.init 0 id)); !count)
      assertEqual 1000000 <| (let count = ref 0 in LazyList.iter (fun x -> incr count) (LazyList.ofSeq (Seq.init 1000000 id)); !count)
  
  [<Test>]
  let ``toList is tail-recursive`` () : unit =
      assertEqual 200000 <| (LazyList.toList (LazyList.ofSeq (Seq.init 200000 id)) |> Seq.length)
  
  [<Test>]
  let ``toArray is tail-recursive`` () : unit =
      assertEqual 200000 <| (LazyList.toArray (LazyList.ofSeq (Seq.init 200000 id)) |> Seq.length)
  
  
  (* Tests which check for termination/laziness. *)
  
negative.code: open NUnit.Framework
  //open FsCheck
  
  
  let private nats =
      0 |> LazyList.unfold (fun z -> Some (z, z + 1))
  