[wasm] Implement WebAssembly.Module.customSections.

test/mjsunit/wasm/js-api.js

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Flags: --expose-wasm --allow-natives-syntax
 
 if ((typeof drainJobQueue) != "function") {
   drainJobQueue = () => { %RunMicrotasks() };
 }
 
 load("test/mjsunit/wasm/wasm-constants.js");
 load("test/mjsunit/wasm/wasm-module-builder.js");
 
 function assertEq(val, expected) {
   assertEquals(expected, val);
 }
+function assertArrayBuffer(val, expected) {
+  assertTrue(val instanceof ArrayBuffer);
+  assertEq(expected.length, val.byteLength);
+  var input = new Int8Array(val);
+  for (var i = 0; i < expected.length; i++) {
+    assertEq(expected[i], input[i]);
+  }
+}
 function wasmIsSupported() {
   return (typeof WebAssembly.Module) == "function";
 }
 function assertErrorMessage(func, type, msg) {
 //TODO   assertThrows(func, type, msg);
   assertThrows(func, type);
 }
 
 let emptyModuleBinary = (() => {
   var builder = new WasmModuleBuilder();
@@ skipping 216 matching lines @@
 assertEq(arr.length, 4);
 assertEq(arr[0].kind, "function");
 assertEq(arr[0].name, "a");
 assertEq(arr[1].kind, "memory");
 assertEq(arr[1].name, "b");
 assertEq(arr[2].kind, "table");
 assertEq(arr[2].name, "c");
 assertEq(arr[3].kind, "global");
 assertEq(arr[3].name, "x");
 
+// 'WebAssembly.Module.customSections' data property
+let moduleCustomSectionsDesc =
+    Object.getOwnPropertyDescriptor(Module, 'customSections');
+assertEq(typeof moduleCustomSectionsDesc.value, 'function');
+assertEq(moduleCustomSectionsDesc.writable, true);
+assertEq(moduleCustomSectionsDesc.enumerable, false);
+assertEq(moduleCustomSectionsDesc.configurable, true);
+
+let moduleCustomSections = moduleCustomSectionsDesc.value;
+assertEq(moduleCustomSections.length, 2);
+assertErrorMessage(
+    () => moduleCustomSections(), TypeError, /requires more than 0 arguments/);
+assertErrorMessage(
+    () => moduleCustomSections(undefined), TypeError,
+    /first argument must be a WebAssembly.Module/);
+assertErrorMessage(
+    () => moduleCustomSections({}), TypeError,
+    /first argument must be a WebAssembly.Module/);
+var arr = moduleCustomSections(emptyModule, 'x');
+assertEq(arr instanceof Array, true);
+assertEq(arr.length, 0);
+
+assertErrorMessage(
+    () => moduleCustomSections(1), TypeError,
+    'first argument must be a WebAssembly.Module');
+assertErrorMessage(
+    () => moduleCustomSections(emptyModule), TypeError,
+    'second argument must be a String');
+assertErrorMessage(
+    () => moduleCustomSections(emptyModule, 3), TypeError,
+    'second argument must be a String');
+
+let customSectionModuleBinary2 = (() => {
+  let builder = new WasmModuleBuilder();
+  builder.addExplicitSection([kUnknownSectionCode, 3, 1, 'x'.charCodeAt(0), 2]);
+  builder.addExplicitSection([
+    kUnknownSectionCode, 6, 3, 'f'.charCodeAt(0), 'o'.charCodeAt(0),
+    'o'.charCodeAt(0), 66, 77
+  ]);
+  builder.addExplicitSection([

[rossberg, 2017/01/24 11:34:42]

Can you add another section not named "foo", to test that it is not included?

[titzer, 2017/01/24 12:38:39]

Well, the section above is called 'x', but I added another one called 'fox'.

+    kUnknownSectionCode, 7, 3, 'f'.charCodeAt(0), 'o'.charCodeAt(0),
+    'o'.charCodeAt(0), 91, 92, 93
+  ]);
+  return new Int8Array(builder.toBuffer());
+})();
+var arr = moduleCustomSections(new Module(customSectionModuleBinary2), 'x');
+assertEq(arr instanceof Array, true);
+assertEq(arr.length, 1);
+assertArrayBuffer(arr[0], [2]);
+var arr = moduleCustomSections(new Module(customSectionModuleBinary2), 'foo');
+assertEq(arr instanceof Array, true);
+assertEq(arr.length, 2);
+assertArrayBuffer(arr[0], [66, 77]);
+assertArrayBuffer(arr[1], [91, 92, 93]);
+var arr = moduleCustomSections(new Module(customSectionModuleBinary2), 'bar');
+assertEq(arr instanceof Array, true);
+assertEq(arr.length, 0);
+
 // 'WebAssembly.Instance' data property
 let instanceDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'Instance');
 assertEq(typeof instanceDesc.value, "function");
 assertTrue(instanceDesc.writable);
 assertFalse(instanceDesc.enumerable);
 assertTrue(instanceDesc.configurable);
 
 // 'WebAssembly.Instance' constructor function
 let Instance = WebAssembly.Instance;
 assertEq(Instance, instanceDesc.value);
@@ skipping 367 matching lines @@
     assertTrue(result.instance instanceof Instance);
   }
 }
 assertInstantiateSuccess(emptyModule);
 assertInstantiateSuccess(emptyModuleBinary);
 assertInstantiateSuccess(emptyModuleBinary.buffer);
 assertInstantiateSuccess(importingModule, {'': {f: () => {}}});
 assertInstantiateSuccess(importingModuleBinary, {"":{f:()=>{}}});
 assertInstantiateSuccess(importingModuleBinary.buffer, {"":{f:()=>{}}});
 assertInstantiateSuccess(memoryImportingModuleBinary, {"": {"my_memory": scratch_memory}});