passes: 312
failures: 0
duration: 0.30s

API properties
- should create a WaveFile object0ms ‣
```
assert.ok(wav);
```
- should have a fmt chunk property1ms ‣
```
assert.ok(wav.fmt);
```
- should have a fact chunk property0ms ‣
```
assert.ok(wav.fact);
```
- should have a cue chunk property0ms ‣
```
assert.ok(wav.cue);
```
- should have a smpl chunk property0ms ‣
```
assert.ok(wav.smpl);
```
- should have a bext chunk property0ms ‣
```
assert.ok(wav.bext);
```
- should have a ds64 chunk property0ms ‣
```
assert.ok(wav.ds64);
```
- should have a data chunk property0ms ‣
```
assert.ok(wav.data);
```
- should have a LIST chunk property0ms ‣
```
assert.ok(wav.LIST);
```
- should have a junk chunk property0ms ‣
```
assert.ok(wav.junk);
```

API Methods

should return a Uint8Array0ms ‣

wav.fromScratch(1, 8000, '8', [0,0], {container: 'RIFX'});
var buffer = wav.toBuffer();
assert.equal(
	buffer.constructor,
	new Uint8Array().constructor);

create a 8-bit wave file from scratch

chunkId should be "RIFF"0ms ‣
```
assert.equal(wav.container, "RIFF");
```
format should be "WAVE"0ms ‣
```
assert.equal(wav.format, "WAVE");
```
fmtChunkId should be "fmt "0ms ‣
```
assert.equal(wav.fmt.chunkId, "fmt ");
```
fmtChunkSize should be 161ms ‣
```
assert.equal(wav.fmt.chunkSize, 16);
```
audioFormat should be 10ms ‣
```
assert.equal(wav.fmt.audioFormat, 1);
```
numChannels should be 10ms ‣
```
assert.equal(wav.fmt.numChannels, 1);
```

sampleRate should be 480000ms ‣

assert.equal(wav.fmt.sampleRate, 48000);

byteRate should be 480000ms ‣
```
assert.equal(wav.fmt.byteRate, 48000);
```
blockAlign should be 10ms ‣
```
assert.equal(wav.fmt.blockAlign, 1);
```
bitsPerSample should be 80ms ‣
```
assert.equal(wav.fmt.bitsPerSample, 8);
```
dataChunkId should be "data"0ms ‣
```
assert.equal(wav.data.chunkId, "data");
```
dataChunkSize should be 40ms ‣
```
assert.equal(wav.data.chunkSize, 4);
```
bitDepth should be "8"0ms ‣
```
assert.equal(wav.bitDepth, "8");
```

create a 16-bit wave file from scratch

chunkId should be "RIFF"0ms ‣
```
assert.equal(wav.container, "RIFF");
```
format should be "WAVE"0ms ‣
```
assert.equal(wav.format, "WAVE");
```
fmtChunkId should be "fmt "0ms ‣
```
assert.equal(wav.fmt.chunkId, "fmt ");
```
fmtChunkSize should be 160ms ‣
```
assert.equal(wav.fmt.chunkSize, 16);
```
audioFormat should be 10ms ‣
```
assert.equal(wav.fmt.audioFormat, 1);
```
numChannels should be 10ms ‣
```
assert.equal(wav.fmt.numChannels, 1);
```

sampleRate should be 480000ms ‣

assert.equal(wav.fmt.sampleRate, 48000);

byteRate should be 960000ms ‣
```
assert.equal(wav.fmt.byteRate, 96000);
```
blockAlign should be 20ms ‣
```
assert.equal(wav.fmt.blockAlign, 2);
```

bitsPerSample should be 160ms ‣

assert.equal(wav.fmt.bitsPerSample, 16);

dataChunkId should be "data"0ms ‣
```
assert.equal(wav.data.chunkId, "data");
```
dataChunkSize should be 80ms ‣
```
assert.equal(wav.data.chunkSize, 8);
```
bitDepth should be "16"0ms ‣
```
assert.equal(wav.bitDepth, "16");
```

create a 24-bit wave file from scratch

chunkId should be "RIFF"0ms ‣
```
assert.equal(wav.container, "RIFF");
```
format should be "WAVE"0ms ‣
```
assert.equal(wav.format, "WAVE");
```
fmtChunkId should be "fmt "0ms ‣
```
assert.equal(wav.fmt.chunkId, "fmt ");
```
fmtChunkSize should be 160ms ‣
```
assert.equal(wav.fmt.chunkSize, 16);
```
audioFormat should be 10ms ‣
```
assert.equal(wav.fmt.audioFormat, 1);
```
numChannels should be 10ms ‣
```
assert.equal(wav.fmt.numChannels, 1);
```

sampleRate should be 480000ms ‣

assert.equal(wav.fmt.sampleRate, 48000);

byteRate should be 1440000ms ‣
```
assert.equal(wav.fmt.byteRate, 144000);
```
blockAlign should be 30ms ‣
```
assert.equal(wav.fmt.blockAlign, 3);
```

bitsPerSample should be 241ms ‣

assert.equal(wav.fmt.bitsPerSample, 24);

