1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
importScripts("resource://gre/modules/workers/require.js");
importScripts("resource://gre/modules/osfile.jsm");
function do_print(x) {
// self.postMessage({kind: "do_print", args: [x]});
dump("TEST-INFO: " + x + "\n");
}
function do_check_true(x) {
self.postMessage({kind: "do_check_true", args: [!!x]});
if (x) {
dump("TEST-PASS: " + x + "\n");
} else {
throw new Error("do_check_true failed");
}
}
function do_check_eq(a, b) {
let result = a == b;
self.postMessage({kind: "do_check_true", args: [result]});
if (!result) {
throw new Error("do_check_eq failed " + a + " != " + b);
}
}
function do_test_complete() {
self.postMessage({kind: "do_test_complete", args:[]});
}
self.onmessage = function() {
try {
run_test();
} catch (ex) {
let {message, moduleStack, moduleName, lineNumber} = ex;
let error = new Error(message, moduleName, lineNumber);
error.stack = moduleStack;
dump("Uncaught error: " + error + "\n");
dump("Full stack: " + moduleStack + "\n");
throw error;
}
};
var Lz4;
var Internals;
function test_import() {
Lz4 = require("resource://gre/modules/lz4.js");
Internals = require("resource://gre/modules/lz4_internal.js");
}
function test_bound() {
for (let k of ["compress", "decompress", "maxCompressedSize"]) {
try {
do_print("Checking the existence of " + k + "\n");
do_check_true(!!Internals[k]);
do_print(k + " exists");
} catch (ex) {
// Ignore errors
do_print(k + " doesn't exist!");
}
}
}
function test_reference_file() {
do_print("Decompress reference file");
let path = OS.Path.join("data", "compression.lz");
let data = OS.File.read(path);
let decompressed = Lz4.decompressFileContent(data);
let text = (new TextDecoder()).decode(decompressed);
do_check_eq(text, "Hello, lz4");
}
function compare_arrays(a, b) {
return Array.prototype.join.call(a) == Array.prototype.join.call(a);
}
function run_rawcompression(name, array) {
do_print("Raw compression test " + name);
let length = array.byteLength;
let compressedArray = new Uint8Array(Internals.maxCompressedSize(length));
let compressedBytes = Internals.compress(array, length, compressedArray);
compressedArray = new Uint8Array(compressedArray.buffer, 0, compressedBytes);
do_print("Raw compressed: " + length + " into " + compressedBytes);
let decompressedArray = new Uint8Array(length);
let decompressedBytes = new ctypes.size_t();
let success = Internals.decompress(compressedArray, compressedBytes,
decompressedArray, length,
decompressedBytes.address());
do_print("Raw decompression success? " + success);
do_print("Raw decompression size: " + decompressedBytes.value);
do_check_true(compare_arrays(array, decompressedArray));
}
function run_filecompression(name, array) {
do_print("File compression test " + name);
let compressed = Lz4.compressFileContent(array);
do_print("Compressed " + array.byteLength + " bytes into " + compressed.byteLength);
let decompressed = Lz4.decompressFileContent(compressed);
do_print("Decompressed " + compressed.byteLength + " bytes into " + decompressed.byteLength);
do_check_true(compare_arrays(array, decompressed));
}
function run_faileddecompression(name, array) {
do_print("invalid decompression test " + name);
// Ensure that raw decompression doesn't segfault
let length = 1 << 14;
let decompressedArray = new Uint8Array(length);
let decompressedBytes = new ctypes.size_t();
Internals.decompress(array, array.byteLength,
decompressedArray, length,
decompressedBytes.address());
// File decompression should fail with an acceptable exception
let exn = null;
try {
Lz4.decompressFileContent(array);
} catch (ex) {
exn = ex;
}
do_check_true(exn);
if (array.byteLength < 10) {
do_check_true(exn.becauseLZNoHeader);
} else {
do_check_true(exn.becauseLZWrongMagicNumber);
}
}
function run_test() {
test_import();
test_bound();
test_reference_file();
for (let length of [0, 1, 1024]) {
let array = new Uint8Array(length);
for (let i = 0; i < length; ++i) {
array[i] = i % 256;
}
let name = length + " bytes";
run_rawcompression(name, array);
run_filecompression(name, array);
run_faileddecompression(name, array);
}
do_test_complete();
}
|
