node_modules/fd-slicer/test/test.js - Code Metrics - Inspection of "Firebase (#34)" - LCSOGthb/Tools - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( 10dbfc...61a674 )

by LCS

created 2025-04-21 14:54 UTC

node_modules/fd-slicer/test/test.js F

↳ Parent: Project

Complexity

Total Complexity	96
Complexity/F	1.35

Size

Lines of Code	350
Function Count	71

Duplication

Duplicated Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	259
dl	0
loc	350
rs	2
c	0
b	0
f	0
wmc	96
mnd	25
bc	25
fnc	71
bpm	0.3521
cpm	1.3521
noi	58

How to fix Complexity

var fdSlicer = require('../');
var fs = require('fs');
var crypto = require('crypto');
var path = require('path');
var streamEqual = require('stream-equal');
var assert = require('assert');
var Pend = require('pend');
var StreamSink = require('streamsink');

var describe = global.describe;
var it = global.it;
var before = global.before;
var beforeEach = global.beforeEach;
var after = global.after;

var testBlobFile = path.join(__dirname, "test-blob.bin");
var testBlobFileSize = 20 * 1024 * 1024;
var testOutBlobFile = path.join(__dirname, "test-blob-out.bin");

describe("FdSlicer", function() {
  before(function(done) {
    var out = fs.createWriteStream(testBlobFile);
    for (var i = 0; i < testBlobFileSize / 1024; i += 1) {
      out.write(crypto.pseudoRandomBytes(1024));
    }
    out.end();
    out.on('close', done);
  });
  beforeEach(function() {
    try {
      fs.unlinkSync(testOutBlobFile);
    } catch (err) {
    }
  });
  after(function() {
    try {
      fs.unlinkSync(testBlobFile);
      fs.unlinkSync(testOutBlobFile);
    } catch (err) {
    }
  });
  it("reads a 20MB file (autoClose on)", function(done) {
    fs.open(testBlobFile, 'r', function(err, fd) {
      if (err) return done(err);
      var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
      var actualStream = slicer.createReadStream();
      var expectedStream = fs.createReadStream(testBlobFile);

      var pend = new Pend();
      pend.go(function(cb) {
        slicer.on('close', cb);
      });
      pend.go(function(cb) {
        streamEqual(expectedStream, actualStream, function(err, equal) {
          if (err) return done(err);
          assert.ok(equal);
          cb();
        });
      });
      pend.wait(done);
    });
  });
  it("reads 4 chunks simultaneously", function(done) {
    fs.open(testBlobFile, 'r', function(err, fd) {
      if (err) return done(err);
      var slicer = fdSlicer.createFromFd(fd);
      var actualPart1 = slicer.createReadStream({start: testBlobFileSize * 0/4, end: testBlobFileSize * 1/4});
      var actualPart2 = slicer.createReadStream({start: testBlobFileSize * 1/4, end: testBlobFileSize * 2/4});
      var actualPart3 = slicer.createReadStream({start: testBlobFileSize * 2/4, end: testBlobFileSize * 3/4});
      var actualPart4 = slicer.createReadStream({start: testBlobFileSize * 3/4, end: testBlobFileSize * 4/4});
      var expectedPart1 = slicer.createReadStream({start: testBlobFileSize * 0/4, end: testBlobFileSize * 1/4});
      var expectedPart2 = slicer.createReadStream({start: testBlobFileSize * 1/4, end: testBlobFileSize * 2/4});
      var expectedPart3 = slicer.createReadStream({start: testBlobFileSize * 2/4, end: testBlobFileSize * 3/4});
      var expectedPart4 = slicer.createReadStream({start: testBlobFileSize * 3/4, end: testBlobFileSize * 4/4});
      var pend = new Pend();
      pend.go(function(cb) {
        streamEqual(expectedPart1, actualPart1, function(err, equal) {
          assert.ok(equal);
          cb(err);
        });
      });
      pend.go(function(cb) {
        streamEqual(expectedPart2, actualPart2, function(err, equal) {
          assert.ok(equal);
          cb(err);
        });
      });
      pend.go(function(cb) {
        streamEqual(expectedPart3, actualPart3, function(err, equal) {
          assert.ok(equal);
          cb(err);
        });
      });
      pend.go(function(cb) {
        streamEqual(expectedPart4, actualPart4, function(err, equal) {
          assert.ok(equal);
          cb(err);
        });
      });
      pend.wait(function(err) {
        if (err) return done(err);
        fs.close(fd, done);
      });
    });
  });

  it("writes a 20MB file (autoClose on)", function(done) {
    fs.open(testOutBlobFile, 'w', function(err, fd) {
      if (err) return done(err);
      var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
      var actualStream = slicer.createWriteStream();
      var inStream = fs.createReadStream(testBlobFile);

      slicer.on('close', function() {
        var expected = fs.createReadStream(testBlobFile);
        var actual = fs.createReadStream(testOutBlobFile);

        streamEqual(expected, actual, function(err, equal) {
          if (err) return done(err);
          assert.ok(equal);
          done();
        });
      });
      inStream.pipe(actualStream);
    });
  });

  it("writes 4 chunks simultaneously", function(done) {
    fs.open(testOutBlobFile, 'w', function(err, fd) {
      if (err) return done(err);
      var slicer = fdSlicer.createFromFd(fd);
      var actualPart1 = slicer.createWriteStream({start: testBlobFileSize * 0/4});
      var actualPart2 = slicer.createWriteStream({start: testBlobFileSize * 1/4});
      var actualPart3 = slicer.createWriteStream({start: testBlobFileSize * 2/4});
      var actualPart4 = slicer.createWriteStream({start: testBlobFileSize * 3/4});
      var in1 = fs.createReadStream(testBlobFile, {start: testBlobFileSize * 0/4, end: testBlobFileSize * 1/4});
      var in2 = fs.createReadStream(testBlobFile, {start: testBlobFileSize * 1/4, end: testBlobFileSize * 2/4});
      var in3 = fs.createReadStream(testBlobFile, {start: testBlobFileSize * 2/4, end: testBlobFileSize * 3/4});
      var in4 = fs.createReadStream(testBlobFile, {start: testBlobFileSize * 3/4, end: testBlobFileSize * 4/4});
      var pend = new Pend();
      pend.go(function(cb) {
        actualPart1.on('finish', cb);
      });
      pend.go(function(cb) {
        actualPart2.on('finish', cb);
      });
      pend.go(function(cb) {
        actualPart3.on('finish', cb);
      });
      pend.go(function(cb) {
        actualPart4.on('finish', cb);
      });
      in1.pipe(actualPart1);
      in2.pipe(actualPart2);
      in3.pipe(actualPart3);
      in4.pipe(actualPart4);
      pend.wait(function() {
        fs.close(fd, function(err) {
          if (err) return done(err);
          var expected = fs.createReadStream(testBlobFile);
          var actual = fs.createReadStream(testOutBlobFile);
          streamEqual(expected, actual, function(err, equal) {
            if (err) return done(err);
            assert.ok(equal);
            done();
          });
        });
      });
    });
  });

  it("throws on invalid ref", function(done) {
    fs.open(testOutBlobFile, 'w', function(err, fd) {
      if (err) return done(err);
      var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
      assert.throws(function() {
        slicer.unref();
      }, /invalid unref/);
      fs.close(fd, done);
    });
  });

  it("write stream emits error when max size exceeded", function(done) {
    fs.open(testOutBlobFile, 'w', function(err, fd) {
      if (err) return done(err);
      var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
      var ws = slicer.createWriteStream({start: 0, end: 1000});
      ws.on('error', function(err) {
        assert.strictEqual(err.code, 'ETOOBIG');
        slicer.on('close', done);
      });
      ws.end(new Buffer(1001));
    });
  });

  it("write stream does not emit error when max size not exceeded", function(done) {
    fs.open(testOutBlobFile, 'w', function(err, fd) {
      if (err) return done(err);
      var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
      var ws = slicer.createWriteStream({end: 1000});
      slicer.on('close', done);
      ws.end(new Buffer(1000));
    });
  });

  it("write stream start and end work together", function(done) {
    fs.open(testOutBlobFile, 'w', function(err, fd) {
      if (err) return done(err);
      var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
      var ws = slicer.createWriteStream({start: 1, end: 1000});
      ws.on('error', function(err) {
        assert.strictEqual(err.code, 'ETOOBIG');
        slicer.on('close', done);
      });
      ws.end(new Buffer(1000));
    });
  });

  it("write stream emits progress events", function(done) {
    fs.open(testOutBlobFile, 'w', function(err, fd) {
      if (err) return done(err);
      var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
      var ws = slicer.createWriteStream();
      var progressEventCount = 0;
      var prevBytesWritten = 0;
      ws.on('progress', function() {
        progressEventCount += 1;
        assert.ok(ws.bytesWritten > prevBytesWritten);
        prevBytesWritten = ws.bytesWritten;
      });
      slicer.on('close', function() {
        assert.ok(progressEventCount > 5);
        done();
      });
      for (var i = 0; i < 10; i += 1) {
        ws.write(new Buffer(16 * 1024 * 2));
      }
      ws.end();
    });
  });

  it("write stream unrefs when destroyed", function(done) {
    fs.open(testOutBlobFile, 'w', function(err, fd) {
      if (err) return done(err);
      var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
      var ws = slicer.createWriteStream();
      slicer.on('close', done);
      ws.write(new Buffer(1000));
      ws.destroy();
    });
  });

  it("read stream unrefs when destroyed", function(done) {
    fs.open(testBlobFile, 'r', function(err, fd) {
      if (err) return done(err);
      var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
      var rs = slicer.createReadStream();
      rs.on('error', function(err) {
        assert.strictEqual(err.message, "stream destroyed");
        slicer.on('close', done);
      });
      rs.destroy();
    });
  });

  it("fdSlicer.read", function(done) {
    fs.open(testBlobFile, 'r', function(err, fd) {
      if (err) return done(err);
      var slicer = fdSlicer.createFromFd(fd);
      var outBuf = new Buffer(1024);
      slicer.read(outBuf, 0, 10, 0, function(err, bytesRead, buf) {
        assert.strictEqual(bytesRead, 10);
        fs.close(fd, done);
      });
    });
  });

  it("fdSlicer.write", function(done) {
    fs.open(testOutBlobFile, 'w', function(err, fd) {
      if (err) return done(err);
      var slicer = fdSlicer.createFromFd(fd);
      slicer.write(new Buffer("blah\n"), 0, 5, 0, function() {
        if (err) return done(err);
        fs.close(fd, done);
      });
    });
  });
});

