Diffusion Ant (mir/inline-method) Code

ant/examples/spec/streams-compression.js
3fa05edd2fe3mir/inline-method

streams-compression.js
View Options

			import { test, testThrows, summary } from './helpers.js';

			console.log('CompressionStream / DecompressionStream Tests\n');

			test('CS typeof', typeof CompressionStream, 'function');
			test('CS toStringTag', Object.prototype.toString.call(new CompressionStream('gzip')), '[object CompressionStream]');

			testThrows('CS requires new', () => CompressionStream('gzip'));
			testThrows('CS requires format', () => new CompressionStream());
			testThrows('CS rejects invalid format', () => new CompressionStream('invalid'));

			const cs0 = new CompressionStream('gzip');
			test('CS readable is ReadableStream', cs0.readable instanceof ReadableStream, true);
			test('CS writable is WritableStream', cs0.writable instanceof WritableStream, true);

			test('DS typeof', typeof DecompressionStream, 'function');
			test('DS toStringTag', Object.prototype.toString.call(new DecompressionStream('gzip')), '[object DecompressionStream]');

			testThrows('DS requires new', () => DecompressionStream('gzip'));
			testThrows('DS requires format', () => new DecompressionStream());
			testThrows('DS rejects invalid format', () => new DecompressionStream('invalid'));

			const ds0 = new DecompressionStream('gzip');
			test('DS readable is ReadableStream', ds0.readable instanceof ReadableStream, true);
			test('DS writable is WritableStream', ds0.writable instanceof WritableStream, true);

			const csBrotli = new CompressionStream('brotli');
			test('CS brotli toStringTag', Object.prototype.toString.call(csBrotli), '[object CompressionStream]');

			async function collectStream(readable) {
			const reader = readable.getReader();
			const chunks = [];
			while (true) {
			const { value, done } = await reader.read();
			if (done) break;
			chunks.push(value);
			}
			let total = 0;
			for (const c of chunks) total += c.byteLength;
			const result = new Uint8Array(total);
			let offset = 0;
			for (const c of chunks) {
			result.set(c, offset);
			offset += c.byteLength;
			}
			return result;
			}

			async function testGzipRoundTrip() {
			const input = new TextEncoder().encode('Hello, compression world!');
			const cs = new CompressionStream('gzip');
			const writer = cs.writable.getWriter();
			writer.write(input);
			writer.close();
			const compressed = await collectStream(cs.readable);
			test('gzip compressed is smaller or has gzip header', compressed[0], 0x1f);
			test('gzip compressed header byte 2', compressed[1], 0x8b);

			const ds = new DecompressionStream('gzip');
			const writer2 = ds.writable.getWriter();
			writer2.write(compressed);
			writer2.close();
			const decompressed = await collectStream(ds.readable);
			test('gzip roundtrip length', decompressed.length, input.length);
			test('gzip roundtrip value', new TextDecoder().decode(decompressed), 'Hello, compression world!');
			}

			async function testDeflateRoundTrip() {
			const input = new TextEncoder().encode('Deflate test data');
			const cs = new CompressionStream('deflate');
			const writer = cs.writable.getWriter();
			writer.write(input);
			writer.close();
			const compressed = await collectStream(cs.readable);
			test('deflate compressed length > 0', compressed.length > 0, true);

			const ds = new DecompressionStream('deflate');
			const writer2 = ds.writable.getWriter();
			writer2.write(compressed);
			writer2.close();
			const decompressed = await collectStream(ds.readable);
			test('deflate roundtrip', new TextDecoder().decode(decompressed), 'Deflate test data');
			}

			async function testDeflateRawRoundTrip() {
			const input = new TextEncoder().encode('Raw deflate test');
			const cs = new CompressionStream('deflate-raw');
			const writer = cs.writable.getWriter();
			writer.write(input);
			writer.close();
			const compressed = await collectStream(cs.readable);
			test('deflate-raw compressed length > 0', compressed.length > 0, true);

			const ds = new DecompressionStream('deflate-raw');
			const writer2 = ds.writable.getWriter();
			writer2.write(compressed);
			writer2.close();
			const decompressed = await collectStream(ds.readable);
			test('deflate-raw roundtrip', new TextDecoder().decode(decompressed), 'Raw deflate test');
			}

			async function testBrotliRoundTrip() {
			const input = new TextEncoder().encode('brotli stream test data');
			const cs = new CompressionStream('brotli');
			const writer = cs.writable.getWriter();
			writer.write(input);
			writer.close();
			const compressed = await collectStream(cs.readable);
			test('brotli compressed length > 0', compressed.length > 0, true);

			const ds = new DecompressionStream('brotli');
			const writer2 = ds.writable.getWriter();
			writer2.write(compressed);
			writer2.close();
			const reader = ds.readable.getReader();
			const first = await reader.read();
			test('brotli decompressed chunk is Uint8Array', first.value.constructor, Uint8Array);
			test('brotli roundtrip', new TextDecoder().decode(first.value), 'brotli stream test data');
			}

			async function testPipeThrough() {
			const input = 'pipe through compression test';
			const encoded = new TextEncoder().encode(input);
			const rs = new ReadableStream({
			start(c) {
			c.enqueue(encoded);
			c.close();
			}
			});
			const compressed = await collectStream(rs.pipeThrough(new CompressionStream('gzip')));

			const rs2 = new ReadableStream({
			start(c) {
			c.enqueue(compressed);
			c.close();
			}
			});
			const decompressed = await collectStream(rs2.pipeThrough(new DecompressionStream('gzip')));
			test('pipeThrough roundtrip', new TextDecoder().decode(decompressed), input);
			}

			async function testMultipleChunks() {
			const cs = new CompressionStream('gzip');
			const writer = cs.writable.getWriter();
			writer.write(new TextEncoder().encode('chunk1 '));
			writer.write(new TextEncoder().encode('chunk2 '));
			writer.write(new TextEncoder().encode('chunk3'));
			writer.close();
			const compressed = await collectStream(cs.readable);

			const ds = new DecompressionStream('gzip');
			const writer2 = ds.writable.getWriter();
			writer2.write(compressed);
			writer2.close();
			const decompressed = await collectStream(ds.readable);
			test('multi-chunk roundtrip', new TextDecoder().decode(decompressed), 'chunk1 chunk2 chunk3');
			}

			async function testLargeData() {
			const str = 'x'.repeat(100000);
			const input = new TextEncoder().encode(str);
			const cs = new CompressionStream('gzip');
			const writer = cs.writable.getWriter();
			writer.write(input);
			writer.close();
			const compressed = await collectStream(cs.readable);
			test('large data compresses', compressed.length < input.length, true);

			const ds = new DecompressionStream('gzip');
			const writer2 = ds.writable.getWriter();
			writer2.write(compressed);
			writer2.close();
			const decompressed = await collectStream(ds.readable);
			test('large data roundtrip length', decompressed.length, input.length);
			}

			await testGzipRoundTrip();
			await testDeflateRoundTrip();
			await testDeflateRawRoundTrip();
			await testBrotliRoundTrip();
			await testPipeThrough();
			await testMultipleChunks();
			await testLargeData();

			summary();

Owner Packages

No Owners