OLD | NEW |
| (Empty) |
1 // Copyright 2014 the V8 project authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 // Flags: --harmony-computed-property-names | |
6 | |
7 | |
8 function ID(x) { | |
9 return x; | |
10 } | |
11 | |
12 | |
13 | |
14 (function TestBasicsString() { | |
15 var object = { | |
16 a: 'A', | |
17 ['b']: 'B', | |
18 c: 'C', | |
19 [ID('d')]: 'D', | |
20 }; | |
21 assertEquals('A', object.a); | |
22 assertEquals('B', object.b); | |
23 assertEquals('C', object.c); | |
24 assertEquals('D', object.d); | |
25 assertArrayEquals(['a', 'b', 'c', 'd'], Object.keys(object)); | |
26 })(); | |
27 | |
28 | |
29 (function TestBasicsNumber() { | |
30 var object = { | |
31 a: 'A', | |
32 [1]: 'B', | |
33 c: 'C', | |
34 [ID(2)]: 'D', | |
35 }; | |
36 assertEquals('A', object.a); | |
37 assertEquals('B', object[1]); | |
38 assertEquals('C', object.c); | |
39 assertEquals('D', object[2]); | |
40 // Array indexes first. | |
41 assertArrayEquals(['1', '2', 'a', 'c'], Object.keys(object)); | |
42 })(); | |
43 | |
44 | |
45 (function TestBasicsSymbol() { | |
46 var sym1 = Symbol(); | |
47 var sym2 = Symbol(); | |
48 var object = { | |
49 a: 'A', | |
50 [sym1]: 'B', | |
51 c: 'C', | |
52 [ID(sym2)]: 'D', | |
53 }; | |
54 assertEquals('A', object.a); | |
55 assertEquals('B', object[sym1]); | |
56 assertEquals('C', object.c); | |
57 assertEquals('D', object[sym2]); | |
58 assertArrayEquals(['a', 'c'], Object.keys(object)); | |
59 assertArrayEquals([sym1, sym2], Object.getOwnPropertySymbols(object)); | |
60 })(); | |
61 | |
62 | |
63 (function TestToNameSideEffects() { | |
64 var counter = 0; | |
65 var key1 = { | |
66 toString: function() { | |
67 assertEquals(0, counter++); | |
68 return 'b'; | |
69 } | |
70 }; | |
71 var key2 = { | |
72 toString: function() { | |
73 assertEquals(1, counter++); | |
74 return 'd'; | |
75 } | |
76 }; | |
77 var object = { | |
78 a: 'A', | |
79 [key1]: 'B', | |
80 c: 'C', | |
81 [key2]: 'D', | |
82 }; | |
83 assertEquals(2, counter); | |
84 assertEquals('A', object.a); | |
85 assertEquals('B', object.b); | |
86 assertEquals('C', object.c); | |
87 assertEquals('D', object.d); | |
88 assertArrayEquals(['a', 'b', 'c', 'd'], Object.keys(object)); | |
89 })(); | |
90 | |
91 | |
92 (function TestToNameSideEffectsNumbers() { | |
93 var counter = 0; | |
94 var key1 = { | |
95 valueOf: function() { | |
96 assertEquals(0, counter++); | |
97 return 1; | |
98 }, | |
99 toString: null | |
100 }; | |
101 var key2 = { | |
102 valueOf: function() { | |
103 assertEquals(1, counter++); | |
104 return 2; | |
105 }, | |
106 toString: null | |
107 }; | |
108 | |
109 var object = { | |
110 a: 'A', | |
111 [key1]: 'B', | |
112 c: 'C', | |
113 [key2]: 'D', | |
114 }; | |
115 assertEquals(2, counter); | |
116 assertEquals('A', object.a); | |
117 assertEquals('B', object[1]); | |
118 assertEquals('C', object.c); | |
119 assertEquals('D', object[2]); | |
120 // Array indexes first. | |
121 assertArrayEquals(['1', '2', 'a', 'c'], Object.keys(object)); | |
122 })(); | |
123 | |
124 | |
125 (function TestDoubleName() { | |
126 var object = { | |
127 [1.2]: 'A', | |
128 [1e55]: 'B', | |
129 [0.000001]: 'C', | |
130 [-0]: 'D', | |
131 // TODO(arv): https://code.google.com/p/v8/issues/detail?id=3815 | |
132 // [Infinity]: 'E', | |
133 // [-Infinity]: 'F', | |
134 [NaN]: 'G', | |
135 }; | |
136 assertEquals('A', object['1.2']); | |
137 assertEquals('B', object['1e+55']); | |
138 assertEquals('C', object['0.000001']); | |
139 assertEquals('D', object[0]); | |
140 // TODO(arv): https://code.google.com/p/v8/issues/detail?id=3815 | |
141 // assertEquals('E', object[Infinity]); | |
142 // assertEquals('F', object[-Infinity]); | |
143 assertEquals('G', object[NaN]); | |
144 })(); | |
145 | |
146 | |
147 (function TestGetter() { | |
148 var object = { | |
149 get ['a']() { | |
150 return 'A'; | |
151 } | |
152 }; | |
153 assertEquals('A', object.a); | |
154 | |
155 object = { | |
156 get b() { | |
157 assertUnreachable(); | |
158 }, | |
159 get ['b']() { | |
160 return 'B'; | |
161 } | |
162 }; | |
163 assertEquals('B', object.b); | |
164 | |
165 object = { | |
166 get c() { | |
167 assertUnreachable(); | |
168 }, | |
169 get ['c']() { | |
170 assertUnreachable(); | |
171 }, | |
172 get ['c']() { | |
173 return 'C'; | |
174 } | |
175 }; | |
176 assertEquals('C', object.c); | |
177 | |
178 object = { | |
179 get ['d']() { | |
180 assertUnreachable(); | |
181 }, | |
182 get d() { | |
183 return 'D'; | |
184 } | |
185 }; | |
186 assertEquals('D', object.d); | |
187 })(); | |
188 | |
189 | |
190 (function TestSetter() { | |
191 var calls = 0; | |
192 var object = { | |
193 set ['a'](_) { | |
194 calls++; | |
195 } | |
196 }; | |
197 object.a = 'A'; | |
198 assertEquals(1, calls); | |
199 | |
200 calls = 0; | |
201 object = { | |
202 set b(_) { | |
203 assertUnreachable(); | |
204 }, | |
205 set ['b'](_) { | |
206 calls++; | |
207 } | |
208 }; | |
209 object.b = 'B'; | |
210 assertEquals(1, calls); | |
211 | |
212 calls = 0; | |
213 object = { | |
214 set c(_) { | |
215 assertUnreachable() | |
216 }, | |
217 set ['c'](_) { | |
218 assertUnreachable() | |
219 }, | |
220 set ['c'](_) { | |
221 calls++ | |
222 } | |
223 }; | |
224 object.c = 'C'; | |
225 assertEquals(1, calls); | |
226 | |
227 calls = 0; | |
228 object = { | |
229 set ['d'](_) { | |
230 assertUnreachable() | |
231 }, | |
232 set d(_) { | |
233 calls++ | |
234 } | |
235 }; | |
236 object.d = 'D'; | |
237 assertEquals(1, calls); | |
238 })(); | |
239 | |
240 | |
241 (function TestDuplicateKeys() { | |
242 'use strict'; | |
243 // ES5 does not allow duplicate keys. | |
244 // ES6 does but we haven't changed our code yet. | |
245 | |
246 var object = { | |
247 a: 1, | |
248 ['a']: 2, | |
249 }; | |
250 assertEquals(2, object.a); | |
251 })(); | |
252 | |
253 | |
254 (function TestProto() { | |
255 var proto = {}; | |
256 var object = { | |
257 __proto__: proto | |
258 }; | |
259 assertEquals(proto, Object.getPrototypeOf(object)); | |
260 | |
261 object = { | |
262 '__proto__': proto | |
263 }; | |
264 assertEquals(proto, Object.getPrototypeOf(object)); | |
265 | |
266 object = { | |
267 ['__proto__']: proto | |
268 }; | |
269 assertEquals(Object.prototype, Object.getPrototypeOf(object)); | |
270 assertEquals(proto, object.__proto__); | |
271 assertTrue(object.hasOwnProperty('__proto__')); | |
272 | |
273 object = { | |
274 [ID('x')]: 'X', | |
275 __proto__: proto | |
276 }; | |
277 assertEquals('X', object.x); | |
278 assertEquals(proto, Object.getPrototypeOf(object)); | |
279 })(); | |
280 | |
281 | |
282 (function TestExceptionInName() { | |
283 function MyError() {}; | |
284 function throwMyError() { | |
285 throw new MyError(); | |
286 } | |
287 assertThrows(function() { | |
288 var o = { | |
289 [throwMyError()]: 42 | |
290 }; | |
291 }, MyError); | |
292 assertThrows(function() { | |
293 var o = { | |
294 get [throwMyError()]() { return 42; } | |
295 }; | |
296 }, MyError); | |
297 assertThrows(function() { | |
298 var o = { | |
299 set [throwMyError()](_) { } | |
300 }; | |
301 }, MyError); | |
302 })(); | |
OLD | NEW |