Duffer Derek
'use strict';
/*
======== A Handy Little QUnit Reference ========
http://api.qunitjs.com/
Test methods:
module(name, {[setup][ ,teardown]})
test(name, callback)
expect(numberOfAssertions)
stop(increment)
start(decrement)
Test assertions:
ok(value, [message])
equal(actual, expected, [message])
notEqual(actual, expected, [message])
deepEqual(actual, expected, [message])
notDeepEqual(actual, expected, [message])
strictEqual(actual, expected, [message])
notStrictEqual(actual, expected, [message])
throws(block, [expected], [message])
*/
var metadataStream, stringToInts, stringToCString, id3Tag, id3Frame, id3Generator, mp2t, QUnit,
webworkify, MetadataStreamTestWorker;
mp2t = require('../lib/m2ts');
QUnit = require('qunit');
id3Generator = require('./utils/id3-generator');
MetadataStreamTestWorker = require('worker!./metadata-stream-test-worker.js');
stringToInts = id3Generator.stringToInts;
stringToCString = id3Generator.stringToCString;
id3Tag = id3Generator.id3Tag;
id3Frame = id3Generator.id3Frame;
QUnit.module('MetadataStream', {
beforeEach: function() {
metadataStream = new mp2t.MetadataStream();
}
});
QUnit.test('can construct a MetadataStream', function(assert) {
assert.ok(metadataStream, 'does not return null');
});
QUnit.test('triggers log for non-id3/invalid data', function(assert) {
var logs = [];
metadataStream.on('log', function(log) {
logs.push(log);
});
// id3 not long enough
metadataStream.push({type: 'timed-metadata', data: new Uint8Array()});
// invalid data
metadataStream.push({type: 'timed-metadata', data: new Uint8Array([
0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01
])});
const zeroFrames = new Uint8Array(stringToInts('ID3').concat([
0x03, 0x00, // version 3.0 of ID3v2 (aka ID3v.2.3.0)
0x40, // flags. include an extended header
0x00, 0x00, 0x00, 0x00, // size. set later
// extended header
0x00, 0x00, 0x00, 0x06, // extended header size. no CRC
0x00, 0x00, // extended flags
0x00, 0x00, 0x00, 0x02 // size of padding
]));
metadataStream.push({type: 'timed-metadata', data: zeroFrames});
assert.deepEqual(logs, [
{level: 'warn', message: 'Skipping unrecognized metadata packet'},
{level: 'warn', message: 'Skipping unrecognized metadata packet'},
{level: 'warn', message: 'Malformed ID3 frame encountered. Skipping remaining metadata parsing.'}
], 'logs as expected.');
});
QUnit.test('parses simple ID3 metadata out of PES packets', function(assert) {
var
events = [],
wxxxPayload = [
0x00 // text encoding. ISO-8859-1
].concat(stringToCString('ad tag URL'), // description
stringToInts('http://example.com/ad?v=1234&q=7')), // value
id3Bytes,
size;
metadataStream.on('data', function(event) {
events.push(event);
});
id3Bytes = new Uint8Array(stringToInts('ID3').concat([
0x03, 0x00, // version 3.0 of ID3v2 (aka ID3v.2.3.0)
0x40, // flags. include an extended header
0x00, 0x00, 0x00, 0x00, // size. set later
// extended header
0x00, 0x00, 0x00, 0x06, // extended header size. no CRC
0x00, 0x00, // extended flags
0x00, 0x00, 0x00, 0x02 // size of padding
// frame 0
// http://id3.org/id3v2.3.0#User_defined_text_information_frame
], id3Frame('WXXX',
wxxxPayload), // value
// frame 1
// custom tag
id3Frame('XINF',
[
0x04, 0x03, 0x02, 0x01 // arbitrary data
]), [
0x00, 0x00 // padding
]));
// set header size field
size = id3Bytes.byteLength - 10;
id3Bytes[6] = (size >>> 21) & 0x7f;
id3Bytes[7] = (size >>> 14) & 0x7f;
id3Bytes[8] = (size >>> 7) & 0x7f;
id3Bytes[9] = (size) & 0x7f;
metadataStream.push({
type: 'timed-metadata',
trackId: 7,
pts: 1000,
dts: 1000,
// header
data: id3Bytes
});
assert.equal(events.length, 1, 'parsed one tag');
assert.equal(events[0].frames.length, 2, 'parsed two frames');
assert.equal(events[0].frames[0].key, 'WXXX', 'parsed a WXXX frame');
assert.deepEqual(new Uint8Array(events[0].frames[0].data),
new Uint8Array(wxxxPayload),
'attached the frame payload');
assert.equal(events[0].frames[1].key, 'XINF', 'parsed a user-defined frame');
assert.deepEqual(new Uint8Array(events[0].frames[1].data),
new Uint8Array([0x04, 0x03, 0x02, 0x01]),
'attached the frame payload');
assert.equal(events[0].pts, 1000, 'did not modify the PTS');
assert.equal(events[0].dts, 1000, 'did not modify the PTS');
});
QUnit.test('skips non-ID3 metadata events', function(assert) {
var events = [];
metadataStream.on('data', function(event) {
events.push(event);
});
metadataStream.push({
type: 'timed-metadata',
trackId: 7,
pts: 1000,
dts: 1000,
// header
data: new Uint8Array([0])
});
assert.equal(events.length, 0, 'did not emit an event');
});
// missing cases:
// unsynchronization
// CRC
// no extended header
// compressed frames
// encrypted frames
// frame groups
// too large/small tag size values
// too large/small frame size values
QUnit.test('parses TXXX frames without null terminators', function(assert) {
var events = [];
metadataStream.on('data', function(event) {
events.push(event);
});
metadataStream.push({
type: 'timed-metadata',
trackId: 7,
pts: 1000,
dts: 900,
// header
data: new Uint8Array(id3Tag(id3Frame('TXXX',
0x03, // utf-8
stringToCString('get done'),
stringToInts('{ "key": "value" }')),
[0x00, 0x00]))
});
assert.equal(events.length, 1, 'parsed one tag');
assert.equal(events[0].frames.length, 1, 'parsed one frame');
assert.equal(events[0].frames[0].key, 'TXXX', 'parsed the frame key');
assert.equal(events[0].frames[0].description, 'get done', 'parsed the description');
assert.deepEqual(JSON.parse(events[0].frames[0].data), { key: 'value' }, 'parsed the data');
});
QUnit.test('parses TXXX frames with null terminators', function(assert) {
var events = [];
metadataStream.on('data', function(event) {
events.push(event);
});
metadataStream.push({
type: 'timed-metadata',
trackId: 7,
pts: 1000,
dts: 900,
// header
data: new Uint8Array(id3Tag(id3Frame('TXXX',
0x03, // utf-8
stringToCString('get done'),
stringToCString('{ "key": "value" }')),
[0x00, 0x00]))
});
assert.equal(events.length, 1, 'parsed one tag');
assert.equal(events[0].frames.length, 1, 'parsed one frame');
assert.equal(events[0].frames[0].key, 'TXXX', 'parsed the frame key');
assert.equal(events[0].frames[0].description, 'get done', 'parsed the description');
assert.deepEqual(JSON.parse(events[0].frames[0].data), { key: 'value' }, 'parsed the data');
});
QUnit.test('parses WXXX frames', function(assert) {
var events = [], url = 'http://example.com/path/file?abc=7&d=4#ty';
metadataStream.on('data', function(event) {
events.push(event);
});
metadataStream.push({
type: 'timed-metadata',
trackId: 7,
pts: 1000,
dts: 900,
// header
data: new Uint8Array(id3Tag(id3Frame('WXXX',
0x03, // utf-8
stringToCString(''),
stringToInts(url)),
[0x00, 0x00]))
});
assert.equal(events.length, 1, 'parsed one tag');
assert.equal(events[0].frames.length, 1, 'parsed one frame');
assert.equal(events[0].frames[0].key, 'WXXX', 'parsed the frame key');
assert.equal(events[0].frames[0].description, '', 'parsed the description');
assert.equal(events[0].frames[0].url, url, 'parsed the value');
});
QUnit.test('parses TXXX frames with characters that have a single-digit hexadecimal representation', function(assert) {
var events = [], value = String.fromCharCode(7);
metadataStream.on('data', function(event) {
events.push(event);
});
metadataStream.push({
type: 'timed-metadata',
trackId: 7,
pts: 1000,
dts: 900,
// header
data: new Uint8Array(id3Tag(id3Frame('TXXX',
0x03, // utf-8
stringToCString(''),
stringToCString(value)),
[0x00, 0x00]))
});
assert.equal(events[0].frames[0].data,
value,
'parsed the single-digit character');
});
QUnit.test('parses PRIV frames', function(assert) {
var
events = [],
payload = stringToInts('arbitrary data may be included in the payload ' +
'of a PRIV frame');
metadataStream.on('data', function(event) {
events.push(event);
});
metadataStream.push({
type: 'timed-metadata',
trackId: 7,
pts: 1000,
dts: 900,
// header
data: new Uint8Array(id3Tag(id3Frame('PRIV',
stringToCString('priv-owner@example.com'),
payload)))
});
assert.equal(events.length, 1, 'parsed a tag');
assert.equal(events[0].frames.length, 1, 'parsed a frame');
assert.equal(events[0].frames[0].key, 'PRIV', 'frame key is PRIV');
assert.equal(events[0].frames[0].owner, 'priv-owner@example.com', 'parsed the owner');
assert.deepEqual(new Uint8Array(events[0].frames[0].data),
new Uint8Array(payload),
'parsed the frame private data');
});
QUnit.test('parses tags split across pushes', function(assert) {
var
events = [],
owner = stringToCString('owner@example.com'),
payload = stringToInts('A TS packet is 188 bytes in length so that it can' +
' be easily transmitted over ATM networks, an ' +
'important medium at one time. We want to be sure' +
' that ID3 frames larger than a TS packet are ' +
'properly re-assembled.'),
tag = new Uint8Array(id3Tag(id3Frame('PRIV', owner, payload))),
front = tag.subarray(0, 100),
back = tag.subarray(100);
metadataStream.on('data', function(event) {
events.push(event);
});
metadataStream.push({
type: 'timed-metadata',
trackId: 7,
pts: 1000,
dts: 900,
data: front,
dataAlignmentIndicator: true
});
assert.equal(events.length, 0, 'parsed zero tags');
metadataStream.push({
type: 'timed-metadata',
trackId: 7,
pts: 1000,
dts: 900,
data: back,
dataAlignmentIndicator: false
});
assert.equal(events.length, 1, 'parsed a tag');
assert.equal(events[0].frames.length, 1, 'parsed a frame');
assert.equal(events[0].frames[0].data.byteLength,
payload.length,
'collected data across pushes');
// parses subsequent fragmented tags
tag = new Uint8Array(id3Tag(id3Frame('PRIV',
owner, payload, payload)));
front = tag.subarray(0, 188);
back = tag.subarray(188);
events = [];
metadataStream.push({
type: 'timed-metadata',
trackId: 7,
pts: 2000,
dts: 2000,
data: front,
dataAlignmentIndicator: true
});
metadataStream.push({
type: 'timed-metadata',
trackId: 7,
pts: 2000,
dts: 2000,
data: back,
dataAlignmentIndicator: false
});
assert.equal(events.length, 1, 'parsed a tag');
assert.equal(events[0].frames.length, 1, 'parsed a frame');
assert.equal(events[0].frames[0].data.byteLength,
2 * payload.length,
'collected data across pushes');
});
QUnit.test('id3 frame is malformed first time but gets corrected in the next frame', function(assert) {
var
events = [],
owner = stringToCString('owner@example.com'),
payload = stringToInts('A TS packet is 188 bytes in length so that it can' +
' be easily transmitted over ATM networks, an ' +
'important medium at one time. We want to be sure' +
' that ID3 frames larger than a TS packet are ' +
'properly re-assembled.'),
tag = new Uint8Array(id3Tag(id3Frame('PRIV', owner, payload))),
front = tag.subarray(0, 100);
metadataStream.on('data', function(event) {
events.push(event);
});
// receives incomplete id3
metadataStream.push({
type: 'timed-metadata',
trackId: 7,
pts: 1000,
dts: 900,
data: front,
dataAlignmentIndicator: true
});
assert.equal(events.length, 0, 'parsed zero tags');
// receives complete id3
metadataStream.push({
type: 'timed-metadata',
trackId: 7,
pts: 1000,
dts: 900,
data: tag,
dataAlignmentIndicator: true
});
assert.equal(events.length, 1, 'parsed a tag');
assert.equal(events[0].frames.length, 1, 'parsed a frame');
assert.equal(events[0].frames[0].data.byteLength,
payload.length,
'collected data across pushes');
});
QUnit.test('id3 frame reports more data than its tagsize ', function(assert) {
var
events = [],
owner = stringToCString('owner@example.com'),
payload = stringToInts('A TS packet is 188 bytes in length so that it can' +
' be easily transmitted over ATM networks, an ' +
'important medium at one time. We want to be sure' +
' that ID3 frames larger than a TS packet are ' +
'properly re-assembled.'),
tag = new Uint8Array(id3Tag(id3Frame('PRIV', owner, payload))),
d = new Uint8Array([0x04, 0x05, 0x06]),
data = new Uint8Array(tag.byteLength + d.byteLength);
data.set(tag);
data.set(d, tag.length);
metadataStream.on('data', function(event) {
events.push(event);
});
metadataStream.push({
type: 'timed-metadata',
trackId: 7,
pts: 1000,
dts: 900,
data: data,
dataAlignmentIndicator: true
});
assert.equal(events.length, 1, 'parsed a tag');
assert.equal(events[0].frames.length, 1, 'parsed a frame');
assert.equal(events[0].frames[0].data.byteLength,
payload.length,
'collected data across pushes');
});
QUnit.test('ignores tags when the header is fragmented', function(assert) {
var
events = [],
tag = new Uint8Array(id3Tag(id3Frame('PRIV',
stringToCString('owner@example.com'),
stringToInts('payload')))),
// split the 10-byte ID3 tag header in half
front = tag.subarray(0, 5),
back = tag.subarray(5);
metadataStream.on('data', function(event) {
events.push(event);
});
metadataStream.push({
type: 'timed-metadata',
trackId: 7,
pts: 1000,
dts: 900,
data: front
});
metadataStream.push({
type: 'timed-metadata',
trackId: 7,
pts: 1000,
dts: 900,
data: back
});
assert.equal(events.length, 0, 'parsed zero tags');
metadataStream.push({
type: 'timed-metadata',
trackId: 7,
pts: 1500,
dts: 1500,
data: new Uint8Array(id3Tag(id3Frame('PRIV',
stringToCString('owner2'),
stringToInts('payload2'))))
});
assert.equal(events.length, 1, 'parsed one tag');
assert.equal(events[0].frames[0].owner, 'owner2', 'dropped the first tag');
});
// https://html.spec.whatwg.org/multipage/embedded-content.html#steps-to-expose-a-media-resource-specific-text-track
QUnit.test('constructs the dispatch type', function(assert) {
metadataStream = new mp2t.MetadataStream({
descriptor: new Uint8Array([0x03, 0x02, 0x01, 0x00])
});
assert.equal(metadataStream.dispatchType, '1503020100', 'built the dispatch type');
});
QUnit.test('should skip tag frame parsing on malformed frame, preserving previous frames', function(assert) {
var events = [],
validFrame = id3Frame('TIT2',
0x03, // utf-8
stringToCString('sample title')),
malformedFrame = id3Frame('WOAF'), // frame with size of 0B
tag = id3Tag(validFrame, malformedFrame);
metadataStream.on('data', function(event) {
events.push(event);
});
metadataStream.push({
type: 'timed-metadata',
data: new Uint8Array(tag)
})
assert.equal(events.length, 1, 'parsed 1 tag')
assert.equal(events[0].frames.length, 1, 'parsed 1 frame');
assert.equal(events[0].frames[0].key, 'TIT2');
});
QUnit.test('can parse APIC frame in web worker', function(assert) {
var worker = new MetadataStreamTestWorker(),
done = assert.async();
worker.addEventListener('message', function(e) {
assert.equal(e.data.frames[0].key, 'APIC', 'frame key is APIC');
assert.equal(e.data.frames[0].mimeType, 'image/jpeg', 'parsed MIME type is "image/jpeg"');
assert.equal(e.data.frames[0].pictureType, 0x03, 'parsed picture type is 0x03');
assert.equal(e.data.frames[0].description, 'sample description', 'parsed description');
assert.deepEqual(e.data.frames[0].pictureData, new Uint8Array(stringToInts("picture binary data")), 'parsed picture data');
assert.equal(e.data.frames[1].key, 'APIC', 'frame key is APIC');
assert.equal(e.data.frames[1].mimeType, '-->', 'parsed MIME type is "-->"');
assert.equal(e.data.frames[1].pictureType, 0x04, 'parsed picture type is 0x04');
assert.equal(e.data.frames[1].description, 'sample description 2', 'parsed description');
assert.equal(e.data.frames[1].url, 'http://example.org/cover-back.jpg', 'parsed picture data');
worker.terminate();
done();
});
worker.postMessage({
type: 'timed-metadata',
data: new Uint8Array(id3Tag(id3Frame('APIC',
0x03, // Text encoding: UTF-8
stringToCString('image/jpeg'), // MIME type + \0
0x03, // Picture type: Cover (front) [ID3v2.4.0 section 4.14]
stringToCString('sample description'), // Decription + \0
stringToInts('picture binary data')
),
id3Frame('APIC',
0x03, // Text encoding: UTF-8
stringToCString('-->'), // MIME type: link to the image [ID3v2.4.0 section 4.14] + \0
0x04, // Picture type: Cover (back) [ID3v2.4.0 section 4.14]
stringToCString('sample description 2'), // Decription + \0
stringToInts('http://example.org/cover-back.jpg')
)))
});
});
QUnit.test('can parse PRIV frames in web worker', function(assert) {
var payload = stringToInts('arbitrary'),
worker = new MetadataStreamTestWorker(),
done = assert.async();
worker.addEventListener('message', function(e) {
assert.equal(e.data.frames[0].key, 'PRIV', 'frame key is PRIV');
assert.deepEqual(new Uint8Array(e.data.frames[0].data), new Uint8Array(payload),
'parsed the frame private data');
worker.terminate();
done();
});
worker.postMessage({
type: 'timed-metadata',
trackId: 7,
pts: 1000,
dts: 900,
// header
data: new Uint8Array(id3Tag(id3Frame('PRIV',
stringToCString('priv-owner@example.com'),
payload)))
});
});
QUnit.test('can parse TXXX frames in web worker', function(assert) {
var worker = new MetadataStreamTestWorker(),
done = assert.async();
worker.addEventListener('message', function(e) {
assert.equal(e.data.frames[0].key, 'TXXX', 'frame key is TXXX');
assert.equal(e.data.frames[0].description, 'get done', 'parsed the description');
assert.deepEqual(JSON.parse(e.data.frames[0].data), { key: 'value' }, 'parsed the data');
worker.terminate();
done();
});
worker.postMessage({
type: 'timed-metadata',
trackId: 7,
pts: 1000,
dts: 900,
// header
data: new Uint8Array(id3Tag(id3Frame('TXXX',
0x03, // utf-8
stringToCString('get done'),
stringToCString('{ "key": "value" }')),
[0x00, 0x00]))
});
});
QUnit.test('should parse text frames in web worker', function(assert) {
var worker = new MetadataStreamTestWorker(),
done = assert.async();
worker.addEventListener('message', function(e) {
assert.equal(e.data.frames.length, 2, 'got 2 frames');
assert.equal(e.data.frames[0].key, 'TIT2', 'frame key is TIT2');
assert.equal(e.data.frames[0].value, 'sample song title', 'parsed value')
assert.equal(e.data.frames[0].values.length, 1, 'parsed value is an array of size 1')
assert.equal(e.data.frames[0].values[0], 'sample song title', 'parsed a non multiple strings value')
assert.equal(e.data.frames[1].key, 'TIT3', 'frame key is TIT3');
assert.equal(e.data.frames[1].value, 'sample title 1\0sample title 2', 'parsed value')
assert.equal(e.data.frames[1].values.length, 2, 'parsed value is an array of size 2')
assert.equal(e.data.frames[1].values[0], 'sample title 1', 'parsed 1st multiple strings value')
assert.equal(e.data.frames[1].values[1], 'sample title 2', 'parsed 2nd multiple strings value')
worker.terminate();
done();
});
worker.postMessage({
type: 'timed-metadata',
data: new Uint8Array(id3Tag(id3Frame('TIT2',
0x03, // utf-8
// frames that allow different types of encoding contain terminated text [ID3v2.4.0 section 4.]
stringToCString('sample song title')),
id3Frame('TIT3',
0x03, // utf-8
// frames that allow different types of encoding contain terminated text [ID3v2.4.0 section 4.]
// text information frames supports multiple strings, stored as a terminator separated list [ID3v2.4.0 section 4.2.]
stringToCString('sample title 1'), stringToCString('sample title 2'))))
});
});
QUnit.test('should parse URL link frames in web worker', function(assert) {
var worker = new MetadataStreamTestWorker(),
done = assert.async(),
payloadBytes;
// if the payload is followed by a string termination all the following information should be ignored [ID3v2.4.0 section 4.3]
payloadBytes = stringToInts('http://example.org\0 ignored \0 part')
worker.addEventListener('message', function(e) {
assert.equal(e.data.frames[0].key, 'WOAF', 'frame key is WOAF');
assert.equal(e.data.frames[0].url, 'http://example.org', 'parsed URL')
worker.terminate();
done();
});
worker.postMessage({
type: 'timed-metadata',
data: new Uint8Array(id3Tag(id3Frame('WOAF', payloadBytes)))
});
});
QUnit.test('triggers special event after parsing a timestamp ID3 tag', function(assert) {
var
array = new Uint8Array(73),
streamTimestamp = 'com.apple.streaming.transportStreamTimestamp',
priv = 'PRIV',
count = 0,
frame,
tag,
metadataStream,
chunk,
i;
metadataStream = new mp2t.MetadataStream();
metadataStream.on('timestamp', function(f) {
frame = f;
count += 1;
});
metadataStream.on('data', function(t) {
tag = t;
});
array[0] = 73;
array[1] = 68;
array[2] = 51;
array[3] = 4;
array[9] = 63;
array[17] = 53;
array[70] = 13;
array[71] = 187;
array[72] = 160;
for (i = 0; i < priv.length; i++) {
array[i + 10] = priv.charCodeAt(i);
}
for (i = 0; i < streamTimestamp.length; i++) {
array[i + 20] = streamTimestamp.charCodeAt(i);
}
chunk = {
type: 'timed-metadata',
data: array
};
metadataStream.push(chunk);
assert.equal(count, 1, 'timestamp event triggered once');
assert.equal(frame.timeStamp, 900000, 'Initial timestamp fired and calculated correctly');
assert.equal(tag.pts, 10 * 90e3, 'set tag PTS');
assert.equal(tag.dts, 10 * 90e3, 'set tag DTS');
});
Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists