OLD | NEW |
(Empty) | |
| 1 importScripts('/resources/testharness.js'); |
| 2 |
| 3 const TEST_OBJECT = { wanwan: 123 }; |
| 4 const CHANNEL1 = new MessageChannel(); |
| 5 const CHANNEL2 = new MessageChannel(); |
| 6 const PORTS = [CHANNEL1.port1, CHANNEL1.port2, CHANNEL2.port1]; |
| 7 function createEvent(initializer) { |
| 8 if (initializer === undefined) |
| 9 return new ExtendableMessageEvent('type'); |
| 10 return new ExtendableMessageEvent('type', initializer); |
| 11 } |
| 12 |
| 13 // These test cases are mostly copied from the following file in the Chromium |
| 14 // project (as of commit 848ad70823991e0f12b437d789943a4ab24d65bb): |
| 15 // third_party/WebKit/LayoutTests/fast/events/constructors/message-event-constru
ctor.html |
| 16 |
| 17 test(function() { |
| 18 assert_false(createEvent().bubbles); |
| 19 assert_false(createEvent().cancelable); |
| 20 assert_equals(createEvent().data, null); |
| 21 assert_equals(createEvent().origin, ''); |
| 22 assert_equals(createEvent().lastEventId, ''); |
| 23 assert_equals(createEvent().source, null); |
| 24 assert_array_equals(createEvent().ports, []); |
| 25 }, 'no initializer specified'); |
| 26 |
| 27 test(function() { |
| 28 assert_false(createEvent({ bubbles: false }).bubbles); |
| 29 assert_true(createEvent({ bubbles: true }).bubbles); |
| 30 }, '`bubbles` is specified'); |
| 31 |
| 32 test(function() { |
| 33 assert_false(createEvent({ cancelable: false }).cancelable); |
| 34 assert_true(createEvent({ cancelable: true }).cancelable); |
| 35 }, '`cancelable` is specified'); |
| 36 |
| 37 test(function() { |
| 38 assert_equals(createEvent({ data: TEST_OBJECT }).data, TEST_OBJECT); |
| 39 assert_equals(createEvent({ data: undefined }).data, null); |
| 40 assert_equals(createEvent({ data: null }).data, null); |
| 41 assert_equals(createEvent({ data: false }).data, false); |
| 42 assert_equals(createEvent({ data: true }).data, true); |
| 43 assert_equals(createEvent({ data: '' }).data, ''); |
| 44 assert_equals(createEvent({ data: 'chocolate' }).data, 'chocolate'); |
| 45 assert_equals(createEvent({ data: 12345 }).data, 12345); |
| 46 assert_equals(createEvent({ data: 18446744073709551615 }).data, |
| 47 18446744073709552000); |
| 48 assert_equals(createEvent({ data: NaN }).data, NaN); |
| 49 // Note that valueOf() is not called, when the left hand side is |
| 50 // evaluated. |
| 51 assert_false( |
| 52 createEvent({ data: { |
| 53 valueOf: function() { return TEST_OBJECT; } } }).data == |
| 54 TEST_OBJECT); |
| 55 assert_equals(createEvent({ get data(){ return 123; } }).data, 123); |
| 56 assert_throws({ name: 'Error' }, function() { |
| 57 createEvent({ get data() { throw { name: 'Error' }; } }); }); |
| 58 }, '`data` is specified'); |
| 59 |
| 60 test(function() { |
| 61 assert_equals(createEvent({ origin: 'melancholy' }).origin, 'melancholy'); |
| 62 assert_equals(createEvent({ origin: '' }).origin, ''); |
| 63 assert_equals(createEvent({ origin: null }).origin, 'null'); |
| 64 assert_equals(createEvent({ origin: false }).origin, 'false'); |
| 65 assert_equals(createEvent({ origin: true }).origin, 'true'); |
| 66 assert_equals(createEvent({ origin: 12345 }).origin, '12345'); |
| 67 assert_equals( |
| 68 createEvent({ origin: 18446744073709551615 }).origin, |
| 69 '18446744073709552000'); |
| 70 assert_equals(createEvent({ origin: NaN }).origin, 'NaN'); |
| 71 assert_equals(createEvent({ origin: [] }).origin, ''); |
| 72 assert_equals(createEvent({ origin: [1, 2, 3] }).origin, '1,2,3'); |
| 73 assert_equals( |
| 74 createEvent({ origin: { melancholy: 12345 } }).origin, |
| 75 '[object Object]'); |
| 76 // Note that valueOf() is not called, when the left hand side is |
| 77 // evaluated. |
| 78 assert_equals( |
| 79 createEvent({ origin: { |
| 80 valueOf: function() { return 'melancholy'; } } }).origin, |
| 81 '[object Object]'); |
| 82 assert_equals( |
| 83 createEvent({ get origin() { return 123; } }).origin, '123'); |
| 84 assert_throws({ name: 'Error' }, function() { |
| 85 createEvent({ get origin() { throw { name: 'Error' }; } }); }); |
| 86 }, '`origin` is specified'); |
| 87 |
| 88 test(function() { |
| 89 assert_equals( |
| 90 createEvent({ lastEventId: 'melancholy' }).lastEventId, 'melancholy'); |
| 91 assert_equals(createEvent({ lastEventId: '' }).lastEventId, ''); |
| 92 assert_equals(createEvent({ lastEventId: null }).lastEventId, 'null'); |
| 93 assert_equals(createEvent({ lastEventId: false }).lastEventId, 'false'); |
| 94 assert_equals(createEvent({ lastEventId: true }).lastEventId, 'true'); |
| 95 assert_equals(createEvent({ lastEventId: 12345 }).lastEventId, '12345'); |
| 96 assert_equals( |
| 97 createEvent({ lastEventId: 18446744073709551615 }).lastEventId, |
| 98 '18446744073709552000'); |
| 99 assert_equals(createEvent({ lastEventId: NaN }).lastEventId, 'NaN'); |
| 100 assert_equals(createEvent({ lastEventId: [] }).lastEventId, ''); |
| 101 assert_equals( |
| 102 createEvent({ lastEventId: [1, 2, 3] }).lastEventId, '1,2,3'); |
| 103 assert_equals( |
| 104 createEvent({ lastEventId: { melancholy: 12345 } }).lastEventId, |
| 105 '[object Object]'); |
| 106 // Note that valueOf() is not called, when the left hand side is |
| 107 // evaluated. |
| 108 assert_equals( |
| 109 createEvent({ lastEventId: { |
| 110 valueOf: function() { return 'melancholy'; } } }).lastEventId, |
| 111 '[object Object]'); |
| 112 assert_equals( |
| 113 createEvent({ get lastEventId() { return 123; } }).lastEventId, |
| 114 '123'); |
| 115 assert_throws({ name: 'Error' }, function() { |
| 116 createEvent({ get lastEventId() { throw { name: 'Error' }; } }); }); |
| 117 }, '`lastEventId` is specified'); |
| 118 |
| 119 test(function() { |
| 120 assert_equals(createEvent({ source: CHANNEL1.port1 }).source, CHANNEL1.port1); |
| 121 assert_equals( |
| 122 createEvent({ source: self.registration.active }).source, |
| 123 self.registration.active); |
| 124 assert_equals( |
| 125 createEvent({ source: CHANNEL1.port1 }).source, CHANNEL1.port1); |
| 126 assert_throws( |
| 127 { name: 'TypeError' }, function() { createEvent({ source: this }); }, |
| 128 'source should be Client or ServiceWorker or MessagePort'); |
| 129 }, '`source` is specified'); |
| 130 |
| 131 test(function() { |
| 132 // Valid message ports. |
| 133 var passed_ports = createEvent({ ports: PORTS}).ports; |
| 134 assert_equals(passed_ports[0], CHANNEL1.port1); |
| 135 assert_equals(passed_ports[1], CHANNEL1.port2); |
| 136 assert_equals(passed_ports[2], CHANNEL2.port1); |
| 137 assert_array_equals(createEvent({ ports: [] }).ports, []); |
| 138 assert_array_equals(createEvent({ ports: undefined }).ports, []); |
| 139 |
| 140 // Invalid message ports. |
| 141 assert_throws({ name: 'TypeError' }, |
| 142 function() { createEvent({ ports: [1, 2, 3] }); }); |
| 143 assert_throws({ name: 'TypeError' }, |
| 144 function() { createEvent({ ports: TEST_OBJECT }); }); |
| 145 assert_throws({ name: 'TypeError' }, |
| 146 function() { createEvent({ ports: null }); }); |
| 147 assert_throws({ name: 'TypeError' }, |
| 148 function() { createEvent({ ports: this }); }); |
| 149 assert_throws({ name: 'TypeError' }, |
| 150 function() { createEvent({ ports: false }); }); |
| 151 assert_throws({ name: 'TypeError' }, |
| 152 function() { createEvent({ ports: true }); }); |
| 153 assert_throws({ name: 'TypeError' }, |
| 154 function() { createEvent({ ports: '' }); }); |
| 155 assert_throws({ name: 'TypeError' }, |
| 156 function() { createEvent({ ports: 'chocolate' }); }); |
| 157 assert_throws({ name: 'TypeError' }, |
| 158 function() { createEvent({ ports: 12345 }); }); |
| 159 assert_throws({ name: 'TypeError' }, |
| 160 function() { createEvent({ ports: 18446744073709551615 }); }); |
| 161 assert_throws({ name: 'TypeError' }, |
| 162 function() { createEvent({ ports: NaN }); }); |
| 163 assert_throws({ name: 'TypeError' }, |
| 164 function() { createEvent({ get ports() { return 123; } }); }); |
| 165 assert_throws({ name: 'Error' }, function() { |
| 166 createEvent({ get ports() { throw { name: 'Error' }; } }); }); |
| 167 // Note that valueOf() is not called, when the left hand side is |
| 168 // evaluated. |
| 169 var valueOf = function() { return PORTS; }; |
| 170 assert_throws({ name: 'TypeError' }, function() { |
| 171 createEvent({ ports: { valueOf: valueOf } }); }); |
| 172 }, '`ports` is specified'); |
| 173 |
| 174 test(function() { |
| 175 var initializers = { |
| 176 bubbles: true, |
| 177 cancelable: true, |
| 178 data: TEST_OBJECT, |
| 179 origin: 'wonderful', |
| 180 lastEventId: 'excellent', |
| 181 source: CHANNEL1.port1, |
| 182 ports: PORTS |
| 183 }; |
| 184 assert_equals(createEvent(initializers).bubbles, true); |
| 185 assert_equals(createEvent(initializers).cancelable, true); |
| 186 assert_equals(createEvent(initializers).data, TEST_OBJECT); |
| 187 assert_equals(createEvent(initializers).origin, 'wonderful'); |
| 188 assert_equals(createEvent(initializers).lastEventId, 'excellent'); |
| 189 assert_equals(createEvent(initializers).source, CHANNEL1.port1); |
| 190 assert_equals(createEvent(initializers).ports[0], PORTS[0]); |
| 191 assert_equals(createEvent(initializers).ports[1], PORTS[1]); |
| 192 assert_equals(createEvent(initializers).ports[2], PORTS[2]); |
| 193 }, 'all initial values are specified'); |
OLD | NEW |