OLD | NEW |
1 // Copyright 2015 the V8 project authors. All rights reserved. | 1 // Copyright 2015 the V8 project authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 // Flags: --harmony-reflect | 5 // Flags: --harmony-reflect |
6 | 6 |
7 // TODO(neis): Test with proxies. | 7 // TODO(neis): Test with proxies. |
8 | 8 |
9 | 9 |
10 | 10 |
(...skipping 29 matching lines...) Expand all Loading... |
40 new WeakSet, | 40 new WeakSet, |
41 new ArrayBuffer(10), | 41 new ArrayBuffer(10), |
42 new Int32Array(5), | 42 new Int32Array(5), |
43 Object, | 43 Object, |
44 Function, | 44 Function, |
45 Date, | 45 Date, |
46 RegExp, | 46 RegExp, |
47 global | 47 global |
48 ]; | 48 ]; |
49 | 49 |
50 function prepare(tgt) { | 50 function prepare(target) { |
51 tgt["bla"] = true; | 51 target["bla"] = true; |
52 tgt[4] = 42; | 52 target[4] = 42; |
53 tgt[sym] = "foo"; | 53 target[sym] = "foo"; |
54 tgt["noconf"] = 43; | 54 target["noconf"] = 43; |
55 Object.defineProperty(tgt, "noconf", {configurable: false}); | 55 Object.defineProperty(target, "noconf", {configurable: false}); |
56 Object.defineProperty(tgt, "getter", | 56 Object.defineProperty(target, "getter", |
57 { get: function () {return this.bla}, configurable: true }); | 57 { get: function () {return this.bla}, configurable: true }); |
58 Object.defineProperty(tgt, "setter", | 58 Object.defineProperty(target, "setter", |
59 { set: function () {}, configurable: true }); | 59 { set: function () {}, configurable: true }); |
60 } | 60 } |
61 | 61 |
62 | 62 |
63 | 63 |
64 //////////////////////////////////////////////////////////////////////////////// | 64 //////////////////////////////////////////////////////////////////////////////// |
65 // Reflect.get | 65 // Reflect.get |
66 | 66 |
67 | 67 |
68 (function testReflectGetArity() { | 68 (function testReflectGetArity() { |
69 assertEquals(3, Reflect.get.length); | 69 assertEquals(3, Reflect.get.length); |
70 })(); | 70 })(); |
71 | 71 |
72 | 72 |
73 (function testReflectGetOnNonObject() { | 73 (function testReflectGetOnNonObject() { |
74 assertThrows(function() { Reflect.get(); }, TypeError); | 74 assertThrows(function() { Reflect.get(); }, TypeError); |
75 assertThrows(function() { Reflect.get(42, "bla"); }, TypeError); | 75 assertThrows(function() { Reflect.get(42, "bla"); }, TypeError); |
76 assertThrows(function() { Reflect.get(null, "bla"); }, TypeError); | 76 assertThrows(function() { Reflect.get(null, "bla"); }, TypeError); |
77 })(); | 77 })(); |
78 | 78 |
79 | 79 |
80 (function testReflectGetKeyConversion() { | 80 (function testReflectGetKeyConversion() { |
81 var tgt = {bla: 42}; | 81 var target = {bla: 42}; |
82 var a = { [Symbol.toPrimitive]: function() { return "bla" } }; | 82 var a = { [Symbol.toPrimitive]: function() { return "bla" } }; |
83 var b = { [Symbol.toPrimitive]: function() { throw "gaga" } }; | 83 var b = { [Symbol.toPrimitive]: function() { throw "gaga" } }; |
84 assertEquals(42, Reflect.get(tgt, a)); | 84 assertEquals(42, Reflect.get(target, a)); |
85 assertThrows(function() { Reflect.get(tgt, b); }, "gaga"); | 85 assertThrows(function() { Reflect.get(target, b); }, "gaga"); |
86 })(); | 86 })(); |
87 | 87 |
88 | 88 |
89 (function testReflectGetOnObject() { | 89 (function testReflectGetOnObject() { |
90 var receiver = {bla: false}; | 90 var receiver = {bla: false}; |
91 for (let tgt of objects) { | 91 for (let target of objects) { |
92 prepare(tgt); | 92 prepare(target); |
93 assertEquals(true, Reflect.get(tgt, "bla")); | 93 assertEquals(true, Reflect.get(target, "bla")); |
94 assertEquals(true, Reflect.get(tgt, "bla", tgt)); | 94 assertEquals(true, Reflect.get(target, "bla", target)); |
95 assertEquals(true, Reflect.get(tgt, "bla", receiver)); | 95 assertEquals(true, Reflect.get(target, "bla", receiver)); |
96 assertEquals(42, Reflect.get(tgt, 4)); | 96 assertEquals(42, Reflect.get(target, 4)); |
97 assertEquals(42, Reflect.get(tgt, 4, tgt)); | 97 assertEquals(42, Reflect.get(target, 4, target)); |
98 assertEquals(42, Reflect.get(tgt, 4, receiver)); | 98 assertEquals(42, Reflect.get(target, 4, receiver)); |
99 assertEquals(42, Reflect.get(tgt, "4")); | 99 assertEquals(42, Reflect.get(target, "4")); |
100 assertEquals(42, Reflect.get(tgt, "4", tgt)); | 100 assertEquals(42, Reflect.get(target, "4", target)); |
101 assertEquals(42, Reflect.get(tgt, "4", receiver)); | 101 assertEquals(42, Reflect.get(target, "4", receiver)); |
102 assertEquals("foo", Reflect.get(tgt, sym)); | 102 assertEquals("foo", Reflect.get(target, sym)); |
103 assertEquals("foo", Reflect.get(tgt, sym, tgt)); | 103 assertEquals("foo", Reflect.get(target, sym, target)); |
104 assertEquals("foo", Reflect.get(tgt, sym, receiver)); | 104 assertEquals("foo", Reflect.get(target, sym, receiver)); |
105 assertEquals(43, Reflect.get(tgt, "noconf")); | 105 assertEquals(43, Reflect.get(target, "noconf")); |
106 assertEquals(43, Reflect.get(tgt, "noconf", tgt)); | 106 assertEquals(43, Reflect.get(target, "noconf", target)); |
107 assertEquals(43, Reflect.get(tgt, "noconf", receiver)); | 107 assertEquals(43, Reflect.get(target, "noconf", receiver)); |
108 assertEquals(true, Reflect.get(tgt, "getter")); | 108 assertEquals(true, Reflect.get(target, "getter")); |
109 assertEquals(true, Reflect.get(tgt, "getter", tgt)); | 109 assertEquals(true, Reflect.get(target, "getter", target)); |
110 assertEquals(false, Reflect.get(tgt, "getter", receiver)); | 110 assertEquals(false, Reflect.get(target, "getter", receiver)); |
111 assertEquals(undefined, Reflect.get(tgt, "setter")); | 111 assertEquals(undefined, Reflect.get(target, "setter")); |
112 assertEquals(undefined, Reflect.get(tgt, "setter", tgt)); | 112 assertEquals(undefined, Reflect.get(target, "setter", target)); |
113 assertEquals(undefined, Reflect.get(tgt, "setter", receiver)); | 113 assertEquals(undefined, Reflect.get(target, "setter", receiver)); |
114 assertEquals(undefined, Reflect.get(tgt, "foo")); | 114 assertEquals(undefined, Reflect.get(target, "foo")); |
115 assertEquals(undefined, Reflect.get(tgt, "foo", tgt)); | 115 assertEquals(undefined, Reflect.get(target, "foo", target)); |
116 assertEquals(undefined, Reflect.get(tgt, "foo", receiver)); | 116 assertEquals(undefined, Reflect.get(target, "foo", receiver)); |
117 assertEquals(undefined, Reflect.get(tgt, 666)); | 117 assertEquals(undefined, Reflect.get(target, 666)); |
118 assertEquals(undefined, Reflect.get(tgt, 666, tgt)); | 118 assertEquals(undefined, Reflect.get(target, 666, target)); |
119 assertEquals(undefined, Reflect.get(tgt, 666, receiver)); | 119 assertEquals(undefined, Reflect.get(target, 666, receiver)); |
120 | 120 |
121 let proto = tgt.__proto__; | 121 let proto = target.__proto__; |
122 tgt.__proto__ = { get foo() {return this.bla} }; | 122 target.__proto__ = { get foo() {return this.bla} }; |
123 assertEquals(true, Reflect.get(tgt, "foo")); | 123 assertEquals(true, Reflect.get(target, "foo")); |
124 assertEquals(true, Reflect.get(tgt, "foo", tgt)); | 124 assertEquals(true, Reflect.get(target, "foo", target)); |
125 assertEquals(false, Reflect.get(tgt, "foo", receiver)); | 125 assertEquals(false, Reflect.get(target, "foo", receiver)); |
126 tgt.__proto__ = proto; | 126 target.__proto__ = proto; |
127 } | 127 } |
128 })(); | 128 })(); |
129 | 129 |
130 | 130 |
131 | 131 |
132 //////////////////////////////////////////////////////////////////////////////// | 132 //////////////////////////////////////////////////////////////////////////////// |
133 // Reflect.has | 133 // Reflect.has |
134 | 134 |
135 | 135 |
136 (function testReflectHasArity() { | 136 (function testReflectHasArity() { |
137 assertEquals(2, Reflect.has.length); | 137 assertEquals(2, Reflect.has.length); |
138 })(); | 138 })(); |
139 | 139 |
140 | 140 |
141 (function testReflectHasOnNonObject() { | 141 (function testReflectHasOnNonObject() { |
142 assertThrows(function() { Reflect.has(); }, TypeError); | 142 assertThrows(function() { Reflect.has(); }, TypeError); |
143 assertThrows(function() { Reflect.has(42, "bla"); }, TypeError); | 143 assertThrows(function() { Reflect.has(42, "bla"); }, TypeError); |
144 assertThrows(function() { Reflect.has(null, "bla"); }, TypeError); | 144 assertThrows(function() { Reflect.has(null, "bla"); }, TypeError); |
145 })(); | 145 })(); |
146 | 146 |
147 | 147 |
148 (function testReflectHasKeyConversion() { | 148 (function testReflectHasKeyConversion() { |
149 var tgt = {bla: 42}; | 149 var target = {bla: 42}; |
150 var a = { [Symbol.toPrimitive]: function() { return "bla" } }; | 150 var a = { [Symbol.toPrimitive]: function() { return "bla" } }; |
151 var b = { [Symbol.toPrimitive]: function() { throw "gaga" } }; | 151 var b = { [Symbol.toPrimitive]: function() { throw "gaga" } }; |
152 assertTrue(Reflect.has(tgt, a)); | 152 assertTrue(Reflect.has(target, a)); |
153 assertThrows(function() { Reflect.has(tgt, b); }, "gaga"); | 153 assertThrows(function() { Reflect.has(target, b); }, "gaga"); |
154 })(); | 154 })(); |
155 | 155 |
156 | 156 |
157 (function testReflectHasOnObject() { | 157 (function testReflectHasOnObject() { |
158 for (let tgt of objects) { | 158 for (let target of objects) { |
159 prepare(tgt); | 159 prepare(target); |
160 assertTrue(Reflect.has(tgt, "bla")); | 160 assertTrue(Reflect.has(target, "bla")); |
161 assertTrue(Reflect.has(tgt, 4)); | 161 assertTrue(Reflect.has(target, 4)); |
162 assertTrue(Reflect.has(tgt, "4")); | 162 assertTrue(Reflect.has(target, "4")); |
163 assertTrue(Reflect.has(tgt, sym)); | 163 assertTrue(Reflect.has(target, sym)); |
164 assertTrue(Reflect.has(tgt, "noconf")); | 164 assertTrue(Reflect.has(target, "noconf")); |
165 assertTrue(Reflect.has(tgt, "getter")); | 165 assertTrue(Reflect.has(target, "getter")); |
166 assertTrue(Reflect.has(tgt, "setter")); | 166 assertTrue(Reflect.has(target, "setter")); |
167 assertFalse(Reflect.has(tgt, "foo")); | 167 assertFalse(Reflect.has(target, "foo")); |
168 assertFalse(Reflect.has(tgt, 666)); | 168 assertFalse(Reflect.has(target, 666)); |
169 | 169 |
170 let proto = tgt.__proto__; | 170 let proto = target.__proto__; |
171 tgt.__proto__ = { get foo() {return this.bla} }; | 171 target.__proto__ = { get foo() {return this.bla} }; |
172 assertEquals(true, Reflect.has(tgt, "foo")); | 172 assertEquals(true, Reflect.has(target, "foo")); |
173 tgt.__proto__ = proto; | 173 target.__proto__ = proto; |
174 } | 174 } |
175 })(); | 175 })(); |
176 | 176 |
177 | 177 |
178 | 178 |
179 //////////////////////////////////////////////////////////////////////////////// | 179 //////////////////////////////////////////////////////////////////////////////// |
180 // Reflect.defineProperty | 180 // Reflect.defineProperty |
181 | 181 |
182 | 182 |
183 (function testReflectDefinePropertyArity() { | 183 (function testReflectDefinePropertyArity() { |
184 assertEquals(3, Reflect.defineProperty.length); | 184 assertEquals(3, Reflect.defineProperty.length); |
185 })(); | 185 })(); |
186 | 186 |
187 | 187 |
188 (function testReflectDefinePropertyOnNonObject() { | 188 (function testReflectDefinePropertyOnNonObject() { |
189 assertThrows(function() { Reflect.defineProperty(); }, TypeError); | 189 assertThrows(function() { Reflect.defineProperty(); }, TypeError); |
190 assertThrows(function() { Reflect.defineProperty(42, "bla"); }, TypeError); | 190 assertThrows(function() { Reflect.defineProperty(42, "bla"); }, TypeError); |
191 assertThrows(function() { Reflect.defineProperty(null, "bla"); }, TypeError); | 191 assertThrows(function() { Reflect.defineProperty(null, "bla"); }, TypeError); |
192 assertThrows(function() { Reflect.defineProperty({}, "bla"); }, TypeError); | 192 assertThrows(function() { Reflect.defineProperty({}, "bla"); }, TypeError); |
193 assertThrows(function() { Reflect.defineProperty({}, "bla", 42); }, | 193 assertThrows(function() { Reflect.defineProperty({}, "bla", 42); }, |
194 TypeError); | 194 TypeError); |
195 assertThrows(function() { Reflect.defineProperty({}, "bla", null); }, | 195 assertThrows(function() { Reflect.defineProperty({}, "bla", null); }, |
196 TypeError); | 196 TypeError); |
197 })(); | 197 })(); |
198 | 198 |
199 | 199 |
200 (function testReflectDefinePropertyKeyConversion() { | 200 (function testReflectDefinePropertyKeyConversion() { |
201 var tgt = {}; | 201 var target = {}; |
202 var a = { [Symbol.toPrimitive]: function() { return "bla" } }; | 202 var a = { [Symbol.toPrimitive]: function() { return "bla" } }; |
203 var b = { [Symbol.toPrimitive]: function() { throw "gaga" } }; | 203 var b = { [Symbol.toPrimitive]: function() { throw "gaga" } }; |
204 assertTrue(Reflect.defineProperty(tgt, a, {value: 42})); | 204 assertTrue(Reflect.defineProperty(target, a, {value: 42})); |
205 assertEquals(tgt.bla, 42); | 205 assertEquals(target.bla, 42); |
206 assertThrows(function() { Reflect.defineProperty(tgt, b); }, "gaga"); | 206 assertThrows(function() { Reflect.defineProperty(target, b); }, "gaga"); |
207 })(); | 207 })(); |
208 | 208 |
209 | 209 |
210 // See reflect-define-property.js for further tests. | 210 // See reflect-define-property.js for further tests. |
211 | 211 |
212 | 212 |
213 | 213 |
214 //////////////////////////////////////////////////////////////////////////////// | 214 //////////////////////////////////////////////////////////////////////////////// |
215 // Reflect.deleteProperty | 215 // Reflect.deleteProperty |
216 | 216 |
217 | 217 |
218 (function testReflectDeletePropertyArity() { | 218 (function testReflectDeletePropertyArity() { |
219 assertEquals(2, Reflect.deleteProperty.length); | 219 assertEquals(2, Reflect.deleteProperty.length); |
220 })(); | 220 })(); |
221 | 221 |
222 | 222 |
223 (function testReflectDeletePropertyOnNonObject() { | 223 (function testReflectDeletePropertyOnNonObject() { |
224 assertThrows(function() { Reflect.deleteProperty(); }, TypeError); | 224 assertThrows(function() { Reflect.deleteProperty(); }, TypeError); |
225 assertThrows(function() { Reflect.deleteProperty(42, "bla"); }, TypeError); | 225 assertThrows(function() { Reflect.deleteProperty(42, "bla"); }, TypeError); |
226 assertThrows(function() { Reflect.deleteProperty(null, "bla"); }, TypeError); | 226 assertThrows(function() { Reflect.deleteProperty(null, "bla"); }, TypeError); |
227 })(); | 227 })(); |
228 | 228 |
229 | 229 |
230 (function testReflectDeletePropertyKeyConversion() { | 230 (function testReflectDeletePropertyKeyConversion() { |
231 var tgt = {bla: 42}; | 231 var target = {bla: 42}; |
232 var a = { [Symbol.toPrimitive]: function() { return "bla" } }; | 232 var a = { [Symbol.toPrimitive]: function() { return "bla" } }; |
233 var b = { [Symbol.toPrimitive]: function() { throw "gaga" } }; | 233 var b = { [Symbol.toPrimitive]: function() { throw "gaga" } }; |
234 assertTrue(Reflect.deleteProperty(tgt, a)); | 234 assertTrue(Reflect.deleteProperty(target, a)); |
235 assertThrows(function() { Reflect.deleteProperty(tgt, b); }, "gaga"); | 235 assertThrows(function() { Reflect.deleteProperty(target, b); }, "gaga"); |
236 })(); | 236 })(); |
237 | 237 |
238 | 238 |
239 (function testReflectDeletePropertyOnObject() { | 239 (function testReflectDeletePropertyOnObject() { |
240 for (let tgt of objects) { | 240 for (let target of objects) { |
241 prepare(tgt); | 241 prepare(target); |
242 assertTrue(Reflect.deleteProperty(tgt, "bla")); | 242 assertTrue(Reflect.deleteProperty(target, "bla")); |
243 assertEquals(undefined, Object.getOwnPropertyDescriptor(tgt, "bla")); | 243 assertEquals(undefined, Object.getOwnPropertyDescriptor(target, "bla")); |
244 if (tgt instanceof Int32Array) { | 244 if (target instanceof Int32Array) { |
245 assertFalse(Reflect.deleteProperty(tgt, 4)); | 245 assertFalse(Reflect.deleteProperty(target, 4)); |
246 } else { | 246 } else { |
247 assertTrue(Reflect.deleteProperty(tgt, 4)); | 247 assertTrue(Reflect.deleteProperty(target, 4)); |
248 assertEquals(undefined, Object.getOwnPropertyDescriptor(tgt, 4)); | 248 assertEquals(undefined, Object.getOwnPropertyDescriptor(target, 4)); |
249 } | 249 } |
250 assertTrue(Reflect.deleteProperty(tgt, sym)); | 250 assertTrue(Reflect.deleteProperty(target, sym)); |
251 assertEquals(undefined, Object.getOwnPropertyDescriptor(tgt, sym)); | 251 assertEquals(undefined, Object.getOwnPropertyDescriptor(target, sym)); |
252 assertFalse(Reflect.deleteProperty(tgt, "noconf")); | 252 assertFalse(Reflect.deleteProperty(target, "noconf")); |
253 assertEquals(43, tgt.noconf); | 253 assertEquals(43, target.noconf); |
254 assertTrue(Reflect.deleteProperty(tgt, "getter")); | 254 assertTrue(Reflect.deleteProperty(target, "getter")); |
255 assertTrue(Reflect.deleteProperty(tgt, "setter")); | 255 assertTrue(Reflect.deleteProperty(target, "setter")); |
256 assertTrue(Reflect.deleteProperty(tgt, "foo")); | 256 assertTrue(Reflect.deleteProperty(target, "foo")); |
257 assertTrue(Reflect.deleteProperty(tgt, 666)); | 257 assertTrue(Reflect.deleteProperty(target, 666)); |
258 | 258 |
259 let proto = tgt.__proto__; | 259 let proto = target.__proto__; |
260 tgt.__proto__ = { get foo() {return this.bla} }; | 260 target.__proto__ = { get foo() {return this.bla} }; |
261 assertEquals(true, Reflect.deleteProperty(tgt, "foo")); | 261 assertEquals(true, Reflect.deleteProperty(target, "foo")); |
262 tgt.__proto__ = proto; | 262 target.__proto__ = proto; |
263 } | 263 } |
264 })(); | 264 })(); |
265 | 265 |
266 | 266 |
267 | 267 |
268 //////////////////////////////////////////////////////////////////////////////// | 268 //////////////////////////////////////////////////////////////////////////////// |
269 // Reflect.getPrototypeOf | 269 // Reflect.getPrototypeOf |
270 | 270 |
271 | 271 |
272 (function testReflectGetPrototypeOfArity() { | 272 (function testReflectGetPrototypeOfArity() { |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
322 | 322 |
323 (function testReflectIsExtensibleOnNonObject() { | 323 (function testReflectIsExtensibleOnNonObject() { |
324 assertThrows(function() { Reflect.isExtensible(); }, TypeError); | 324 assertThrows(function() { Reflect.isExtensible(); }, TypeError); |
325 assertThrows(function() { Reflect.isExtensible(42); }, TypeError); | 325 assertThrows(function() { Reflect.isExtensible(42); }, TypeError); |
326 assertThrows(function() { Reflect.isExtensible(null); }, TypeError); | 326 assertThrows(function() { Reflect.isExtensible(null); }, TypeError); |
327 })(); | 327 })(); |
328 | 328 |
329 | 329 |
330 (function testReflectIsExtensibleOnObject() { | 330 (function testReflectIsExtensibleOnObject() { |
331 // This should be the last test on [objects] as it modifies them irreversibly. | 331 // This should be the last test on [objects] as it modifies them irreversibly. |
332 for (let tgt of objects) { | 332 for (let target of objects) { |
333 prepare(tgt); | 333 prepare(target); |
334 if (tgt instanceof Int32Array) continue; // issue v8:4460 | 334 if (target instanceof Int32Array) continue; // issue v8:4460 |
335 assertTrue(Reflect.isExtensible(tgt)); | 335 assertTrue(Reflect.isExtensible(target)); |
336 Object.preventExtensions(tgt); | 336 Object.preventExtensions(target); |
337 assertFalse(Reflect.isExtensible(tgt)); | 337 assertFalse(Reflect.isExtensible(target)); |
338 } | 338 } |
339 })(); | 339 })(); |
340 | 340 |
341 | 341 |
342 | 342 |
343 //////////////////////////////////////////////////////////////////////////////// | 343 //////////////////////////////////////////////////////////////////////////////// |
344 // Reflect.enumerate | 344 // Reflect.enumerate |
345 | 345 |
346 | 346 |
347 (function testReflectEnumerateArity() { | 347 (function testReflectEnumerateArity() { |
348 assertEquals(1, Reflect.enumerate.length); | 348 assertEquals(1, Reflect.enumerate.length); |
349 })(); | 349 })(); |
350 | 350 |
351 | 351 |
352 (function testReflectEnumerateOnNonObject() { | 352 (function testReflectEnumerateOnNonObject() { |
353 assertThrows(function() { Reflect.enumerate(); }, TypeError); | 353 assertThrows(function() { Reflect.enumerate(); }, TypeError); |
354 assertThrows(function() { Reflect.enumerate(42); }, TypeError); | 354 assertThrows(function() { Reflect.enumerate(42); }, TypeError); |
355 assertThrows(function() { Reflect.enumerate(null); }, TypeError); | 355 assertThrows(function() { Reflect.enumerate(null); }, TypeError); |
356 })(); | 356 })(); |
357 | 357 |
358 | 358 |
359 // See reflect-enumerate*.js for further tests. | 359 // See reflect-enumerate*.js for further tests. |
360 | 360 |
361 | 361 |
362 | 362 |
363 //////////////////////////////////////////////////////////////////////////////// | 363 //////////////////////////////////////////////////////////////////////////////// |
| 364 // Reflect.getOwnPropertyDescriptor |
| 365 |
| 366 |
| 367 (function testReflectGetOwnPropertyDescriptorArity() { |
| 368 assertEquals(2, Reflect.getOwnPropertyDescriptor.length); |
| 369 })(); |
| 370 |
| 371 |
| 372 (function testReflectGetOwnPropertyDescriptorOnNonObject() { |
| 373 assertThrows(function() { Reflect.getOwnPropertyDescriptor(); }, TypeError); |
| 374 assertThrows(function() { Reflect.getOwnPropertyDescriptor(42); }, |
| 375 TypeError); |
| 376 assertThrows(function() { Reflect.getOwnPropertyDescriptor(null); }, |
| 377 TypeError); |
| 378 })(); |
| 379 |
| 380 |
| 381 (function testReflectGetOwnPropertyDescriptorKeyConversion() { |
| 382 var target = {bla: 42}; |
| 383 var a = { [Symbol.toPrimitive]: function() { return "bla" } }; |
| 384 var b = { [Symbol.toPrimitive]: function() { throw "gaga" } }; |
| 385 assertEquals(42, Reflect.getOwnPropertyDescriptor(target, a).value); |
| 386 assertThrows(function() { Reflect.getOwnPropertyDescriptor(target, b); }, |
| 387 "gaga"); |
| 388 })(); |
| 389 |
| 390 |
| 391 // See reflect-get-own-property-descriptor.js for further tests. |
| 392 |
| 393 |
| 394 |
| 395 //////////////////////////////////////////////////////////////////////////////// |
364 // Reflect.preventExtensions | 396 // Reflect.preventExtensions |
365 | 397 |
366 | 398 |
367 (function testReflectPreventExtensionsArity() { | 399 (function testReflectPreventExtensionsArity() { |
368 assertEquals(1, Reflect.preventExtensions.length); | 400 assertEquals(1, Reflect.preventExtensions.length); |
369 })(); | 401 })(); |
370 | 402 |
371 | 403 |
372 (function testReflectPreventExtensionsOnNonObject() { | 404 (function testReflectPreventExtensionsOnNonObject() { |
373 assertThrows(function() { Reflect.preventExtensions(); }, TypeError); | 405 assertThrows(function() { Reflect.preventExtensions(); }, TypeError); |
374 assertThrows(function() { Reflect.preventExtensions(42); }, TypeError); | 406 assertThrows(function() { Reflect.preventExtensions(42); }, TypeError); |
375 assertThrows(function() { Reflect.preventExtensions(null); }, TypeError); | 407 assertThrows(function() { Reflect.preventExtensions(null); }, TypeError); |
376 })(); | 408 })(); |
377 | 409 |
378 | 410 |
379 // See reflect-prevent-extensions.js for further tests. | 411 // See reflect-prevent-extensions.js for further tests. |
380 | 412 |
381 // TODO(neis): Need proxies to test the situation where | 413 // TODO(neis): Need proxies to test the situation where |
382 // [[preventExtensions]] returns false. | 414 // [[preventExtensions]] returns false. |
OLD | NEW |