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