46462135

Build Type

push

appveyor

Committed by Benjamin Russell

Commit Message

Merge branch 'release/v5.1.0'

Run Details

3096 of 3788 branches covered (81.73%)

Branch coverage included in aggregate %.

2171 of 2171 new or added lines in 47 files covered. (100.0%)

25320 of 26463 relevant lines covered (95.68%)

437.0 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.57

/test-unit/ebml/ebmlParserTests.ts

import {suite, test} from "@testdeck/mocha";
import {assert} from "chai";

import EbmlElement from "../../src/ebml/ebmlElement";
import EbmlParser from "../../src/ebml/ebmlParser";
import TestFile from "../utilities/testFile"
import {ByteVector} from "../../src/byteVector";
import {File} from "../../src/file";
import {Allow, Testers} from "../utilities/testers";

@suite
class Ebml_ParserTests {
    private static TEST_BYTES = [
        0x00, 0x00, 0x00, 0x00, // Buffer
        0x42, 0x86, // Identifier (EBMLVersion)
        0x81,       // Size (1)
        0x01,       // Value (1)
        0x42, 0xF7, // Identifier (EBMLReadVersion)
        0x81,       // Size (1)
        0x01,       // Value (1)
        0x42, 0xF2, // Identifier (EBMLMaxIDLength)
        0x81,       // Size (1)
        0x04,       // Value (4)
        0x42, 0xF3, // Identifier (EBMLMaxSizeLength)
        0x81,       // Size (1)
        0x08,       // Value (8)
        0x42, 0x82, // Identifier (DocType)
        0x84,       // Size (4)
        0x77, 0x65, 0x62, 0x6D, // Value (webm)
        0x42, 0x87, // Identifier (DocTypeVersion)
        0x81,       // Size (1)
        0x04,       // Value (4)
        0x42, 0x85, // Identifier (DocTypeReadVersion)
        0x81,       // Size (1)
        0x02,       // Value (2)
    ]

    @test
    public constructor_invalidParams() {
        // Act / Assert
        Testers.testTruthy((f: File) => new EbmlParser(f, 0, 123));
        Testers.testSafeUint((o: number) => new EbmlParser(TestFile.mockFile(), o, 123));
        Testers.testSafeUint((o: number) => new EbmlParser(TestFile.mockFile(), 0, o))
    }

    @test
    public constructor_invalidOptions() {
        // Act / Asssert
        Testers.testSafeUint((o: number) => {
            const options = { maxIdLength: o }
            const _ = new EbmlParser(TestFile.mockFile(), 0, 123, options);
        }, Allow.Undefined | Allow.Null);

        Testers.testSafeUint((o: number) => {
            const options = { maxSizeLength: o };
            const _ = new EbmlParser(TestFile.mockFile(), 0, 123, options);
        }, Allow.Undefined | Allow.Null);
    }

    @test
    public constructor_unsupportedOptions() {
        // Arrange 1
        const options1 = { maxIdLength: 16 };

        // Act / Assert 1
        assert.throws(() => new EbmlParser(TestFile.mockFile(), 0, 123, options1));

        // Arrange 2
        const options2 = { maxSizeLength: 16 };

        // Act / Assert 2
        assert.throws(() => new EbmlParser(TestFile.mockFile(), 0, 123, options2));

    }

    @test
    public constructor_validNoOptions() {
        // Act
        const parser = new EbmlParser(TestFile.mockFile(), 0, 123);

        // Assert
        assert.strictEqual(parser.currentElement, undefined);
        assert.strictEqual(parser["_offset"], 0);
        assert.strictEqual(parser["_maxOffset"], 123);
        assert.strictEqual(parser["_options"].maxSizeLength, 8);
        assert.strictEqual(parser["_options"].maxIdLength, 4);
    }

    @test
    public constructor_validWithOptions() {
        // Arrange
        const options = {
            maxSizeLength: 3,
            maxIdLength: 5
        };

        // Act
        const parser = new EbmlParser(TestFile.mockFile(), 0, 123, options);

        // Assert
        assert.strictEqual(parser.currentElement, undefined);
        assert.strictEqual(parser["_offset"], 0);
        assert.strictEqual(parser["_maxOffset"], 123);
        assert.strictEqual(parser["_options"].maxSizeLength, 3);
        assert.strictEqual(parser["_options"].maxIdLength, 5);
    }

