64bit-from-scratch.js ➔ ... ➔ it(ꞌsamples_ should be the same as the argsꞌ) - Code Metrics - Inspection of "create wave files from scratch" - rochars/wavefile - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — master (4064de)

by Rafael S.

created 2017-11-17 19:39 UTC

sꞌ) A

↳ Parent: 64bit-from-scratch.js ➔ describe(ꞌcreate 64-bit wave file from scratchꞌ)

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	3
Ratio	100 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
c	1
b	0
f	0
nc	1
nop	0
dl	3
loc	3
rs	10

/*!
 * riffwave64
 * Read & write wave files with 8, 16, 24, 32 PCM, 32 IEEE & 64-bit data.
 * Copyright (c) 2017 Rafael da Silva Rocha.
 * https://github.com/rochars/riffwave64
 * https://tr2099.github.io
 *
 */
 
var assert = require('assert');


describe('create 64-bit wave file from scratch', function() {
    
    let wavefile = require('../../index.js');
    let wav = new wavefile.WaveFile();
    wav.fromScratch(1, 44100, '64', [0.0, 0.04029440055111987, -0.04029440055111987, 1.0]);

    let fs = require('fs');
    fs.writeFileSync("./test/files/out/64-bit-441kHz-mono-fromScratch.wav", wav.toBytes());

    it('chunkId should be "RIFF"', function() {
        assert.equal(wav.chunkId, "RIFF");
    });

    it('format should be "WAVE"', function() {
        assert.equal(wav.format, "WAVE");
    });

    it('subChunk1Id should be "fmt "', function() {
        assert.equal(wav.subChunk1Id, "fmt ");
    });

    it('subChunk1Size should be 16', function() {
        assert.equal(wav.subChunk1Size, 16);
    });

    it('audioFormat should be 3', function() {
        assert.equal(wav.audioFormat, 3);
    });

    it('numChannels should be 1', function() {
        assert.equal(wav.numChannels, 1);
    });

    it('sampleRate should be 44100', function() {
        assert.equal(wav.sampleRate, 44100);
    });

    it('byteRate should be 176400', function() {
        assert.equal(wav.byteRate, 352800);
    });

    it('blockAlign should be 4', function() {
        assert.equal(wav.blockAlign, 8);
    });

    it('bitsPerSample should be 32', function() {
        assert.equal(wav.bitsPerSample, 64);
    });

    it('subChunk2Id should be "data"', function() {
        assert.equal(wav.subChunk2Id, "data");
    });

    it('subChunk2Size should be 16', function() {
        assert.equal(wav.subChunk2Size, 32);
    });

    it('samples_ should be the same as the args', function() {
        assert.deepEqual(wav.samples_, [0.0, 0.04029440055111987, -0.04029440055111987, 1.0]);
    });

    it('bitDepth_ should be "24"', function() {
        assert.equal(wav.bitDepth_, "64");
    });

    /*
    it('should return a wave file with 64-bit audio', function() {
        let wav = rw64.writeWavBytes(1, 48000, '64',
            [0.0, 0.04029440055111987, -0.04029440055111987, 1.0]);
        let wavRead = rw64.readWavBytes(wav);

        assert.equal(wavRead.audioFormat, 3);
        assert.equal(wavRead.numChannels, 1);
        assert.equal(wavRead.sampleRate, 48000);
        assert.equal(wavRead.blockAlign, 8);
        assert.equal(wavRead.bitsPerSample, 64);
        assert.deepEqual(wavRead.samples,
            [0.0, 0.04029440055111987, -0.04029440055111987, 1.0]);
    });

    it('should return a wave file with 64-bit ' +
        'audio and a odd number of samples',
            function() {
        let wav = rw64.writeWavBytes(1, 48000, '64',
            [0.0, 0.04029440055111987, -0.04029440055111987, 1.0, 1]);
        let wavRead = rw64.readWavBytes(wav);

        assert.equal(wavRead.audioFormat, 3);
        assert.equal(wavRead.numChannels, 1);
        assert.equal(wavRead.sampleRate, 48000);
        assert.equal(wavRead.blockAlign, 8);
        assert.equal(wavRead.bitsPerSample, 64);
        assert.deepEqual(wavRead.samples,
            [0.0, 0.04029440055111987, -0.04029440055111987, 1, 1]);
    });

    it('check rouding for double values on read/write',
            function() {
        let wav = rw64.writeWavBytes(1, 48000, '64',
            [3.141592653589793]);
        let wavRead = rw64.readWavBytes(wav);
        
        assert.ok(wavRead.samples[0] ==
            3.141592653589793);

    });

    it('check rouding for double values on read/write (forced change)',
        function() {
        let wav = rw64.writeWavBytes(1, 48000, '64',
            [3.141592653589793]);
        let wavRead = rw64.readWavBytes(wav);
        
        assert.ok(wavRead.samples[0] !=
            3.141592653589792);
    });

    it('should return a wave file with 64-bit audio on max and min range',
            function() {
        let wav = rw64.writeWavBytes(1, 48000, '64', [0,1,0,-1]);
        let wavRead = rw64.readWavBytes(wav);

        assert.equal(wavRead.audioFormat, 3);
        assert.equal(wavRead.numChannels, 1);
        assert.equal(wavRead.sampleRate, 48000);
        assert.equal(wavRead.blockAlign, 8);
        assert.equal(wavRead.bitsPerSample, 64);
        assert.deepEqual(wavRead.samples, [0,1,0,-1]);
    });

    it('should return another wave file with 64-bit audio', function() {
        let wav = rw64.writeWavBytes(1, 48000, '64',
            [0.0, 0.99999999999999999, -0.00000000000000001, 1]);
        let wavRead = rw64.readWavBytes(wav);

        assert.equal(wavRead.audioFormat, 3);
        assert.equal(wavRead.numChannels, 1);
        assert.equal(wavRead.sampleRate, 48000);
        assert.equal(wavRead.blockAlign, 8);
        assert.equal(wavRead.bitsPerSample, 64);
        assert.deepEqual(wavRead.samples,
            [0, 0.99999999999999999, -0.00000000000000001, 1]);
    });

    it('should return one more wave file with 64-bit audio', function() {
        let wav = rw64.writeWavBytes(1, 48000, '64',
            [0, 1, 1, -1, 0, -1, 0.99999999999999999,
            -0.00000000000000001, 1]);
        let wavRead = rw64.readWavBytes(wav);

        assert.equal(wavRead.audioFormat, 3);
        assert.equal(wavRead.numChannels, 1);
        assert.equal(wavRead.sampleRate, 48000);
        assert.equal(wavRead.blockAlign, 8);
        assert.equal(wavRead.bitsPerSample, 64);
        assert.deepEqual(wavRead.samples,
            [0, 1, 1, -1, 0, -1, 0.99999999999999999,
            -0.00000000000000001, 1]);
    });

    it('should return a 64-bit wave file encoded as a base 64 string',
            function() {
        assert.ok(rw64.writeWavBase64(1, 48000, '64',
            [0, 0.5, -0.5]));
    });

    it('should return a 64-bit wave file encoded as a Data URI',
            function() {
        assert.ok(rw64.writeWavDataURI(1, 48000, '64',
            [0, 0.5, -0.5]));
    });

    it('should return another 64-bit wave file encoded as a Data URI',
            function() {
        assert.ok(rw64.writeWavDataURI(1, 48000, '64',
            [0, 1, -1, 0, 1]));
    });

    it('should write a 64-bit stereo wav file', function() {
        let channels = [
            [0,1,-1],
            [0,1,-1]
        ];
        let samples = rw64.interleave(channels);
        let wav = rw64.writeWavBytes(2, 44100, '64', samples);
        let read = rw64.readWavBytes(wav);
        
        assert.equal(read.subChunk1Size, 16);
        assert.equal(read.audioFormat, 3);
        assert.equal(read.numChannels, 2);
        assert.equal(read.sampleRate, 44100);
        assert.equal(read.blockAlign, 16);
        assert.equal(read.bitsPerSample, 64);
    });

    it('should return a 64-bit wave file with non-negative 0',
            function() {
        let wav = rw64.writeWavBytes(1, 48000, '64', [0, 1, -1, -0, 1]);
        let wavRead = rw64.readWavBytes(wav);
        assert.equal(wavRead.audioFormat, 3);
        assert.equal(wavRead.numChannels, 1);
        assert.equal(wavRead.sampleRate, 48000);
        assert.equal(wavRead.blockAlign, 8);
        assert.equal(wavRead.bitsPerSample, 64);
        assert.deepEqual(wavRead.samples, [0, 1, -1, 0, 1]);
    });
    */
});


