Upstream service worker message event tests to WPT

third_party/WebKit/LayoutTests/external/wpt/service-workers/service-worker/ServiceWorkerGlobalScope/resources/extendable-message-event-constructor-worker.js

Index: third_party/WebKit/LayoutTests/external/wpt/service-workers/service-worker/ServiceWorkerGlobalScope/resources/extendable-message-event-constructor-worker.js
diff --git a/third_party/WebKit/LayoutTests/external/wpt/service-workers/service-worker/ServiceWorkerGlobalScope/resources/extendable-message-event-constructor-worker.js b/third_party/WebKit/LayoutTests/external/wpt/service-workers/service-worker/ServiceWorkerGlobalScope/resources/extendable-message-event-constructor-worker.js
new file mode 100644
index 0000000000000000000000000000000000000000..d1739091a916bc6bce2c5df3e9d278888b870c40
--- /dev/null
+++ b/third_party/WebKit/LayoutTests/external/wpt/service-workers/service-worker/ServiceWorkerGlobalScope/resources/extendable-message-event-constructor-worker.js
@@ -0,0 +1,190 @@
+importScripts('/resources/testharness.js');

[falken, 2017/03/21 14:42:56]

A suggestion: For files like this that Rietveld can't provide a diff for, it'd
help for reviewing if you could possibly link to a diff of the existing vs new
content, and point out changes (or the lack of changes).

[mike3, 2017/03/21 17:15:29]