    @test
    public read() {
        // Arrange
        const parser = this.getTestParser(Ebml_ParserTests.TEST_BYTES, 4);

        // Read 1
        assert.isTrue(parser.read());
        assert.strictEqual(parser["_offset"], 8);

        let element = parser.currentElement;
        assert.isOk(element);
        assert.strictEqual(element.id, 0x4286);
        assert.strictEqual(element.length, 1);
        assert.strictEqual(element["_dataOffset"], 7)

        // Read 2
        assert.isTrue(parser.read());
        assert.strictEqual(parser["_offset"], 12);

        element = parser.currentElement;
        assert.isOk(element);
        assert.strictEqual(element.id, 0x42F7);
        assert.strictEqual(element.length, 1);
        assert.strictEqual(element["_dataOffset"], 11)

        // Read 3
        assert.isTrue(parser.read());
        assert.strictEqual(parser["_offset"], 16);

        element = parser.currentElement;
        assert.isOk(element);
        assert.strictEqual(element.id, 0x42F2);
        assert.strictEqual(element.length, 1);
        assert.strictEqual(element["_dataOffset"], 15)

        // Read 4
        assert.isTrue(parser.read());
        assert.strictEqual(parser["_offset"], 20);

        element = parser.currentElement;
        assert.isOk(element);
        assert.strictEqual(element.id, 0x42F3);
        assert.strictEqual(element.length, 1);
        assert.strictEqual(element["_dataOffset"], 19)

        // Read 5
        assert.isTrue(parser.read());
        assert.strictEqual(parser["_offset"], 27);

        element = parser.currentElement;
        assert.isOk(element);
        assert.strictEqual(element.id, 0x4282);
        assert.strictEqual(element.length, 4);
        assert.strictEqual(element["_dataOffset"], 23)

        // Read 6
        assert.isTrue(parser.read());
        assert.strictEqual(parser["_offset"], 31);

        element = parser.currentElement;
        assert.isOk(element);
        assert.strictEqual(element.id, 0x4287);
        assert.strictEqual(element.length, 1);
        assert.strictEqual(element["_dataOffset"], 30)

        // Read 7
        assert.isTrue(parser.read());
        assert.strictEqual(parser["_offset"], 35);

        element = parser.currentElement;
        assert.isOk(element);
        assert.strictEqual(element.id, 0x4285);
        assert.strictEqual(element.length, 1);
        assert.strictEqual(element["_dataOffset"], 34)

        // Read 8
        assert.isFalse(parser.read());
        assert.strictEqual(parser.currentElement, element);
    }

    @test
    public readAllValues() {
        // Arrange
        const parser = this.getTestParser(Ebml_ParserTests.TEST_BYTES, 4);

        // Act
        const elements = EbmlParser.getAllElements(parser);

        // Assert
        assert.isOk(elements);
        assert.strictEqual(elements.size, 7);

        let element = elements.get(0x4286)
        assert.strictEqual(element.id, 0x4286);
        assert.strictEqual(element.length, 1);
        assert.strictEqual(element["_dataOffset"], 7)

        element = elements.get(0x42F7)
        assert.strictEqual(element.id, 0x42F7);
        assert.strictEqual(element.length, 1);
        assert.strictEqual(element["_dataOffset"], 11)

        element = elements.get(0x42F2)
        assert.strictEqual(element.id, 0x42F2);
        assert.strictEqual(element.length, 1);
        assert.strictEqual(element["_dataOffset"], 15)

        element = elements.get(0x42F3)
        assert.strictEqual(element.id, 0x42F3);
        assert.strictEqual(element.length, 1);
        assert.strictEqual(element["_dataOffset"], 19)

        element = elements.get(0x4282)
        assert.strictEqual(element.id, 0x4282);
        assert.strictEqual(element.length, 4);
        assert.strictEqual(element["_dataOffset"], 23)

        element = elements.get(0x4287)
        assert.strictEqual(element.id, 0x4287);
        assert.strictEqual(element.length, 1);
        assert.strictEqual(element["_dataOffset"], 30)

        element = elements.get(0x4285)
        assert.strictEqual(element.id, 0x4285);
        assert.strictEqual(element.length, 1);
        assert.strictEqual(element["_dataOffset"], 34)
    }

