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