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]; | |
falken
2017/03/22 00:55:14
nit: Would it be worth naming these like const TES
mike3
2017/03/22 22:45:28
Sounds good to me.
| |
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 // lastEventId is passed. | |
falken
2017/03/22 00:55:14
nit: You probably meant to remove this comment, li
mike3
2017/03/22 22:45:28
Indeed!
| |
90 assert_equals( | |
91 createEvent({ lastEventId: 'melancholy' }).lastEventId, 'melancholy'); | |
92 assert_equals(createEvent({ lastEventId: '' }).lastEventId, ''); | |
93 assert_equals(createEvent({ lastEventId: null }).lastEventId, 'null'); | |
94 assert_equals(createEvent({ lastEventId: false }).lastEventId, 'false'); | |
95 assert_equals(createEvent({ lastEventId: true }).lastEventId, 'true'); | |
96 assert_equals(createEvent({ lastEventId: 12345 }).lastEventId, '12345'); | |
97 assert_equals( | |
98 createEvent({ lastEventId: 18446744073709551615 }).lastEventId, | |
99 '18446744073709552000'); | |
100 assert_equals(createEvent({ lastEventId: NaN }).lastEventId, 'NaN'); | |
101 assert_equals(createEvent({ lastEventId: [] }).lastEventId, ''); | |
102 assert_equals( | |
103 createEvent({ lastEventId: [1, 2, 3] }).lastEventId, '1,2,3'); | |
104 assert_equals( | |
105 createEvent({ lastEventId: { melancholy: 12345 } }).lastEventId, | |
106 '[object Object]'); | |
107 // Note that valueOf() is not called, when the left hand side is | |
108 // evaluated. | |
109 assert_equals( | |
110 createEvent({ lastEventId: { | |
111 valueOf: function() { return 'melancholy'; } } }).lastEventId, | |
112 '[object Object]'); | |
113 assert_equals( | |
114 createEvent({ get lastEventId() { return 123; } }).lastEventId, | |
115 '123'); | |
116 assert_throws({ name: 'Error' }, function() { | |
117 createEvent({ get lastEventId() { throw { name: 'Error' }; } }); }); | |
118 }, '`lastEventId` is specified'); | |
119 | |
120 test(function() { | |
121 assert_equals(createEvent({ source: channel1.port1 }).source, channel1.port1); | |
122 assert_equals( | |
123 createEvent({ source: self.registration.active }).source, | |
124 self.registration.active); | |
125 assert_equals( | |
126 createEvent({ source: channel1.port1 }).source, channel1.port1); | |
127 assert_throws( | |
128 { name: 'TypeError' }, function() { createEvent({ source: this }); }, | |
129 'source should be Client or ServiceWorker or MessagePort'); | |
130 }, '`source` is specified'); | |
131 | |
132 test(function() { | |
133 // Valid message ports. | |
134 var passed_ports = createEvent({ ports: ports}).ports; | |
135 assert_equals(passed_ports[0], channel1.port1); | |
136 assert_equals(passed_ports[1], channel1.port2); | |
137 assert_equals(passed_ports[2], channel2.port1); | |
138 assert_array_equals(createEvent({ ports: [] }).ports, []); | |
139 assert_array_equals(createEvent({ ports: undefined }).ports, []); | |
140 | |
141 // Invalid message ports. | |
142 assert_throws({ name: 'TypeError' }, | |
143 function() { createEvent({ ports: [1, 2, 3] }); }); | |
144 assert_throws({ name: 'TypeError' }, | |
145 function() { createEvent({ ports: test_object }); }); | |
146 assert_throws({ name: 'TypeError' }, | |
147 function() { createEvent({ ports: null }); }); | |
148 assert_throws({ name: 'TypeError' }, | |
149 function() { createEvent({ ports: this }); }); | |
150 assert_throws({ name: 'TypeError' }, | |
151 function() { createEvent({ ports: false }); }); | |
152 assert_throws({ name: 'TypeError' }, | |
153 function() { createEvent({ ports: true }); }); | |
154 assert_throws({ name: 'TypeError' }, | |
155 function() { createEvent({ ports: '' }); }); | |
156 assert_throws({ name: 'TypeError' }, | |
157 function() { createEvent({ ports: 'chocolate' }); }); | |
158 assert_throws({ name: 'TypeError' }, | |
159 function() { createEvent({ ports: 12345 }); }); | |
160 assert_throws({ name: 'TypeError' }, | |
161 function() { createEvent({ ports: 18446744073709551615 }); }); | |
162 assert_throws({ name: 'TypeError' }, | |
163 function() { createEvent({ ports: NaN }); }); | |
164 assert_throws({ name: 'TypeError' }, | |
165 function() { createEvent({ get ports() { return 123; } }); }); | |
166 assert_throws({ name: 'Error' }, function() { | |
167 createEvent({ get ports() { throw { name: 'Error' }; } }); }); | |
168 // Note that valueOf() is not called, when the left hand side is | |
169 // evaluated. | |
170 var valueOf = function() { return ports; }; | |
171 assert_throws({ name: 'TypeError' }, function() { | |
172 createEvent({ ports: { valueOf: valueOf } }); }); | |
173 }, '`ports` is specified'); | |
174 | |
175 test(function() { | |
176 var initializers = { | |
177 bubbles: true, | |
178 cancelable: true, | |
179 data: test_object, | |
180 origin: 'wonderful', | |
181 lastEventId: 'excellent', | |
182 source: channel1.port1, | |
183 ports: ports | |
184 }; | |
185 assert_equals(createEvent(initializers).bubbles, true); | |
186 assert_equals(createEvent(initializers).cancelable, true); | |
187 assert_equals(createEvent(initializers).data, test_object); | |
188 assert_equals(createEvent(initializers).origin, 'wonderful'); | |
189 assert_equals(createEvent(initializers).lastEventId, 'excellent'); | |
190 assert_equals(createEvent(initializers).source, channel1.port1); | |
191 assert_equals(createEvent(initializers).ports[0], ports[0]); | |
192 assert_equals(createEvent(initializers).ports[1], ports[1]); | |
193 assert_equals(createEvent(initializers).ports[2], ports[2]); | |
194 }, 'all initial values are specified'); | |
OLD | NEW |