Crash in libxml2.2.dylib: xmlDictReference
[WebKit-https.git] / JSTests / stress / object-rest-deconstruct.js
1 let assert = (e) => {
2     if (!e)
3         throw Error("Bad assertion!");
4 }
5
6 let assertPropDescriptor = (restObj, prop) => {
7     let desc = Object.getOwnPropertyDescriptor(restObj, prop);
8     assert(desc.enumerable);
9     assert(desc.writable);
10     assert(desc.configurable);
11 }
12
13 // Base Case
14 (() => {
15     let obj = {x: 1, y: 2, a: 5, b: 3}
16
17     let {a, b, ...rest} = obj;
18
19     assert(a === 5);
20     assert(b === 3);
21
22     assert(rest.x === 1);
23     assert(rest.y === 2);
24
25     assertPropDescriptor(rest, 'x');
26     assertPropDescriptor(rest, 'y');
27 })();
28
29 // Empty Object
30 (() => {
31     let obj = {}
32
33     let {a, b, ...rest} = obj;
34
35     assert(a === undefined);
36     assert(b === undefined);
37
38     assert(typeof rest === "object");
39 })();
40
41 // Number case
42 (() => {
43     let obj = 3;
44
45     let {...rest} = obj;
46
47     assert(typeof rest === "object");
48 })();
49
50 // String case
51 (() => {
52     let obj = "foo";
53
54     let {...rest} = obj;
55
56     assert(typeof rest === "object");
57 })();
58
59 // Symbol case
60 (() => {
61     let obj = Symbol("foo");
62
63     let {...rest} = obj;
64
65     assert(typeof rest === "object");
66 })();
67
68 // null case
69 (() => {
70     let obj = null;
71
72     try {
73         let {...rest} = obj;
74         assert(false);
75     } catch (e) {
76         assert(e.message == "Right side of assignment cannot be destructured");
77     }
78
79 })();
80
81 // undefined case
82 (() => {
83     let obj = undefined;
84
85     try {
86         let {...rest} = obj;
87         assert(false);
88     } catch (e) {
89         assert(e.message == "Right side of assignment cannot be destructured");
90     }
91
92 })();
93
94 // getter case
95 (() => {
96     let obj = {a: 3, b: 4};
97     Object.defineProperty(obj, "x", { get: () => 3, enumerable: true });
98
99     let {a, b, ...rest} = obj;
100
101     assert(a === 3);
102     assert(b === 4);
103
104     assert(rest.x === 3);
105     assertPropDescriptor(rest, 'x');
106 })();
107
108 // Skip non-enumerable case
109 (() => {
110     let obj = {a: 3, b: 4};
111     Object.defineProperty(obj, "x", { value: 4, enumerable: false });
112
113     let {...rest} = obj;
114
115     assert(rest.a === 3);
116     assert(rest.b === 4);
117     assert(rest.x === undefined);
118 })();
119
120 // Don't copy descriptor case
121 (() => {
122     let obj = {};
123     Object.defineProperty(obj, "a", { value: 3, configurable: false, enumerable: true });
124     Object.defineProperty(obj, "b", { value: 4, writable: false, enumerable: true });
125
126     let {...rest} = obj;
127
128     assert(rest.a === 3);
129     assert(rest.b === 4);
130
131     assertPropDescriptor(rest, 'a');
132     assertPropDescriptor(rest, 'b');
133 })();
134
135 // Nested base case
136 (() => {
137     let obj = {a: 1, b: 2, c: 3, d: 4, e: 5};
138
139     let {a, b, ...{c, e}} = obj;
140
141     assert(a === 1);
142     assert(b === 2);
143     assert(c === 3);
144     assert(e === 5);
145 })();
146
147 // Nested rest case
148 (() => {
149     let obj = {a: 1, b: 2, c: 3, d: 4, e: 5};
150
151     let {a, b, ...{c, ...rest}} = obj;
152
153     assert(a === 1);
154     assert(b === 2);
155     assert(c === 3);
156
157     assert(rest.d === 4);
158     assert(rest.e === 5);
159 })();
160
161 // Destructuring Only Own Properties
162 (() => {
163     var o = Object.create({ x: 1, y: 2 });
164     o.z = 3;
165
166     var x, y, z;
167
168     // Destructuring assignment allows nested objects
169     ({ x, ...{y , z} } = o);
170
171     assert(x === 1);
172     assert(y === undefined);
173     assert(z === 3);
174 })();
175
176 // Destructuring function parameter
177
178 (() => {
179
180     var o = { x: 1, y: 2, w: 3, z: 4 };
181     
182     function foo({ x, y, ...rest }) {
183         assert(x === 1);
184         assert(y === 2);
185         assert(rest.w === 3);
186         assert(rest.z === 4);
187     }
188     foo(o);
189 })();
190
191 // Destructuring arrow function parameter
192
193 (() => {
194
195     var o = { x: 1, y: 2, w: 3, z: 4 };
196     
197     (({ x, y, ...rest }) => {
198         assert(x === 1);
199         assert(y === 2);
200         assert(rest.w === 3);
201         assert(rest.z === 4);
202     })(o);
203 })();
204
205 // Destructuring to a property
206 (() => {
207
208     var o = { x: 1, y: 2};
209     
210     let settedValue;
211     let src = {};
212     ({...src.y} = o);
213     assert(src.y.x === 1);
214     assert(src.y.y === 2);
215 })();
216
217 // Destructuring with setter
218 (() => {
219
220     var o = { x: 1, y: 2};
221     
222     let settedValue;
223     let src = {
224         get y() { throw Error("The property should not be accessed"); }, 
225         set y(v) {
226             settedValue = v;
227         }
228     }
229     src.y = undefined;
230     ({...src.y} = o);
231     assert(settedValue.x === 1);
232     assert(settedValue.y === 2);
233 })();
234
235 // Destructuring yield
236 (() => {
237
238     var o = { x: 1, y: 2, w: 3, z: 4 };
239     
240     let gen = (function * (o) {
241         ({...{ x = yield }} = o);
242     })(o);
243     
244     assert(gen.next().value === undefined);
245 })();
246