Skip to content

test: refactor test-fs-read-stream #13643

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
Trott wants to merge 1 commit into from
Closed

test: refactor test-fs-read-stream #13643

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
310 changes: 163 additions & 147 deletions test/parallel/test-fs-read-stream.js
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -21,183 +21,199 @@

'use strict';
const common = require('../common');
const assert = require('assert');

const path = require('path');
const assert = require('assert');
const fs = require('fs');
const path = require('path');

const fn = path.join(common.fixturesDir, 'elipses.txt');
const rangeFile = path.join(common.fixturesDir, 'x.txt');

const callbacks = { open: 0, end: 0, close: 0 };
{
let paused = false;
let bytesRead = 0;

let paused = false;
let bytesRead = 0;
const file = fs.ReadStream(fn);
const fileSize = fs.statSync(fn).size;

const file = fs.ReadStream(fn);
const fileSize = fs.statSync(fn).size;
assert.strictEqual(file.bytesRead, 0);

assert.strictEqual(file.bytesRead, 0);
file.on('open', common.mustCall(function(fd) {
file.length = 0;
assert.strictEqual('number', typeof fd);
assert.strictEqual(file.bytesRead, 0);
assert.ok(file.readable);

file.on('open', function(fd) {
file.length = 0;
callbacks.open++;
assert.strictEqual('number', typeof fd);
assert.strictEqual(file.bytesRead, 0);
assert.ok(file.readable);
// GH-535
file.pause();
file.resume();
file.pause();
file.resume();
}));

// GH-535
file.pause();
file.resume();
file.pause();
file.resume();
});
file.on('data', function(data) {
assert.ok(data instanceof Buffer);
assert.ok(!paused);
file.length += data.length;

file.on('data', function(data) {
assert.ok(data instanceof Buffer);
assert.ok(!paused);
file.length += data.length;
bytesRead += data.length;
assert.strictEqual(file.bytesRead, bytesRead);

bytesRead += data.length;
assert.strictEqual(file.bytesRead, bytesRead);
paused = true;
file.pause();

paused = true;
file.pause();
setTimeout(function() {
paused = false;
file.resume();
}, 10);
});

setTimeout(function() {
paused = false;
file.resume();
}, 10);
});

file.on('end', common.mustCall(function(chunk) {
assert.strictEqual(bytesRead, fileSize);
assert.strictEqual(file.bytesRead, fileSize);
}));

file.on('end', function(chunk) {
assert.strictEqual(bytesRead, fileSize);
assert.strictEqual(file.bytesRead, fileSize);
callbacks.end++;
});

file.on('close', common.mustCall(function() {
assert.strictEqual(bytesRead, fileSize);
assert.strictEqual(file.bytesRead, fileSize);
}));

file.on('close', function() {
assert.strictEqual(bytesRead, fileSize);
assert.strictEqual(file.bytesRead, fileSize);
callbacks.close++;
process.on('exit', function() {
assert.strictEqual(file.length, 30000);
});
}

//assert.strictEqual(fs.readFileSync(fn), fileContent);
});
{
const file = fs.createReadStream(fn, {encoding: 'utf8'});
file.length = 0;
file.on('data', function(data) {
assert.strictEqual('string', typeof data);
file.length += data.length;

for (let i = 0; i < data.length; i++) {
// http://www.fileformat.info/info/unicode/char/2026/index.htm
assert.strictEqual('\u2026', data[i]);
}
});

const file3 = fs.createReadStream(fn, {encoding: 'utf8'});
file3.length = 0;
file3.on('data', function(data) {
assert.strictEqual('string', typeof data);
file3.length += data.length;
file.on('close', common.mustCall());

for (let i = 0; i < data.length; i++) {
// http://www.fileformat.info/info/unicode/char/2026/index.htm
assert.strictEqual('\u2026', data[i]);
}
});

file3.on('close', function() {
callbacks.close++;
});

process.on('exit', function() {
assert.strictEqual(1, callbacks.open);
assert.strictEqual(1, callbacks.end);
assert.strictEqual(2, callbacks.close);
assert.strictEqual(30000, file.length);
assert.strictEqual(10000, file3.length);
console.error('ok');
});

const file4 = fs.createReadStream(rangeFile, {bufferSize: 1, start: 1, end: 2});
let contentRead = '';
file4.on('data', function(data) {
contentRead += data.toString('utf-8');
});
file4.on('end', function(data) {
assert.strictEqual(contentRead, 'yz');
});

const file5 = fs.createReadStream(rangeFile, {bufferSize: 1, start: 1});
file5.data = '';
file5.on('data', function(data) {
file5.data += data.toString('utf-8');
});
file5.on('end', function() {
assert.strictEqual(file5.data, 'yz\n');
});

// https://github.com/joyent/node/issues/2320
const file6 = fs.createReadStream(rangeFile, {bufferSize: 1.23, start: 1});
file6.data = '';
file6.on('data', function(data) {
file6.data += data.toString('utf-8');
});
file6.on('end', function() {
assert.strictEqual(file6.data, 'yz\n');
});
process.on('exit', function() {
assert.strictEqual(file.length, 10000);
});
}