dataChunkId should be "data"0ms ‣
```
assert.equal(wav.data.chunkId, "data");
```
dataChunkSize should be 120ms ‣
```
assert.equal(wav.data.chunkSize, 12);
```
bitDepth should be "24"0ms ‣
```
assert.equal(wav.bitDepth, "24");
```

create a 32-bit wave file from scratch

chunkId should be "RIFF"0ms ‣
```
assert.equal(wav.container, "RIFF");
```
format should be "WAVE"0ms ‣
```
assert.equal(wav.format, "WAVE");
```
fmtChunkId should be "fmt "0ms ‣
```
assert.equal(wav.fmt.chunkId, "fmt ");
```
fmtChunkSize should be 160ms ‣
```
assert.equal(wav.fmt.chunkSize, 16);
```
audioFormat should be 10ms ‣
```
assert.equal(wav.fmt.audioFormat, 1);
```
numChannels should be 10ms ‣
```
assert.equal(wav.fmt.numChannels, 1);
```

sampleRate should be 441000ms ‣

assert.equal(wav.fmt.sampleRate, 44100);

byteRate should be 1764000ms ‣
```
assert.equal(wav.fmt.byteRate, 176400);
```
blockAlign should be 40ms ‣
```
assert.equal(wav.fmt.blockAlign, 4);
```

bitsPerSample should be 320ms ‣

assert.equal(wav.fmt.bitsPerSample, 32);

dataChunkId should be "data"0ms ‣
```
assert.equal(wav.data.chunkId, "data");
```
dataChunkSize should be 160ms ‣
```
assert.equal(wav.data.chunkSize, 16);
```
bitDepth should be "24"0ms ‣
```
assert.equal(wav.bitDepth, "32");
```

create a 32-bit FP wave file from scratch

chunkId should be "RIFF"0ms ‣
```
assert.equal(wav.container, "RIFF");
```
format should be "WAVE"0ms ‣
```
assert.equal(wav.format, "WAVE");
```
fmtChunkId should be "fmt "1ms ‣
```
assert.equal(wav.fmt.chunkId, "fmt ");
```
fmtChunkSize should be 160ms ‣
```
assert.equal(wav.fmt.chunkSize, 16);
```
audioFormat should be 30ms ‣
```
assert.equal(wav.fmt.audioFormat, 3);
```
numChannels should be 10ms ‣
```
assert.equal(wav.fmt.numChannels, 1);
```

sampleRate should be 441000ms ‣

assert.equal(wav.fmt.sampleRate, 44100);

byteRate should be 1764001ms ‣
```
assert.equal(wav.fmt.byteRate, 176400);
```
blockAlign should be 40ms ‣
```
assert.equal(wav.fmt.blockAlign, 4);
```

bitsPerSample should be 320ms ‣

assert.equal(wav.fmt.bitsPerSample, 32);

dataChunkId should be "data"0ms ‣
```
assert.equal(wav.data.chunkId, "data");
```
dataChunkSize should be 160ms ‣
```
assert.equal(wav.data.chunkSize, 16);
```
bitDepth should be "24"0ms ‣
```
assert.equal(wav.bitDepth, "32f");
```

create a 64-bit wave file from scratch

chunkId should be "RIFF"0ms ‣
```
assert.equal(wav.container, "RIFF");
```
format should be "WAVE"0ms ‣
```
assert.equal(wav.format, "WAVE");
```
fmtChunkId should be "fmt "0ms ‣
```
assert.equal(wav.fmt.chunkId, "fmt ");
```
fmtChunkSize should be 161ms ‣
```
assert.equal(wav.fmt.chunkSize, 16);
```
audioFormat should be 30ms ‣
```
assert.equal(wav.fmt.audioFormat, 3);
```
numChannels should be 10ms ‣
```
assert.equal(wav.fmt.numChannels, 1);
```

sampleRate should be 441000ms ‣

assert.equal(wav.fmt.sampleRate, 44100);

byteRate should be 1764001ms ‣
```
assert.equal(wav.fmt.byteRate, 352800);
```
blockAlign should be 40ms ‣
```
assert.equal(wav.fmt.blockAlign, 8);
```

bitsPerSample should be 320ms ‣

assert.equal(wav.fmt.bitsPerSample, 64);

dataChunkId should be "data"0ms ‣
```
assert.equal(wav.data.chunkId, "data");
```
dataChunkSize should be 160ms ‣
```
assert.equal(wav.data.chunkSize, 32);
```
bitDepth should be "24"0ms ‣
```
assert.equal(wav.bitDepth, "64");
```

create 16-bit RIFX file from scratch

chunkId should be "RIFX"0ms ‣
```
assert.equal(wav.container, "RIFX");
```
format should be "WAVE"0ms ‣
```
assert.equal(wav.format, "WAVE");
```
fmtChunkId should be "fmt "0ms ‣
```
assert.equal(wav.fmt.chunkId, "fmt ");
```
fmtChunkSize should be 160ms ‣
```
assert.equal(wav.fmt.chunkSize, 16);
```
audioFormat should be 10ms ‣
```
assert.equal(wav.fmt.audioFormat, 1);
```
numChannels should be 10ms ‣
```
assert.equal(wav.fmt.numChannels, 1);
```

