test: add tests for stream3 buffering using cork

test/parallel/test-stream3-cork-end.js

@@ -0,0 +1,91 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const stream = require('stream');
+const Writable = stream.Writable;
+
+// Test the buffering behaviour of Writable streams.
+//
+// The call to cork() triggers storing chunks which are flushed
+// on calling end() and the stream subsequently ended.
+//
+// node version target: 0.12
+
+const expectedChunks = ['please', 'buffer', 'me', 'kindly'];
+var inputChunks = expectedChunks.slice(0);
+var seenChunks = [];
+var seenEnd = false;
+
+var w = new Writable();
+// lets arrange to store the chunks
+w._write = function(chunk, encoding, cb) {
+  // stream end event is not seen before the last write
+  assert.ok(!seenEnd);
+  // default encoding given none was specified
+  assert.equal(encoding, 'buffer');
+
+  seenChunks.push(chunk);
+  cb();
+};
+// lets record the stream end event
+w.on('finish', () => {
+  seenEnd = true;
+});
+
+function writeChunks(remainingChunks, callback) {
+  var writeChunk = remainingChunks.shift();
+  var writeState;
+
+  if (writeChunk) {
+    setImmediate(() => {
+      writeState = w.write(writeChunk);
+      // we were not told to stop writing
+      assert.ok(writeState);
+
+      writeChunks(remainingChunks, callback);
+    });
+  } else {
+    callback();
+  }
+}
+
+// do an initial write
+w.write('stuff');
+// the write was immediate
+assert.equal(seenChunks.length, 1);
+// reset the seen chunks
+seenChunks = [];
+
+// trigger stream buffering
+w.cork();
+
+// write the bufferedChunks
+writeChunks(inputChunks, () => {
+  // should not have seen anything yet
+  assert.equal(seenChunks.length, 0);
+
+  // trigger flush and ending the stream
+  w.end();
+
+  // stream should not ended in current tick
+  assert.ok(!seenEnd);
+
+  // buffered bytes should be seen in current tick
+  assert.equal(seenChunks.length, 4);
+
+  // did the chunks match
+  for (var i = 0, l = expectedChunks.length; i < l; i++) {
+    var seen = seenChunks[i];
+    // there was a chunk
+    assert.ok(seen);
+
+    var expected = new Buffer(expectedChunks[i]);
+    // it was what we expected
+    assert.ok(seen.equals(expected));
+  }
+
+  setImmediate(() => {
+    // stream should have ended in next tick
+    assert.ok(seenEnd);
+  });
+});

test/parallel/test-stream3-cork-uncork.js

@@ -0,0 +1,86 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const stream = require('stream');
+const Writable = stream.Writable;
+
+// Test the buffering behaviour of Writable streams.
+//
+// The call to cork() triggers storing chunks which are flushed
+// on calling uncork() in the same tick.
+//
+// node version target: 0.12
+
+const expectedChunks = ['please', 'buffer', 'me', 'kindly'];
+var inputChunks = expectedChunks.slice(0);
+var seenChunks = [];
+var seenEnd = false;
+
+var w = new Writable();
+// lets arrange to store the chunks
+w._write = function(chunk, encoding, cb) {
+  // default encoding given none was specified
+  assert.equal(encoding, 'buffer');
+
+  seenChunks.push(chunk);
+  cb();
+};
+// lets record the stream end event
+w.on('finish', () => {
+  seenEnd = true;
+});
+
+function writeChunks(remainingChunks, callback) {
+  var writeChunk = remainingChunks.shift();
+  var writeState;
+
+  if (writeChunk) {
+    setImmediate(() => {
+      writeState = w.write(writeChunk);
+      // we were not told to stop writing
+      assert.ok(writeState);
+
+      writeChunks(remainingChunks, callback);
+    });
+  } else {
+    callback();
+  }
+}
+
+// do an initial write
+w.write('stuff');
+// the write was immediate
+assert.equal(seenChunks.length, 1);
+// reset the chunks seen so far
+seenChunks = [];
+
+// trigger stream buffering
+w.cork();
+
+// write the bufferedChunks
+writeChunks(inputChunks, () => {
+  // should not have seen anything yet
+  assert.equal(seenChunks.length, 0);
+
+  // trigger writing out the buffer
+  w.uncork();
+
+  // buffered bytes shoud be seen in current tick
+  assert.equal(seenChunks.length, 4);
+
+  // did the chunks match
+  for (var i = 0, l = expectedChunks.length; i < l; i++) {
+    var seen = seenChunks[i];
+    // there was a chunk
+    assert.ok(seen);
+
+    var expected = new Buffer(expectedChunks[i]);
+    // it was what we expected
+    assert.ok(seen.equals(expected));
+  }
+
+  setImmediate(() => {
+    // the stream should not have been ended
+    assert.ok(!seenEnd);
+  });
+});