Update web-platform-tests to revision 58eb04cecbbec2e18531ab440225e38944a9c444

tests/wpt/web-platform-tests/streams/writable-streams/properties.js

@@ -0,0 +1,219 @@
+'use strict';
+
+if (self.importScripts) {
+  self.importScripts('/resources/testharness.js');
+}
+
+// The purpose of this file is to test for objects, attributes and arguments that should not exist.
+// The test cases are generated from data tables to reduce duplication.
+
+// Courtesy of André Bargull. Source is https://esdiscuss.org/topic/isconstructor#content-11.
+function IsConstructor(o) {
+  try {
+    new new Proxy(o, { construct: () => ({}) })();
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+for (const func of ['WritableStreamDefaultController', 'WritableStreamDefaultWriter']) {
+  test(() => {
+    assert_equals(self[func], undefined, `${func} should not be defined`);
+  }, `${func} should not be exported on the global object`);
+}
+
+// Now get hold of the symbols so we can test their properties.
+self.WritableStreamDefaultController = (() => {
+  let controller;
+  new WritableStream({
+    start(c) {
+      controller = c;
+    }
+  });
+  return controller.constructor;
+})();
+self.WritableStreamDefaultWriter = new WritableStream().getWriter().constructor;
+
+const expected = {
+  WritableStream: {
+    constructor: {
+      type: 'constructor',
+      length: 0
+    },
+    locked: {
+      type: 'getter'
+    },
+    abort: {
+      type: 'method',
+      length: 1
+    },
+    getWriter: {
+      type: 'method',
+      length: 0
+    }
+  },
+  WritableStreamDefaultController: {
+    constructor: {
+      type: 'constructor',
+      length: 4
+    },
+    error: {
+      type: 'method',
+      length: 1
+    }
+  },
+  WritableStreamDefaultWriter: {
+    constructor: {
+      type: 'constructor',
+      length: 1
+    },
+    closed: {
+      type: 'getter'
+    },
+    desiredSize: {
+      type: 'getter'
+    },
+    ready: {
+      type: 'getter'
+    },
+    abort: {
+      type: 'method',
+      length: 1
+    },
+    close: {
+      type: 'method',
+      length: 0
+    },
+    releaseLock: {
+      type: 'method',
+      length: 0
+    },
+    write: {
+      type: 'method',
+      length: 1
+    }
+  }
+};
+
+for (const c in expected) {
+  const properties = expected[c];
+  const prototype = self[c].prototype;
+  for (const name in properties) {
+    const fullName = `${c}.prototype.${name}`;
+    const descriptor = Object.getOwnPropertyDescriptor(prototype, name);
+    test(() => {
+      const { configurable, enumerable } = descriptor;
+      assert_true(configurable, `${name} should be configurable`);
+      assert_false(enumerable, `${name} should not be enumerable`);
+    }, `${fullName} should have standard properties`);
+    const type = properties[name].type;
+    switch (type) {
+      case 'getter':
+        test(() => {
+          const { writable, get, set } = descriptor;
+          assert_equals(writable, undefined, `${name} should not be a data descriptor`);
+          assert_equals(typeof get, 'function', `${name} should have a getter`);
+          assert_equals(set, undefined, `${name} should not have a setter`);
+        }, `${fullName} should be a getter`);
+        break;
+
+      case 'constructor':
+      case 'method':
+        test(() => {
+          assert_true(descriptor.writable, `${name} should be writable`);
+          assert_equals(typeof prototype[name], 'function', `${name} should be a function`);
+          assert_equals(prototype[name].length, properties[name].length,
+                        `${name} should take ${properties[name].length} arguments`);
+          if (type === 'constructor') {
+            assert_true(IsConstructor(prototype[name]), `${name} should be a constructor`);
+          } else {
+            assert_false(IsConstructor(prototype[name]), `${name} should not be a constructor`);
+          }
+        }, `${fullName} should be a ${type}`);
+        break;
+    }
+  }
+  test(() => {
+    const expectedPropertyNames = Object.keys(properties).sort();
+    const actualPropertyNames = Object.getOwnPropertyNames(prototype).sort();
+    assert_array_equals(actualPropertyNames, expectedPropertyNames,
+                        `${c} properties should match expected properties`);
+  }, `${c}.prototype should have exactly the expected properties`);
+}
+
+const sinkMethods = {
+  start: {
+    length: 1,
+    trigger: () => {}
+  },
+  write: {
+    length: 2,
+    trigger: writer => writer.write()
+  },
+  close: {
+    length: 0,
+    trigger: writer => writer.close()
+  },
+  abort: {
+    length: 1,
+    trigger: writer => writer.abort()
+  }
+};
+
+for (const method in sinkMethods) {
+  const { length, trigger } = sinkMethods[method];
+
+  // Some semantic tests of how sink methods are called can be found in general.js, as well as in the test files
+  // specific to each method.
+  promise_test(() => {
+    let argCount;
+    const ws = new WritableStream({
+      [method](...args) {
+        argCount = args.length;
+      }
+    });
+    return Promise.resolve(trigger(ws.getWriter())).then(() => {
+      assert_equals(argCount, length, `${method} should be called with ${length} arguments`);
+    });
+  }, `sink method ${method} should be called with the right number of arguments`);
+
+  promise_test(() => {
+    let methodWasCalled = false;
+    function Sink() {}
+    Sink.prototype = {
+      [method]() {
+        methodWasCalled = true;
+      }
+    };
+    const ws = new WritableStream(new Sink());
+    return Promise.resolve(trigger(ws.getWriter())).then(() => {
+      assert_true(methodWasCalled, `${method} should be called`);
+    });
+  }, `sink method ${method} should be called even when it's located on the prototype chain`);
+
+  if (method !== 'start') {
+    promise_test(t => {
+      const unreachedTraps = ['getPrototypeOf', 'setPrototypeOf', 'isExtensible', 'preventExtensions',
+                              'getOwnPropertyDescriptor', 'defineProperty', 'has', 'set', 'deleteProperty', 'ownKeys',
+                              'apply', 'construct'];
+      const handler = {
+        get: t.step_func((target, property) => {
+          if (property === 'type') {
+            return undefined;
+          }
+          assert_in_array(property, ['start', method], `only start() and ${method}() should be called`);
+          return () => Promise.resolve();
+        })
+      };
+      for (const trap of unreachedTraps) {
+        handler[trap] = t.unreached_func(`${trap} should not be trapped`);
+      }
+      const sink = new Proxy({}, handler);
+      const ws = new WritableStream(sink);
+      return trigger(ws.getWriter());
+    }, `unexpected properties should not be accessed when calling sink method ${method}`);
+  }
+}
+
+done();