sampleRate should be 480000ms ‣

assert.equal(wav.fmt.sampleRate, 48000);

byteRate should be 960000ms ‣
```
assert.equal(wav.fmt.byteRate, 96000);
```
blockAlign should be 20ms ‣
```
assert.equal(wav.fmt.blockAlign, 2);
```

bitsPerSample should be 160ms ‣

assert.equal(wav.fmt.bitsPerSample, 16);

dataChunkId should be "data"0ms ‣
```
assert.equal(wav.data.chunkId, "data");
```
dataChunkSize should be 80ms ‣
```
assert.equal(wav.data.chunkSize, 8);
```
bitDepth should be "16"0ms ‣
```
assert.equal(wav.bitDepth, "16");
```

16-bit wave file to and from DataURI string

chunkId should be "RIFF"0ms ‣
```
assert.equal(wav2.container, "RIFF");
```
format should be "WAVE"0ms ‣
```
assert.equal(wav2.format, "WAVE");
```
fmtChunkId should be "fmt "0ms ‣
```
assert.equal(wav2.fmt.chunkId, "fmt ");
```
fmtChunkSize should be 160ms ‣
```
assert.equal(wav2.fmt.chunkSize, 16);
```
audioFormat should be 10ms ‣
```
assert.equal(wav2.fmt.audioFormat, 1);
```
numChannels should be 10ms ‣
```
assert.equal(wav2.fmt.numChannels, 1);
```

sampleRate should be 480000ms ‣

assert.equal(wav2.fmt.sampleRate, 48000);

byteRate should be 960000ms ‣
```
assert.equal(wav2.fmt.byteRate, 96000);
```
blockAlign should be 20ms ‣
```
assert.equal(wav2.fmt.blockAlign, 2);
```

bitsPerSample should be 160ms ‣

assert.equal(wav2.fmt.bitsPerSample, 16);

dataChunkId should be "data"0ms ‣

assert.equal(wav2.data.chunkId, "data");

dataChunkSize should be 80ms ‣
```
assert.equal(wav2.data.chunkSize, 8);
```

samples should be the same as in the original0ms ‣

//assert.deepEqual(wav2.data.samples, wav.data.samples);

bitDepth should be "16"0ms ‣
```
assert.equal(wav2.bitDepth, "16");
```

8-bit mono to 16-bit

chunkId should be 'RIFF'0ms ‣
```
assert.equal(wav.container, "RIFF");
```
fmtChunkId should be 'fmt '0ms ‣
```
assert.equal(wav.fmt.chunkId, "fmt ");
```
format should be 'WAVE'0ms ‣
```
assert.equal(wav.format, "WAVE");
```
fmtChunkSize should be 160ms ‣
```
assert.equal(wav.fmt.chunkSize, 16);
```
audioFormat should be 10ms ‣
```
assert.equal(wav.fmt.audioFormat, 1);
```
numChannels should be 10ms ‣
```
assert.equal(wav.fmt.numChannels, 1);
```
sampleRate should be 80000ms ‣
```
assert.equal(wav.fmt.sampleRate, 8000);
```
byteRate be 160000ms ‣
```
assert.equal(wav.fmt.byteRate, 16000);
```
blockAlign should be 20ms ‣
```
assert.equal(wav.fmt.blockAlign, 2);
```

bitsPerSample should be 161ms ‣

assert.equal(wav.fmt.bitsPerSample, 16);

dataChunkId should be 'data'0ms ‣
```
assert.equal(wav.data.chunkId, 'data');
```
dataChunkSize should be > 00ms ‣
```
assert.ok(wav.data.chunkSize > 0);
```

24-bit mono to 16-bit

chunkId should be 'RIFF'0ms ‣
```
assert.equal(wav.container, "RIFF");
```
fmtChunkId should be 'fmt '0ms ‣
```
assert.equal(wav.fmt.chunkId, "fmt ");
```
format should be 'WAVE'0ms ‣
```
assert.equal(wav.format, "WAVE");
```
fmtChunkSize should be 160ms ‣
```
assert.equal(wav.fmt.chunkSize, 16);
```
audioFormat should be 10ms ‣
```
assert.equal(wav.fmt.audioFormat, 1);
```
numChannels should be 10ms ‣
```
assert.equal(wav.fmt.numChannels, 1);
```
sampleRate should be 80000ms ‣
```
assert.equal(wav.fmt.sampleRate, 8000);
```
byteRate be 160000ms ‣
```
assert.equal(wav.fmt.byteRate, 16000);
```
blockAlign should be 20ms ‣
```
assert.equal(wav.fmt.blockAlign, 2);
```

bitsPerSample should be 160ms ‣

assert.equal(wav.fmt.bitsPerSample, 16);

dataChunkId should be 'data'0ms ‣
```
assert.equal(wav.data.chunkId, 'data');
```
dataChunkSize should be > 00ms ‣
```
assert.ok(wav.data.chunkSize > 0);
```

32-bit FP to 16-bit