    @test
    public processElements() {
        // Arrange
        const parser = this.getTestParser(Ebml_ParserTests.TEST_BYTES, 4);
        const validation = [false, false, false, false, false, false, false, true];

        const actions = new Map<number, (e: EbmlElement) => void>([
            [0x4286, (e) => { assert.strictEqual(e.id, 0x4286); validation[0] = true;}],
            [0x42F7, (e) => { assert.strictEqual(e.id, 0x42F7); validation[1] = true;}],
            [0x42F2, (e) => { assert.strictEqual(e.id, 0x42F2); validation[2] = true;}],
            [0x42F3, (e) => { assert.strictEqual(e.id, 0x42F3); validation[3] = true;}],
            [0x4282, (e) => { assert.strictEqual(e.id, 0x4282); validation[4] = true;}],
            [0x4287, (e) => { assert.strictEqual(e.id, 0x4287); validation[5] = true;}],
            [0x4285, (e) => { assert.strictEqual(e.id, 0x4285); validation[6] = true;}],
            [0x1234, (e) => { validation[7] = false; }]
        ])

        // Act
        EbmlParser.processElements(parser, actions);

        // Assert
        const expected = new Array(8).fill(true);
        assert.sameOrderedMembers(validation, expected);

    }

    @test
    public readVariableInteger_1ByteValue() {
        // Arrange
        const parser = this.getTestParser([0xBB]);

        // Act
        const result = parser["readVariableInteger"](8);

        // Assert
        assert.isOk(result);
        assert.strictEqual(result.bytes, 1);
        assert.strictEqual(result.value, 0x3B);
    }

    @test
    public readVariableInteger_2ByteValue() {
        // Arrange
        const parser = this.getTestParser([0x6A, 0xAA])

        // Act
        const result = parser["readVariableInteger"](8);

        // Assert
        assert.isOk(result);
        assert.strictEqual(result.bytes, 2);
        assert.strictEqual(result.value, 0x2AAA);
    }

    @test
    public readVariableInteger_3ByteValue() {
        // Arrange
        const parser = this.getTestParser([0x36, 0x7A, 0xA5]);

        // Act
        const result = parser["readVariableInteger"](8);

        // Assert
        assert.isOk(result);
        assert.strictEqual(result.bytes, 3);
        assert.strictEqual(result.value, 0x167AA5);
    }

    @test
    public readVariableInteger_4ByteValue() {
        // Arrange
        const parser = this.getTestParser([0x1C, 0x16, 0x7A, 0xA5])

        // Act
        const result = parser["readVariableInteger"](8);

        // Assert
        assert.isOk(result);
        assert.strictEqual(result.bytes, 4);
        assert.strictEqual(result.value, 0x0C167AA5);
    }

    @test
    public readVariableInteger_5ByteValue() {
        // Arrange
        const parser = this.getTestParser([0x0E, 0x6C, 0x16, 0x7A, 0xA5]);

        // Act
        const result = parser["readVariableInteger"](8);

        // Assert
        assert.isOk(result);
        assert.strictEqual(result.bytes, 5);
        assert.strictEqual(result.value, 0x066C167AA5);
    }

    @test
    public readVariableInteger_6ByteValue() {
        // Arrange
        const parser = this.getTestParser([0x07, 0x28, 0x6C, 0x16, 0x7A, 0xA5]);

        // Act
        const result = parser["readVariableInteger"](8);

        // Assert
        assert.isOk(result);
        assert.strictEqual(result.bytes, 6);
        assert.strictEqual(result.value, 0x03286C167AA5);
    }

    @test
    public readVariableInteger_7ByteValue() {
        // Arrange
        const parser = this.getTestParser([0x03, 0x63, 0x28, 0x6C, 0x16, 0x7A, 0xA5]);

        // Act
        const result = parser["readVariableInteger"](8);

        // Assert
        assert.isOk(result);
        assert.strictEqual(result.bytes, 7);
        assert.strictEqual(result.value, 0x0163286C167AA5);
    }

    @test
    public readVariableInteger_8ByteValue() {
        // Arrange
        const parser = this.getTestParser([0x01, 0x0F, 0x63, 0x28, 0x6C, 0x16, 0x7A, 0xA5]);

        // Act
        const result = parser["readVariableInteger"](8);

        // Assert
        assert.isOk(result);
        assert.strictEqual(result.bytes, 8);
        assert.strictEqual(result.value, 0x0F63286C167AA5);
    }

    @test
    public readVariableInteger_overflow() {
        // Arrange
        const parser = this.getTestParser([0x01, 0x1F, 0x63, 0x28, 0x6C, 0x16, 0x7A, 0xA5]);

        // Act / Assert
        assert.throws(() => parser["readVariableInteger"](8));
    }

    @test
    public readVariableInteger_tooFewBytes() {
        // Arrange
        const parser = this.getTestParser([0x01, 0x1F, 0x63, 0x28, 0x6C, 0x16, 0x7A]);

        // Act / Assert
        assert.throws(() => parser["readVariableInteger"](8));
    }

    @test
    public renderVariableInteger_1ByteValue() {
        // Arrange
        const parser = this.getTestParser([], 0);

        // Act
        const result = parser["renderVariableInteger"](0x3B);

        // Assert
        Testers.bvEqual(result, [0xBB]);
    }

