Support for arbitrarily large fixed delayed writes

tests/test_output_stream.nim

@@ -1,5 +1,5 @@
 import
-  os, unittest,
+  os, unittest, random,
   stew/ranges/ptr_arith,
   ../faststreams
 
@@ -14,12 +14,17 @@ proc repeat(b: byte, count: int): seq[byte] =
   result = newSeq[byte](count)
   for i in 0 ..< count: result[i] = b
 
+proc randomBytes(n: int): seq[byte] =
+  result.newSeq n
+  for i in 0 ..< n:
+    result[i] = byte(rand(255))
+
 suite "output stream":
   setup:
     var memStream = OutputStream.init
     var altOutput: seq[byte] = @[]
     var tempFilePath = getTempDir() / "faststreams_testfile"
-    var fileStream = OutputStream.init tempFilePath
+    # var fileStream = OutputStream.init tempFilePath
 
     const bufferSize = 1000000
     var buffer = alloc(bufferSize)
@@ -32,18 +37,18 @@ suite "output stream":
     altOutput.add bytes(val)
 
     memStream.append val
-    fileStream.append val
+    # fileStream.append val
     existingBufferStream.append val
 
   template checkOutputsMatch =
-    fileStream.flush
+    # fileStream.flush
 
     let
-      fileContents = readFile(tempFilePath).string.bytes
+      # fileContents = readFile(tempFilePath).string.bytes
       memStreamContents = memStream.getOutput
 
     check altOutput == memStreamContents
-    check altOutput == fileContents
+    # check altOutput == fileContents
     check altOutput == makeOpenArray(cast[ptr byte](buffer),
                                      existingBufferStream.pos)
 
@@ -66,7 +71,7 @@ suite "output stream":
     let cursorStart = memStream.pos
     altOutput.add delayedWriteContent
 
-    fileStream.append delayedWriteContent
+    # fileStream.append delayedWriteContent
     existingBufferStream.append delayedWriteContent
 
     var totalBytesWritten = 0
@@ -79,3 +84,65 @@ suite "output stream":
 
     checkOutputsMatch()
 
+  test "multi-page delayed writes":
+    randomize(1000)
+
+    type
+      DelayedWrite = object
+        cursor: WriteCursor
+        content: seq[byte]
+        written: int
+
+    var delayedWrites = newSeq[DelayedWrite]()
+
+    for i in 0..50:
+      let
+        size = rand(8000) + 2000
+        randomBytes = randomBytes(size)
+        decision = rand(100)
+
+      if decision < 70:
+        # Write at some random cursor
+        if delayedWrites.len == 0:
+          continue
+
+        let
+          i = rand(delayedWrites.len - 1)
+          written = delayedWrites[i].written
+          remaining = delayedWrites[i].content.len - written
+          toWrite = min(rand(remaining) + 10, remaining)
+
+        delayedWrites[i].cursor.append delayedWrites[i].content[written ..< written + toWrite]
+        delayedWrites[i].written += toWrite
+
+        if remaining - toWrite == 0:
+          dispose delayedWrites[i].cursor
+          if i != delayedWrites.len - 1:
+            swap(delayedWrites[i], delayedWrites[^1])
+          delayedWrites.setLen(delayedWrites.len - 1)
+
+      elif decision < 90:
+        # Normal write
+        memStream.append randomBytes
+        altOutput.add randomBytes
+
+      else:
+        # Create cursor
+        altOutput.add randomBytes
+        delayedWrites.add DelayedWrite(
+          cursor: memStream.delayFixedSizeWrite(randomBytes.len),
+          content: randomBytes,
+          written: 0)
+
+      # Check that the stream position is consistently tracked at every step
+      check altOutput.len == memStream.pos
+
+    # Write all unwritten data to all outstanding cursors
+    for dw in mitems(delayedWrites):
+      let remaining = dw.content.len - dw.written
+      dw.cursor.append dw.content[dw.written ..< dw.written + remaining]
+      dispose dw.cursor
+
+    # The final outputs are the same
+    check altOutput == memStream.getOutput
+