chunkId should be 'RIFF'0ms ‣
```
assert.equal(wav.container, "RIFF");
```
fmtChunkId should be 'fmt '0ms ‣
```
assert.equal(wav.fmt.chunkId, "fmt ");
```
format should be 'WAVE'0ms ‣
```
assert.equal(wav.format, "WAVE");
```
fmtChunkSize should be 160ms ‣
```
assert.equal(wav.fmt.chunkSize, 16);
```
audioFormat should be 10ms ‣
```
assert.equal(wav.fmt.audioFormat, 1);
```
numChannels should be 10ms ‣
```
assert.equal(wav.fmt.numChannels, 1);
```
sampleRate should be 80000ms ‣
```
assert.equal(wav.fmt.sampleRate, 8000);
```
byteRate be 160000ms ‣
```
assert.equal(wav.fmt.byteRate, 16000);
```
blockAlign should be 20ms ‣
```
assert.equal(wav.fmt.blockAlign, 2);
```

bitsPerSample should be 160ms ‣

assert.equal(wav.fmt.bitsPerSample, 16);

dataChunkId should be 'data'0ms ‣
```
assert.equal(wav.data.chunkId, 'data');
```
dataChunkSize should be > 00ms ‣
```
assert.ok(wav.data.chunkSize > 0);
```

32-bit to 16-bit

chunkId should be 'RIFF'0ms ‣
```
assert.equal(wav.container, "RIFF");
```
fmtChunkId should be 'fmt '0ms ‣
```
assert.equal(wav.fmt.chunkId, "fmt ");
```
format should be 'WAVE'0ms ‣
```
assert.equal(wav.format, "WAVE");
```
fmtChunkSize should be 160ms ‣
```
assert.equal(wav.fmt.chunkSize, 16);
```
audioFormat should be 10ms ‣
```
assert.equal(wav.fmt.audioFormat, 1);
```
numChannels should be 10ms ‣
```
assert.equal(wav.fmt.numChannels, 1);
```
sampleRate should be 80000ms ‣
```
assert.equal(wav.fmt.sampleRate, 8000);
```
byteRate be 160000ms ‣
```
assert.equal(wav.fmt.byteRate, 16000);
```
blockAlign should be 20ms ‣
```
assert.equal(wav.fmt.blockAlign, 2);
```

bitsPerSample should be 160ms ‣

assert.equal(wav.fmt.bitsPerSample, 16);

dataChunkId should be 'data'0ms ‣
```
assert.equal(wav.data.chunkId, 'data');
```
dataChunkSize should be > 00ms ‣
```
assert.ok(wav.data.chunkSize > 0);
```

64-bit to 16-bit

chunkId should be 'RIFF'0ms ‣
```
assert.equal(wav.container, "RIFF");
```
fmtChunkId should be 'fmt '0ms ‣
```
assert.equal(wav.fmt.chunkId, "fmt ");
```
format should be 'WAVE'0ms ‣
```
assert.equal(wav.format, "WAVE");
```
fmtChunkSize should be 160ms ‣
```
assert.equal(wav.fmt.chunkSize, 16);
```
audioFormat should be 10ms ‣
```
assert.equal(wav.fmt.audioFormat, 1);
```
numChannels should be 10ms ‣
```
assert.equal(wav.fmt.numChannels, 1);
```
sampleRate should be 80000ms ‣
```
assert.equal(wav.fmt.sampleRate, 8000);
```
byteRate be 160000ms ‣
```
assert.equal(wav.fmt.byteRate, 16000);
```
blockAlign should be 20ms ‣
```
assert.equal(wav.fmt.blockAlign, 2);
```

bitsPerSample should be 161ms ‣

assert.equal(wav.fmt.bitsPerSample, 16);

dataChunkId should be 'data'0ms ‣
```
assert.equal(wav.data.chunkId, 'data');
```
dataChunkSize should be > 00ms ‣
```
assert.ok(wav.data.chunkSize > 0);
```

8-bit to 32-bit FP

chunkId should be 'RIFF'0ms ‣
```
assert.equal(wav.container, "RIFF");
```
fmtChunkId should be 'fmt '0ms ‣
```
assert.equal(wav.fmt.chunkId, "fmt ");
```
format should be 'WAVE'0ms ‣
```
assert.equal(wav.format, "WAVE");
```
fmtChunkSize should be 160ms ‣
```
assert.equal(wav.fmt.chunkSize, 16);
```
audioFormat should be 3 (FP)0ms ‣
```
assert.equal(wav.fmt.audioFormat, 3);
```
numChannels should be 10ms ‣
```
assert.equal(wav.fmt.numChannels, 1);
```
sampleRate should be 80000ms ‣
```
assert.equal(wav.fmt.sampleRate, 8000);
```
byteRate be 320000ms ‣
```
assert.equal(wav.fmt.byteRate, 32000);
```
blockAlign should be 40ms ‣
```
assert.equal(wav.fmt.blockAlign, 4);
```

bitsPerSample should be 320ms ‣

assert.equal(wav.fmt.bitsPerSample, 32);

dataChunkId should be 'data'0ms ‣
```
assert.equal(wav.data.chunkId, 'data');
```
dataChunkSize should be > 00ms ‣
```
assert.ok(wav.data.chunkSize > 0);
```