    @test
    public renderVariableInteger_2ByteValue() {
        // Arrange
        const parser = this.getTestParser([], 0);

        // Act
        const result = parser["renderVariableInteger"](0x2AAA);

        // Assert
        Testers.bvEqual(result, [0x6A, 0xAA]);
    }

    @test
    public renderVariableInteger_3ByteValue() {
        // Arrange
        const parser = this.getTestParser([], 0);

        // Act
        const result = parser["renderVariableInteger"](0x167AA5);

        // Assert
        Testers.bvEqual(result, [0x36, 0x7A, 0xA5]);
    }

    @test
    public renderVariableInteger_4ByteValue() {
        // Arrange
        const parser = this.getTestParser([], 0);

        // Act
        const result = parser["renderVariableInteger"](0x0C167AA5);

        // Assert
        Testers.bvEqual(result, [0x1C, 0x16, 0x7A, 0xA5]);
    }

    @test
    public renderVariableInteger_5ByteValue() {
        // Arrange
        const parser = this.getTestParser([], 0);

        // Act
        const result = parser["renderVariableInteger"](0x066C167AA5);

        // Assert
        Testers.bvEqual(result, [0x0E, 0x6C, 0x16, 0x7A, 0xA5]);
    }

    @test
    public renderVariableInteger_6ByteValue() {
        // Arrange
        const parser = this.getTestParser([], 0);

        // Act
        const result = parser["renderVariableInteger"](0x03286C167AA5);

        // Assert
        Testers.bvEqual(result, [0x07, 0x28, 0x6C, 0x16, 0x7A, 0xA5]);
    }

    @test
    public renderVariableInteger_7ByteValue() {
        // Arrange
        const parser = this.getTestParser([], 0);

        // Act
        const result = parser["renderVariableInteger"](0x0163286C167AA5);

        // Assert
        Testers.bvEqual(result, [0x03, 0x63, 0x28, 0x6C, 0x16, 0x7A, 0xA5]);
    }

    @test
    public renderVariableInteger_8ByteValue() {
        // Arrange
        const parser = this.getTestParser([], 0);

        // Act
        const result = parser["renderVariableInteger"](0x0F63286C167AA5);

        // Assert
        Testers.bvEqual(result, [0x01, 0x0F, 0x63, 0x28, 0x6C, 0x16, 0x7A, 0xA5]);
    }

    @test
    public renderVariableInteger_overflow() {
        // Arrange
        const parser = this.getTestParser([], 0);

        // Act / Assert
        assert.throws(() => parser["renderVariableInteger"](BigInt("9151314442816847872")));
    }

    private getTestParser(bytes: ByteVector|number[], offset: number = 0): EbmlParser {
        const file = TestFile.getFile(bytes);
        return new EbmlParser(file, offset, bytes.length);
    }
}

