OLD | NEW |
---|---|
(Empty) | |
1 importScripts('/resources/testharness.js'); | |
falken
2017/03/21 14:42:56
A suggestion: For files like this that Rietveld ca
mike3
2017/03/21 17:15:29
Sure thing. It looks like you had to do this yours
| |
2 | |
falken
2017/03/21 14:42:56
I think we've lost a comment: "These test cases ar
mike3
2017/03/21 17:15:29
I've re-added that comment, expanded with addition
| |
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, []); | |
falken
2017/03/21 14:42:56
The original file tested |null| also, is removing
mike3
2017/03/21 17:15:29
Good eye! This is intentional: that assertion was
| |
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 |