1		/*!
2		* riffwave64
3		* Read & write wave files with 8, 16, 24, 32 PCM, 32 IEEE & 64-bit data.
4		* Copyright (c) 2017 Rafael da Silva Rocha.
5		* https://github.com/rochars/riffwave64
6		* https://tr2099.github.io
7		*
8		*/
9
10	View Code Duplication	var assert = require('assert');
		0 ignored issues – show Duplication introduced 2017-11-17 19:40 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
11
12		describe('create 64-bit wave file from scratch', function() {
13
14		let wavefile = require('../../index.js');
15		let wav = new wavefile.WaveFile();
16		wav.fromScratch(1, 44100, '64', [0.0, 0.04029440055111987, -0.04029440055111987, 1.0]);
17
18		let fs = require('fs');
19		fs.writeFileSync("./test/files/out/64-bit-441kHz-mono-fromScratch.wav", wav.toBytes());
20
21		it('chunkId should be "RIFF"', function() {
22		assert.equal(wav.chunkId, "RIFF");
23		});
24
25		it('format should be "WAVE"', function() {
26		assert.equal(wav.format, "WAVE");
27		});
28
29		it('subChunk1Id should be "fmt "', function() {
30		assert.equal(wav.subChunk1Id, "fmt ");
31		});
32
33		it('subChunk1Size should be 16', function() {
34		assert.equal(wav.subChunk1Size, 16);
35		});
36
37		it('audioFormat should be 3', function() {
38		assert.equal(wav.audioFormat, 3);
39		});
40
41		it('numChannels should be 1', function() {
42		assert.equal(wav.numChannels, 1);
43		});
44
45		it('sampleRate should be 44100', function() {
46		assert.equal(wav.sampleRate, 44100);
47		});
48
49		it('byteRate should be 176400', function() {
50		assert.equal(wav.byteRate, 352800);
51		});
52
53		it('blockAlign should be 4', function() {
54		assert.equal(wav.blockAlign, 8);
55		});
56
57		it('bitsPerSample should be 32', function() {
58		assert.equal(wav.bitsPerSample, 64);
59		});
60
61		it('subChunk2Id should be "data"', function() {
62		assert.equal(wav.subChunk2Id, "data");
63		});
64
65		it('subChunk2Size should be 16', function() {
66		assert.equal(wav.subChunk2Size, 32);
67		});
68
69		it('samples_ should be the same as the args', function() {
70		assert.deepEqual(wav.samples_, [0.0, 0.04029440055111987, -0.04029440055111987, 1.0]);
71		});
72
73		it('bitDepth_ should be "24"', function() {
74		assert.equal(wav.bitDepth_, "64");
75		});
76
77		/*
78		it('should return a wave file with 64-bit audio', function() {
79		let wav = rw64.writeWavBytes(1, 48000, '64',
80		[0.0, 0.04029440055111987, -0.04029440055111987, 1.0]);
81		let wavRead = rw64.readWavBytes(wav);
82
83		assert.equal(wavRead.audioFormat, 3);
84		assert.equal(wavRead.numChannels, 1);
85		assert.equal(wavRead.sampleRate, 48000);
86		assert.equal(wavRead.blockAlign, 8);
87		assert.equal(wavRead.bitsPerSample, 64);
88		assert.deepEqual(wavRead.samples,
89		[0.0, 0.04029440055111987, -0.04029440055111987, 1.0]);
90		});
91
92		it('should return a wave file with 64-bit ' +
93		'audio and a odd number of samples',
94		function() {
95		let wav = rw64.writeWavBytes(1, 48000, '64',
96		[0.0, 0.04029440055111987, -0.04029440055111987, 1.0, 1]);
97		let wavRead = rw64.readWavBytes(wav);
98
99		assert.equal(wavRead.audioFormat, 3);
100		assert.equal(wavRead.numChannels, 1);
101		assert.equal(wavRead.sampleRate, 48000);
102		assert.equal(wavRead.blockAlign, 8);
103		assert.equal(wavRead.bitsPerSample, 64);
104		assert.deepEqual(wavRead.samples,
105		[0.0, 0.04029440055111987, -0.04029440055111987, 1, 1]);
106		});
107
108		it('check rouding for double values on read/write',
109		function() {
110		let wav = rw64.writeWavBytes(1, 48000, '64',
111		[3.141592653589793]);
112		let wavRead = rw64.readWavBytes(wav);
113
114		assert.ok(wavRead.samples[0] ==
115		3.141592653589793);
116
117		});
118
119		it('check rouding for double values on read/write (forced change)',
120		function() {
121		let wav = rw64.writeWavBytes(1, 48000, '64',
122		[3.141592653589793]);
123		let wavRead = rw64.readWavBytes(wav);
124
125		assert.ok(wavRead.samples[0] !=
126		3.141592653589792);
127		});
128
129		it('should return a wave file with 64-bit audio on max and min range',
130		function() {
131		let wav = rw64.writeWavBytes(1, 48000, '64', [0,1,0,-1]);
132		let wavRead = rw64.readWavBytes(wav);
133
134		assert.equal(wavRead.audioFormat, 3);
135		assert.equal(wavRead.numChannels, 1);
136		assert.equal(wavRead.sampleRate, 48000);
137		assert.equal(wavRead.blockAlign, 8);
138		assert.equal(wavRead.bitsPerSample, 64);
139		assert.deepEqual(wavRead.samples, [0,1,0,-1]);
140		});
141
142		it('should return another wave file with 64-bit audio', function() {
143		let wav = rw64.writeWavBytes(1, 48000, '64',
144		[0.0, 0.99999999999999999, -0.00000000000000001, 1]);
145		let wavRead = rw64.readWavBytes(wav);
146
147		assert.equal(wavRead.audioFormat, 3);
148		assert.equal(wavRead.numChannels, 1);
149		assert.equal(wavRead.sampleRate, 48000);
150		assert.equal(wavRead.blockAlign, 8);
151		assert.equal(wavRead.bitsPerSample, 64);
152		assert.deepEqual(wavRead.samples,
153		[0, 0.99999999999999999, -0.00000000000000001, 1]);
154		});
155
156		it('should return one more wave file with 64-bit audio', function() {
157		let wav = rw64.writeWavBytes(1, 48000, '64',
158		[0, 1, 1, -1, 0, -1, 0.99999999999999999,
159		-0.00000000000000001, 1]);
160		let wavRead = rw64.readWavBytes(wav);
161
162		assert.equal(wavRead.audioFormat, 3);
163		assert.equal(wavRead.numChannels, 1);
164		assert.equal(wavRead.sampleRate, 48000);
165		assert.equal(wavRead.blockAlign, 8);
166		assert.equal(wavRead.bitsPerSample, 64);
167		assert.deepEqual(wavRead.samples,
168		[0, 1, 1, -1, 0, -1, 0.99999999999999999,
169		-0.00000000000000001, 1]);
170		});
171
172		it('should return a 64-bit wave file encoded as a base 64 string',
173		function() {
174		assert.ok(rw64.writeWavBase64(1, 48000, '64',
175		[0, 0.5, -0.5]));
176		});
177
178		it('should return a 64-bit wave file encoded as a Data URI',
179		function() {
180		assert.ok(rw64.writeWavDataURI(1, 48000, '64',
181		[0, 0.5, -0.5]));
182		});
183
184		it('should return another 64-bit wave file encoded as a Data URI',
185		function() {
186		assert.ok(rw64.writeWavDataURI(1, 48000, '64',
187		[0, 1, -1, 0, 1]));
188		});
189
190		it('should write a 64-bit stereo wav file', function() {
191		let channels = [
192		[0,1,-1],
193		[0,1,-1]
194		];
195		let samples = rw64.interleave(channels);
196		let wav = rw64.writeWavBytes(2, 44100, '64', samples);
197		let read = rw64.readWavBytes(wav);
198
199		assert.equal(read.subChunk1Size, 16);
200		assert.equal(read.audioFormat, 3);
201		assert.equal(read.numChannels, 2);
202		assert.equal(read.sampleRate, 44100);
203		assert.equal(read.blockAlign, 16);
204		assert.equal(read.bitsPerSample, 64);
205		});
206
207		it('should return a 64-bit wave file with non-negative 0',
208		function() {
209		let wav = rw64.writeWavBytes(1, 48000, '64', [0, 1, -1, -0, 1]);
210		let wavRead = rw64.readWavBytes(wav);
211		assert.equal(wavRead.audioFormat, 3);
212		assert.equal(wavRead.numChannels, 1);
213		assert.equal(wavRead.sampleRate, 48000);
214		assert.equal(wavRead.blockAlign, 8);
215		assert.equal(wavRead.bitsPerSample, 64);
216		assert.deepEqual(wavRead.samples, [0, 1, -1, 0, 1]);
217		});
218		*/
219		});
220

rochars / wavefile

Branch — master (4064de)

sꞌ) A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like