|
|
|
// Copyright Joyent, Inc. and other Node contributors.
|
|
|
|
//
|
|
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
// copy of this software and associated documentation files (the
|
|
|
|
// "Software"), to deal in the Software without restriction, including
|
|
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
|
|
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
|
|
|
// persons to whom the Software is furnished to do so, subject to the
|
|
|
|
// following conditions:
|
|
|
|
//
|
|
|
|
// The above copyright notice and this permission notice shall be included
|
|
|
|
// in all copies or substantial portions of the Software.
|
|
|
|
//
|
|
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
|
|
|
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|
|
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
|
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
|
|
|
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
|
|
|
|
|
|
|
|
var common = require('../common.js');
|
|
|
|
var assert = require('assert');
|
|
|
|
var R = require('_stream_readable');
|
|
|
|
var util = require('util');
|
|
|
|
|
|
|
|
// tiny node-tap lookalike.
|
|
|
|
var tests = [];
|
|
|
|
var count = 0;
|
|
|
|
|
|
|
|
function test(name, fn) {
|
|
|
|
count++;
|
|
|
|
tests.push([name, fn]);
|
|
|
|
}
|
|
|
|
|
|
|
|
function run() {
|
|
|
|
var next = tests.shift();
|
|
|
|
if (!next)
|
|
|
|
return console.error('ok');
|
|
|
|
|
|
|
|
var name = next[0];
|
|
|
|
var fn = next[1];
|
|
|
|
console.log('# %s', name);
|
|
|
|
fn({
|
|
|
|
same: assert.deepEqual,
|
|
|
|
equal: assert.equal,
|
|
|
|
end: function () {
|
|
|
|
count--;
|
|
|
|
run();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
// ensure all tests have run
|
|
|
|
process.on("exit", function () {
|
|
|
|
assert.equal(count, 0);
|
|
|
|
});
|
|
|
|
|
|
|
|
process.nextTick(run);
|
|
|
|
|
|
|
|
/////
|
|
|
|
|
|
|
|
util.inherits(TestReader, R);
|
|
|
|
|
|
|
|
function TestReader(n, opts) {
|
|
|
|
R.call(this, util._extend({
|
|
|
|
bufferSize: 5
|
|
|
|
}, opts));
|
|
|
|
|
|
|
|
this.pos = 0;
|
|
|
|
this.len = n || 100;
|
|
|
|
}
|
|
|
|
|
stream: There is no _read cb, there is only push
This makes it so that `stream.push(chunk)` is the only way to signal the
end of reading, removing the confusing disparity between the
callback-style _read method, and the fact that most real-world streams
do not have a 1:1 corollation between the "please give me data" event,
and the actual arrival of a chunk of data.
It is still possible, of course, to implement a `CallbackReadable` on
top of this. Simply provide a method like this as the callback:
function readCallback(er, chunk) {
if (er)
stream.emit('error', er);
else
stream.push(chunk);
}
However, *only* fs streams actually would behave in this way, so it
makes not a lot of sense to make TCP, TLS, HTTP, and all the rest have
to bend into this uncomfortable paradigm.
12 years ago
|
|
|
TestReader.prototype._read = function(n) {
|
|
|
|
setTimeout(function() {
|
|
|
|
|
|
|
|
if (this.pos >= this.len) {
|
stream: There is no _read cb, there is only push
This makes it so that `stream.push(chunk)` is the only way to signal the
end of reading, removing the confusing disparity between the
callback-style _read method, and the fact that most real-world streams
do not have a 1:1 corollation between the "please give me data" event,
and the actual arrival of a chunk of data.
It is still possible, of course, to implement a `CallbackReadable` on
top of this. Simply provide a method like this as the callback:
function readCallback(er, chunk) {
if (er)
stream.emit('error', er);
else
stream.push(chunk);
}
However, *only* fs streams actually would behave in this way, so it
makes not a lot of sense to make TCP, TLS, HTTP, and all the rest have
to bend into this uncomfortable paradigm.
12 years ago
|
|
|
return this.push(null);
|
|
|
|
}
|
|
|
|
|
|
|
|
n = Math.min(n, this.len - this.pos);
|
|
|
|
if (n <= 0) {
|
stream: There is no _read cb, there is only push
This makes it so that `stream.push(chunk)` is the only way to signal the
end of reading, removing the confusing disparity between the
callback-style _read method, and the fact that most real-world streams
do not have a 1:1 corollation between the "please give me data" event,
and the actual arrival of a chunk of data.
It is still possible, of course, to implement a `CallbackReadable` on
top of this. Simply provide a method like this as the callback:
function readCallback(er, chunk) {
if (er)
stream.emit('error', er);
else
stream.push(chunk);
}
However, *only* fs streams actually would behave in this way, so it
makes not a lot of sense to make TCP, TLS, HTTP, and all the rest have
to bend into this uncomfortable paradigm.
12 years ago
|
|
|
return this.push(null);
|
|
|
|
}
|
|
|
|
|
|
|
|
this.pos += n;
|
|
|
|
var ret = new Buffer(n);
|
|
|
|
ret.fill('a');
|
|
|
|
|
stream: There is no _read cb, there is only push
This makes it so that `stream.push(chunk)` is the only way to signal the
end of reading, removing the confusing disparity between the
callback-style _read method, and the fact that most real-world streams
do not have a 1:1 corollation between the "please give me data" event,
and the actual arrival of a chunk of data.
It is still possible, of course, to implement a `CallbackReadable` on
top of this. Simply provide a method like this as the callback:
function readCallback(er, chunk) {
if (er)
stream.emit('error', er);
else
stream.push(chunk);
}
However, *only* fs streams actually would behave in this way, so it
makes not a lot of sense to make TCP, TLS, HTTP, and all the rest have
to bend into this uncomfortable paradigm.
12 years ago
|
|
|
console.log("this.push(ret)", ret)
|
|
|
|
|
stream: There is no _read cb, there is only push
This makes it so that `stream.push(chunk)` is the only way to signal the
end of reading, removing the confusing disparity between the
callback-style _read method, and the fact that most real-world streams
do not have a 1:1 corollation between the "please give me data" event,
and the actual arrival of a chunk of data.
It is still possible, of course, to implement a `CallbackReadable` on
top of this. Simply provide a method like this as the callback:
function readCallback(er, chunk) {
if (er)
stream.emit('error', er);
else
stream.push(chunk);
}
However, *only* fs streams actually would behave in this way, so it
makes not a lot of sense to make TCP, TLS, HTTP, and all the rest have
to bend into this uncomfortable paradigm.
12 years ago
|
|
|
return this.push(ret);
|
|
|
|
}.bind(this), 1);
|
|
|
|
};
|
|
|
|
|
|
|
|
test('setEncoding utf8', function(t) {
|
|
|
|
var tr = new TestReader(100);
|
|
|
|
tr.setEncoding('utf8');
|
|
|
|
var out = [];
|
|
|
|
var expect =
|
|
|
|
[ 'aaaaaaaaaa',
|
|
|
|
'aaaaaaaaaa',
|
|
|
|
'aaaaaaaaaa',
|
|
|
|
'aaaaaaaaaa',
|
|
|
|
'aaaaaaaaaa',
|
|
|
|
'aaaaaaaaaa',
|
|
|
|
'aaaaaaaaaa',
|
|
|
|
'aaaaaaaaaa',
|
|
|
|
'aaaaaaaaaa',
|
|
|
|
'aaaaaaaaaa' ];
|
|
|
|
|
|
|
|
tr.on('readable', function flow() {
|
|
|
|
var chunk;
|
|
|
|
while (null !== (chunk = tr.read(10)))
|
|
|
|
out.push(chunk);
|
|
|
|
});
|
|
|
|
|
|
|
|
tr.on('end', function() {
|
|
|
|
t.same(out, expect);
|
|
|
|
t.end();
|
|
|
|
});
|
|
|
|
|
|
|
|
// just kick it off.
|
|
|
|
tr.emit('readable');
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
test('setEncoding hex', function(t) {
|
|
|
|
var tr = new TestReader(100);
|
|
|
|
tr.setEncoding('hex');
|
|
|
|
var out = [];
|
|
|
|
var expect =
|
|
|
|
[ '6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161' ];
|
|
|
|
|
|
|
|
tr.on('readable', function flow() {
|
|
|
|
var chunk;
|
|
|
|
while (null !== (chunk = tr.read(10)))
|
|
|
|
out.push(chunk);
|
|
|
|
});
|
|
|
|
|
|
|
|
tr.on('end', function() {
|
|
|
|
t.same(out, expect);
|
|
|
|
t.end();
|
|
|
|
});
|
|
|
|
|
|
|
|
// just kick it off.
|
|
|
|
tr.emit('readable');
|
|
|
|
});
|
|
|
|
|
|
|
|
test('setEncoding hex with read(13)', function(t) {
|
|
|
|
var tr = new TestReader(100);
|
|
|
|
tr.setEncoding('hex');
|
|
|
|
var out = [];
|
|
|
|
var expect =
|
|
|
|
[ "6161616161616",
|
|
|
|
"1616161616161",
|
|
|
|
"6161616161616",
|
|
|
|
"1616161616161",
|
|
|
|
"6161616161616",
|
|
|
|
"1616161616161",
|
|
|
|
"6161616161616",
|
|
|
|
"1616161616161",
|
|
|
|
"6161616161616",
|
|
|
|
"1616161616161",
|
|
|
|
"6161616161616",
|
|
|
|
"1616161616161",
|
|
|
|
"6161616161616",
|
|
|
|
"1616161616161",
|
|
|
|
"6161616161616",
|
|
|
|
"16161" ];
|
|
|
|
|
|
|
|
tr.on('readable', function flow() {
|
|
|
|
console.log("readable once")
|
|
|
|
var chunk;
|
|
|
|
while (null !== (chunk = tr.read(13)))
|
|
|
|
out.push(chunk);
|
|
|
|
});
|
|
|
|
|
|
|
|
tr.on('end', function() {
|
|
|
|
console.log("END")
|
|
|
|
t.same(out, expect);
|
|
|
|
t.end();
|
|
|
|
});
|
|
|
|
|
|
|
|
// just kick it off.
|
|
|
|
tr.emit('readable');
|
|
|
|
});
|
|
|
|
|
|
|
|
test('encoding: utf8', function(t) {
|
|
|
|
var tr = new TestReader(100, { encoding: 'utf8' });
|
|
|
|
var out = [];
|
|
|
|
var expect =
|
|
|
|
[ 'aaaaaaaaaa',
|
|
|
|
'aaaaaaaaaa',
|
|
|
|
'aaaaaaaaaa',
|
|
|
|
'aaaaaaaaaa',
|
|
|
|
'aaaaaaaaaa',
|
|
|
|
'aaaaaaaaaa',
|
|
|
|
'aaaaaaaaaa',
|
|
|
|
'aaaaaaaaaa',
|
|
|
|
'aaaaaaaaaa',
|
|
|
|
'aaaaaaaaaa' ];
|
|
|
|
|
|
|
|
tr.on('readable', function flow() {
|
|
|
|
var chunk;
|
|
|
|
while (null !== (chunk = tr.read(10)))
|
|
|
|
out.push(chunk);
|
|
|
|
});
|
|
|
|
|
|
|
|
tr.on('end', function() {
|
|
|
|
t.same(out, expect);
|
|
|
|
t.end();
|
|
|
|
});
|
|
|
|
|
|
|
|
// just kick it off.
|
|
|
|
tr.emit('readable');
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
test('encoding: hex', function(t) {
|
|
|
|
var tr = new TestReader(100, { encoding: 'hex' });
|
|
|
|
var out = [];
|
|
|
|
var expect =
|
|
|
|
[ '6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161',
|
|
|
|
'6161616161' ];
|
|
|
|
|
|
|
|
tr.on('readable', function flow() {
|
|
|
|
var chunk;
|
|
|
|
while (null !== (chunk = tr.read(10)))
|
|
|
|
out.push(chunk);
|
|
|
|
});
|
|
|
|
|
|
|
|
tr.on('end', function() {
|
|
|
|
t.same(out, expect);
|
|
|
|
t.end();
|
|
|
|
});
|
|
|
|
|
|
|
|
// just kick it off.
|
|
|
|
tr.emit('readable');
|
|
|
|
});
|
|
|
|
|
|
|
|
test('encoding: hex with read(13)', function(t) {
|
|
|
|
var tr = new TestReader(100, { encoding: 'hex' });
|
|
|
|
var out = [];
|
|
|
|
var expect =
|
|
|
|
[ "6161616161616",
|
|
|
|
"1616161616161",
|
|
|
|
"6161616161616",
|
|
|
|
"1616161616161",
|
|
|
|
"6161616161616",
|
|
|
|
"1616161616161",
|
|
|
|
"6161616161616",
|
|
|
|
"1616161616161",
|
|
|
|
"6161616161616",
|
|
|
|
"1616161616161",
|
|
|
|
"6161616161616",
|
|
|
|
"1616161616161",
|
|
|
|
"6161616161616",
|
|
|
|
"1616161616161",
|
|
|
|
"6161616161616",
|
|
|
|
"16161" ];
|
|
|
|
|
|
|
|
tr.on('readable', function flow() {
|
|
|
|
var chunk;
|
|
|
|
while (null !== (chunk = tr.read(13)))
|
|
|
|
out.push(chunk);
|
|
|
|
});
|
|
|
|
|
|
|
|
tr.on('end', function() {
|
|
|
|
t.same(out, expect);
|
|
|
|
t.end();
|
|
|
|
});
|
|
|
|
|
|
|
|
// just kick it off.
|
|
|
|
tr.emit('readable');
|
|
|
|
});
|