anchor.diff:          }
   
           member __.DeleteDirectory(container : string, recursiveDelete : bool) = async {
  -            return 
  -                try Directory.Delete(normalize container, recursiveDelete)
  -                with :? DirectoryNotFoundException -> ()
  +            try return! retryAsync fileDeleteRetryPolicy (async { return Directory.Delete(normalize container, recursiveDelete) })
  +            with :? DirectoryNotFoundException -> ()
           }
   
           member __.EnumerateDirectories(directory) = async {
  
positive.code: 
          member __.ReadETag(path : string, etag : ETag) = async {
              let path = normalize path
              let fs = retry ioConcurrencyPolicy (fun () -> new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
              if etag = getETag path then
                  return Some(fs :> Stream)
              else
  
negative.code: 
      // IOException will be signifies attempt to perform concurrent writes of file.
      // An exception to this rule is FileNotFoundException, which is a subtype of IOException.
      static let fileAccessRetryPolicy = 
          Policy(fun retries exn ->
              match exn with
              | :? FileNotFoundException 
              | :? DirectoryNotFoundException -> None
              | :? UnauthorizedAccessException when retries < 5 -> TimeSpan.FromMilliseconds 200. |> Some
              | :? IOException -> TimeSpan.FromMilliseconds 200. |> Some
              | _ -> None)
  
      static let fileDeleteRetryPolicy = 
          Policy(fun retries exn ->
              match exn with
              | :? FileNotFoundException 
              | :? DirectoryNotFoundException -> None
              | :? UnauthorizedAccessException when retries < 10 -> TimeSpan.FromMilliseconds 200. |> Some
              | :? IOException when retries < 10 -> TimeSpan.FromMilliseconds 200. |> Some
              | _ -> None)
  
      let initDir dir =
  