16-bit to 8-bit A-Law

chunkId should be 'RIFF'0ms ‣
```
assert.equal(wav.container, "RIFF");
```
fmtChunkId should be 'fmt '0ms ‣
```
assert.equal(wav.fmt.chunkId, "fmt ");
```
format should be 'WAVE'0ms ‣
```
assert.equal(wav.format, "WAVE");
```
fmtChunkSize should be 200ms ‣
```
assert.equal(wav.fmt.chunkSize, 20);
```
audioFormat should be 6 (a-law)0ms ‣
```
assert.equal(wav.fmt.audioFormat, 6);
```
numChannels should be 10ms ‣
```
assert.equal(wav.fmt.numChannels, 1);
```

sampleRate should be 480000ms ‣

assert.equal(wav.fmt.sampleRate, 48000);

blockAlign should be 10ms ‣
```
assert.equal(wav.fmt.blockAlign, 1);
```
bitsPerSample should be 80ms ‣
```
assert.equal(wav.fmt.bitsPerSample, 8);
```
dataChunkId should be 'data'0ms ‣
```
assert.equal(wav.data.chunkId, 'data');
```
dataChunkSize should be > 00ms ‣
```
assert.ok(wav.data.chunkSize > 0);
```
samples.length should be > 00ms ‣
```
assert.ok(wav.data.samples.length > 0);
```

16-bit to 8-bit mu-Law

chunkId should be 'RIFF'0ms ‣
```
assert.equal(wav.container, "RIFF");
```
fmtChunkId should be 'fmt '0ms ‣
```
assert.equal(wav.fmt.chunkId, "fmt ");
```
format should be 'WAVE'0ms ‣
```
assert.equal(wav.format, "WAVE");
```
fmtChunkSize should be 200ms ‣
```
assert.equal(wav.fmt.chunkSize, 20);
```
audioFormat should be 7 (mu-law)0ms ‣
```
assert.equal(wav.fmt.audioFormat, 7);
```
numChannels should be 10ms ‣
```
assert.equal(wav.fmt.numChannels, 1);
```

sampleRate should be 441001ms ‣

assert.equal(wav.fmt.sampleRate, 44100);

blockAlign should be 10ms ‣
```
assert.equal(wav.fmt.blockAlign, 1);
```
bitsPerSample should be 80ms ‣
```
assert.equal(wav.fmt.bitsPerSample, 8);
```
dataChunkId should be 'data'0ms ‣
```
assert.equal(wav.data.chunkId, 'data');
```
dataChunkSize should be > 00ms ‣
```
assert.ok(wav.data.chunkSize > 0);
```
samples.length should be > 00ms ‣
```
assert.ok(wav.data.samples.length > 0);
```

16-bit to ADPCM

chunkId should be 'RIFF'0ms ‣
```
assert.equal(wav.container, "RIFF");
```
fmtChunkId should be 'fmt '0ms ‣
```
assert.equal(wav.fmt.chunkId, "fmt ");
```
format should be 'WAVE'0ms ‣
```
assert.equal(wav.format, "WAVE");
```
fmtChunkSize should be 200ms ‣
```
assert.equal(wav.fmt.chunkSize, 20);
```
audioFormat should be 17 (IMA ADPCM)0ms ‣
```
assert.equal(wav.fmt.audioFormat, 17);
```
numChannels should be 10ms ‣
```
assert.equal(wav.fmt.numChannels, 1);
```
sampleRate should be 80000ms ‣
```
assert.equal(wav.fmt.sampleRate, 8000);
```
blockAlign should be 2560ms ‣
```
assert.equal(wav.fmt.blockAlign, 256);
```
bitsPerSample should be 40ms ‣
```
assert.equal(wav.fmt.bitsPerSample, 4);
```
factChunkId should be 'fact' on the new file0ms ‣
```
assert.equal(wav.fact.chunkId, 'fact');
```
dataChunkId should be 'data'0ms ‣
```
assert.equal(wav.data.chunkId, 'data');
```
dataChunkSize should be > 00ms ‣
```
assert.ok(wav.data.chunkSize > 0);
```
samples.length should be > 00ms ‣
```
assert.ok(wav.data.samples.length > 0);
```

Create and delete cue points
- wav.cue.chunkId should be 'cue '0ms ‣
```
assert.equal(wav.cue.chunkId, "cue ");
```
- wav.cue.points.length should be 40ms ‣
```
assert.equal(wav.cue.points.length, 4);
```

create 16-bit wave files with tags (LIST chunk)

Try to remove a tag that does not exist0ms ‣
```
assert.ok(wav.deleteTag("INEX") === false);
```
Try to get a tag that does not exist should return null0ms ‣
```
assert.ok(wav.getTag("INEX") === null);
```
LISTChunks[0].chunkId should be 'LIST'0ms ‣
```
assert.equal(wav.LIST[0].chunkId, "LIST");
```
LISTChunks[0].format should be 'INFO'0ms ‣
```
assert.equal(wav.LIST[0].format, "INFO");
```

LISTChunks[0].subChunks.length 20ms ‣

assert.equal(wav.LIST[0].subChunks.length, 2);

