anchor.diff:          shouldfail(fun () -> persisted |> CloudFlow.length |> runRemote |> ignore)
   
       [<Test>]
  -    member __.``1. PersistedCloudFlow : cached objects`` () =
  -        // ensure that initial array is large enough for disk caching to kick in,
  -        // otherwise persisted fragments will be encapsulated in the reference as an optimization.
  -        // Limit is currently set to 512KiB, so total size must be 512KiB * cluster size.
  -        let xs = Array.init 10000 (fun _ -> "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.")
  -        let cv = xs |> CloudFlow.OfArray |> CloudFlow.map (fun x -> { Payload = x }) |> CloudFlow.cache |> runRemote
  -        let x = cv |> CloudFlow.map (fun ref -> ref.GetHashCode()) |> CloudFlow.toArray |> runRemote
  -        for i in 1 .. 5 do
  -            let y = cv |> CloudFlow.map (fun ref -> ref.GetHashCode()) |> CloudFlow.toArray |> runRemote
  -            Assert.AreEqual(x, y)
  +    member __.``1. PersistedCloudFlow : StorageLevel.Memory caching`` () =
  +        if __.IsSupportedStorageLevel StorageLevel.Memory then
  +            // ensure that initial array is large enough for disk caching to kick in,
  +            // otherwise persisted fragments will be encapsulated in the reference as an optimization.
  +            // Limit is currently set to 512KiB, so total size must be 512KiB * cluster size.
  +            // Arrays have reference equality semantics, compare hashcodes to ensure that caching is taking place.
  +            let cv = [|1 .. 20|] |> CloudFlow.OfArray |> CloudFlow.map (fun _ -> [|1L .. 1000000L|]) |> CloudFlow.cache |> runRemote
  +            let x = cv |> CloudFlow.map (fun ref -> ref.GetHashCode()) |> CloudFlow.toArray |> runRemote
  +            for i in 1 .. 5 do
  +                let y = cv |> CloudFlow.map (fun ref -> ref.GetHashCode()) |> CloudFlow.toArray |> runRemote
  +                Assert.AreEqual(x, y)
  +
  +    [<Test>]
  +    member __.``1. PersistedCloudFlow : Simple StorageLevel.MemorySerialized`` () =
  +        if __.IsSupportedStorageLevel StorageLevel.MemorySerialized then
  +            let f(xs : int[]) =            
  +                let pf = xs |> CloudFlow.OfArray |> CloudFlow.map ((+)1) |> CloudFlow.persist StorageLevel.MemorySerialized |> runRemote
  +                let ys = pf |> CloudFlow.length |> runRemote
  +                Assert.AreEqual(ys, xs.LongLength)
  +            Check.QuickThrowOnFail(f, self.FsCheckMaxNumberOfTests)
   
       [<Test>]
       member __.``1. PersistedCloudFlow : merging`` () =
  
positive.code:     // #region Flow persist tests
  
      [<Test>]
      member __.``1. PersistedCloudFlow : simple persist`` () =
          if __.IsSupportedStorageLevel StorageLevel.Disk then
              let inputs = [|1L .. 1000000L|]
              let persisted = inputs |> CloudFlow.OfArray |> CloudFlow.persist StorageLevel.Disk |> runRemote
  
negative.code: // Helper type
  type Separator = N | R | RN
  
  // General-purpose, runtime independent CloudFlow tests
  [<TestFixture>]
  module ``CloudFlow Core property tests`` =
  