2024-01-01 19:58:21 +00:00
|
|
|
// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
|
2023-06-24 14:12:08 +00:00
|
|
|
|
2024-02-13 02:05:10 +00:00
|
|
|
import { assert, assertEquals } from "@std/assert/mod.ts";
|
|
|
|
import { fromFileUrl, relative } from "@std/path/mod.ts";
|
2023-06-24 14:12:08 +00:00
|
|
|
import {
|
2023-12-31 11:53:09 +00:00
|
|
|
brotliCompress,
|
2023-06-24 14:12:08 +00:00
|
|
|
brotliCompressSync,
|
|
|
|
brotliDecompressSync,
|
|
|
|
createBrotliCompress,
|
|
|
|
createBrotliDecompress,
|
2023-08-11 11:42:35 +00:00
|
|
|
createDeflate,
|
2024-01-03 13:33:51 +00:00
|
|
|
gzipSync,
|
|
|
|
unzipSync,
|
2023-06-24 14:12:08 +00:00
|
|
|
} from "node:zlib";
|
|
|
|
import { Buffer } from "node:buffer";
|
|
|
|
import { createReadStream, createWriteStream } from "node:fs";
|
2024-02-07 16:23:32 +00:00
|
|
|
import { Readable } from "node:stream";
|
|
|
|
import { buffer } from "node:stream/consumers";
|
2023-06-24 14:12:08 +00:00
|
|
|
|
|
|
|
Deno.test("brotli compression sync", () => {
|
|
|
|
const buf = Buffer.from("hello world");
|
|
|
|
const compressed = brotliCompressSync(buf);
|
|
|
|
const decompressed = brotliDecompressSync(compressed);
|
|
|
|
assertEquals(decompressed.toString(), "hello world");
|
|
|
|
});
|
|
|
|
|
2023-12-31 11:53:09 +00:00
|
|
|
Deno.test("brotli compression async", async () => {
|
|
|
|
const buf = Buffer.from("hello world");
|
|
|
|
const compressed: Buffer = await new Promise((resolve) =>
|
|
|
|
brotliCompress(buf, (_, res) => {
|
|
|
|
return resolve(res);
|
|
|
|
})
|
|
|
|
);
|
|
|
|
assertEquals(compressed instanceof Buffer, true);
|
|
|
|
const decompressed = brotliDecompressSync(compressed);
|
|
|
|
assertEquals(decompressed.toString(), "hello world");
|
|
|
|
});
|
|
|
|
|
2024-01-03 13:33:51 +00:00
|
|
|
Deno.test("gzip compression sync", { sanitizeResources: false }, () => {
|
|
|
|
const buf = Buffer.from("hello world");
|
|
|
|
const compressed = gzipSync(buf);
|
|
|
|
const decompressed = unzipSync(compressed);
|
|
|
|
assertEquals(decompressed.toString(), "hello world");
|
|
|
|
});
|
|
|
|
|
2024-03-21 17:01:11 +00:00
|
|
|
Deno.test("brotli compression", {
|
|
|
|
ignore: true,
|
|
|
|
}, async () => {
|
2024-03-01 20:48:09 +00:00
|
|
|
const promise = Promise.withResolvers<void>();
|
2023-06-24 14:12:08 +00:00
|
|
|
const compress = createBrotliCompress();
|
|
|
|
const filePath = relative(
|
|
|
|
Deno.cwd(),
|
|
|
|
fromFileUrl(new URL("./testdata/lorem_ipsum.txt", import.meta.url)),
|
|
|
|
);
|
|
|
|
const input = createReadStream(filePath);
|
|
|
|
const output = createWriteStream("lorem_ipsum.txt.br");
|
|
|
|
|
|
|
|
const stream = input.pipe(compress).pipe(output);
|
|
|
|
|
|
|
|
stream.on("finish", () => {
|
|
|
|
const decompress = createBrotliDecompress();
|
|
|
|
const input2 = createReadStream("lorem_ipsum.txt.br");
|
|
|
|
const output2 = createWriteStream("lorem_ipsum.txt");
|
|
|
|
|
|
|
|
const stream2 = input2.pipe(decompress).pipe(output2);
|
2024-03-01 20:48:09 +00:00
|
|
|
stream2.on("close", () => promise.resolve());
|
2023-06-24 14:12:08 +00:00
|
|
|
});
|
|
|
|
|
2024-03-01 20:48:09 +00:00
|
|
|
await Promise.all([
|
|
|
|
promise.promise,
|
|
|
|
new Promise((r) => stream.on("close", r)),
|
|
|
|
]);
|
|
|
|
|
2023-06-24 14:12:08 +00:00
|
|
|
const content = Deno.readTextFileSync("lorem_ipsum.txt");
|
2024-03-21 17:01:11 +00:00
|
|
|
assert(content.startsWith("Lorem ipsum dolor sit amet"), content);
|
2023-06-24 14:12:08 +00:00
|
|
|
try {
|
|
|
|
Deno.removeSync("lorem_ipsum.txt.br");
|
|
|
|
} catch {
|
|
|
|
// pass
|
|
|
|
}
|
|
|
|
try {
|
|
|
|
Deno.removeSync("lorem_ipsum.txt");
|
|
|
|
} catch {
|
|
|
|
// pass
|
|
|
|
}
|
|
|
|
});
|
2023-08-11 11:42:35 +00:00
|
|
|
|
2023-09-08 03:41:33 +00:00
|
|
|
Deno.test("brotli end-to-end with 4097 bytes", () => {
|
|
|
|
const a = "a".repeat(4097);
|
|
|
|
const compressed = brotliCompressSync(a);
|
|
|
|
const decompressed = brotliDecompressSync(compressed);
|
|
|
|
assertEquals(decompressed.toString(), a);
|
|
|
|
});
|
|
|
|
|
2023-08-11 11:42:35 +00:00
|
|
|
Deno.test(
|
|
|
|
"zlib create deflate with dictionary",
|
|
|
|
{ sanitizeResources: false },
|
|
|
|
async () => {
|
2023-11-22 11:11:20 +00:00
|
|
|
const { promise, resolve } = Promise.withResolvers<void>();
|
2023-08-11 11:42:35 +00:00
|
|
|
const handle = createDeflate({
|
|
|
|
dictionary: Buffer.alloc(0),
|
|
|
|
});
|
|
|
|
|
2023-11-22 11:11:20 +00:00
|
|
|
handle.on("close", () => resolve());
|
2023-08-11 11:42:35 +00:00
|
|
|
handle.end();
|
|
|
|
handle.destroy();
|
|
|
|
|
|
|
|
await promise;
|
|
|
|
},
|
|
|
|
);
|
2023-12-13 16:58:56 +00:00
|
|
|
|
|
|
|
Deno.test(
|
|
|
|
"zlib flush i32",
|
|
|
|
// FIXME: Handle is not closed properly
|
|
|
|
{ sanitizeResources: false },
|
|
|
|
function () {
|
|
|
|
const handle = createDeflate({
|
|
|
|
// @ts-expect-error: passing non-int flush value
|
|
|
|
flush: "",
|
|
|
|
});
|
|
|
|
|
|
|
|
handle.end();
|
|
|
|
handle.destroy();
|
|
|
|
},
|
|
|
|
);
|
2023-12-31 11:50:37 +00:00
|
|
|
|
|
|
|
Deno.test("should work with dataview", () => {
|
|
|
|
const buf = Buffer.from("hello world");
|
|
|
|
const compressed = brotliCompressSync(new DataView(buf.buffer));
|
|
|
|
const decompressed = brotliDecompressSync(compressed);
|
|
|
|
assertEquals(decompressed.toString(), "hello world");
|
|
|
|
});
|
|
|
|
|
|
|
|
Deno.test("should work with a buffer from an encoded string", () => {
|
|
|
|
const encoder = new TextEncoder();
|
|
|
|
const buffer = encoder.encode("hello world");
|
|
|
|
const buf = Buffer.from(buffer);
|
|
|
|
const compressed = brotliCompressSync(buf);
|
|
|
|
const decompressed = brotliDecompressSync(compressed);
|
|
|
|
assertEquals(decompressed.toString(), "hello world");
|
|
|
|
});
|
2024-01-03 13:33:51 +00:00
|
|
|
|
|
|
|
Deno.test(
|
|
|
|
"zlib compression with dataview",
|
|
|
|
{ sanitizeResources: false },
|
|
|
|
() => {
|
|
|
|
const buf = Buffer.from("hello world");
|
|
|
|
const compressed = gzipSync(new DataView(buf.buffer));
|
|
|
|
const decompressed = unzipSync(compressed);
|
|
|
|
assertEquals(decompressed.toString(), "hello world");
|
|
|
|
},
|
|
|
|
);
|
|
|
|
|
|
|
|
Deno.test("zlib compression with an encoded string", {
|
|
|
|
sanitizeResources: false,
|
|
|
|
}, () => {
|
|
|
|
const encoder = new TextEncoder();
|
|
|
|
const buffer = encoder.encode("hello world");
|
|
|
|
const compressed = gzipSync(buffer);
|
|
|
|
const decompressed = unzipSync(compressed);
|
|
|
|
assertEquals(decompressed.toString(), "hello world");
|
|
|
|
});
|
2024-02-07 16:23:32 +00:00
|
|
|
|
|
|
|
Deno.test("brotli large chunk size", async () => {
|
|
|
|
const input = new Uint8Array(1000000);
|
|
|
|
for (let i = 0; i < input.length; i++) {
|
|
|
|
input[i] = Math.random() * 256;
|
|
|
|
}
|
|
|
|
const output = await buffer(
|
|
|
|
Readable.from([input])
|
|
|
|
.pipe(createBrotliCompress())
|
|
|
|
.pipe(createBrotliDecompress()),
|
|
|
|
);
|
|
|
|
assertEquals(output.length, input.length);
|
|
|
|
});
|
2024-03-12 11:53:31 +00:00
|
|
|
|
|
|
|
Deno.test("brotli decompress flush restore size", async () => {
|
|
|
|
const input = new Uint8Array(1000000);
|
|
|
|
const output = await buffer(
|
|
|
|
Readable.from([input])
|
|
|
|
.pipe(createBrotliCompress())
|
|
|
|
.pipe(createBrotliDecompress()),
|
|
|
|
);
|
|
|
|
assertEquals(output.length, input.length);
|
|
|
|
});
|