test,stream: enable compression WPTs

PR-URL: #50631 Reviewed-By: James M Snell <[email protected]> Reviewed-By: Matteo Collina <[email protected]>

Author: panva

test/common/wpt.js

@@ -210,6 +210,7 @@ class ResourceLoader{
 constdata=awaitfsPromises.readFile(file);
 return{
 ok: true,
+arrayBuffer(){returndata.buffer;},
 json(){returnJSON.parse(data.toString());},
 text(){returndata.toString();},
 };
@@ -382,7 +383,7 @@ const kIntlRequirement ={
 // TODO(joyeecheung): we may need to deal with --with-intl=system-icu
 };
 
-classIntlRequirement{
+classBuildRequirement{
 constructor(){
 this.currentIntl=kIntlRequirement.none;
 if(process.config.variables.v8_enable_i18n_support===0){
@@ -395,6 +396,9 @@ class IntlRequirement{
 }else{
 this.currentIntl=kIntlRequirement.full;
 }
+// Not using common.hasCrypto because of the global leak checks
+this.hasCrypto=Boolean(process.versions.openssl)&&
+!process.env.NODE_SKIP_CRYPTO;
 }
 
 /**
@@ -409,11 +413,14 @@ class IntlRequirement{
 if(requires.has('small-icu')&&current<kIntlRequirement.small){
 return'small-icu';
 }
+if(requires.has('crypto')&&!this.hasCrypto){
+return'crypto';
+}
 returnfalse;
 }
 }
 
-constintlRequirements=newIntlRequirement();
+constbuildRequirements=newBuildRequirement();
 
 classStatusLoader{
 /**
@@ -440,7 +447,7 @@ class StatusLoader{
 constlist=this.grep(filepath);
 result=result.concat(list);
 }else{
-if(!(/\.\w+\.js$/.test(filepath))||filepath.endsWith('.helper.js')){
+if(!(/\.\w+\.js$/.test(filepath))){
 continue;
 }
 result.push(filepath);
@@ -945,9 +952,9 @@ class WPTRunner{
 continue;
 }
 
-constlackingIntl=intlRequirements.isLacking(spec.requires);
-if(lackingIntl){
-this.skip(spec,[`requires ${lackingIntl}`]);
+constlackingSupport=buildRequirements.isLacking(spec.requires);
+if(lackingSupport){
+this.skip(spec,[`requires ${lackingSupport}`]);
 continue;
 }
 

test/fixtures/wpt/README.md

@@ -11,6 +11,7 @@ See [test/wpt](../../wpt/README.md) for information on how these tests are run.
 Last update:
 
 - common: https://github.com/web-platform-tests/wpt/tree/dbd648158d/common
+- compression: https://github.com/web-platform-tests/wpt/tree/c82521cfa5/compression
 - console: https://github.com/web-platform-tests/wpt/tree/767ae35464/console
 - dom/abort: https://github.com/web-platform-tests/wpt/tree/d1f1ecbd52/dom/abort
 - dom/events: https://github.com/web-platform-tests/wpt/tree/ab8999891c/dom/events

test/fixtures/wpt/compression/META.yml

@@ -0,0 +1,3 @@
+spec: https://wicg.github.io/compression/
+suggested_reviewers:
+ - ricea

test/fixtures/wpt/compression/compression-bad-chunks.tentative.any.js

@@ -0,0 +1,74 @@
+// META: global=window,worker,shadowrealm
+
+'use strict';
+
+constbadChunks=[
+{
+name: 'undefined',
+value: undefined
+},
+{
+name: 'null',
+value: null
+},
+{
+name: 'numeric',
+value: 3.14
+},
+{
+name: 'object, not BufferSource',
+value: {}
+},
+{
+name: 'array',
+value: [65]
+},
+{
+name: 'SharedArrayBuffer',
+// Use a getter to postpone construction so that all tests don't fail where
+// SharedArrayBuffer is not yet implemented.
+getvalue(){
+// See https://github.com/whatwg/html/issues/5380 for why not `new SharedArrayBuffer()`
+returnnewWebAssembly.Memory({shared:true,initial:1,maximum:1}).buffer;
+}
+},
+{
+name: 'shared Uint8Array',
+getvalue(){
+// See https://github.com/whatwg/html/issues/5380 for why not `new SharedArrayBuffer()`
+returnnewUint8Array(newWebAssembly.Memory({shared:true,initial:1,maximum:1}).buffer)
+}
+},
+];
+
+for(constchunkofbadChunks){
+promise_test(asynct=>{
+constcs=newCompressionStream('gzip');
+constreader=cs.readable.getReader();
+constwriter=cs.writable.getWriter();
+constwritePromise=writer.write(chunk.value);
+constreadPromise=reader.read();
+awaitpromise_rejects_js(t,TypeError,writePromise,'write should reject');
+awaitpromise_rejects_js(t,TypeError,readPromise,'read should reject');
+},`chunk of type ${chunk.name} should error the stream for gzip`);
+
+promise_test(asynct=>{
+constcs=newCompressionStream('deflate');
+constreader=cs.readable.getReader();
+constwriter=cs.writable.getWriter();
+constwritePromise=writer.write(chunk.value);
+constreadPromise=reader.read();
+awaitpromise_rejects_js(t,TypeError,writePromise,'write should reject');
+awaitpromise_rejects_js(t,TypeError,readPromise,'read should reject');
+},`chunk of type ${chunk.name} should error the stream for deflate`);
+
+promise_test(asynct=>{
+constcs=newCompressionStream('deflate-raw');
+constreader=cs.readable.getReader();
+constwriter=cs.writable.getWriter();
+constwritePromise=writer.write(chunk.value);
+constreadPromise=reader.read();
+awaitpromise_rejects_js(t,TypeError,writePromise,'write should reject');
+awaitpromise_rejects_js(t,TypeError,readPromise,'read should reject');
+},`chunk of type ${chunk.name} should error the stream for deflate-raw`);
+}

test/fixtures/wpt/compression/compression-constructor-error.tentative.any.js

@@ -0,0 +1,15 @@
+// META: global=window,worker,shadowrealm
+
+'use strict';
+
+test(t=>{
+assert_throws_js(TypeError,()=>newCompressionStream('a'),'constructor should throw');
+},'"a" should cause the constructor to throw');
+
+test(t=>{
+assert_throws_js(TypeError,()=>newCompressionStream(),'constructor should throw');
+},'no input should cause the constructor to throw');
+
+test(t=>{
+assert_throws_js(Error,()=>newCompressionStream({toString(){throwError();}}),'constructor should throw');
+},'non-string input should cause the constructor to throw');

test/fixtures/wpt/compression/compression-including-empty-chunk.tentative.any.js

@@ -0,0 +1,63 @@
+// META: global=window,worker,shadowrealm
+// META: script=third_party/pako/pako_inflate.min.js
+// META: timeout=long
+
+'use strict';
+
+// This test asserts that compressing '' doesn't affect the compressed data.
+// Example: compressing ['Hello', '', 'Hello'] results in 'HelloHello'
+
+asyncfunctioncompressChunkList(chunkList,format){
+constcs=newCompressionStream(format);
+constwriter=cs.writable.getWriter();
+for(constchunkofchunkList){
+constchunkByte=newTextEncoder().encode(chunk);
+writer.write(chunkByte);
+}
+constclosePromise=writer.close();
+constout=[];
+constreader=cs.readable.getReader();
+lettotalSize=0;
+while(true){
+const{ value, done }=awaitreader.read();
+if(done)
+break;
+out.push(value);
+totalSize+=value.byteLength;
+}
+awaitclosePromise;
+constconcatenated=newUint8Array(totalSize);
+letoffset=0;
+for(constarrayofout){
+concatenated.set(array,offset);
+offset+=array.byteLength;
+}
+returnconcatenated;
+}
+
+constchunkLists=[
+['','Hello','Hello'],
+['Hello','','Hello'],
+['Hello','Hello','']
+];
+constexpectedValue=newTextEncoder().encode('HelloHello');
+
+for(constchunkListofchunkLists){
+promise_test(asynct=>{
+constcompressedData=awaitcompressChunkList(chunkList,'deflate');
+// decompress with pako, and check that we got the same result as our original string
+assert_array_equals(expectedValue,pako.inflate(compressedData),'value should match');
+},`the result of compressing [${chunkList}] with deflate should be 'HelloHello'`);
+
+promise_test(asynct=>{
+constcompressedData=awaitcompressChunkList(chunkList,'gzip');
+// decompress with pako, and check that we got the same result as our original string
+assert_array_equals(expectedValue,pako.inflate(compressedData),'value should match');
+},`the result of compressing [${chunkList}] with gzip should be 'HelloHello'`);
+
+promise_test(asynct=>{
+constcompressedData=awaitcompressChunkList(chunkList,'deflate-raw');
+// decompress with pako, and check that we got the same result as our original string
+assert_array_equals(expectedValue,pako.inflateRaw(compressedData),'value should match');
+},`the result of compressing [${chunkList}] with deflate-raw should be 'HelloHello'`);
+}

test/fixtures/wpt/compression/compression-large-flush-output.any.js

@@ -0,0 +1,41 @@
+// META: global=window,worker,shadowrealm
+// META: script=third_party/pako/pako_inflate.min.js
+// META: script=resources/concatenate-stream.js
+// META: timeout=long
+
+'use strict';
+
+// This test verifies that a large flush output will not truncate the
+// final results.
+
+asyncfunctioncompressData(chunk,format){
+constcs=newCompressionStream(format);
+constwriter=cs.writable.getWriter();
+writer.write(chunk);
+writer.close();
+returnawaitconcatenateStream(cs.readable);
+}
+
+// JSON-encoded array of 10 thousands numbers ("[0,1,2,...]"). This produces 48_891 bytes of data.
+constfullData=newTextEncoder().encode(JSON.stringify(Array.from({length: 10_000},(_,i)=>i)));
+constdata=fullData.subarray(0,35_579);
+constexpectedValue=data;
+
+promise_test(asynct=>{
+constcompressedData=awaitcompressData(data,'deflate');
+// decompress with pako, and check that we got the same result as our original string
+assert_array_equals(expectedValue,pako.inflate(compressedData),'value should match');
+},`deflate compression with large flush output`);
+
+promise_test(asynct=>{
+constcompressedData=awaitcompressData(data,'gzip');
+// decompress with pako, and check that we got the same result as our original string
+assert_array_equals(expectedValue,pako.inflate(compressedData),'value should match');
+},`gzip compression with large flush output`);
+
+promise_test(asynct=>{
+constcompressedData=awaitcompressData(data,'deflate-raw');
+// decompress with pako, and check that we got the same result as our original string
+assert_array_equals(expectedValue,pako.inflateRaw(compressedData),'value should match');
+},`deflate-raw compression with large flush output`);
+

test/fixtures/wpt/compression/compression-multiple-chunks.tentative.any.js

@@ -0,0 +1,67 @@
+// META: global=window,worker,shadowrealm
+// META: script=third_party/pako/pako_inflate.min.js
+// META: timeout=long
+
+'use strict';
+
+// This test asserts that compressing multiple chunks should work.
+
+// Example: ('Hello', 3) => TextEncoder().encode('HelloHelloHello')
+functionmakeExpectedChunk(input,numberOfChunks){
+constexpectedChunk=input.repeat(numberOfChunks);
+returnnewTextEncoder().encode(expectedChunk);
+}
+
+// Example: ('Hello', 3, 'deflate') => compress ['Hello', 'Hello', Hello']
+asyncfunctioncompressMultipleChunks(input,numberOfChunks,format){
+constcs=newCompressionStream(format);
+constwriter=cs.writable.getWriter();
+constchunk=newTextEncoder().encode(input);
+for(leti=0;i<numberOfChunks;++i){
+writer.write(chunk);
+}
+constclosePromise=writer.close();
+constout=[];
+constreader=cs.readable.getReader();
+lettotalSize=0;
+while(true){
+const{ value, done }=awaitreader.read();
+if(done)
+break;
+out.push(value);
+totalSize+=value.byteLength;
+}
+awaitclosePromise;
+constconcatenated=newUint8Array(totalSize);
+letoffset=0;
+for(constarrayofout){
+concatenated.set(array,offset);
+offset+=array.byteLength;
+}
+returnconcatenated;
+}
+
+consthello='Hello';
+
+for(letnumberOfChunks=2;numberOfChunks<=16;++numberOfChunks){
+promise_test(asynct=>{
+constcompressedData=awaitcompressMultipleChunks(hello,numberOfChunks,'deflate');
+constexpectedValue=makeExpectedChunk(hello,numberOfChunks);
+// decompress with pako, and check that we got the same result as our original string
+assert_array_equals(expectedValue,pako.inflate(compressedData),'value should match');
+},`compressing ${numberOfChunks} chunks with deflate should work`);
+
+promise_test(asynct=>{
+constcompressedData=awaitcompressMultipleChunks(hello,numberOfChunks,'gzip');
+constexpectedValue=makeExpectedChunk(hello,numberOfChunks);
+// decompress with pako, and check that we got the same result as our original string
+assert_array_equals(expectedValue,pako.inflate(compressedData),'value should match');
+},`compressing ${numberOfChunks} chunks with gzip should work`);
+
+promise_test(asynct=>{
+constcompressedData=awaitcompressMultipleChunks(hello,numberOfChunks,'deflate-raw');
+constexpectedValue=makeExpectedChunk(hello,numberOfChunks);
+// decompress with pako, and check that we got the same result as our original string
+assert_array_equals(expectedValue,pako.inflateRaw(compressedData),'value should match');
+},`compressing ${numberOfChunks} chunks with deflate-raw should work`);
+}