describe("BufferSlicer", function() {
  it("invalid ref", function() {
    var slicer = fdSlicer.createFromBuffer(new Buffer(16));
    slicer.ref();
    slicer.unref();
    assert.throws(function() {
      slicer.unref();
    }, /invalid unref/);
  });
  it("read and write", function(done) {
    var buf = new Buffer("through the tangled thread the needle finds its way");
    var slicer = fdSlicer.createFromBuffer(buf);
    var outBuf = new Buffer(1024);
    slicer.read(outBuf, 10, 11, 8, function(err) {
      if (err) return done(err);
      assert.strictEqual(outBuf.toString('utf8', 10, 21), "the tangled");
      slicer.write(new Buffer("derp"), 0, 4, 7, function(err) {
        if (err) return done(err);
        assert.strictEqual(buf.toString('utf8', 7, 19), "derp tangled");
        done();
      });
    });
  });
  it("createReadStream", function(done) {
    var str = "I never conquered rarely came, 16 just held such better days";
    var buf = new Buffer(str);
    var slicer = fdSlicer.createFromBuffer(buf);
    var inStream = slicer.createReadStream();
    var sink = new StreamSink();
    inStream.pipe(sink);
    sink.on('finish', function() {
      assert.strictEqual(sink.toString(), str);
      inStream.destroy();
      done();
    });
  });
  it("createWriteStream exceed buffer size", function(done) {
    var slicer = fdSlicer.createFromBuffer(new Buffer(4));
    var outStream = slicer.createWriteStream();
    outStream.on('error', function(err) {
      assert.strictEqual(err.code, 'ETOOBIG');
      done();
    });
    outStream.write("hi!\n");
    outStream.write("it warked\n");
    outStream.end();
  });
  it("createWriteStream ok", function(done) {
    var buf = new Buffer(1024);
    var slicer = fdSlicer.createFromBuffer(buf);
    var outStream = slicer.createWriteStream();
    outStream.on('finish', function() {
      assert.strictEqual(buf.toString('utf8', 0, "hi!\nit warked\n".length), "hi!\nit warked\n");
      outStream.destroy();
      done();
    });
    outStream.write("hi!\n");
    outStream.write("it warked\n");
    outStream.end();
  });
});