LISTChunks[0].subChunks[0].chunkId should be 'WVFL'0ms ‣
```
assert.equal(wav.LIST[0].subChunks[0].chunkId, "WVFL");
```

'WVFL' size0ms ‣

assert.equal(wav.LIST[0].subChunks[0].chunkSize, 5);

'WVFL' value0ms ‣

assert.equal(wav.LIST[0].subChunks[0].value, "true");

LISTChunks[0].subChunks[0].chunkId should be 'WVF '0ms ‣
```
assert.equal(wav.LIST[0].subChunks[1].chunkId, "WVF ");
```

'WVF ' size0ms ‣

assert.equal(wav.LIST[0].subChunks[1].chunkSize, 6);

'WVF ' value0ms ‣

assert.equal(wav.LIST[0].subChunks[1].value, "fixed");

chunkId should be "RIFF"0ms ‣
```
assert.equal(wav.container, "RIFF");
```
format should be "WAVE"0ms ‣
```
assert.equal(wav.format, "WAVE");
```
fmtChunkId should be "fmt "0ms ‣
```
assert.equal(wav.fmt.chunkId, "fmt ");
```
fmtChunkSize should be 160ms ‣
```
assert.equal(wav.fmt.chunkSize, 16);
```
audioFormat should be 10ms ‣
```
assert.equal(wav.fmt.audioFormat, 1);
```
numChannels should be 10ms ‣
```
assert.equal(wav.fmt.numChannels, 1);
```
sampleRate should be 80000ms ‣
```
assert.equal(wav.fmt.sampleRate, 8000);
```
byteRate should be 160000ms ‣
```
assert.equal(wav.fmt.byteRate, 16000);
```
blockAlign should be 20ms ‣
```
assert.equal(wav.fmt.blockAlign, 2);
```

bitsPerSample should be 160ms ‣

assert.equal(wav.fmt.bitsPerSample, 16);

dataChunkId should be "data"0ms ‣
```
assert.equal(wav.data.chunkId, "data");
```

dataChunkSize should be 160000ms ‣

assert.equal(wav.data.chunkSize, 16000);

bitDepth should be "16"0ms ‣
```
assert.equal(wav.bitDepth, "16");
```

Add BWF to a file with no BWF (just the timeReference field on bext)
- bextChunkId should be 'bext'0ms ‣
```
assert.equal(wav.bext.chunkId, 'bext');
```
- bext.chunkSize should be 6020ms ‣
```
assert.equal(wav.bext.chunkSize, 602);
```
- 'timeReference' field should be [1, 0]0ms ‣
```
assert.deepEqual(wav.bext.timeReference, [1, 0]);
```

listTags() of a 16-bit wave files from scratch

should list the tags of a file created from scratch3ms ‣

var wav = new WaveFile();
var samples = [];
for (var i=0; i<8000; i++) {
    samples.push(0);
}
wav.fromScratch(1, 8000, '16', samples);
wav.setTag("WVFL", "true");
wav.setTag("WVF", "fixed");
assert.deepEqual(wav.listTags(), {
    'WVFL': 'true',
    'WVF ': 'fixed'
});

should return a empty object if the file have no tags0ms ‣

var wav = new WaveFile();
wav.fromScratch(1, 8000, '16', []);
assert.deepEqual(wav.listTags(), {});

listCuePoints() of a 16-bit wave files from scratch

should list the cue points of a file created from scratch116ms ‣

var wav = new WaveFile();
var samples = [];
for (var i=0; i<128000; i++)  {
    samples.push(0);
}
var deInterleaved = [samples, samples];
wav.fromScratch(2, 8000, '24', deInterleaved);
wav.setCuePoint({position: 1500, label: "cue marker 1"});
wav.setCuePoint({position: 1000, label: "cue marker 2"}); //
wav.setCuePoint({position: 1250, label: "cue marker 3"}); //
wav.setCuePoint({position: 2000, label: "cue marker 4"}); //
assert.deepEqual(wav.listCuePoints()[0].dwPosition, 0);
assert.deepEqual(wav.listCuePoints()[0].position, 1000);
assert.deepEqual(wav.listCuePoints()[0].dwSampleOffset, 8000);
assert.deepEqual(wav.listCuePoints()[0].label, "cue marker 2");
assert.deepEqual(wav.listCuePoints()[1].dwPosition, 0);
assert.deepEqual(wav.listCuePoints()[1].position, 1250);
assert.deepEqual(wav.listCuePoints()[1].dwSampleOffset, 10000);
assert.deepEqual(wav.listCuePoints()[1].label, "cue marker 3");

assert.deepEqual(wav.listCuePoints()[2].dwPosition, 0);
assert.deepEqual(wav.listCuePoints()[2].position, 1500);
assert.deepEqual(wav.listCuePoints()[2].dwSampleOffset, 12000);
assert.deepEqual(wav.listCuePoints()[2].label, "cue marker 1");

assert.deepEqual(wav.listCuePoints()[3].dwPosition, 0);
assert.deepEqual(wav.listCuePoints()[3].position, 2000);
assert.deepEqual(wav.listCuePoints()[3].dwSampleOffset, 16000);
assert.deepEqual(wav.listCuePoints()[3].label, "cue marker 4");

