stream: Don't stop reading on zero-length decoded output

Fixes regression introduced in 7e1cf84c9efd491d72b25968a70656458ecb6b7c

lib/_stream_readable.js

@@ -291,9 +291,6 @@ function onread(stream, er, chunk) {
     return;
   }
 
-  if (state.decoder)
-    chunk = state.decoder.write(chunk);
-
   // at this point, if we got a zero-length buffer or string,
   // and we're not in object-mode, then there's really no point
   // continuing.  it means that there is nothing to read right
@@ -305,6 +302,9 @@ function onread(stream, er, chunk) {
       0 === chunk.length)
     return;
 
+  if (state.decoder)
+    chunk = state.decoder.write(chunk);
+
   // update the buffer info.
   state.length += state.objectMode ? 1 : chunk.length;
   state.buffer.push(chunk);

test/simple/test-stream2-readable-empty-buffer-no-eof.js

@@ -24,62 +24,95 @@ var assert = require('assert');
 
 var Readable = require('stream').Readable;
 
-var r = new Readable();
+test1();
+test2();
 
-// should not end when we get a Buffer(0) or '' as the _read result
+function test1() {
-// that just means that there is *temporarily* no data, but to go
+  var r = new Readable();
-// ahead and try again later.
-//
-// note that this is very unusual.  it only works for crypto streams
-// because the other side of the stream will call read(0) to cycle
-// data through openssl.  that's why we set the timeouts to call
-// r.read(0) again later, otherwise there is no more work being done
-// and the process just exits.
 
-var buf = new Buffer(5);
+  // should not end when we get a Buffer(0) or '' as the _read result
-buf.fill('x');
+  // that just means that there is *temporarily* no data, but to go
-var reads = 5;
+  // ahead and try again later.
-r._read = function(n, cb) {
+  //
-  switch (reads--) {
+  // note that this is very unusual.  it only works for crypto streams
-    case 0:
+  // because the other side of the stream will call read(0) to cycle
-      return cb(null, null); // EOF
+  // data through openssl.  that's why we set the timeouts to call
-    case 1:
+  // r.read(0) again later, otherwise there is no more work being done
-      return cb(null, buf);
+  // and the process just exits.
-    case 2:
+
-      setTimeout(r.read.bind(r, 0), 10);
+  var buf = new Buffer(5);
-      return cb(null, new Buffer(0)); // Not-EOF!
+  buf.fill('x');
-    case 3:
+  var reads = 5;
-      setTimeout(r.read.bind(r, 0), 10);
+  r._read = function(n, cb) {
-      return process.nextTick(function() {
+    switch (reads--) {
-        return cb(null, new Buffer(0));
+      case 0:
-      });
+        return cb(null, null); // EOF
-    case 4:
+      case 1:
-      setTimeout(r.read.bind(r, 0), 10);
-      return setTimeout(function() {
-        return cb(null, new Buffer(0));
-      });
-    case 5:
-      return setTimeout(function() {
         return cb(null, buf);
-      });
+      case 2:
-    default:
+        setTimeout(r.read.bind(r, 0), 10);
-      throw new Error('unreachable');
+        return cb(null, new Buffer(0)); // Not-EOF!
+      case 3:
+        setTimeout(r.read.bind(r, 0), 10);
+        return process.nextTick(function() {
+          return cb(null, new Buffer(0));
+        });
+      case 4:
+        setTimeout(r.read.bind(r, 0), 10);
+        return setTimeout(function() {
+          return cb(null, new Buffer(0));
+        });
+      case 5:
+        return setTimeout(function() {
+          return cb(null, buf);
+        });
+      default:
+        throw new Error('unreachable');
+    }
+  };
+
+  var results = [];
+  function flow() {
+    var chunk;
+    while (null !== (chunk = r.read()))
+      results.push(chunk + '');
   }
-};
+  r.on('readable', flow);
+  r.on('end', function() {
+    results.push('EOF');
+  });
+  flow();
 
-var results = [];
+  process.on('exit', function() {
-function flow() {
+    assert.deepEqual(results, [ 'xxxxx', 'xxxxx', 'EOF' ]);
-  var chunk;
+    console.log('ok');
-  while (null !== (chunk = r.read()))
+  });
-    results.push(chunk + '');
 }
-r.on('readable', flow);
-r.on('end', function() {
-  results.push('EOF');
-});
-flow();
 
-process.on('exit', function() {
+function test2() {
-  assert.deepEqual(results, [ 'xxxxx', 'xxxxx', 'EOF' ]);
+  var r = new Readable({ encoding: 'base64' });
-  console.log('ok');
+  var reads = 5;
-});
+  r._read = function(n, cb) {
+    if (!reads--)
+      return cb(null, null); // EOF
+    else
+      return cb(null, new Buffer('x'));
+  };
+
+  var results = [];
+  function flow() {
+    var chunk;
+    while (null !== (chunk = r.read()))
+      results.push(chunk + '');
+  }
+  r.on('readable', flow);
+  r.on('end', function() {
+    results.push('EOF');
+  });
+  flow();
+
+  process.on('exit', function() {
+    assert.deepEqual(results, [ 'eHh4', 'eHg=', 'EOF' ]);
+    console.log('ok');
+  });
+}