1			var fdSlicer = require('../');
2			var fs = require('fs');
3			var crypto = require('crypto');
4			var path = require('path');
5			var streamEqual = require('stream-equal');
6			var assert = require('assert');
7			var Pend = require('pend');
8			var StreamSink = require('streamsink');
9
10			var describe = global.describe;
11			var it = global.it;
12			var before = global.before;
13			var beforeEach = global.beforeEach;
14			var after = global.after;
15
16			var testBlobFile = path.join(__dirname, "test-blob.bin");
17			var testBlobFileSize = 20 * 1024 * 1024;
18			var testOutBlobFile = path.join(__dirname, "test-blob-out.bin");
19
20			describe("FdSlicer", function() {
21			before(function(done) {
22			var out = fs.createWriteStream(testBlobFile);
23			for (var i = 0; i < testBlobFileSize / 1024; i += 1) {
24			out.write(crypto.pseudoRandomBytes(1024));
25			}
26			out.end();
27			out.on('close', done);
28			});
29			beforeEach(function() {
30			try {
31			fs.unlinkSync(testOutBlobFile);
32			} catch (err) {
33			}
34			});
35			after(function() {
36			try {
37			fs.unlinkSync(testBlobFile);
38			fs.unlinkSync(testOutBlobFile);
39			} catch (err) {
40			}
41			});
42			it("reads a 20MB file (autoClose on)", function(done) {
43			fs.open(testBlobFile, 'r', function(err, fd) {
44			if (err) return done(err);
45			var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
46			var actualStream = slicer.createReadStream();
47			var expectedStream = fs.createReadStream(testBlobFile);
48
49			var pend = new Pend();
50			pend.go(function(cb) {
51			slicer.on('close', cb);
52			});
53			pend.go(function(cb) {
54			streamEqual(expectedStream, actualStream, function(err, equal) {
55			if (err) return done(err);
56			assert.ok(equal);
57			cb();
58			});
59			});
60			pend.wait(done);
61			});
62			});
63			it("reads 4 chunks simultaneously", function(done) {
64			fs.open(testBlobFile, 'r', function(err, fd) {
65			if (err) return done(err);
66			var slicer = fdSlicer.createFromFd(fd);
67			var actualPart1 = slicer.createReadStream({start: testBlobFileSize * 0/4, end: testBlobFileSize * 1/4});
68			var actualPart2 = slicer.createReadStream({start: testBlobFileSize * 1/4, end: testBlobFileSize * 2/4});
69			var actualPart3 = slicer.createReadStream({start: testBlobFileSize * 2/4, end: testBlobFileSize * 3/4});
70			var actualPart4 = slicer.createReadStream({start: testBlobFileSize * 3/4, end: testBlobFileSize * 4/4});
71			var expectedPart1 = slicer.createReadStream({start: testBlobFileSize * 0/4, end: testBlobFileSize * 1/4});
72			var expectedPart2 = slicer.createReadStream({start: testBlobFileSize * 1/4, end: testBlobFileSize * 2/4});
73			var expectedPart3 = slicer.createReadStream({start: testBlobFileSize * 2/4, end: testBlobFileSize * 3/4});
74			var expectedPart4 = slicer.createReadStream({start: testBlobFileSize * 3/4, end: testBlobFileSize * 4/4});
75			var pend = new Pend();
76			pend.go(function(cb) {
77			streamEqual(expectedPart1, actualPart1, function(err, equal) {
78			assert.ok(equal);
79			cb(err);
80			});
81			});
82			pend.go(function(cb) {
83			streamEqual(expectedPart2, actualPart2, function(err, equal) {
84			assert.ok(equal);
85			cb(err);
86			});
87			});
88			pend.go(function(cb) {
89			streamEqual(expectedPart3, actualPart3, function(err, equal) {
90			assert.ok(equal);
91			cb(err);
92			});
93			});
94			pend.go(function(cb) {
95			streamEqual(expectedPart4, actualPart4, function(err, equal) {
96			assert.ok(equal);
97			cb(err);
98			});
99			});
100			pend.wait(function(err) {
101			if (err) return done(err);
102			fs.close(fd, done);
103			});
104			});
105			});
106
107			it("writes a 20MB file (autoClose on)", function(done) {
108			fs.open(testOutBlobFile, 'w', function(err, fd) {
109			if (err) return done(err);
110			var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
111			var actualStream = slicer.createWriteStream();
112			var inStream = fs.createReadStream(testBlobFile);
113
114			slicer.on('close', function() {
115			var expected = fs.createReadStream(testBlobFile);
116			var actual = fs.createReadStream(testOutBlobFile);
117
118			streamEqual(expected, actual, function(err, equal) {
119			if (err) return done(err);
120			assert.ok(equal);
121			done();
122			});
123			});
124			inStream.pipe(actualStream);
125			});
126			});
127
128			it("writes 4 chunks simultaneously", function(done) {
129			fs.open(testOutBlobFile, 'w', function(err, fd) {
130			if (err) return done(err);
131			var slicer = fdSlicer.createFromFd(fd);
132			var actualPart1 = slicer.createWriteStream({start: testBlobFileSize * 0/4});
133			var actualPart2 = slicer.createWriteStream({start: testBlobFileSize * 1/4});
134			var actualPart3 = slicer.createWriteStream({start: testBlobFileSize * 2/4});
135			var actualPart4 = slicer.createWriteStream({start: testBlobFileSize * 3/4});
136			var in1 = fs.createReadStream(testBlobFile, {start: testBlobFileSize * 0/4, end: testBlobFileSize * 1/4});
137			var in2 = fs.createReadStream(testBlobFile, {start: testBlobFileSize * 1/4, end: testBlobFileSize * 2/4});
138			var in3 = fs.createReadStream(testBlobFile, {start: testBlobFileSize * 2/4, end: testBlobFileSize * 3/4});
139			var in4 = fs.createReadStream(testBlobFile, {start: testBlobFileSize * 3/4, end: testBlobFileSize * 4/4});
140			var pend = new Pend();
141			pend.go(function(cb) {
142			actualPart1.on('finish', cb);
143			});
144			pend.go(function(cb) {
145			actualPart2.on('finish', cb);
146			});
147			pend.go(function(cb) {
148			actualPart3.on('finish', cb);
149			});
150			pend.go(function(cb) {
151			actualPart4.on('finish', cb);
152			});
153			in1.pipe(actualPart1);
154			in2.pipe(actualPart2);
155			in3.pipe(actualPart3);
156			in4.pipe(actualPart4);
157			pend.wait(function() {
158			fs.close(fd, function(err) {
159			if (err) return done(err);
160			var expected = fs.createReadStream(testBlobFile);
161			var actual = fs.createReadStream(testOutBlobFile);
162			streamEqual(expected, actual, function(err, equal) {
163			if (err) return done(err);
164			assert.ok(equal);
165			done();
166			});
167			});
168			});
169			});
170			});
171
172			it("throws on invalid ref", function(done) {
173			fs.open(testOutBlobFile, 'w', function(err, fd) {
174			if (err) return done(err);
175			var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
176			assert.throws(function() {
177			slicer.unref();
178			}, /invalid unref/);
179			fs.close(fd, done);
180			});
181			});
182
183			it("write stream emits error when max size exceeded", function(done) {
184			fs.open(testOutBlobFile, 'w', function(err, fd) {
185			if (err) return done(err);
186			var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
187			var ws = slicer.createWriteStream({start: 0, end: 1000});
188			ws.on('error', function(err) {
189			assert.strictEqual(err.code, 'ETOOBIG');
190			slicer.on('close', done);
191			});
192			ws.end(new Buffer(1001));
193			});
194			});
195
196			it("write stream does not emit error when max size not exceeded", function(done) {
197			fs.open(testOutBlobFile, 'w', function(err, fd) {
198			if (err) return done(err);
199			var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
200			var ws = slicer.createWriteStream({end: 1000});
201			slicer.on('close', done);
202			ws.end(new Buffer(1000));
203			});
204			});
205
206			it("write stream start and end work together", function(done) {
207			fs.open(testOutBlobFile, 'w', function(err, fd) {
208			if (err) return done(err);
209			var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
210			var ws = slicer.createWriteStream({start: 1, end: 1000});
211			ws.on('error', function(err) {
212			assert.strictEqual(err.code, 'ETOOBIG');
213			slicer.on('close', done);
214			});
215			ws.end(new Buffer(1000));
216			});
217			});
218
219			it("write stream emits progress events", function(done) {
220			fs.open(testOutBlobFile, 'w', function(err, fd) {
221			if (err) return done(err);
222			var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
223			var ws = slicer.createWriteStream();
224			var progressEventCount = 0;
225			var prevBytesWritten = 0;
226			ws.on('progress', function() {
227			progressEventCount += 1;
228			assert.ok(ws.bytesWritten > prevBytesWritten);
229			prevBytesWritten = ws.bytesWritten;
230			});
231			slicer.on('close', function() {
232			assert.ok(progressEventCount > 5);
233			done();
234			});
235			for (var i = 0; i < 10; i += 1) {
236			ws.write(new Buffer(16 * 1024 * 2));
237			}
238			ws.end();
239			});
240			});
241
242			it("write stream unrefs when destroyed", function(done) {
243			fs.open(testOutBlobFile, 'w', function(err, fd) {
244			if (err) return done(err);
245			var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
246			var ws = slicer.createWriteStream();
247			slicer.on('close', done);
248			ws.write(new Buffer(1000));
249			ws.destroy();
250			});
251			});
252
253			it("read stream unrefs when destroyed", function(done) {
254			fs.open(testBlobFile, 'r', function(err, fd) {
255			if (err) return done(err);
256			var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
257			var rs = slicer.createReadStream();
258			rs.on('error', function(err) {
259			assert.strictEqual(err.message, "stream destroyed");
260			slicer.on('close', done);
261			});
262			rs.destroy();
263			});
264			});
265
266			it("fdSlicer.read", function(done) {
267			fs.open(testBlobFile, 'r', function(err, fd) {
268			if (err) return done(err);
269			var slicer = fdSlicer.createFromFd(fd);
270			var outBuf = new Buffer(1024);
271			slicer.read(outBuf, 0, 10, 0, function(err, bytesRead, buf) {
272			assert.strictEqual(bytesRead, 10);
273			fs.close(fd, done);
274			});
275			});
276			});
277
278			it("fdSlicer.write", function(done) {
279			fs.open(testOutBlobFile, 'w', function(err, fd) {
280			if (err) return done(err);
281			var slicer = fdSlicer.createFromFd(fd);
282			slicer.write(new Buffer("blah\n"), 0, 5, 0, function() {
283			if (err) return done(err);
284			fs.close(fd, done);
285			});
286			});
287			});
288			});
289
290			describe("BufferSlicer", function() {
291			it("invalid ref", function() {
292			var slicer = fdSlicer.createFromBuffer(new Buffer(16));
293			slicer.ref();
294			slicer.unref();
295			assert.throws(function() {
296			slicer.unref();
297			}, /invalid unref/);
298			});
299			it("read and write", function(done) {
300			var buf = new Buffer("through the tangled thread the needle finds its way");
301			var slicer = fdSlicer.createFromBuffer(buf);
302			var outBuf = new Buffer(1024);
303			slicer.read(outBuf, 10, 11, 8, function(err) {
304			if (err) return done(err);
305			assert.strictEqual(outBuf.toString('utf8', 10, 21), "the tangled");
306			slicer.write(new Buffer("derp"), 0, 4, 7, function(err) {
307			if (err) return done(err);
308			assert.strictEqual(buf.toString('utf8', 7, 19), "derp tangled");
309			done();
310			});
311			});
312			});
313			it("createReadStream", function(done) {
314			var str = "I never conquered rarely came, 16 just held such better days";
315			var buf = new Buffer(str);
316			var slicer = fdSlicer.createFromBuffer(buf);
317			var inStream = slicer.createReadStream();
318			var sink = new StreamSink();
319			inStream.pipe(sink);
320			sink.on('finish', function() {
321			assert.strictEqual(sink.toString(), str);
322			inStream.destroy();
323			done();
324			});
325			});
326			it("createWriteStream exceed buffer size", function(done) {
327			var slicer = fdSlicer.createFromBuffer(new Buffer(4));
328			var outStream = slicer.createWriteStream();
329			outStream.on('error', function(err) {
330			assert.strictEqual(err.code, 'ETOOBIG');
331			done();
332			});
333			outStream.write("hi!\n");
334			outStream.write("it warked\n");
335			outStream.end();
336			});
337			it("createWriteStream ok", function(done) {
338			var buf = new Buffer(1024);
339			var slicer = fdSlicer.createFromBuffer(buf);
340			var outStream = slicer.createWriteStream();
341			outStream.on('finish', function() {
342			assert.strictEqual(buf.toString('utf8', 0, "hi!\nit warked\n".length), "hi!\nit warked\n");
343			outStream.destroy();
344			done();
345			});
346			outStream.write("hi!\n");
347			outStream.write("it warked\n");
348			outStream.end();
349			});
350			});
351

LCSOGthb / Tools

Push — main ( 10dbfc...61a674 )

node_modules/fd-slicer/test/test.js F

Complexity

Size

Duplication

Importance

How to fix Complexity

Complexity

Duplication Side-by-Side

Filter issues like