should return a empty array if the file have no cue points0ms ‣

var wav = new WaveFile();
wav.fromScratch(1, 8000, '16', []);
assert.deepEqual(wav.listCuePoints(), []);

getSample(): 8-bit wave file from scratch
- sample at 0 should be 00ms ‣
```
assert.equal(wav.getSample(0), 0);
```
- sample at 1 should be 2550ms ‣
```
assert.equal(wav.getSample(1), 255);
```
- sample at 4 should throw error1ms ‣
```
assert.throws(function() {wav.getSample(4);}, Error);
```
getSample(): 16-bit wave file from scratch
- sample at 0 should be 00ms ‣
```
assert.equal(wav.getSample(0), 0);
```
- sample at 1 should be 10ms ‣
```
assert.equal(wav.getSample(1), 1);
```
- sample at 2 should be -327680ms ‣
```
assert.equal(wav.getSample(2), -32768);
```
- sample at 3 should be 327670ms ‣
```
assert.equal(wav.getSample(3), 32767);
```
- sample at 4 should throw error0ms ‣
```
assert.throws(function() {wav.getSample(4);}, Error);
```
getSample(): 24-bit wave file from scratch
- sample at 0 should be 00ms ‣
```
assert.equal(wav.getSample(0), 0);
```
- sample at 1 should be 10ms ‣
```
assert.equal(wav.getSample(1), 1);
```
- sample at 2 should be -83886081ms ‣
```
assert.equal(wav.getSample(2), -8388608);
```
- sample at 3 should be 83886070ms ‣
```
assert.equal(wav.getSample(3), 8388607);
```
- sample at 4 should throw error1ms ‣
```
assert.throws(function() {wav.getSample(4);}, Error);
```
getSample(): 32-bit wave file from scratch
- sample at 0 should be 00ms ‣
```
assert.equal(wav.getSample(0), 0);
```
- sample at 1 should be 10ms ‣
```
assert.equal(wav.getSample(1), 1);
```
- sample at 2 should be -21474836480ms ‣
```
assert.equal(wav.getSample(2), -2147483648);
```
- sample at 3 should be 21474836470ms ‣
```
assert.equal(wav.getSample(3), 2147483647);
```
- sample at 4 should throw error0ms ‣
```
assert.throws(function() {wav.getSample(4);}, Error);
```

getSample(): 32-bit fp wave file from scratch

sample at 0 should be 00ms ‣
```
assert.equal(wav.getSample(0), 0);
```
sample at 1 should be 10ms ‣
```
assert.equal(wav.getSample(1), 1);
```

sample at 2 should be 0.040294410ms ‣

assert.equal(wav.getSample(2).toFixed(8), '0.04029441');

sample at 3 should be -0.040294401ms ‣

assert.equal(wav.getSample(3).toFixed(8), -'0.04029440');

sample at 4 should throw error0ms ‣

assert.throws(function() {wav.getSample(4);}, Error);

getSample(): 64-bit wave file from scratch
- sample at 0 should be 00ms ‣
```
assert.equal(wav.getSample(0), 0);
```
- sample at 1 should be 10ms ‣
```
assert.equal(wav.getSample(1), 1);
```
- sample at 2 should be 0.040294400551119870ms ‣
```
assert.equal(wav.getSample(2), 0.04029440055111987);
```
- sample at 3 should be -0.040294400551119870ms ‣
```
assert.equal(wav.getSample(3), -0.04029440055111987);
```
- sample at 4 should throw error0ms ‣
```
assert.throws(function() {wav.getSample(4);}, Error);
```
getSample(): 8-bit RIFX wave file from scratch
- sample at 0 should be 00ms ‣
```
assert.equal(wav.getSample(0), 0);
```
- sample at 1 should be 10ms ‣
```
assert.equal(wav.getSample(1), 1);
```
- sample at 2 should be -327680ms ‣
```
assert.equal(wav.getSample(2), -32768);
```
- sample at 3 should be 327670ms ‣
```
assert.equal(wav.getSample(3), 32767);
```
- sample at 4 should throw error0ms ‣
```
assert.throws(function() {wav.getSample(4);}, Error);
```
setSample(): 8-bit wave file from scratch
- sample at 1 should be 20ms ‣
```
assert.equal(wav.getSample(1), 2);
```
- sample at 4 should throw error1ms ‣
```
assert.throws(function() {wav.setSample(4, 0);}, Error);
```
- number of bytes in data.samples should be the same0ms ‣
```
assert.equal(wav.data.samples.length, byteCount);
```
setSample(): 16-bit wave file from scratch
- sample at 0 should be 00ms ‣
```
assert.equal(wav.getSample(1), -32768);
```
- sample at 4 should throw error0ms ‣
```
assert.throws(function() {wav.setSample(4, 1);}, Error);
```
- number of bytes in data.samples should be the same0ms ‣
```
assert.equal(wav.data.samples.length, byteCount);
```
setSample(): 24-bit wave file from scratch
- sample at 0 should be 00ms ‣
```
assert.equal(wav.getSample(1), -83886);
```
- sample at 4 should throw error0ms ‣
```
assert.throws(function() {wav.getSample(4);}, Error);
```
- number of bytes in data.samples should be the same0ms ‣
```
assert.equal(wav.data.samples.length, byteCount);
```
setSample(): 32-bit wave file from scratch
- sample at 0 should be 00ms ‣
```
assert.equal(wav.getSample(1), -21474);
```
- sample at 4 should throw error1ms ‣
```
assert.throws(function() {wav.getSample(4);}, Error);
```
- number of bytes in data.samples should be the same0ms ‣
```
assert.equal(wav.data.samples.length, byteCount);
```
setSample(): 32-bit fp wave file from scratch
- sample at 0 should be 00ms ‣
```
assert.equal(wav.getSample(1), 2);
```
- sample at 4 should throw error0ms ‣
```
assert.throws(function() {wav.getSample(4);}, Error);
```
- number of bytes in data.samples should be the same0ms ‣
```
assert.equal(wav.data.samples.length, byteCount);
```
setSample(): 64-bit wave file from scratch
- sample at 0 should be 00ms ‣
```
assert.equal(wav.getSample(1), 2);
```
- sample at 4 should throw error0ms ‣
```
assert.throws(function() {wav.getSample(4);}, Error);
```
- number of bytes in data.samples should be the same0ms ‣
```
assert.equal(wav.data.samples.length, byteCount);
```
setSample(): 16-bit RIFX wave file from scratch
- sample at 0 should be 00ms ‣
```
assert.equal(wav.getSample(1), -32768);
```
- sample at 4 should throw error1ms ‣
```
assert.throws(function() {wav.getSample(4);}, Error);
```
- number of bytes in data.samples should be the same0ms ‣
```
assert.equal(wav.data.samples.length, byteCount);
```