Sure thing. It looks like you had to do this yourself for your prior
review--sorry about that. Here's a diff for this file (generated using `git
diff`'s `-w` option to limit noise):

https://gist.github.com/jugglinmike/05fd45204be5e0635cf06731802b4e39

For this file, I introduced `testharness.js` so we could segment the assertions
into more targeted tests. This included some trivial reformatting. Beyond that,
I updated three invalid assertions regarding the `ports` option--the invalidity
is the subject of the Chromium bugs I filed.

+

[falken, 2017/03/21 14:42:56]

I think we've lost a comment: "These test cases are mostly copied from
fast/events/constructors/message-event-constructor.html" which still seems
relevant.

[mike3, 2017/03/21 17:15:29]

I've re-added that comment, expanded with additional context to make it
meaningful from WPT.

+var test_object = { wanwan: 123 };
+var channel1 = new MessageChannel();
+var channel2 = new MessageChannel();
+var ports = [channel1.port1, channel1.port2, channel2.port1];
+function createEvent(initializer) {
+  if (initializer === undefined)
+    return new ExtendableMessageEvent('type');
+  return new ExtendableMessageEvent('type', initializer);
+}
+
+test(function() {
+  assert_false(createEvent().bubbles);
+  assert_false(createEvent().cancelable);
+  assert_equals(createEvent().data, null);
+  assert_equals(createEvent().origin, '');
+  assert_equals(createEvent().lastEventId, '');
+  assert_equals(createEvent().source, null);
+  assert_array_equals(createEvent().ports, []);
+}, 'no initializer specified');
+
+test(function() {
+  assert_false(createEvent({ bubbles: false }).bubbles);
+  assert_true(createEvent({ bubbles: true }).bubbles);
+}, '`bubbles` is specified');
+
+test(function() {
+  assert_false(createEvent({ cancelable: false }).cancelable);
+  assert_true(createEvent({ cancelable: true }).cancelable);
+}, '`cancelable` is specified');
+
+test(function() {
+  assert_equals(createEvent({ data: test_object }).data, test_object);
+  assert_equals(createEvent({ data: undefined }).data, null);
+  assert_equals(createEvent({ data: null }).data, null);
+  assert_equals(createEvent({ data: false }).data, false);
+  assert_equals(createEvent({ data: true }).data, true);
+  assert_equals(createEvent({ data: '' }).data, '');
+  assert_equals(createEvent({ data: 'chocolate' }).data, 'chocolate');
+  assert_equals(createEvent({ data: 12345 }).data, 12345);
+  assert_equals(createEvent({ data: 18446744073709551615 }).data,
+                            18446744073709552000);
+  assert_equals(createEvent({ data: NaN }).data, NaN);
+  // Note that valueOf() is not called, when the left hand side is
+  // evaluated.
+  assert_false(
+      createEvent({ data: {
+          valueOf: function() { return test_object; } } }).data ==
+      test_object);
+  assert_equals(createEvent({ get data(){ return 123; } }).data, 123);
+  assert_throws({ name: 'Error' }, function() {
+      createEvent({ get data() { throw { name: 'Error' }; } }); });
+}, '`data` is specified');
+
+test(function() {
+  assert_equals(createEvent({ origin: 'melancholy' }).origin, 'melancholy');
+  assert_equals(createEvent({ origin: '' }).origin, '');
+  assert_equals(createEvent({ origin: null }).origin, 'null');
+  assert_equals(createEvent({ origin: false }).origin, 'false');
+  assert_equals(createEvent({ origin: true }).origin, 'true');
+  assert_equals(createEvent({ origin: 12345 }).origin, '12345');
+  assert_equals(
+      createEvent({ origin: 18446744073709551615 }).origin,
+      '18446744073709552000');
+  assert_equals(createEvent({ origin: NaN }).origin, 'NaN');
+  assert_equals(createEvent({ origin: [] }).origin, '');
+  assert_equals(createEvent({ origin: [1, 2, 3] }).origin, '1,2,3');
+  assert_equals(
+      createEvent({ origin: { melancholy: 12345 } }).origin,
+      '[object Object]');
+  // Note that valueOf() is not called, when the left hand side is
+  // evaluated.
+  assert_equals(
+      createEvent({ origin: {
+          valueOf: function() { return 'melancholy'; } } }).origin,
+      '[object Object]');
+  assert_equals(
+      createEvent({ get origin() { return 123; } }).origin, '123');
+  assert_throws({ name: 'Error' }, function() {
+      createEvent({ get origin() { throw { name: 'Error' }; } }); });
+}, '`origin` is specified');
+
+test(function() {
+  // lastEventId is passed.
+  assert_equals(
+      createEvent({ lastEventId: 'melancholy' }).lastEventId, 'melancholy');
+  assert_equals(createEvent({ lastEventId: '' }).lastEventId, '');
+  assert_equals(createEvent({ lastEventId: null }).lastEventId, 'null');
+  assert_equals(createEvent({ lastEventId: false }).lastEventId, 'false');
+  assert_equals(createEvent({ lastEventId: true }).lastEventId, 'true');
+  assert_equals(createEvent({ lastEventId: 12345 }).lastEventId, '12345');
+  assert_equals(
+      createEvent({ lastEventId: 18446744073709551615 }).lastEventId,
+      '18446744073709552000');
+  assert_equals(createEvent({ lastEventId: NaN }).lastEventId, 'NaN');
+  assert_equals(createEvent({ lastEventId: [] }).lastEventId, '');
+  assert_equals(
+      createEvent({ lastEventId: [1, 2, 3] }).lastEventId, '1,2,3');
+  assert_equals(
+      createEvent({ lastEventId: { melancholy: 12345 } }).lastEventId,
+      '[object Object]');
+  // Note that valueOf() is not called, when the left hand side is
+  // evaluated.
+  assert_equals(
+      createEvent({ lastEventId: {
+          valueOf: function() { return 'melancholy'; } } }).lastEventId,
+      '[object Object]');
+  assert_equals(
+      createEvent({ get lastEventId() { return 123; } }).lastEventId,
+      '123');
+  assert_throws({ name: 'Error' }, function() {
+      createEvent({ get lastEventId() { throw { name: 'Error' }; } }); });
+}, '`lastEventId` is specified');
+
+test(function() {
+  assert_equals(createEvent({ source: channel1.port1 }).source, channel1.port1);
+  assert_equals(
+      createEvent({ source: self.registration.active }).source,
+      self.registration.active);
+  assert_equals(
+      createEvent({ source: channel1.port1 }).source, channel1.port1);
+  assert_throws(
+      { name: 'TypeError' }, function() { createEvent({ source: this }); },
+      'source should be Client or ServiceWorker or MessagePort');
+}, '`source` is specified');
+
+test(function() {
+  // Valid message ports.
+  var passed_ports = createEvent({ ports: ports}).ports;
+  assert_equals(passed_ports[0], channel1.port1);
+  assert_equals(passed_ports[1], channel1.port2);
+  assert_equals(passed_ports[2], channel2.port1);
+  assert_array_equals(createEvent({ ports: [] }).ports, []);
+  assert_array_equals(createEvent({ ports: undefined }).ports, []);

[falken, 2017/03/21 14:42:56]

The original file tested |null| also, is removing that intended?

[mike3, 2017/03/21 17:15:29]

Good eye! This is intentional: that assertion was invalid. In this new
version of the file, we are still testing for `null`, but we're instead
asserting that it triggers an exception (included below, under "Invalid
message ports.")

+
+  // Invalid message ports.
+  assert_throws({ name: 'TypeError' },
+      function() { createEvent({ ports: [1, 2, 3] }); });
+  assert_throws({ name: 'TypeError' },
+      function() { createEvent({ ports: test_object }); });
+  assert_throws({ name: 'TypeError' },
+      function() { createEvent({ ports: null }); });
+  assert_throws({ name: 'TypeError' },
+      function() { createEvent({ ports: this }); });
+  assert_throws({ name: 'TypeError' },
+      function() { createEvent({ ports: false }); });
+  assert_throws({ name: 'TypeError' },
+      function() { createEvent({ ports: true }); });
+  assert_throws({ name: 'TypeError' },
+      function() { createEvent({ ports: '' }); });
+  assert_throws({ name: 'TypeError' },
+      function() { createEvent({ ports: 'chocolate' }); });
+  assert_throws({ name: 'TypeError' },
+      function() { createEvent({ ports: 12345 }); });
+  assert_throws({ name: 'TypeError' },
+      function() { createEvent({ ports: 18446744073709551615 }); });
+  assert_throws({ name: 'TypeError' },
+      function() { createEvent({ ports: NaN }); });
+  assert_throws({ name: 'TypeError' },
+      function() { createEvent({ get ports() { return 123; } }); });
+  assert_throws({ name: 'Error' }, function() {
+      createEvent({ get ports() { throw { name: 'Error' }; } }); });
+  // Note that valueOf() is not called, when the left hand side is
+  // evaluated.
+  var valueOf = function() { return ports; };
+  assert_throws({ name: 'TypeError' }, function() {
+      createEvent({ ports: { valueOf: valueOf } }); });
+}, '`ports` is specified');
+
+test(function() {
+  var initializers = {
+      bubbles: true,
+      cancelable: true,
+      data: test_object,
+      origin: 'wonderful',
+      lastEventId: 'excellent',
+      source: channel1.port1,
+      ports: ports
+  };
+  assert_equals(createEvent(initializers).bubbles, true);
+  assert_equals(createEvent(initializers).cancelable, true);
+  assert_equals(createEvent(initializers).data, test_object);
+  assert_equals(createEvent(initializers).origin, 'wonderful');
+  assert_equals(createEvent(initializers).lastEventId, 'excellent');
+  assert_equals(createEvent(initializers).source, channel1.port1);
+  assert_equals(createEvent(initializers).ports[0], ports[0]);
+  assert_equals(createEvent(initializers).ports[1], ports[1]);
+  assert_equals(createEvent(initializers).ports[2], ports[2]);
+}, 'all initial values are specified');