{
const file =
fs.createReadStream(rangeFile, {bufferSize: 1, start: 1, end: 2});
let contentRead = '';
file.on('data', function(data) {
contentRead += data.toString('utf-8');
});
file.on('end', common.mustCall(function(data) {
assert.strictEqual(contentRead, 'yz');
}));
}

{
const file = fs.createReadStream(rangeFile, {bufferSize: 1, start: 1});
file.data = '';
file.on('data', function(data) {
file.data += data.toString('utf-8');
});
file.on('end', common.mustCall(function() {
assert.strictEqual(file.data, 'yz\n');
}));
}

{
// Ref: https://github.com/nodejs/node-v0.x-archive/issues/2320
const file = fs.createReadStream(rangeFile, {bufferSize: 1.23, start: 1});
file.data = '';
file.on('data', function(data) {
file.data += data.toString('utf-8');
});
file.on('end', common.mustCall(function() {
assert.strictEqual(file.data, 'yz\n');
}));
}

assert.throws(function() {
fs.createReadStream(rangeFile, {start: 10, end: 2});
}, /"start" option must be <= "end" option/);

const stream = fs.createReadStream(rangeFile, { start: 0, end: 0 });
stream.data = '';

stream.on('data', function(chunk) {
stream.data += chunk;
});

stream.on('end', function() {
assert.strictEqual('x', stream.data);
});

// pause and then resume immediately.
const pauseRes = fs.createReadStream(rangeFile);
pauseRes.pause();
pauseRes.resume();

let file7 = fs.createReadStream(rangeFile, {autoClose: false });
file7.on('data', common.noop);
file7.on('end', function() {
process.nextTick(function() {
assert(!file7.closed);
assert(!file7.destroyed);
file7Next();
});
});

function file7Next() {
// This will tell us if the fd is usable again or not.
file7 = fs.createReadStream(null, {fd: file7.fd, start: 0 });
file7.data = '';
file7.on('data', function(data) {
file7.data += data;
});
file7.on('end', function(err) {
assert.strictEqual(file7.data, 'xyz\n');
{
const stream = fs.createReadStream(rangeFile, { start: 0, end: 0 });
stream.data = '';

stream.on('data', function(chunk) {
stream.data += chunk;
});

stream.on('end', common.mustCall(function() {
assert.strictEqual('x', stream.data);
}));
}

// Just to make sure autoClose won't close the stream because of error.
const file8 = fs.createReadStream(null, {fd: 13337, autoClose: false });
file8.on('data', common.noop);
file8.on('error', common.mustCall());
{
// pause and then resume immediately.
const pauseRes = fs.createReadStream(rangeFile);
pauseRes.pause();
pauseRes.resume();
}

// Make sure stream is destroyed when file does not exist.
const file9 = fs.createReadStream('/path/to/file/that/does/not/exist');
file9.on('data', common.noop);
file9.on('error', common.mustCall());
{
let file = fs.createReadStream(rangeFile, {autoClose: false });
let data = '';
file.on('data', function(chunk) { data += chunk; });
file.on('end', common.mustCall(function() {
assert.strictEqual(data, 'xyz\n');
process.nextTick(function() {
assert(!file.closed);
assert(!file.destroyed);
fileNext();
});
}));

function fileNext() {
// This will tell us if the fd is usable again or not.
file = fs.createReadStream(null, {fd: file.fd, start: 0 });
file.data = '';
file.on('data', function(data) {
file.data += data;
});
file.on('end', common.mustCall(function(err) {
assert.strictEqual(file.data, 'xyz\n');
}));
process.on('exit', function() {
assert(file.closed);
assert(file.destroyed);
});
}
}

process.on('exit', function() {
assert(file7.closed);
assert(file7.destroyed);
{
// Just to make sure autoClose won't close the stream because of error.
const file = fs.createReadStream(null, {fd: 13337, autoClose: false });
file.on('data', common.mustNotCall());
file.on('error', common.mustCall());
process.on('exit', function() {
assert(!file.closed);
assert(!file.destroyed);
assert(file.fd);
});
}

assert(!file8.closed);
assert(!file8.destroyed);
assert(file8.fd);
{
// Make sure stream is destroyed when file does not exist.
const file = fs.createReadStream('/path/to/file/that/does/not/exist');
file.on('data', common.mustNotCall());
file.on('error', common.mustCall());

assert(!file9.closed);
assert(file9.destroyed);
});
process.on('exit', function() {
assert(!file.closed);
assert(file.destroyed);
});
}