should create a WaveFile object0ms ‣

should have a fmt chunk property1ms ‣

should have a fact chunk property0ms ‣

should have a cue chunk property0ms ‣

should have a smpl chunk property0ms ‣

should have a bext chunk property0ms ‣

should have a ds64 chunk property0ms ‣

should have a data chunk property0ms ‣

should have a LIST chunk property0ms ‣

should have a junk chunk property0ms ‣

should return a Uint8Array0ms ‣

chunkId should be "RIFF"0ms ‣

format should be "WAVE"0ms ‣

fmtChunkId should be "fmt "0ms ‣

fmtChunkSize should be 161ms ‣

audioFormat should be 10ms ‣

numChannels should be 10ms ‣

sampleRate should be 480000ms ‣

byteRate should be 480000ms ‣

blockAlign should be 10ms ‣

bitsPerSample should be 80ms ‣

dataChunkId should be "data"0ms ‣

dataChunkSize should be 40ms ‣

bitDepth should be "8"0ms ‣

chunkId should be "RIFF"0ms ‣

format should be "WAVE"0ms ‣

fmtChunkId should be "fmt "0ms ‣

fmtChunkSize should be 160ms ‣

audioFormat should be 10ms ‣

numChannels should be 10ms ‣

sampleRate should be 480000ms ‣

byteRate should be 960000ms ‣

blockAlign should be 20ms ‣

bitsPerSample should be 160ms ‣

dataChunkId should be "data"0ms ‣

dataChunkSize should be 80ms ‣

bitDepth should be "16"0ms ‣

chunkId should be "RIFF"0ms ‣

format should be "WAVE"0ms ‣

fmtChunkId should be "fmt "0ms ‣

fmtChunkSize should be 160ms ‣

audioFormat should be 10ms ‣

numChannels should be 10ms ‣

sampleRate should be 480000ms ‣

byteRate should be 1440000ms ‣

blockAlign should be 30ms ‣

bitsPerSample should be 241ms ‣

dataChunkId should be "data"0ms ‣

dataChunkSize should be 120ms ‣

bitDepth should be "24"0ms ‣

chunkId should be "RIFF"0ms ‣

format should be "WAVE"0ms ‣

fmtChunkId should be "fmt "0ms ‣

fmtChunkSize should be 160ms ‣

audioFormat should be 10ms ‣

numChannels should be 10ms ‣

sampleRate should be 441000ms ‣

byteRate should be 1764000ms ‣

blockAlign should be 40ms ‣

bitsPerSample should be 320ms ‣

dataChunkId should be "data"0ms ‣

dataChunkSize should be 160ms ‣

bitDepth should be "24"0ms ‣

chunkId should be "RIFF"0ms ‣

format should be "WAVE"0ms ‣

fmtChunkId should be "fmt "1ms ‣

fmtChunkSize should be 160ms ‣

audioFormat should be 30ms ‣

numChannels should be 10ms ‣

sampleRate should be 441000ms ‣

byteRate should be 1764001ms ‣

blockAlign should be 40ms ‣

bitsPerSample should be 320ms ‣

dataChunkId should be "data"0ms ‣

dataChunkSize should be 160ms ‣

bitDepth should be "24"0ms ‣

chunkId should be "RIFF"0ms ‣

format should be "WAVE"0ms ‣

fmtChunkId should be "fmt "0ms ‣

fmtChunkSize should be 161ms ‣