1	import {suite, test} from "@testdeck/mocha";	1✔
2	import {assert} from "chai";	1✔
3
4	import EbmlElement from "../../src/ebml/ebmlElement";
5	import EbmlParser from "../../src/ebml/ebmlParser";	1✔
6	import TestFile from "../utilities/testFile"	1✔
7	import {ByteVector} from "../../src/byteVector";
8	import {File} from "../../src/file";
9	import {Allow, Testers} from "../utilities/testers";	1✔
10
11	@suite
12	class Ebml_ParserTests {	1✔
13	private static TEST_BYTES = [	1✔
14	0x00, 0x00, 0x00, 0x00, // Buffer
15	0x42, 0x86, // Identifier (EBMLVersion)
16	0x81, // Size (1)
17	0x01, // Value (1)
18	0x42, 0xF7, // Identifier (EBMLReadVersion)
19	0x81, // Size (1)
20	0x01, // Value (1)
21	0x42, 0xF2, // Identifier (EBMLMaxIDLength)
22	0x81, // Size (1)
23	0x04, // Value (4)
24	0x42, 0xF3, // Identifier (EBMLMaxSizeLength)
25	0x81, // Size (1)
26	0x08, // Value (8)
27	0x42, 0x82, // Identifier (DocType)
28	0x84, // Size (4)
29	0x77, 0x65, 0x62, 0x6D, // Value (webm)
30	0x42, 0x87, // Identifier (DocTypeVersion)
31	0x81, // Size (1)
32	0x04, // Value (4)
33	0x42, 0x85, // Identifier (DocTypeReadVersion)
34	0x81, // Size (1)
35	0x02, // Value (2)
36	]
37
38	@test
39	public constructor_invalidParams() {	1✔
40	// Act / Assert
41	Testers.testTruthy((f: File) => new EbmlParser(f, 0, 123));	2✔
42	Testers.testSafeUint((o: number) => new EbmlParser(TestFile.mockFile(), o, 123));	5✔
43	Testers.testSafeUint((o: number) => new EbmlParser(TestFile.mockFile(), 0, o))	5✔
44	}
45
46	@test
47	public constructor_invalidOptions() {	1✔
48	// Act / Asssert
49	Testers.testSafeUint((o: number) => {	1✔
50	const options = { maxIdLength: o }	3✔
51	const _ = new EbmlParser(TestFile.mockFile(), 0, 123, options);	3✔
52	}, Allow.Undefined \| Allow.Null);
53
54	Testers.testSafeUint((o: number) => {	1✔
55	const options = { maxSizeLength: o };	3✔
56	const _ = new EbmlParser(TestFile.mockFile(), 0, 123, options);	3✔
57	}, Allow.Undefined \| Allow.Null);
58	}
59
60	@test
61	public constructor_unsupportedOptions() {	1✔
62	// Arrange 1
63	const options1 = { maxIdLength: 16 };	1✔
64
65	// Act / Assert 1
66	assert.throws(() => new EbmlParser(TestFile.mockFile(), 0, 123, options1));	1✔
67
68	// Arrange 2
69	const options2 = { maxSizeLength: 16 };	1✔
70
71	// Act / Assert 2
72	assert.throws(() => new EbmlParser(TestFile.mockFile(), 0, 123, options2));	1✔
73
74	}
75
76	@test
77	public constructor_validNoOptions() {	1✔
78	// Act
79	const parser = new EbmlParser(TestFile.mockFile(), 0, 123);	1✔
80
81	// Assert
82	assert.strictEqual(parser.currentElement, undefined);	1✔
83	assert.strictEqual(parser["_offset"], 0);	1✔
84	assert.strictEqual(parser["_maxOffset"], 123);	1✔
85	assert.strictEqual(parser["_options"].maxSizeLength, 8);	1✔
86	assert.strictEqual(parser["_options"].maxIdLength, 4);	1✔
87	}
88
89	@test
90	public constructor_validWithOptions() {	1✔
91	// Arrange
92	const options = {	1✔
93	maxSizeLength: 3,
94	maxIdLength: 5
95	};
96
97	// Act
98	const parser = new EbmlParser(TestFile.mockFile(), 0, 123, options);	1✔
99
100	// Assert
101	assert.strictEqual(parser.currentElement, undefined);	1✔
102	assert.strictEqual(parser["_offset"], 0);	1✔
103	assert.strictEqual(parser["_maxOffset"], 123);	1✔
104	assert.strictEqual(parser["_options"].maxSizeLength, 3);	1✔
105	assert.strictEqual(parser["_options"].maxIdLength, 5);	1✔
106	}
107
108	@test
109	public read() {	1✔
110	// Arrange
111	const parser = this.getTestParser(Ebml_ParserTests.TEST_BYTES, 4);	1✔
112
113	// Read 1
114	assert.isTrue(parser.read());	1✔
115	assert.strictEqual(parser["_offset"], 8);	1✔
116
117	let element = parser.currentElement;	1✔
118	assert.isOk(element);	1✔
119	assert.strictEqual(element.id, 0x4286);	1✔
120	assert.strictEqual(element.length, 1);	1✔
121	assert.strictEqual(element["_dataOffset"], 7)	1✔
122
123	// Read 2
124	assert.isTrue(parser.read());	1✔
125	assert.strictEqual(parser["_offset"], 12);	1✔
126
127	element = parser.currentElement;	1✔
128	assert.isOk(element);	1✔
129	assert.strictEqual(element.id, 0x42F7);	1✔
130	assert.strictEqual(element.length, 1);	1✔
131	assert.strictEqual(element["_dataOffset"], 11)	1✔
132
133	// Read 3
134	assert.isTrue(parser.read());	1✔
135	assert.strictEqual(parser["_offset"], 16);	1✔
136
137	element = parser.currentElement;	1✔
138	assert.isOk(element);	1✔
139	assert.strictEqual(element.id, 0x42F2);	1✔
140	assert.strictEqual(element.length, 1);	1✔
141	assert.strictEqual(element["_dataOffset"], 15)	1✔
142
143	// Read 4
144	assert.isTrue(parser.read());	1✔
145	assert.strictEqual(parser["_offset"], 20);	1✔
146
147	element = parser.currentElement;	1✔
148	assert.isOk(element);	1✔
149	assert.strictEqual(element.id, 0x42F3);	1✔
150	assert.strictEqual(element.length, 1);	1✔
151	assert.strictEqual(element["_dataOffset"], 19)	1✔
152
153	// Read 5
154	assert.isTrue(parser.read());	1✔
155	assert.strictEqual(parser["_offset"], 27);	1✔
156
157	element = parser.currentElement;	1✔
158	assert.isOk(element);	1✔
159	assert.strictEqual(element.id, 0x4282);	1✔
160	assert.strictEqual(element.length, 4);	1✔
161	assert.strictEqual(element["_dataOffset"], 23)	1✔
162
163	// Read 6
164	assert.isTrue(parser.read());	1✔
165	assert.strictEqual(parser["_offset"], 31);	1✔
166
167	element = parser.currentElement;	1✔
168	assert.isOk(element);	1✔
169	assert.strictEqual(element.id, 0x4287);	1✔
170	assert.strictEqual(element.length, 1);	1✔
171	assert.strictEqual(element["_dataOffset"], 30)	1✔
172
173	// Read 7
174	assert.isTrue(parser.read());	1✔
175	assert.strictEqual(parser["_offset"], 35);	1✔
176
177	element = parser.currentElement;	1✔
178	assert.isOk(element);	1✔
179	assert.strictEqual(element.id, 0x4285);	1✔
180	assert.strictEqual(element.length, 1);	1✔
181	assert.strictEqual(element["_dataOffset"], 34)	1✔
182
183	// Read 8
184	assert.isFalse(parser.read());	1✔
185	assert.strictEqual(parser.currentElement, element);	1✔
186	}
187
188	@test
189	public readAllValues() {	1✔
190	// Arrange
191	const parser = this.getTestParser(Ebml_ParserTests.TEST_BYTES, 4);	1✔
192
193	// Act
194	const elements = EbmlParser.getAllElements(parser);	1✔
195
196	// Assert
197	assert.isOk(elements);	1✔
198	assert.strictEqual(elements.size, 7);	1✔
199
200	let element = elements.get(0x4286)	1✔
201	assert.strictEqual(element.id, 0x4286);	1✔
202	assert.strictEqual(element.length, 1);	1✔
203	assert.strictEqual(element["_dataOffset"], 7)	1✔
204
205	element = elements.get(0x42F7)	1✔
206	assert.strictEqual(element.id, 0x42F7);	1✔
207	assert.strictEqual(element.length, 1);	1✔
208	assert.strictEqual(element["_dataOffset"], 11)	1✔
209
210	element = elements.get(0x42F2)	1✔
211	assert.strictEqual(element.id, 0x42F2);	1✔
212	assert.strictEqual(element.length, 1);	1✔
213	assert.strictEqual(element["_dataOffset"], 15)	1✔
214
215	element = elements.get(0x42F3)	1✔
216	assert.strictEqual(element.id, 0x42F3);	1✔
217	assert.strictEqual(element.length, 1);	1✔
218	assert.strictEqual(element["_dataOffset"], 19)	1✔
219
220	element = elements.get(0x4282)	1✔
221	assert.strictEqual(element.id, 0x4282);	1✔
222	assert.strictEqual(element.length, 4);	1✔
223	assert.strictEqual(element["_dataOffset"], 23)	1✔
224
225	element = elements.get(0x4287)	1✔
226	assert.strictEqual(element.id, 0x4287);	1✔
227	assert.strictEqual(element.length, 1);	1✔
228	assert.strictEqual(element["_dataOffset"], 30)	1✔
229
230	element = elements.get(0x4285)	1✔
231	assert.strictEqual(element.id, 0x4285);	1✔
232	assert.strictEqual(element.length, 1);	1✔
233	assert.strictEqual(element["_dataOffset"], 34)	1✔
234	}
235
236	@test
237	public processElements() {	1✔
238	// Arrange
239	const parser = this.getTestParser(Ebml_ParserTests.TEST_BYTES, 4);	1✔
240	const validation = [false, false, false, false, false, false, false, true];	1✔
241
242	const actions = new Map<number, (e: EbmlElement) => void>([	1✔
243	[0x4286, (e) => { assert.strictEqual(e.id, 0x4286); validation[0] = true;}],	1✔
244	[0x42F7, (e) => { assert.strictEqual(e.id, 0x42F7); validation[1] = true;}],	1✔
245	[0x42F2, (e) => { assert.strictEqual(e.id, 0x42F2); validation[2] = true;}],	1✔
246	[0x42F3, (e) => { assert.strictEqual(e.id, 0x42F3); validation[3] = true;}],	1✔
247	[0x4282, (e) => { assert.strictEqual(e.id, 0x4282); validation[4] = true;}],	1✔
248	[0x4287, (e) => { assert.strictEqual(e.id, 0x4287); validation[5] = true;}],	1✔
249	[0x4285, (e) => { assert.strictEqual(e.id, 0x4285); validation[6] = true;}],	1✔
250	[0x1234, (e) => { validation[7] = false; }]	×
251	])
252
253	// Act
254	EbmlParser.processElements(parser, actions);	1✔
255
256	// Assert
257	const expected = new Array(8).fill(true);	1✔
258	assert.sameOrderedMembers(validation, expected);	1✔
259
260	}
261
262	@test
263	public readVariableInteger_1ByteValue() {	1✔
264	// Arrange
265	const parser = this.getTestParser([0xBB]);	1✔
266
267	// Act
268	const result = parser["readVariableInteger"](8);	1✔
269
270	// Assert
271	assert.isOk(result);	1✔
272	assert.strictEqual(result.bytes, 1);	1✔
273	assert.strictEqual(result.value, 0x3B);	1✔
274	}
275
276	@test
277	public readVariableInteger_2ByteValue() {	1✔
278	// Arrange
279	const parser = this.getTestParser([0x6A, 0xAA])	1✔
280
281	// Act
282	const result = parser["readVariableInteger"](8);	1✔
283
284	// Assert
285	assert.isOk(result);	1✔
286	assert.strictEqual(result.bytes, 2);	1✔
287	assert.strictEqual(result.value, 0x2AAA);	1✔
288	}
289
290	@test
291	public readVariableInteger_3ByteValue() {	1✔
292	// Arrange
293	const parser = this.getTestParser([0x36, 0x7A, 0xA5]);	1✔
294
295	// Act
296	const result = parser["readVariableInteger"](8);	1✔
297
298	// Assert
299	assert.isOk(result);	1✔
300	assert.strictEqual(result.bytes, 3);	1✔
301	assert.strictEqual(result.value, 0x167AA5);	1✔
302	}
303
304	@test
305	public readVariableInteger_4ByteValue() {	1✔
306	// Arrange
307	const parser = this.getTestParser([0x1C, 0x16, 0x7A, 0xA5])	1✔
308
309	// Act
310	const result = parser["readVariableInteger"](8);	1✔
311
312	// Assert
313	assert.isOk(result);	1✔
314	assert.strictEqual(result.bytes, 4);	1✔
315	assert.strictEqual(result.value, 0x0C167AA5);	1✔
316	}
317
318	@test
319	public readVariableInteger_5ByteValue() {	1✔
320	// Arrange
321	const parser = this.getTestParser([0x0E, 0x6C, 0x16, 0x7A, 0xA5]);	1✔
322
323	// Act
324	const result = parser["readVariableInteger"](8);	1✔
325
326	// Assert
327	assert.isOk(result);	1✔
328	assert.strictEqual(result.bytes, 5);	1✔
329	assert.strictEqual(result.value, 0x066C167AA5);	1✔
330	}
331
332	@test
333	public readVariableInteger_6ByteValue() {	1✔
334	// Arrange
335	const parser = this.getTestParser([0x07, 0x28, 0x6C, 0x16, 0x7A, 0xA5]);	1✔
336
337	// Act
338	const result = parser["readVariableInteger"](8);	1✔
339
340	// Assert
341	assert.isOk(result);	1✔
342	assert.strictEqual(result.bytes, 6);	1✔
343	assert.strictEqual(result.value, 0x03286C167AA5);	1✔
344	}
345
346	@test
347	public readVariableInteger_7ByteValue() {	1✔
348	// Arrange
349	const parser = this.getTestParser([0x03, 0x63, 0x28, 0x6C, 0x16, 0x7A, 0xA5]);	1✔
350
351	// Act
352	const result = parser["readVariableInteger"](8);	1✔
353
354	// Assert
355	assert.isOk(result);	1✔
356	assert.strictEqual(result.bytes, 7);	1✔
357	assert.strictEqual(result.value, 0x0163286C167AA5);	1✔
358	}
359
360	@test
361	public readVariableInteger_8ByteValue() {	1✔
362	// Arrange
363	const parser = this.getTestParser([0x01, 0x0F, 0x63, 0x28, 0x6C, 0x16, 0x7A, 0xA5]);	1✔
364
365	// Act
366	const result = parser["readVariableInteger"](8);	1✔
367
368	// Assert
369	assert.isOk(result);	1✔
370	assert.strictEqual(result.bytes, 8);	1✔
371	assert.strictEqual(result.value, 0x0F63286C167AA5);	1✔
372	}
373
374	@test
375	public readVariableInteger_overflow() {	1✔
376	// Arrange
377	const parser = this.getTestParser([0x01, 0x1F, 0x63, 0x28, 0x6C, 0x16, 0x7A, 0xA5]);	1✔
378
379	// Act / Assert
380	assert.throws(() => parser["readVariableInteger"](8));	1✔
381	}
382
383	@test
384	public readVariableInteger_tooFewBytes() {	1✔
385	// Arrange
386	const parser = this.getTestParser([0x01, 0x1F, 0x63, 0x28, 0x6C, 0x16, 0x7A]);	1✔
387
388	// Act / Assert
389	assert.throws(() => parser["readVariableInteger"](8));	1✔
390	}
391
392	@test
393	public renderVariableInteger_1ByteValue() {	1✔
394	// Arrange
395	const parser = this.getTestParser([], 0);	1✔
396
397	// Act
398	const result = parser["renderVariableInteger"](0x3B);	1✔
399
400	// Assert
401	Testers.bvEqual(result, [0xBB]);	1✔
402	}
403
404	@test
405	public renderVariableInteger_2ByteValue() {	1✔
406	// Arrange
407	const parser = this.getTestParser([], 0);	1✔
408
409	// Act
410	const result = parser["renderVariableInteger"](0x2AAA);	1✔
411
412	// Assert
413	Testers.bvEqual(result, [0x6A, 0xAA]);	1✔
414	}
415
416	@test
417	public renderVariableInteger_3ByteValue() {	1✔
418	// Arrange
419	const parser = this.getTestParser([], 0);	1✔
420
421	// Act
422	const result = parser["renderVariableInteger"](0x167AA5);	1✔
423
424	// Assert
425	Testers.bvEqual(result, [0x36, 0x7A, 0xA5]);	1✔
426	}
427
428	@test
429	public renderVariableInteger_4ByteValue() {	1✔
430	// Arrange
431	const parser = this.getTestParser([], 0);	1✔
432
433	// Act
434	const result = parser["renderVariableInteger"](0x0C167AA5);	1✔
435
436	// Assert
437	Testers.bvEqual(result, [0x1C, 0x16, 0x7A, 0xA5]);	1✔
438	}
439
440	@test
441	public renderVariableInteger_5ByteValue() {	1✔
442	// Arrange
443	const parser = this.getTestParser([], 0);	1✔
444
445	// Act
446	const result = parser["renderVariableInteger"](0x066C167AA5);	1✔
447
448	// Assert
449	Testers.bvEqual(result, [0x0E, 0x6C, 0x16, 0x7A, 0xA5]);	1✔
450	}
451
452	@test
453	public renderVariableInteger_6ByteValue() {	1✔
454	// Arrange
455	const parser = this.getTestParser([], 0);	1✔
456
457	// Act
458	const result = parser["renderVariableInteger"](0x03286C167AA5);	1✔
459
460	// Assert
461	Testers.bvEqual(result, [0x07, 0x28, 0x6C, 0x16, 0x7A, 0xA5]);	1✔
462	}
463
464	@test
465	public renderVariableInteger_7ByteValue() {	1✔
466	// Arrange
467	const parser = this.getTestParser([], 0);	1✔
468
469	// Act
470	const result = parser["renderVariableInteger"](0x0163286C167AA5);	1✔
471
472	// Assert
473	Testers.bvEqual(result, [0x03, 0x63, 0x28, 0x6C, 0x16, 0x7A, 0xA5]);	1✔
474	}
475
476	@test
477	public renderVariableInteger_8ByteValue() {	1✔
478	// Arrange
479	const parser = this.getTestParser([], 0);	1✔
480
481	// Act
482	const result = parser["renderVariableInteger"](0x0F63286C167AA5);	1✔
483
484	// Assert
485	Testers.bvEqual(result, [0x01, 0x0F, 0x63, 0x28, 0x6C, 0x16, 0x7A, 0xA5]);	1✔
486	}
487
488	@test
489	public renderVariableInteger_overflow() {	1✔
490	// Arrange
491	const parser = this.getTestParser([], 0);	1✔
492
493	// Act / Assert
494	assert.throws(() => parser["renderVariableInteger"](BigInt("9151314442816847872")));	1✔
495	}
496
497	private getTestParser(bytes: ByteVector\|number[], offset: number = 0): EbmlParser {	10✔
498	const file = TestFile.getFile(bytes);	22✔
499	return new EbmlParser(file, offset, bytes.length);	22✔
500	}
501	}

benrr101 / node-taglib-sharp / 46462135

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous