diff --git a/test/language/expressions/assignment/destructuring/array-elem-elision.js b/test/language/expressions/assignment/destructuring/array-elem-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..dd7c6dd6128555777191cfb0abcb67f764e37c0e
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-elision.js
@@ -0,0 +1,19 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    ArrayAssignmentPattern may include elisions at any position in a
+    AssignmentElementList that does not contain an AssignmentRestElement.
+es6id: 12.14.5
+---*/
+
+var value = [1, 2, 3, 4, 5, 6];
+var x, y;
+var result;
+
+result = [, x, , y, ,] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 2);
+assert.sameValue(y, 4);
diff --git a/test/language/expressions/assignment/destructuring/array-elem-init-assignment.js b/test/language/expressions/assignment/destructuring/array-elem-init-assignment.js
new file mode 100644
index 0000000000000000000000000000000000000000..3eea1f6863282f33063d701cd698fdae5a1ee935
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-init-assignment.js
@@ -0,0 +1,41 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    If the Initializer is present and v is undefined, the Initializer should be
+    evaluated and the result assigned to the target reference.
+es6id: 12.14.5.3
+---*/
+
+var result, value, x;
+
+value = [];
+result = [ x = 10 ] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 10, 'no element at index');
+
+value = [2];
+result = [ x = 11 ] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 2, 'element at index (truthy value)');
+
+value = [ null ];
+result = [ x = 12 ] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, null, 'element at index (`null`)');
+
+value = [ undefined ];
+result = [ x = 13 ] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 13, 'element at index (`undefined`)');
+
+value = [ , ];
+result = [ x = 14 ] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 14, 'element at index (sparse array)');
diff --git a/test/language/expressions/assignment/destructuring/array-elem-init-evaluation.js b/test/language/expressions/assignment/destructuring/array-elem-init-evaluation.js
new file mode 100644
index 0000000000000000000000000000000000000000..0e5198eeac048de52b6f29e772600f76d5d6d9ab
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-init-evaluation.js
@@ -0,0 +1,24 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    The Initializer should only be evaluated if v is undefined.
+es6id: 12.14.5.3
+---*/
+
+var result, value, x, flag;
+
+value = [];
+flag = false;
+result = [ x = flag = true ] = value;
+assert.sameValue(result, value);
+assert.sameValue(x, true);
+assert.sameValue(flag, true);
+
+value = [14];
+flag = false;
+result = [ x = flag = true ] = value;
+assert.sameValue(result, value);
+assert.sameValue(x, 14);
+assert.sameValue(flag, false);
diff --git a/test/language/expressions/assignment/destructuring/array-elem-init-in.js b/test/language/expressions/assignment/destructuring/array-elem-init-in.js
new file mode 100644
index 0000000000000000000000000000000000000000..8fddbff152d9cec041fa8b283135ccc38c478b33
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-init-in.js
@@ -0,0 +1,16 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    The Initializer in an AssignmentElement may be an `in` expression.
+es6id: 12.14.5
+---*/
+
+var value = [];
+var result, x;
+
+result = [ x = 'x' in {} ] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, false);
diff --git a/test/language/expressions/assignment/destructuring/array-elem-init-let.js b/test/language/expressions/assignment/destructuring/array-elem-init-let.js
new file mode 100644
index 0000000000000000000000000000000000000000..b11f14491fcfa4c17048966d19267916e145a788
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-init-let.js
@@ -0,0 +1,16 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    Value retrieval of Initializer obeys `let` semantics.
+es6id: 12.14.5.3
+features: [let]
+---*/
+
+var x;
+
+assert.throws(ReferenceError, function() {
+  [ x = y ] = [];
+  let y;
+});
diff --git a/test/language/expressions/assignment/destructuring/array-elem-init-order.js b/test/language/expressions/assignment/destructuring/array-elem-init-order.js
new file mode 100644
index 0000000000000000000000000000000000000000..43ff62a45631e3b40938a3a906d94cb5742f0978
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-init-order.js
@@ -0,0 +1,19 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    Initializer values should be assigned in left-to-right order.
+es6id: 12.14.5.3
+---*/
+
+var value = [];
+var x = 0;
+var a, b, result;
+
+result = [ a = x += 1, b = x *= 2 ] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(a, 1);
+assert.sameValue(b, 2);
+assert.sameValue(x, 2);
diff --git a/test/language/expressions/assignment/destructuring/array-elem-init-simple-no-strict.js b/test/language/expressions/assignment/destructuring/array-elem-init-simple-no-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..b3a5e9c73c9d73f0eed0ba5aa7545c18fcc0ef7d
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-init-simple-no-strict.js
@@ -0,0 +1,20 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    Identifiers that appear as the DestructuringAssignmentTarget in an
+    AssignmentElement should take on the iterated value corresponding to their
+    position in the ArrayAssignmentPattern.
+es6id: 12.14.5.3
+flags: [noStrict]
+---*/
+
+var value = [];
+var result, argument, eval;
+
+result = [arguments = 4, eval = 5] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(arguments, 4);
+assert.sameValue(eval, 5);
diff --git a/test/language/expressions/assignment/destructuring/array-elem-init-simple-strict.js b/test/language/expressions/assignment/destructuring/array-elem-init-simple-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..2d0659bf428e6dc8474aaac1b33ae5dc173993c6
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-init-simple-strict.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    It is a Syntax Error if LeftHandSideExpression is neither an
+    ObjectLiteral nor an ArrayLiteral and
+    IsValidSimpleAssignmentTarget(LeftHandSideExpression) is
+    false.
+es6id: 12.14.5.1
+flags: [onlyStrict]
+negative: SyntaxError
+---*/
+
+([arguments] = []);
diff --git a/test/language/expressions/assignment/destructuring/array-elem-init-yield-expr.js b/test/language/expressions/assignment/destructuring/array-elem-init-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..8f4a5d8b2492f3c6a9552702715401c9bfb409e8
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-init-yield-expr.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the Initializer of an
+    AssignmentElement within a generator function body, it behaves as a
+    YieldExpression.
+es6id: 12.14.5.4
+features: [generators]
+---*/
+
+var value = [];
+var assignmentResult, iterationResult, iter, x;
+
+iter = (function*() {
+  assignmentResult = [ x = yield ] = value;
+})();
+
+iterationResult = iter.next();
+
+assert.sameValue(assignmentResult, undefined);
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, false);
+assert.sameValue(x, undefined);
+
+iterationResult = iter.next(86);
+
+assert.sameValue(assignmentResult, value);
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, true);
+assert.sameValue(x, 86);
diff --git a/test/language/expressions/assignment/destructuring/array-elem-init-yield-ident-invalid.js b/test/language/expressions/assignment/destructuring/array-elem-init-yield-ident-invalid.js
new file mode 100644
index 0000000000000000000000000000000000000000..429eb26b89fb0e4fb34de374fa9d3cf6af3f618d
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-init-yield-ident-invalid.js
@@ -0,0 +1,14 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the Initializer of an AssignmentElement
+    outside of a generator function body, it behaves as an IdentifierReference.
+es6id: 12.14.5.4
+flags: [onlyStrict]
+negative: SyntaxError
+---*/
+
+var x;
+[ x = yield ] = [];
diff --git a/test/language/expressions/assignment/destructuring/array-elem-init-yield-ident-valid.js b/test/language/expressions/assignment/destructuring/array-elem-init-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..3d8d87cc57b16259ced4478516ec1b69bdec327c
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-init-yield-ident-valid.js
@@ -0,0 +1,19 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the Initializer of an AssignmentElement
+    outside of a generator function body, it behaves as an IdentifierReference.
+es6id: 12.14.5.4
+flags: [noStrict]
+---*/
+
+var value = [];
+var yield = 4;
+var result, x;
+
+result = [ x = yield ] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 4);
diff --git a/test/language/expressions/assignment/destructuring/array-elem-nested-array-invalid.js b/test/language/expressions/assignment/destructuring/array-elem-nested-array-invalid.js
new file mode 100644
index 0000000000000000000000000000000000000000..8c5e1831903c59f7f3e8a9437a0de0e3bf005278
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-nested-array-invalid.js
@@ -0,0 +1,16 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    It is a Syntax Error if LeftHandSideExpression is either an ObjectLiteral
+    or an ArrayLiteral and if the lexical token sequence matched by
+    LeftHandSideExpression cannot be parsed with no tokens left over using
+    AssignmentPattern as the goal symbol.
+es6id: 12.14.5.1
+negative: SyntaxError
+---*/
+
+var x, y;
+
+[[(x, y)]] = [[]];
diff --git a/test/language/expressions/assignment/destructuring/array-elem-nested-array-null.js b/test/language/expressions/assignment/destructuring/array-elem-nested-array-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..98362d693f4a6f40f66e2eb3e09b00d2e8eb946f
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-nested-array-null.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an array literal and the value is
+    `null`, a TypeError should be thrown.
+es6id: 12.14.5.3
+---*/
+
+var x;
+
+assert.throws(TypeError, function() {
+  [[ x ]] = [null];
+});
diff --git a/test/language/expressions/assignment/destructuring/array-elem-nested-array-undefined-hole.js b/test/language/expressions/assignment/destructuring/array-elem-nested-array-undefined-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..047e093c2ea8f03db409595d6e5e277e5920e087
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-nested-array-undefined-hole.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an array literal and the value is a
+    "hole", a TypeError should be thrown.
+es6id: 12.14.5.3
+---*/
+
+var x;
+
+assert.throws(TypeError, function() {
+  [[ x ]] = [ , ];
+});
diff --git a/test/language/expressions/assignment/destructuring/array-elem-nested-array-undefined-own.js b/test/language/expressions/assignment/destructuring/array-elem-nested-array-undefined-own.js
new file mode 100644
index 0000000000000000000000000000000000000000..c9b72457c821667c5e06cbbd870652eeb76ab84a
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-nested-array-undefined-own.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an array literal and the value is
+    `undefined`, a TypeError should be thrown.
+es6id: 12.14.5.3
+---*/
+
+var x;
+
+assert.throws(TypeError, function() {
+  [[ x ]] = [undefined];
+});
diff --git a/test/language/expressions/assignment/destructuring/array-elem-nested-array-undefined.js b/test/language/expressions/assignment/destructuring/array-elem-nested-array-undefined.js
new file mode 100644
index 0000000000000000000000000000000000000000..d280bf26974586638302863879f852eb875a161d
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-nested-array-undefined.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an array literal and no value is
+    defined, a TypeError should be thrown.
+es6id: 12.14.5.3
+---*/
+
+var x;
+
+assert.throws(TypeError, function() {
+  [[ x ]] = [];
+});
diff --git a/test/language/expressions/assignment/destructuring/array-elem-nested-array-yield-expr.js b/test/language/expressions/assignment/destructuring/array-elem-nested-array-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..5128f3774e12c748c62d2035fe0bc9b01bab212d
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-nested-array-yield-expr.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the DestructuringAssignmentTarget of a
+    nested destructuring assignment and within a generator function body, it
+    behaves as a YieldExpression.
+es6id: 12.14.5.3
+features: [generators]
+---*/
+
+var value = [[22]];
+var x = {};
+var assignmentResult, iterationResult, iter;
+
+iter = (function*() {
+  assignmentResult = [[x[yield]]] = value;
+}());
+
+iterationResult = iter.next();
+
+assert.sameValue(assignmentResult, undefined);
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, false);
+assert.sameValue(x.prop, undefined);
+
+iterationResult = iter.next('prop');
+
+assert.sameValue(assignmentResult, value);
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, true);
+assert.sameValue(x.prop, 22);
diff --git a/test/language/expressions/assignment/destructuring/array-elem-nested-array-yield-ident-invalid.js b/test/language/expressions/assignment/destructuring/array-elem-nested-array-yield-ident-invalid.js
new file mode 100644
index 0000000000000000000000000000000000000000..bba32536e3334239c2b428b536510d16e73d6769
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-nested-array-yield-ident-invalid.js
@@ -0,0 +1,14 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the DestructuringAssignmentTarget of a
+    nested destructuring assignment outside of strict mode, it behaves as an
+    IdentifierReference.
+es6id: 12.14.5.3
+flags: [onlyStrict]
+negative: SyntaxError
+---*/
+
+[[x[yield]]] = value;
diff --git a/test/language/expressions/assignment/destructuring/array-elem-nested-array-yield-ident-valid.js b/test/language/expressions/assignment/destructuring/array-elem-nested-array-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..01ea78ebaef8e8d2dfea8585560e578b0ebd40f7
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-nested-array-yield-ident-valid.js
@@ -0,0 +1,21 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the DestructuringAssignmentTarget of a
+    nested destructuring assignment outside of strict mode, it behaves as an
+    IdentifierReference.
+es6id: 12.14.5.3
+flags: [noStrict]
+---*/
+
+var value = [[22]];
+var yield = 'prop';
+var x = {};
+var result;
+
+result = [[x[yield]]] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x.prop, 22);
diff --git a/test/language/expressions/assignment/destructuring/array-elem-nested-array.js b/test/language/expressions/assignment/destructuring/array-elem-nested-array.js
new file mode 100644
index 0000000000000000000000000000000000000000..0fb07e27b17a85e43e5e05c0d306cce25373f86d
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-nested-array.js
@@ -0,0 +1,18 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an array literal, it should be parsed
+    parsed as a DestructuringAssignmentPattern and evaluated as a destructuring
+    assignment.
+es6id: 12.14.5.3
+---*/
+
+var value = [[1]];
+var x, result;
+
+result = [[x]] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 1);
diff --git a/test/language/expressions/assignment/destructuring/array-elem-nested-obj-invalid.js b/test/language/expressions/assignment/destructuring/array-elem-nested-obj-invalid.js
new file mode 100644
index 0000000000000000000000000000000000000000..1f771e07ad806351d36ed6c74d52a9190d90080a
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-nested-obj-invalid.js
@@ -0,0 +1,14 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    It is a Syntax Error if LeftHandSideExpression is either an ObjectLiteral
+    or an ArrayLiteral and if the lexical token sequence matched by
+    LeftHandSideExpression cannot be parsed with no tokens left over using
+    AssignmentPattern as the goal symbol.
+es6id: 12.14.5.1
+negative: SyntaxError
+---*/
+
+[{ get x() {} }] = [{}];
diff --git a/test/language/expressions/assignment/destructuring/array-elem-nested-obj-null.js b/test/language/expressions/assignment/destructuring/array-elem-nested-obj-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..5485fde7363a9ca7180a32a9f86cd219c6f53006
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-nested-obj-null.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an object literal and the value is
+    `null`, a TypeError should be thrown.
+es6id: 12.14.5.3
+---*/
+
+var x;
+
+assert.throws(TypeError, function() {
+  [{ x }] = [null];
+});
diff --git a/test/language/expressions/assignment/destructuring/array-elem-nested-obj-undefined-hole.js b/test/language/expressions/assignment/destructuring/array-elem-nested-obj-undefined-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..3984ff7a31b0ed6a0665814d04688701a0d3e014
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-nested-obj-undefined-hole.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an object literal and the value is a
+    "hole", a TypeError should be thrown.
+es6id: 12.14.5.3
+---*/
+
+var x;
+
+assert.throws(TypeError, function() {
+  [{ x }] = [ , ];
+});
diff --git a/test/language/expressions/assignment/destructuring/array-elem-nested-obj-undefined-own.js b/test/language/expressions/assignment/destructuring/array-elem-nested-obj-undefined-own.js
new file mode 100644
index 0000000000000000000000000000000000000000..39614e4bdfeb44dec0f67c5fe5451ca840b9d415
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-nested-obj-undefined-own.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an object literal and the value is
+    `undefined`, a TypeError should be thrown.
+es6id: 12.14.5.3
+---*/
+
+var x;
+
+assert.throws(TypeError, function() {
+  [{ x }] = [undefined];
+});
diff --git a/test/language/expressions/assignment/destructuring/array-elem-nested-obj-undefined.js b/test/language/expressions/assignment/destructuring/array-elem-nested-obj-undefined.js
new file mode 100644
index 0000000000000000000000000000000000000000..8326c339aae7f97d5cff4fb46731153083129c46
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-nested-obj-undefined.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an object literal and no value is
+    defined, a TypeError should be thrown.
+es6id: 12.14.5.3
+---*/
+
+var x;
+
+assert.throws(TypeError, function() {
+  [{ x }] = [];
+});
diff --git a/test/language/expressions/assignment/destructuring/array-elem-nested-obj-yield-expr.js b/test/language/expressions/assignment/destructuring/array-elem-nested-obj-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..3d72841db92b7ecb33487886ae30456669cdc157
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-nested-obj-yield-expr.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the Initializer of a nested
+    destructuring assignment and within a generator function body, it behaves
+    as a YieldExpression.
+es6id: 12.14.5.3
+features: [generators]
+---*/
+
+var value = [{}];
+var assignmentResult, iterationResult, iter, x;
+
+iter = (function*() {
+  assignmentResult = [{ x = yield }] = value;
+}());
+
+iterationResult = iter.next();
+
+assert.sameValue(assignmentResult, undefined);
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, false);
+assert.sameValue(x, undefined);
+
+iterationResult = iter.next(4);
+
+assert.sameValue(assignmentResult, value);
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, true);
+assert.sameValue(x, 4);
diff --git a/test/language/expressions/assignment/destructuring/array-elem-nested-obj-yield-ident-invalid.js b/test/language/expressions/assignment/destructuring/array-elem-nested-obj-yield-ident-invalid.js
new file mode 100644
index 0000000000000000000000000000000000000000..39a024f39303df2521cd74167425a5e10cafc6ea
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-nested-obj-yield-ident-invalid.js
@@ -0,0 +1,14 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the Initializer of a nested
+    destructuring assignment outside of a generator function body, it behaves
+    as a IdentifierReference.
+es6id: 12.14.5.3
+flags: [onlyStrict]
+negative: SyntaxError
+---*/
+
+[{ x = yield }] = [{}];
diff --git a/test/language/expressions/assignment/destructuring/array-elem-nested-obj-yield-ident-valid.js b/test/language/expressions/assignment/destructuring/array-elem-nested-obj-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..6837411f45079ae953490aa7826697234258ecd3
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-nested-obj-yield-ident-valid.js
@@ -0,0 +1,20 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the Initializer of a nested
+    destructuring assignment outside of a generator function body, it behaves
+    as an IdentifierReference.
+es6id: 12.14.5.3
+flags: [noStrict]
+---*/
+
+var value = [{}];
+var yield = 2;
+var result, x;
+
+result = [{ x = yield }] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 2);
diff --git a/test/language/expressions/assignment/destructuring/array-elem-nested-obj.js b/test/language/expressions/assignment/destructuring/array-elem-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..94778a614e264eb2af7daf43c0ce6d403f350075
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-nested-obj.js
@@ -0,0 +1,18 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an object literal, it should be
+    parsed as a DestructuringAssignmentPattern and evaluated as a destructuring
+    assignment.
+es6id: 12.14.5.3
+---*/
+
+var value = [{ x: 2 }];
+var result, x;
+
+result = [{ x }] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 2);
diff --git a/test/language/expressions/assignment/destructuring/array-elem-put-const.js b/test/language/expressions/assignment/destructuring/array-elem-put-const.js
new file mode 100644
index 0000000000000000000000000000000000000000..44f8985b571e319dcdc1f4abafd915ae4896effa
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-put-const.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    The assignment target should obey `const` semantics.
+es6id: 12.14.5.3
+features: [const]
+---*/
+
+const c = null;
+
+assert.throws(TypeError, function() {
+  [ c ] = [1];
+});
diff --git a/test/language/expressions/assignment/destructuring/array-elem-put-let.js b/test/language/expressions/assignment/destructuring/array-elem-put-let.js
new file mode 100644
index 0000000000000000000000000000000000000000..018d8b1a6e36478f2b4690656f100b75a54df47e
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-put-let.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    The assignment target should obey `let` semantics.
+es6id: 12.14.5.3
+features: [let]
+---*/
+
+assert.throws(ReferenceError, function() {
+  'use strict';
+  [ x ] = [];
+  let x;
+});
diff --git a/test/language/expressions/assignment/destructuring/array-elem-put-prop-ref-no-get.js b/test/language/expressions/assignment/destructuring/array-elem-put-prop-ref-no-get.js
new file mode 100644
index 0000000000000000000000000000000000000000..4bd7a8a8adc5e06bf9b9811a438acc880bc99f0d
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-put-prop-ref-no-get.js
@@ -0,0 +1,25 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    If the DestructuringAssignmentTarget of an AssignmentElement is a
+    PropertyReference, it should not be evaluated.
+es6id: 12.14.5.3
+---*/
+
+var value = [23];
+var x, setValue, result;
+x = {
+  get y() {
+    $ERROR('The property should not be accessed.');
+  },
+  set y(val) {
+    setValue = val;
+  }
+};
+
+result = [x.y] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(setValue, 23);
diff --git a/test/language/expressions/assignment/destructuring/array-elem-put-prop-ref-user-err.js b/test/language/expressions/assignment/destructuring/array-elem-put-prop-ref-user-err.js
new file mode 100644
index 0000000000000000000000000000000000000000..00c43f26562f532418d5a7f757cfac3fc70cbb89
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-put-prop-ref-user-err.js
@@ -0,0 +1,20 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    Any error raised as a result of setting the value should be forwarded to
+    the runtime.
+es6id: 12.14.5.3
+---*/
+
+var value = [23];
+var x = {
+  set y(val) {
+    throw new Test262Error();
+  }
+};
+
+assert.throws(Test262Error, function() {
+  [x.y] = value;
+});
diff --git a/test/language/expressions/assignment/destructuring/array-elem-put-prop-ref.js b/test/language/expressions/assignment/destructuring/array-elem-put-prop-ref.js
new file mode 100644
index 0000000000000000000000000000000000000000..b0b419c7bd04e647741c759da436b9ac9f5338f1
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-put-prop-ref.js
@@ -0,0 +1,18 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    The DestructuringAssignmentTarget of an AssignmentElement may be a
+    PropertyReference.
+es6id: 12.14.5.3
+---*/
+
+var value = [4];
+var x = {};
+var result;
+
+result = [x.y] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x.y, 4);
diff --git a/test/language/expressions/assignment/destructuring/array-elem-put-unresolvable-no-strict.js b/test/language/expressions/assignment/destructuring/array-elem-put-unresolvable-no-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..41fc5d4153e61213bd6640d9f0e093d417f97422
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-put-unresolvable-no-strict.js
@@ -0,0 +1,16 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    Outside of strict mode, if the the assignment target is an unresolvable
+    reference, a new `var` binding should be created in the environment record.
+es6id: 12.14.5.3
+flags: [noStrict]
+---*/
+
+{
+  [ unresolvable ] = [];
+}
+
+assert.sameValue(unresolvable, undefined);
diff --git a/test/language/expressions/assignment/destructuring/array-elem-put-unresolvable-strict.js b/test/language/expressions/assignment/destructuring/array-elem-put-unresolvable-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..b06bac9c559cf9b0cd62e96c249d13ad87862c3d
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-put-unresolvable-strict.js
@@ -0,0 +1,14 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    In strict mode, if the the assignment target is an unresolvable reference,
+    a ReferenceError should be thrown.
+es6id: 12.14.5.3
+flags: [onlyStrict]
+---*/
+
+assert.throws(ReferenceError, function() {
+  [ unresolvable ] = [];
+});
diff --git a/test/language/expressions/assignment/destructuring/array-elem-target-identifier.js b/test/language/expressions/assignment/destructuring/array-elem-target-identifier.js
new file mode 100644
index 0000000000000000000000000000000000000000..17e1e403d935bdd7a465389175e99c1627b343c1
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-target-identifier.js
@@ -0,0 +1,21 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    Identifiers that appear as the DestructuringAssignmentTarget in an
+    AssignmentElement should take on the iterated value corresponding to their
+    position in the ArrayAssignmentPattern.
+es6id: 12.14.5.3
+---*/
+
+var value = [1, 2, 3];
+var x, y, z;
+var result;
+
+result = [x, y, z] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 1);
+assert.sameValue(y, 2);
+assert.sameValue(z, 3);
diff --git a/test/language/expressions/assignment/destructuring/array-elem-target-simple-no-strict.js b/test/language/expressions/assignment/destructuring/array-elem-target-simple-no-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..93421ae7efb355a513ff7b6791ad863cd1a4ed70
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-target-simple-no-strict.js
@@ -0,0 +1,20 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    Identifiers that appear as the DestructuringAssignmentTarget in an
+    AssignmentElement should take on the iterated value corresponding to their
+    position in the ArrayAssignmentPattern.
+es6id: 12.14.5.3
+flags: [noStrict]
+---*/
+
+var value = [2, 3];
+var result, argument, eval;
+
+result = [arguments, eval] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(arguments, 2);
+assert.sameValue(eval, 3);
diff --git a/test/language/expressions/assignment/destructuring/array-elem-target-simple-strict.js b/test/language/expressions/assignment/destructuring/array-elem-target-simple-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..2d0659bf428e6dc8474aaac1b33ae5dc173993c6
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-target-simple-strict.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    It is a Syntax Error if LeftHandSideExpression is neither an
+    ObjectLiteral nor an ArrayLiteral and
+    IsValidSimpleAssignmentTarget(LeftHandSideExpression) is
+    false.
+es6id: 12.14.5.1
+flags: [onlyStrict]
+negative: SyntaxError
+---*/
+
+([arguments] = []);
diff --git a/test/language/expressions/assignment/destructuring/array-elem-target-yield-expr.js b/test/language/expressions/assignment/destructuring/array-elem-target-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..6505a39694de37374b7f829f337099c04aeddd0f
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-target-yield-expr.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the DestructuringAssignmentTarget of an
+    AssignmentElement within a generator function body, it behaves as a
+    YieldExpression.
+es6id: 12.14.5.4
+features: [generators]
+---*/
+
+var value = [33];
+var x = {};
+var assignmentResult, iterationResult, iter;
+
+iter = (function*() {
+  assignmentResult = [ x[yield] ] = value;
+}());
+
+iterationResult = iter.next();
+
+assert.sameValue(assignmentResult, undefined);
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, false);
+assert.sameValue(x.prop, undefined);
+
+iterationResult = iter.next('prop');
+
+assert.sameValue(assignmentResult, value);
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, true);
+assert.sameValue(x.prop, 33);
diff --git a/test/language/expressions/assignment/destructuring/array-elem-target-yield-invalid.js b/test/language/expressions/assignment/destructuring/array-elem-target-yield-invalid.js
new file mode 100644
index 0000000000000000000000000000000000000000..f03f598683f323df547b69987a4e382b7146e7e0
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-target-yield-invalid.js
@@ -0,0 +1,14 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the DestructuringAssignmentTarget of an
+    AssignmentElement and outside of a generator function body, it behaves as
+    an IdentifierReference.
+es6id: 12.14.5.4
+flags: [onlyStrict]
+negative: SyntaxError
+---*/
+
+[ x[yield] ] = [];
diff --git a/test/language/expressions/assignment/destructuring/array-elem-target-yield-valid.js b/test/language/expressions/assignment/destructuring/array-elem-target-yield-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..0363d1d3c6b856358c79687a033652bd0455a5a0
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-target-yield-valid.js
@@ -0,0 +1,21 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the DestructuringAssignmentTarget of an
+    AssignmentElement outside of a generator function body, it behaves as an
+    IdentifierReference.
+es6id: 12.14.5.4
+flags: [noStrict]
+---*/
+
+var value = [33];
+var yield = 'prop';
+var x = {};
+var result;
+
+result = [ x[yield] ] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x.prop, 33);
diff --git a/test/language/expressions/assignment/destructuring/array-empty.js b/test/language/expressions/assignment/destructuring/array-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..524f73f8fdbb6d7bc3fb0c42dc0b0ad70663e3ec
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-empty.js
@@ -0,0 +1,40 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    An ArrayAssignmentPattern without an AssignmentElementList requires
+    iterable values and throws for other values.
+es6id: 12.14.5.2
+---*/
+
+var value, result;
+
+assert.throws(TypeError, function() {
+  [] = undefined;
+});
+
+assert.throws(TypeError, function() {
+  [] = null;
+});
+
+assert.throws(TypeError, function() {
+  [] = true;
+});
+
+assert.throws(TypeError, function() {
+  [] = 1;
+});
+
+result = [] = 'string literal';
+
+assert.sameValue(result, 'string literal');
+
+assert.throws(TypeError, function() {
+  [] = Symbol('s');
+});
+
+value = [];
+result = [] = value;
+
+assert.sameValue(result, value);
diff --git a/test/language/expressions/assignment/destructuring/array-iteration.js b/test/language/expressions/assignment/destructuring/array-iteration.js
new file mode 100644
index 0000000000000000000000000000000000000000..bbaa568a87fb024737d6c206031235b95e9570e0
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-iteration.js
@@ -0,0 +1,53 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    Value iteration only proceeds for the number of elements in the
+    ArrayAssignmentPattern.
+es6id: 12.14.5.3
+features: [generators]
+---*/
+
+var count, iter, result;
+var g = function*() {
+  count += 1;
+  yield;
+  count += 1;
+  yield;
+  count += 1;
+}
+
+count = 0;
+iter = g();
+result = [] = iter;
+
+assert.sameValue(result, iter);
+assert.sameValue(count, 0);
+
+iter = g();
+result = [,] = iter;
+
+assert.sameValue(result, iter);
+assert.sameValue(count, 1);
+
+count = 0;
+iter = g();
+result = [,,] = iter;
+
+assert.sameValue(result, iter);
+assert.sameValue(count, 2);
+
+count = 0;
+iter = g();
+result = [,,,] = iter;
+
+assert.sameValue(result, iter);
+assert.sameValue(count, 3);
+
+count = 0;
+iter = g();
+result = [,,,,] = iter;
+
+assert.sameValue(result, iter);
+assert.sameValue(count, 3);
diff --git a/test/language/expressions/assignment/destructuring/array-rest-after-element.js b/test/language/expressions/assignment/destructuring/array-rest-after-element.js
new file mode 100644
index 0000000000000000000000000000000000000000..4bfbcb625550312d06932bfee359dae9ce53457a
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-after-element.js
@@ -0,0 +1,18 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    An AssignmentRestElement following an AssignmentElement consumes all
+    remaining iterable values.
+es6id: 12.14.5.3
+---*/
+
+var x, y;
+
+[x, ...y] = [1, 2, 3];
+
+assert.sameValue(x, 1);
+assert.sameValue(y.length, 2);
+assert.sameValue(y[0], 2);
+assert.sameValue(y[1], 3);
diff --git a/test/language/expressions/assignment/destructuring/array-rest-after-elision.js b/test/language/expressions/assignment/destructuring/array-rest-after-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..379683ed0f8efe81de84ea179113db1dcc8bded2
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-after-elision.js
@@ -0,0 +1,17 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    An AssignmentRestElement following an elision consumes all remaining
+    iterable values.
+es6id: 12.14.5.3
+---*/
+
+var x;
+
+[, ...x] = [1, 2, 3];
+
+assert.sameValue(x.length, 2);
+assert.sameValue(x[0], 2);
+assert.sameValue(x[1], 3);
diff --git a/test/language/expressions/assignment/destructuring/array-rest-before-element.js b/test/language/expressions/assignment/destructuring/array-rest-before-element.js
new file mode 100644
index 0000000000000000000000000000000000000000..8c53b9b655649ec76817322d47d4e81e747247a9
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-before-element.js
@@ -0,0 +1,14 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    An AssignmentElement may not follow an AssignmentRestElement in an
+    AssignmentElementList.
+es6id: 12.14.5
+negative: SyntaxError
+---*/
+
+var x, y;
+
+[...x, y] = [];
diff --git a/test/language/expressions/assignment/destructuring/array-rest-before-elision.js b/test/language/expressions/assignment/destructuring/array-rest-before-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..6480747165c7fe7823b819fa59850d5041f847e3
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-before-elision.js
@@ -0,0 +1,14 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    An elision may not follow an AssignmentRestElement in an
+    AssignmentElementList.
+es6id: 12.14.5
+negative: SyntaxError
+---*/
+
+var x;
+
+[...x,] = [];
diff --git a/test/language/expressions/assignment/destructuring/array-rest-before-rest.js b/test/language/expressions/assignment/destructuring/array-rest-before-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..207cb39ba81009272199505334cabad2e469031b
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-before-rest.js
@@ -0,0 +1,14 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    An AssignmentRestElement may not follow another AssignmentRestElement in an
+    AssignmentElementList.
+es6id: 12.14.5
+negative: SyntaxError
+---*/
+
+var x, y;
+
+[...x, ...y] = [];
diff --git a/test/language/expressions/assignment/destructuring/array-rest-elision-invalid.js b/test/language/expressions/assignment/destructuring/array-rest-elision-invalid.js
new file mode 100644
index 0000000000000000000000000000000000000000..e26ebff5995203b41c2a0fe5c08d9fa30e8ee46e
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-elision-invalid.js
@@ -0,0 +1,12 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    ArrayAssignmentPattern may not include elisions following an
+    AssignmentRestElement in a AssignmentElementList.
+es6id: 12.14.5
+negative: SyntaxError
+---*/
+
+[...x,] = [];
diff --git a/test/language/expressions/assignment/destructuring/array-rest-elision.js b/test/language/expressions/assignment/destructuring/array-rest-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..4a0bc1cc61ec575d70c550c3ccabf0a21666a9ec
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-elision.js
@@ -0,0 +1,21 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    ArrayAssignmentPattern may include elisions at any position preceeding a
+    AssignmentRestElement in a AssignmentElementList.
+es6id: 12.14.5
+---*/
+
+var value = [1, 2, 3, 4, 5, 6];
+var x, y;
+var result;
+
+result = [, , x, , ...y] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 3);
+assert.sameValue(y.length, 2);
+assert.sameValue(y[0], 5);
+assert.sameValue(y[1], 6);
diff --git a/test/language/expressions/assignment/destructuring/array-rest-init.js b/test/language/expressions/assignment/destructuring/array-rest-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..2fbe698d94d13b9f102f5e60f4ceca66d93814ce
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-init.js
@@ -0,0 +1,13 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    The AssignmentRestElement does not support an initializer.
+es6id: 12.14.5
+negative: SyntaxError
+---*/
+
+var x;
+
+[...x = 1] = [];
diff --git a/test/language/expressions/assignment/destructuring/array-rest-iteration.js b/test/language/expressions/assignment/destructuring/array-rest-iteration.js
new file mode 100644
index 0000000000000000000000000000000000000000..735ee9914ec29690647a4e39a81d992682598969
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-iteration.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    In the presense of an AssignmentRestElement, value iteration exhausts the
+    iterable value;
+es6id: 12.14.5.3
+features: [generators]
+---*/
+
+var count = 0;
+var g = function*() {
+  count += 1;
+  yield;
+  count += 1;
+  yield;
+  count += 1;
+}
+var iter, result, x;
+
+iter = g();
+result = [...x] = iter;
+
+assert.sameValue(result, iter);
+assert.sameValue(count, 3);
diff --git a/test/language/expressions/assignment/destructuring/array-rest-nested-array-invalid.js b/test/language/expressions/assignment/destructuring/array-rest-nested-array-invalid.js
new file mode 100644
index 0000000000000000000000000000000000000000..1b0a2471edcf8a186ab78adad7bb1c94f1affa74
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-nested-array-invalid.js
@@ -0,0 +1,16 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    It is a Syntax Error if LeftHandSideExpression is either an ObjectLiteral
+    or an ArrayLiteral and if the lexical token sequence matched by
+    LeftHandSideExpression cannot be parsed with no tokens left over using
+    AssignmentPattern as the goal symbol.
+es6id: 12.14.5.1
+negative: SyntaxError
+---*/
+
+var x, y;
+
+[...[(x, y)]] = [[]];
diff --git a/test/language/expressions/assignment/destructuring/array-rest-nested-array-null.js b/test/language/expressions/assignment/destructuring/array-rest-nested-array-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..73e2a81420564b149d4bf12448ac911a1b01230b
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-nested-array-null.js
@@ -0,0 +1,19 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an array literal and the iterable
+    emits `null` as the only value, an array with a single `null` element
+    should be used as the value of the nested DestructuringAssignment.
+es6id: 12.14.5.3
+---*/
+
+var value = [null];
+var result, x, y;
+
+result = [...[x, y]] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, null);
+assert.sameValue(y, undefined);
diff --git a/test/language/expressions/assignment/destructuring/array-rest-nested-array-undefined-hole.js b/test/language/expressions/assignment/destructuring/array-rest-nested-array-undefined-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..a01b0b84eb7c3afe3885b24fb39c7c0b83c0fc65
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-nested-array-undefined-hole.js
@@ -0,0 +1,18 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an array literal and the iterable is
+    an array with a "hole", an array with a single `undefined` element should
+    be used as the value of the nested DestructuringAssignment.
+es6id: 12.14.5.3
+---*/
+
+var value = [ , ];
+var result, x;
+
+result = [...[x]] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, undefined);
diff --git a/test/language/expressions/assignment/destructuring/array-rest-nested-array-undefined-own.js b/test/language/expressions/assignment/destructuring/array-rest-nested-array-undefined-own.js
new file mode 100644
index 0000000000000000000000000000000000000000..1ba0a502fb7ac368d4c8b49f7c4c57ff9889a315
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-nested-array-undefined-own.js
@@ -0,0 +1,18 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an array literal and the iterable
+    emits `undefined` as the only value, an array with a single `undefined`
+    element should be used as the value of the nested DestructuringAssignment.
+es6id: 12.14.5.3
+---*/
+
+var value = [undefined];
+var result, x;
+
+result = [...[x]] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, undefined);
diff --git a/test/language/expressions/assignment/destructuring/array-rest-nested-array-undefined.js b/test/language/expressions/assignment/destructuring/array-rest-nested-array-undefined.js
new file mode 100644
index 0000000000000000000000000000000000000000..d8c743a03b1ab3813a5517f1c55a9f64aad662ce
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-nested-array-undefined.js
@@ -0,0 +1,18 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an array literal and the iterable is
+    emits no values, an empty array should be used as the value of the nested
+    DestructuringAssignment.
+es6id: 12.14.5.3
+---*/
+
+var value = [];
+var result, x;
+
+result = [...[x]] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, undefined);
diff --git a/test/language/expressions/assignment/destructuring/array-rest-nested-array-yield-expr.js b/test/language/expressions/assignment/destructuring/array-rest-nested-array-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..89578a84a5fdfcf025eeab6a72f04a7b78a5dd57
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-nested-array-yield-expr.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the DestructuringAssignmentTarget of a
+    nested destructuring assignment and within a generator function body, it
+    should behave as a YieldExpression.
+es6id: 12.14.5.3
+features: [generators]
+---*/
+
+var value = [86];
+var x = {};
+var assignmentResult, iterationResult, iter;
+
+iter = (function*() {
+  assignmentResult = [...[x[yield]]] = value;
+}());
+
+iterationResult = iter.next();
+
+assert.sameValue(assignmentResult, undefined);
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, false);
+assert.sameValue(x.prop, undefined);
+
+iterationResult = iter.next('prop');
+
+assert.sameValue(assignmentResult, value);
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, true);
+assert.sameValue(x.prop, 86);
diff --git a/test/language/expressions/assignment/destructuring/array-rest-nested-array-yield-ident-invalid.js b/test/language/expressions/assignment/destructuring/array-rest-nested-array-yield-ident-invalid.js
new file mode 100644
index 0000000000000000000000000000000000000000..dc34b696e8bbfe3b29541b9735501eddb82c6e95
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-nested-array-yield-ident-invalid.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the DestructuringAssignmentTarget of a
+    nested destructuring assignment and outside of a generator function body,
+    it should behave as an IdentifierExpression.
+es6id: 12.14.5.3
+flags: [onlyStrict]
+negative: SyntaxError
+---*/
+
+var x;
+[...[x[yield]]] = [];
diff --git a/test/language/expressions/assignment/destructuring/array-rest-nested-array-yield-ident-valid.js b/test/language/expressions/assignment/destructuring/array-rest-nested-array-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..d60b4ccd110452a3f4725dc73fc164043937c13a
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-nested-array-yield-ident-valid.js
@@ -0,0 +1,21 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the DestructuringAssignmentTarget of a
+    nested destructuring assignment and outside of a generator function body,
+    it should behave as an IdentifierExpression.
+es6id: 12.14.5.3
+flags: [noStrict]
+---*/
+
+var value = [86];
+var yield = 'prop';
+var x = {};
+var result;
+
+result = [...[x[yield]]] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x.prop, 86);
diff --git a/test/language/expressions/assignment/destructuring/array-rest-nested-array.js b/test/language/expressions/assignment/destructuring/array-rest-nested-array.js
new file mode 100644
index 0000000000000000000000000000000000000000..fd77214f426512e426f1614eb8fa3d93919ad3c1
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-nested-array.js
@@ -0,0 +1,18 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an array literal, it should be parsed
+    parsed as a DestructuringAssignmentPattern and evaluated as a destructuring
+    assignment.
+es6id: 12.14.5.3
+---*/
+
+var value = [1, 2, 3];
+var x, result;
+
+result = [...[x]] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 1);
diff --git a/test/language/expressions/assignment/destructuring/array-rest-nested-obj-invalid.js b/test/language/expressions/assignment/destructuring/array-rest-nested-obj-invalid.js
new file mode 100644
index 0000000000000000000000000000000000000000..35d467839d923e9d32f9a8033d8b02847447d817
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-nested-obj-invalid.js
@@ -0,0 +1,14 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    It is a Syntax Error if LeftHandSideExpression is either an ObjectLiteral
+    or an ArrayLiteral and if the lexical token sequence matched by
+    LeftHandSideExpression cannot be parsed with no tokens left over using
+    AssignmentPattern as the goal symbol.
+es6id: 12.14.5.1
+negative: SyntaxError
+---*/
+
+[...{ get x() {} }] = [[]];
diff --git a/test/language/expressions/assignment/destructuring/array-rest-nested-obj-null.js b/test/language/expressions/assignment/destructuring/array-rest-nested-obj-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..b5efac41cad1f1231e661cedb7b6f18c64e717bf
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-nested-obj-null.js
@@ -0,0 +1,19 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an object literal and the iterable
+    emits `null` as the only value, an array with a single `null` element
+    should be used as the value of the nested DestructuringAssignment.
+es6id: 12.14.5.3
+---*/
+
+var value = [null];
+var result, x, length;
+
+result = [...{ 0: x, length }] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, null);
+assert.sameValue(length, 1);
diff --git a/test/language/expressions/assignment/destructuring/array-rest-nested-obj-undefined-hole.js b/test/language/expressions/assignment/destructuring/array-rest-nested-obj-undefined-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..e01715a39eb4b9cb767f3c0f499edecb085be224
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-nested-obj-undefined-hole.js
@@ -0,0 +1,19 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an array literal and the iterable is
+    an array with a "hole", an array with a single `undefined` element should
+    be used as the value of the nested DestructuringAssignment.
+es6id: 12.14.5.3
+---*/
+
+var value = [ , ];
+var result, x, length;
+
+result = [...{ 0: x, length }] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, undefined);
+assert.sameValue(length, 1);
diff --git a/test/language/expressions/assignment/destructuring/array-rest-nested-obj-undefined-own.js b/test/language/expressions/assignment/destructuring/array-rest-nested-obj-undefined-own.js
new file mode 100644
index 0000000000000000000000000000000000000000..70735f34ff1e0839f920a99670735f3c3821d5d4
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-nested-obj-undefined-own.js
@@ -0,0 +1,19 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an array literal and the iterable
+    emits `undefined` as the only value, an array with a single `undefined`
+    element should be used as the value of the nested DestructuringAssignment.
+es6id: 12.14.5.3
+---*/
+
+var value = [undefined];
+var result, x, length;
+
+result = [...{ 0: x, length }] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, undefined);
+assert.sameValue(length, 1);
diff --git a/test/language/expressions/assignment/destructuring/array-rest-nested-obj-undefined.js b/test/language/expressions/assignment/destructuring/array-rest-nested-obj-undefined.js
new file mode 100644
index 0000000000000000000000000000000000000000..53425d44f8616c97563275478212002a5aa241a3
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-nested-obj-undefined.js
@@ -0,0 +1,19 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an obect literal and the iterable is
+    emits no values, an empty array should be used as the value of the nested
+    DestructuringAssignment.
+es6id: 12.14.5.3
+---*/
+
+var value = [];
+var result, x, length;
+
+result = [...{ 0: x, length }] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, undefined);
+assert.sameValue(length, 0);
diff --git a/test/language/expressions/assignment/destructuring/array-rest-nested-obj-yield-expr.js b/test/language/expressions/assignment/destructuring/array-rest-nested-obj-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..0daf86e0c2c24bcc67543a9a9a8fba52207bff1a
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-nested-obj-yield-expr.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the Initializer of a nested
+    destructuring assignment and within a generator function body, it should
+    behave as a YieldExpression.
+es6id: 12.14.5.3
+features: [generators]
+---*/
+
+var value = [{}];
+var assignmentResult, iterationResult, iter, x;
+
+iter = (function*() {
+  assignmentResult = [...{ x = yield }] = value;
+}());
+
+iterationResult = iter.next();
+
+assert.sameValue(assignmentResult, undefined);
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, false);
+assert.sameValue(x, undefined);
+
+iterationResult = iter.next(4);
+
+assert.sameValue(assignmentResult, value);
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, true);
+assert.sameValue(x, 4);
diff --git a/test/language/expressions/assignment/destructuring/array-rest-nested-obj-yield-ident-invalid.js b/test/language/expressions/assignment/destructuring/array-rest-nested-obj-yield-ident-invalid.js
new file mode 100644
index 0000000000000000000000000000000000000000..ebb79b43145e2936bcb838ff5364e4a3096fb134
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-nested-obj-yield-ident-invalid.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the Initializer of a nested
+    destructuring assignment and outside of a generator function body, it
+    should behave as an IdentifierExpression.
+es6id: 12.14.5.3
+flags: [onlyStrict]
+negative: SyntaxError
+---*/
+
+var value = [{}];
+[...{ x = yield }] = value;
diff --git a/test/language/expressions/assignment/destructuring/array-rest-nested-obj-yield-ident-valid.js b/test/language/expressions/assignment/destructuring/array-rest-nested-obj-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..b220b0dd54fe76401c7b87f5907bb3e56b3b0d9a
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-nested-obj-yield-ident-valid.js
@@ -0,0 +1,20 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the Initializer of a nested
+    destructuring assignment and outside of a generator function body, it
+    should behave as an IdentifierExpression.
+es6id: 12.14.5.3
+flags: [noStrict]
+---*/
+
+var value = [{}];
+var yield = 2;
+var result, iterationResult, iter, x;
+
+result = [...{ x = yield }] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 2);
diff --git a/test/language/expressions/assignment/destructuring/array-rest-nested-obj.js b/test/language/expressions/assignment/destructuring/array-rest-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..f5812ba5f013ae3f415377afda8ec6efd51ee5a1
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-nested-obj.js
@@ -0,0 +1,18 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an object literal, it should be
+    parsed as a DestructuringAssignmentPattern and evaluated as a destructuring
+    assignment.
+es6id: 12.14.5.3
+---*/
+
+var value = [1, 2, 3];
+var result, x;
+
+result = [...{ 1: x }] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 2);
diff --git a/test/language/expressions/assignment/destructuring/array-rest-put-const.js b/test/language/expressions/assignment/destructuring/array-rest-put-const.js
new file mode 100644
index 0000000000000000000000000000000000000000..96bf0d9e8a07b19a034f1762005f052f4f522a2a
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-put-const.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    The assignment target should obey `const` semantics.
+es6id: 12.14.5.3
+features: [const]
+---*/
+
+const c = null;
+
+assert.throws(TypeError, function() {
+  [ ...c ] = [1];
+});
diff --git a/test/language/expressions/assignment/destructuring/array-rest-put-let.js b/test/language/expressions/assignment/destructuring/array-rest-put-let.js
new file mode 100644
index 0000000000000000000000000000000000000000..a1507234619bc720316b998e7f479923f7c42b3b
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-put-let.js
@@ -0,0 +1,14 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    The assignment target should obey `let` semantics.
+es6id: 12.14.5.3
+features: [let]
+---*/
+
+assert.throws(ReferenceError, function() {
+  [ ...x ] = [];
+  let x;
+});
diff --git a/test/language/expressions/assignment/destructuring/array-rest-put-prop-ref-no-get.js b/test/language/expressions/assignment/destructuring/array-rest-put-prop-ref-no-get.js
new file mode 100644
index 0000000000000000000000000000000000000000..d57bf425f3f303e5bb8db1f34faa86d5feab9a4a
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-put-prop-ref-no-get.js
@@ -0,0 +1,28 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    If the DestructuringAssignmentTarget of an AssignmentElement is a
+    PropertyReference, it should not be evaluated.
+es6id: 12.14.5.3
+---*/
+
+var value = [23, 45, 99];
+var x, setValue, result;
+x = {
+  get y() {
+    $ERROR('The property should not be accessed.');
+  },
+  set y(val) {
+    setValue = val;
+  }
+};
+
+result = [...x.y] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(setValue.length, 3);
+assert.sameValue(setValue[0], 23);
+assert.sameValue(setValue[1], 45);
+assert.sameValue(setValue[2], 99);
diff --git a/test/language/expressions/assignment/destructuring/array-rest-put-prop-ref-user-err.js b/test/language/expressions/assignment/destructuring/array-rest-put-prop-ref-user-err.js
new file mode 100644
index 0000000000000000000000000000000000000000..1b03ef780e1644a70e6317315c4e2ee4a00e2717
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-put-prop-ref-user-err.js
@@ -0,0 +1,20 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    Any error raised as a result of setting the value should be forwarded to
+    the runtime.
+es6id: 12.14.5.3
+---*/
+
+var value = [23];
+var x = {
+  set y(val) {
+    throw new Test262Error();
+  }
+};
+
+assert.throws(Test262Error, function() {
+  [...x.y] = value;
+});
diff --git a/test/language/expressions/assignment/destructuring/array-rest-put-prop-ref.js b/test/language/expressions/assignment/destructuring/array-rest-put-prop-ref.js
new file mode 100644
index 0000000000000000000000000000000000000000..bdc04a820024f4e27f95a6694aafa625389dc985
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-put-prop-ref.js
@@ -0,0 +1,21 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    The DestructuringAssignmentTarget of an AssignmentElement may be a
+    PropertyReference.
+es6id: 12.14.5.3
+---*/
+
+var value = [4, 3, 2];
+var x = {};
+var result;
+
+result = [...x.y] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x.y.length, 3);
+assert.sameValue(x.y[0], 4);
+assert.sameValue(x.y[1], 3);
+assert.sameValue(x.y[2], 2);
diff --git a/test/language/expressions/assignment/destructuring/array-rest-put-unresolvable-no-strict.js b/test/language/expressions/assignment/destructuring/array-rest-put-unresolvable-no-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..d904f55f2a74a43a592e14f36649abee954facad
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-put-unresolvable-no-strict.js
@@ -0,0 +1,16 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    Outside of strict mode, if the the assignment target is an unresolvable
+    reference, a new `var` binding should be created in the environment record.
+es6id: 12.14.5.3
+flags: [noStrict]
+---*/
+
+{
+  [ ...unresolvable ] = [];
+}
+
+assert.sameValue(unresolvable.length, 0);
diff --git a/test/language/expressions/assignment/destructuring/array-rest-put-unresolvable-strict.js b/test/language/expressions/assignment/destructuring/array-rest-put-unresolvable-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..43bad4b253bfc8909ab592aa0d9ce4778855cd3e
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-put-unresolvable-strict.js
@@ -0,0 +1,14 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    In strict mode, if the the assignment target is an unresolvable reference,
+    a ReferenceError should be thrown.
+es6id: 12.14.5.3
+flags: [onlyStrict]
+---*/
+
+assert.throws(ReferenceError, function() {
+  [ ...unresolvable ] = [];
+});
diff --git a/test/language/expressions/assignment/destructuring/array-rest-yield-expr.js b/test/language/expressions/assignment/destructuring/array-rest-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..e373478de864e2b07d6883789d22e173b8e7042b
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-yield-expr.js
@@ -0,0 +1,36 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the DestructuringAssignmentTarget of
+    an AssignmentRestElement and within the body of a generator function, it
+    should behave as a YieldExpression.
+es6id: 12.14.5
+features: [generators]
+---*/
+
+var value = [33, 44, 55];
+var x = {};
+var assignmentResult, iterationResult, iter;
+
+iter = (function*() {
+  assignmentResult = [...x[yield]] = value;
+}());
+
+iterationResult = iter.next();
+
+assert.sameValue(assignmentResult, undefined);
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, false);
+assert.sameValue(x.prop, undefined);
+
+iterationResult = iter.next('prop');
+
+assert.sameValue(assignmentResult, value);
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, true);
+assert.sameValue(x.prop.length, 3);
+assert.sameValue(x.prop[0], 33);
+assert.sameValue(x.prop[1], 44);
+assert.sameValue(x.prop[2], 55);
diff --git a/test/language/expressions/assignment/destructuring/array-rest-yield-ident-invalid.js b/test/language/expressions/assignment/destructuring/array-rest-yield-ident-invalid.js
new file mode 100644
index 0000000000000000000000000000000000000000..427fe68038fdc5ab1c089c3c4050eaf1abd99c00
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-yield-ident-invalid.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the DestructuringAssignmentTarget of an
+    AssignmentRestElement and outside of a generator function body, it should
+    behave as an IdentifierReference.
+es6id: 12.14.5
+flags: [onlyStrict]
+negative: SyntaxError
+---*/
+
+var x = {};
+[...x[yield]] = [];
diff --git a/test/language/expressions/assignment/destructuring/array-rest-yield-ident-valid.js b/test/language/expressions/assignment/destructuring/array-rest-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..4f56b9abe8768287f6f090c37fa5a182f3f929eb
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-rest-yield-ident-valid.js
@@ -0,0 +1,24 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the DestructuringAssignmentTarget of an
+    AssignmentRestElement and outside of a generator function body, it should
+    behave as an IdentifierReference.
+es6id: 12.14.5
+flags: [noStrict]
+---*/
+
+var value = [33, 44, 55];
+var yield = 'prop';
+var x = {};
+var result;
+
+result = [...x[yield]] = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x.prop.length, 3);
+assert.sameValue(x.prop[0], 33);
+assert.sameValue(x.prop[1], 44);
+assert.sameValue(x.prop[2], 55);
diff --git a/test/language/expressions/assignment/destructuring/array-sparse.js b/test/language/expressions/assignment/destructuring/array-sparse.js
new file mode 100644
index 0000000000000000000000000000000000000000..0699f8909b1fbeeac5ac259cf4791af710d761fb
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-sparse.js
@@ -0,0 +1,40 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    A sparse ArrayAssignmentPattern without an AssignmentElementList requires
+    iterable values and throws for other values.
+es6id: 12.14.5.2
+---*/
+
+var value, result;
+
+assert.throws(TypeError, function() {
+  [,] = undefined;
+});
+
+assert.throws(TypeError, function() {
+  [,] = null;
+});
+
+assert.throws(TypeError, function() {
+  [,] = true;
+});
+
+assert.throws(TypeError, function() {
+  [,] = 1;
+});
+
+result = [,] = 'string literal';
+
+assert.sameValue(result, 'string literal');
+
+assert.throws(TypeError, function() {
+  [,] = Symbol('s');
+});
+
+value = [];
+result = [,] = value;
+
+assert.sameValue(result, value);
diff --git a/test/language/expressions/assignment/destructuring/obj-id-identifier-resolution.js b/test/language/expressions/assignment/destructuring/obj-id-identifier-resolution.js
new file mode 100644
index 0000000000000000000000000000000000000000..ff3dd5a201ed02b9f648685d622feb6217473dc6
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-id-identifier-resolution.js
@@ -0,0 +1,45 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    Evaluation of DestructuringAssignmentTarget.
+es6id: 12.14.5.4
+---*/
+
+var result, value, w, x, y;
+
+x = null;
+value = { x: 1 };
+result = { x } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 1);
+
+x = null;
+value = { x: 2 };
+result = { x, } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 2);
+
+x = null;
+value = { x: 3 };
+result = { x, y } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 3);
+
+x = null;
+value = { x: 4 };
+result = { w, x } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 4);
+
+x = null;
+value = { x: 5 };
+result = { w, x, y } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 5);
diff --git a/test/language/expressions/assignment/destructuring/obj-id-identifier-yield-expr.js b/test/language/expressions/assignment/destructuring/obj-id-identifier-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..d1a99ea4c75da91427de77aaa51d6e6dceaabe1e
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-id-identifier-yield-expr.js
@@ -0,0 +1,13 @@
+/*---
+description: >
+    `yield` is not a valid IdentifierReference in an AssignmentProperty within
+    generator function bodies.
+es6id: 12.14.5
+flags: [noStrict]
+features: [generators]
+negative: SyntaxError
+---*/
+
+(function*() {
+  { yield } = {};
+});
diff --git a/test/language/expressions/assignment/destructuring/obj-id-identifier-yield-ident-invalid.js b/test/language/expressions/assignment/destructuring/obj-id-identifier-yield-ident-invalid.js
new file mode 100644
index 0000000000000000000000000000000000000000..2ebfa8575856b5f87cc719f08af66829a1245b14
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-id-identifier-yield-ident-invalid.js
@@ -0,0 +1,10 @@
+/*---
+description: >
+    `yield` is not a valid IdentifierReference in an AssignmentProperty within
+    strict mode code.
+es6id: 12.14.5
+flags: [onlyStrict]
+negative: SyntaxError
+---*/
+
+var { yield } = {};
diff --git a/test/language/expressions/assignment/destructuring/obj-id-identifier-yield-ident-valid.js b/test/language/expressions/assignment/destructuring/obj-id-identifier-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..dd75922c2dec02ea6c4879789b2cf8e5b07f59dd
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-id-identifier-yield-ident-valid.js
@@ -0,0 +1,15 @@
+/*---
+description: >
+    `yield` is a valid IdentifierReference in an AssignmentProperty outside of
+    strict mode and generator functions.
+es6id: 12.14.5
+flags: [noStrict]
+---*/
+
+var value = { yield: 3 };
+var result, yield;
+
+result = { yield } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(yield, 3);
diff --git a/test/language/expressions/assignment/destructuring/obj-id-init-assignment.js b/test/language/expressions/assignment/destructuring/obj-id-init-assignment.js
new file mode 100644
index 0000000000000000000000000000000000000000..5e9da802e441d974738d7b93404be4f133a3f0dd
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-id-init-assignment.js
@@ -0,0 +1,35 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    If the Initializer is present and v is undefined, the Initializer should be
+    evaluated and the result assigned to the target reference.
+es6id: 12.14.5.4
+---*/
+
+var result, value, x;
+
+value = {};
+result = { x = 1 } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 1, 'no property defined');
+
+value = { x: 2 };
+result = { x = 1 } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 2, 'own property defined (truthy value)');
+
+value = { x: null };
+result = { x = 1 } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, null, 'own property defined (`null`)');
+
+value = { x: undefined };
+result = { x = 1 } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 1, 'own property defined (`undefined`)');
diff --git a/test/language/expressions/assignment/destructuring/obj-id-init-evaluation.js b/test/language/expressions/assignment/destructuring/obj-id-init-evaluation.js
new file mode 100644
index 0000000000000000000000000000000000000000..af03125bd2fd49394c2449a105f421cc0c868ad1
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-id-init-evaluation.js
@@ -0,0 +1,24 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    The Initializer should only be evaluated if v is undefined.
+es6id: 12.14.5.4
+---*/
+
+var result, value, x, flag;
+
+value = {};
+flag = false;
+result = { x = flag = true } = value;
+assert.sameValue(result, value);
+assert.sameValue(x, true);
+assert.sameValue(flag, true);
+
+value = { x: 1 };
+flag = false;
+result = { x = flag = true } = value;
+assert.sameValue(result, value);
+assert.sameValue(x, 1);
+assert.sameValue(flag, false);
diff --git a/test/language/expressions/assignment/destructuring/obj-id-init-in.js b/test/language/expressions/assignment/destructuring/obj-id-init-in.js
new file mode 100644
index 0000000000000000000000000000000000000000..5626c44b3a466b938312cdeeab4084612f7289ae
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-id-init-in.js
@@ -0,0 +1,16 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    The Initializer in an AssignmentProperty may be an `in` expression.
+es6id: 12.14.5
+---*/
+
+var value = {};
+var result, prop;
+
+result = { prop = 'x' in {} } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(prop, false);
diff --git a/test/language/expressions/assignment/destructuring/obj-id-init-let.js b/test/language/expressions/assignment/destructuring/obj-id-init-let.js
new file mode 100644
index 0000000000000000000000000000000000000000..0cae52ea93ea3c106cca42e626d392e2034b1f89
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-id-init-let.js
@@ -0,0 +1,16 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    Value retrieval of Initializer obeys `let` semantics.
+es6id: 12.14.5.4
+features: [let]
+---*/
+
+var x;
+
+assert.throws(ReferenceError, function() {
+  ({ x = y } = {});
+  let y;
+});
diff --git a/test/language/expressions/assignment/destructuring/obj-id-init-order.js b/test/language/expressions/assignment/destructuring/obj-id-init-order.js
new file mode 100644
index 0000000000000000000000000000000000000000..cdec7decf0e6f1344c75239428446d0f2ced2421
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-id-init-order.js
@@ -0,0 +1,19 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    Initializer values should be assigned in left-to-right order.
+es6id: 12.14.5.4
+---*/
+
+var value = {};
+var x = 0;
+var a, b, result;
+
+result = { a = x += 1, b = x *= 2 } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(a, 1);
+assert.sameValue(b, 2);
+assert.sameValue(x, 2);
diff --git a/test/language/expressions/assignment/destructuring/obj-id-init-simple-no-strict.js b/test/language/expressions/assignment/destructuring/obj-id-init-simple-no-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..79b976fad4aff6d79658ed4e84a0d5164f094abe
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-id-init-simple-no-strict.js
@@ -0,0 +1,18 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    Evaluation of DestructuringAssignmentTarget.
+es6id: 12.14.5.4
+flags: [noStrict]
+---*/
+
+var value = {};
+var eval, arguments, result;
+
+result = { eval = 3, arguments = 4 } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(eval, 3);
+assert.sameValue(arguments, 4);
diff --git a/test/language/expressions/assignment/destructuring/obj-id-init-simple-strict.js b/test/language/expressions/assignment/destructuring/obj-id-init-simple-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..da9c5f017e569576f5c473564cb585745f9b7406
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-id-init-simple-strict.js
@@ -0,0 +1,13 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    It is a Syntax Error if IsValidSimpleAssignmentTarget of
+    IdentifierReference is false.
+es6id: 12.14.5.1
+flags: [onlyStrict]
+negative: SyntaxError
+---*/
+
+({ eval = 0 } = {});
diff --git a/test/language/expressions/assignment/destructuring/obj-id-init-yield-expr.js b/test/language/expressions/assignment/destructuring/obj-id-init-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..2991a435e9734157d5a7d22334f892d6e3b706fb
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-id-init-yield-expr.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the Initializer of an
+    AssignmentProperty and within a generator function body, it should behave
+    as a YieldExpression.
+es6id: 12.14.5
+features: [generators]
+---*/
+
+var value = {};
+var assignmentResult, iterationResult, x, iter;
+
+iter = (function*() {
+  assignmentResult = { x = yield } = value;
+}());
+
+iterationResult = iter.next();
+
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, false);
+assert.sameValue(x, undefined);
+assert.sameValue(assignmentResult, undefined);
+
+iterationResult = iter.next(3);
+
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, true);
+assert.sameValue(x, 3);
+assert.sameValue(assignmentResult, value);
diff --git a/test/language/expressions/assignment/destructuring/obj-id-init-yield-ident-invalid.js b/test/language/expressions/assignment/destructuring/obj-id-init-yield-ident-invalid.js
new file mode 100644
index 0000000000000000000000000000000000000000..3edd831389aa454cbfaecb87b6b6c5eaea830e0b
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-id-init-yield-ident-invalid.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the Initializer of an
+    AssignmentProperty and outside of a generator function body, it should
+    behave as an IdentifierReference.
+es6id: 12.14.5
+flags: [onlyStrict]
+negative: SyntaxError
+---*/
+
+var x;
+0, { x = yield } = {};
diff --git a/test/language/expressions/assignment/destructuring/obj-id-init-yield-ident-valid.js b/test/language/expressions/assignment/destructuring/obj-id-init-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..4759be1e296c02023efb74c3dd142eba4a0095b1
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-id-init-yield-ident-valid.js
@@ -0,0 +1,20 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the Initializer of an
+    AssignmentProperty and outside of a generator function body, it should
+    behave as an IdentifierReference.
+es6id: 12.14.5
+flags: [noStrict]
+---*/
+
+var value = {};
+var yield = 3;
+var result, x;
+
+result = { x = yield } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 3);
diff --git a/test/language/expressions/assignment/destructuring/obj-id-put-const.js b/test/language/expressions/assignment/destructuring/obj-id-put-const.js
new file mode 100644
index 0000000000000000000000000000000000000000..79c801d261da7233a7f6e62657eb7b85a697a8de
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-id-put-const.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    The assignment target should obey `const` semantics.
+es6id: 12.14.5.4
+features: [const]
+---*/
+
+const c = null;
+
+assert.throws(TypeError, function() {
+  ({ c } = { c: 1 });
+});
diff --git a/test/language/expressions/assignment/destructuring/obj-id-put-let.js b/test/language/expressions/assignment/destructuring/obj-id-put-let.js
new file mode 100644
index 0000000000000000000000000000000000000000..28c1145de0d567e001067c92f2198767a6c5a7e9
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-id-put-let.js
@@ -0,0 +1,14 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    The assignment target should obey `let` semantics.
+es6id: 12.14.5.4
+features: [let]
+---*/
+
+assert.throws(ReferenceError, function() {
+  ({ x } = {});
+  let x;
+});
diff --git a/test/language/expressions/assignment/destructuring/obj-id-put-unresolvable-no-strict.js b/test/language/expressions/assignment/destructuring/obj-id-put-unresolvable-no-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..e98a59f6f233bdd584881232d9331f758527c1e6
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-id-put-unresolvable-no-strict.js
@@ -0,0 +1,16 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    Outside of strict mode, if the the assignment target is an unresolvable
+    reference, a new `var` binding should be created in the environment record.
+es6id: 12.14.5.4
+flags: [noStrict]
+---*/
+
+{
+  ({ unresolvable } = {});
+}
+
+assert.sameValue(unresolvable, undefined);
diff --git a/test/language/expressions/assignment/destructuring/obj-id-put-unresolvable-strict.js b/test/language/expressions/assignment/destructuring/obj-id-put-unresolvable-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..d205e5f035199915fb0acf7dfd73022621105041
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-id-put-unresolvable-strict.js
@@ -0,0 +1,14 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    In strict mode, if the the assignment target is an unresolvable reference,
+    a ReferenceError should be thrown.
+es6id: 12.14.5.4
+flags: [onlyStrict]
+---*/
+
+assert.throws(ReferenceError, function() {
+  ({ unresolvable } = {});
+});
diff --git a/test/language/expressions/assignment/destructuring/obj-id-simple-no-strict.js b/test/language/expressions/assignment/destructuring/obj-id-simple-no-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..f2e924ab47a355af610d6d1db33d057f483d3e72
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-id-simple-no-strict.js
@@ -0,0 +1,18 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    Evaluation of DestructuringAssignmentTarget.
+es6id: 12.14.5.4
+flags: [noStrict]
+---*/
+
+var value = { eval: 1, arguments: 2 };
+var eval, arguments, result;
+
+result = { eval, arguments } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(eval, 1);
+assert.sameValue(arguments, 2);
diff --git a/test/language/expressions/assignment/destructuring/obj-id-simple-strict.js b/test/language/expressions/assignment/destructuring/obj-id-simple-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..af7d5a1eeb1b664096e2f9c12ec93480c1ee0282
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-id-simple-strict.js
@@ -0,0 +1,13 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    It is a Syntax Error if IsValidSimpleAssignmentTarget of
+    IdentifierReference is false.
+es6id: 12.14.5.1
+flags: [onlyStrict]
+negative: SyntaxError
+---*/
+
+({ eval } = {});
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-elem-init-assignment.js b/test/language/expressions/assignment/destructuring/obj-prop-elem-init-assignment.js
new file mode 100644
index 0000000000000000000000000000000000000000..85c013feaef9ba2ef0204cb486f4000ffe7ae040
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-elem-init-assignment.js
@@ -0,0 +1,35 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    If the Initializer is present and v is undefined, the Initializer should be
+    evaluated and the result assigned to the target reference.
+es6id: 12.14.5.4
+---*/
+
+var result, value, x;
+
+value = {};
+result = { y: x = 1 } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 1, 'no property defined');
+
+value = { y: 2 };
+result = { y: x = 1 } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 2, 'own property defined (truthy value)');
+
+value = { y: null };
+result = { y: x = 1 } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, null, 'own property defined (`null`)');
+
+value = { y: undefined };
+result = { y: x = 1 } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 1, 'own property defined (`undefined`)');
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-elem-init-evaluation.js b/test/language/expressions/assignment/destructuring/obj-prop-elem-init-evaluation.js
new file mode 100644
index 0000000000000000000000000000000000000000..efd1237e31855db779effe4f5a4ace059d63e8dc
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-elem-init-evaluation.js
@@ -0,0 +1,24 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    The Initializer should only be evaluated if v is undefined.
+es6id: 12.14.5.4
+---*/
+
+var result, value, x, flag;
+
+value = {};
+flag = false;
+result = { x: x = flag = true } = value;
+assert.sameValue(result, value);
+assert.sameValue(x, true);
+assert.sameValue(flag, true);
+
+value = { y: 1 };
+flag = false;
+result = { y: x = flag = true } = value;
+assert.sameValue(result, value);
+assert.sameValue(x, 1);
+assert.sameValue(flag, false);
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-elem-init-in.js b/test/language/expressions/assignment/destructuring/obj-prop-elem-init-in.js
new file mode 100644
index 0000000000000000000000000000000000000000..c8d724717db42a76f739cb3c489f52b8a3223657
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-elem-init-in.js
@@ -0,0 +1,16 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    The Initializer in an AssignmentElement may be an `in` expression.
+es6id: 12.14.5
+---*/
+
+var value = {};
+var result, prop;
+
+result = { x: prop = 'x' in {} } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(prop, false);
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-elem-init-let.js b/test/language/expressions/assignment/destructuring/obj-prop-elem-init-let.js
new file mode 100644
index 0000000000000000000000000000000000000000..492454ba1630ea29a61382e85a2886f1901a8573
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-elem-init-let.js
@@ -0,0 +1,16 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    Value retrieval of Initializer obeys `let` semantics.
+es6id: 12.14.5.4
+features: [let]
+---*/
+
+var x;
+
+assert.throws(ReferenceError, function() {
+  ({ x: x = y } = {});
+  let y;
+});
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-elem-init-yield-expr.js b/test/language/expressions/assignment/destructuring/obj-prop-elem-init-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..df69c2a2adc82363b46d84b94b88a265bcf247aa
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-elem-init-yield-expr.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the Initializer of an AssignmentElement
+    and within a generator function body, it should behave as a
+    YieldExpression.
+es6id: 12.14.5.4
+features: [generators]
+---*/
+
+var value = {};
+var assignmentResult, iterationResult, iter, x;
+
+iter = (function*() {
+  assignmentResult = { x: x = yield } = value;
+}());
+
+iterationResult = iter.next();
+
+assert.sameValue(assignmentResult, undefined);
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, false);
+assert.sameValue(x, undefined);
+
+iterationResult = iter.next(86);
+
+assert.sameValue(assignmentResult, value);
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, true);
+assert.sameValue(x, 86);
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-elem-init-yield-ident-invalid.js b/test/language/expressions/assignment/destructuring/obj-prop-elem-init-yield-ident-invalid.js
new file mode 100644
index 0000000000000000000000000000000000000000..51f730df26c47659064feb875c217854084bcb2d
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-elem-init-yield-ident-invalid.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the Initializer of an AssignmentElement
+    and outside of a generator function body, it should behave as an
+    IdentifierReference.
+es6id: 12.14.5.4
+flags: [onlyStrict]
+negative: SyntaxError
+---*/
+
+var x;
+0, { x: x = yield } = {};
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-elem-init-yield-ident-valid.js b/test/language/expressions/assignment/destructuring/obj-prop-elem-init-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..a197faea090c54ff746535598be1a3cd5c3317a4
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-elem-init-yield-ident-valid.js
@@ -0,0 +1,20 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the Initializer of an AssignmentElement
+    and outside of a generator function body, it should behave as an
+    IdentifierReference.
+es6id: 12.14.5.4
+flags: [noStrict]
+---*/
+
+var value = {};
+var yield = 4;
+var x;
+
+assignmentResult = { x: x = yield } = value;
+
+assert.sameValue(assignmentResult, value);
+assert.sameValue(x, 4);
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-elem-target-yield-expr.js b/test/language/expressions/assignment/destructuring/obj-prop-elem-target-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..644634311cab7145cb55e2e5d0d04d70211c0332
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-elem-target-yield-expr.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the DestructuringAssignmentTarget of an
+    AssignmentElement and within a generator function body, it should behave as
+    a YieldExpression.
+es6id: 12.14.5.4
+features: [generators]
+---*/
+
+var value = { x: 23 };
+var x = {};
+var assignmentResult, iterationResult, iter;
+
+iter = (function*() {
+  assignmentResult = { x: x[yield] } = value;
+}());
+
+iterationResult = iter.next();
+
+assert.sameValue(assignmentResult, undefined);
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, false);
+assert.sameValue(x.prop, undefined);
+
+iterationResult = iter.next('prop');
+
+assert.sameValue(assignmentResult, value);
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, true);
+assert.sameValue(x.prop, 23);
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-elem-target-yield-ident-invalid.js b/test/language/expressions/assignment/destructuring/obj-prop-elem-target-yield-ident-invalid.js
new file mode 100644
index 0000000000000000000000000000000000000000..c48c1289a76f3a1f7f78166afa02ef099240a225
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-elem-target-yield-ident-invalid.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the DestructuringAssignmentTarget of an
+    AssignmentElement and outside of a generator function body, it should
+    behave as an IdentifierReference.
+es6id: 12.14.5.4
+flags: [onlyStrict]
+negative: SyntaxError
+---*/
+
+var x = {};
+0, { x: x[yield] } = {};
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-elem-target-yield-ident-valid.js b/test/language/expressions/assignment/destructuring/obj-prop-elem-target-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..fe0d3aeb6fe29adc58a9a57945fdab673cb46ddd
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-elem-target-yield-ident-valid.js
@@ -0,0 +1,21 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the DestructuringAssignmentTarget of an
+    AssignmentElement and outside of a generator function body, it should
+    behave as an IdentifierReference.
+es6id: 12.14.5.4
+flags: [noStrict]
+---*/
+
+var value = { x: 23 };
+var yield = 'prop';
+var x = {};
+var result;
+
+result = { x: x[yield] } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x.prop, 23);
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-identifier-resolution.js b/test/language/expressions/assignment/destructuring/obj-prop-identifier-resolution.js
new file mode 100644
index 0000000000000000000000000000000000000000..2798828162fbc754be98557b43587a560b13b43e
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-identifier-resolution.js
@@ -0,0 +1,45 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    Evaluation of DestructuringAssignmentTarget.
+es6id: 12.14.5.4
+---*/
+
+var result, value, w, x, y;
+
+x = null;
+value = { a: 1 };
+result = { a: x } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 1);
+
+x = null;
+value = { a: 2 };
+result = { a: x, } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 2);
+
+x = null;
+value = { a: 3 };
+result = { a: x, y } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 3);
+
+x = null;
+value = { a: 4 };
+result = { w, a: x } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 4);
+
+x = null;
+value = { a: 5 };
+result = { w, a: x, y } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 5);
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-name-evaluation-error.js b/test/language/expressions/assignment/destructuring/obj-prop-name-evaluation-error.js
new file mode 100644
index 0000000000000000000000000000000000000000..854c6b9c59a516d9cd3490cb920eacf8cf0c57ad
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-name-evaluation-error.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    Any error raised as a result of evaluating PropertyName should be forwarded
+    to the runtime.
+es6id: 12.14.5.2
+---*/
+
+var a, x;
+
+assert.throws(TypeError, function() {
+  ({ [a.b]: x } = {});
+});
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-name-evaluation.js b/test/language/expressions/assignment/destructuring/obj-prop-name-evaluation.js
new file mode 100644
index 0000000000000000000000000000000000000000..52d4b6ef69a33c937207075b058770e22355edbc
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-name-evaluation.js
@@ -0,0 +1,18 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    PropertyName of an AssignmentProperty may be a ComputedPropertyName.
+es6id: 12.14.5.2
+---*/
+
+var value = { x: 1, xy: 23, y: 2 };
+var result, x, y, xy;
+
+result = { ['x' + 'y']: x } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 23);
+assert.sameValue(y, undefined);
+assert.sameValue(xy, undefined);
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-nested-array-invalid.js b/test/language/expressions/assignment/destructuring/obj-prop-nested-array-invalid.js
new file mode 100644
index 0000000000000000000000000000000000000000..011b8291df21378fedd2a66b443f7644ec14b634
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-nested-array-invalid.js
@@ -0,0 +1,16 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    It is a Syntax Error if LeftHandSideExpression is either an ObjectLiteral
+    or an ArrayLiteral and if the lexical token sequence matched by
+    LeftHandSideExpression cannot be parsed with no tokens left over using
+    AssignmentPattern as the goal symbol.
+es6id: 12.14.5.1
+negative: SyntaxError
+---*/
+
+var x, y;
+
+({ x: [(x, y)] } = { x: [] });
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-nested-array-null.js b/test/language/expressions/assignment/destructuring/obj-prop-nested-array-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..7a40d1fb78d223c0372223c3d2f340502e6c5973
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-nested-array-null.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an array literal and the value is
+    `null`, a TypeError should be thrown.
+es6id: 12.14.5.4
+---*/
+
+var x;
+
+assert.throws(TypeError, function() {
+  ({ x: [ x ] } = { x: null });
+});
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-nested-array-undefined-own.js b/test/language/expressions/assignment/destructuring/obj-prop-nested-array-undefined-own.js
new file mode 100644
index 0000000000000000000000000000000000000000..e1f0dd63c737228cdc8bdc375a4b437b557a99e4
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-nested-array-undefined-own.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an array literal and the value is
+    `undefined`, a TypeError should be thrown.
+es6id: 12.14.5.4
+---*/
+
+var x;
+
+assert.throws(TypeError, function() {
+  ({ x: [ x ] } = { x: undefined });
+});
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-nested-array-undefined.js b/test/language/expressions/assignment/destructuring/obj-prop-nested-array-undefined.js
new file mode 100644
index 0000000000000000000000000000000000000000..95554b916584f7615c04a6f87cd71d159f637f19
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-nested-array-undefined.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an array literal and the value is not
+    defined, a TypeError should be thrown.
+es6id: 12.14.5.4
+---*/
+
+var x;
+
+assert.throws(TypeError, function() {
+  ({ x: [ x ] } = {});
+});
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-nested-array-yield-expr.js b/test/language/expressions/assignment/destructuring/obj-prop-nested-array-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..4e1e142e2393ef91ad3f17357bca7aa0bfcbbeeb
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-nested-array-yield-expr.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the Initializer of a nested
+    destructuring assignment and within a generator function body, it should
+    behave as a YieldExpression.
+es6id: 12.14.5.4
+features: [generators]
+---*/
+
+var value = { x: [] };
+var assignmentResult, iterationResult, iter, x;
+
+iter = (function*() {
+  assignmentResult = { x: [x = yield] } = value;
+}());
+
+iterationResult = iter.next();
+
+assert.sameValue(assignmentResult = undefined);
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, false);
+assert.sameValue(x, undefined);
+
+iterationResult = iter.next(24601);
+
+assert.sameValue(assignmentResult, value);
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, true);
+assert.sameValue(x, 24601);
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-nested-array-yield-ident-invalid.js b/test/language/expressions/assignment/destructuring/obj-prop-nested-array-yield-ident-invalid.js
new file mode 100644
index 0000000000000000000000000000000000000000..29a8e9c6c4e19ae1250d327504032b311ef70aad
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-nested-array-yield-ident-invalid.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the Initializer of a nested
+    destructuring assignment and outside of a generator function body, it
+    should behave as an IdentifierReference.
+es6id: 12.14.5.4
+flags: [onlyStrict]
+negative: SyntaxError
+---*/
+
+var x;
+0, { x: [x = yield] } = { x: [] };
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-nested-array-yield-ident-valid.js b/test/language/expressions/assignment/destructuring/obj-prop-nested-array-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..83df76722c48c0bad7174fa805561bea50c93525
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-nested-array-yield-ident-valid.js
@@ -0,0 +1,20 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the Initializer of a nested
+    destructuring assignment and outside of a generator function body, it
+    should behave as an IdentifierReference.
+es6id: 12.14.5.4
+flags: [noStrict]
+---*/
+
+var value = { x: [] };
+var yield = 22;
+var result, x;
+
+result = { x: [x = yield] } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 22);
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-nested-array.js b/test/language/expressions/assignment/destructuring/obj-prop-nested-array.js
new file mode 100644
index 0000000000000000000000000000000000000000..a28cc299c804b7fbb4da2e2590a36057fe044d7d
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-nested-array.js
@@ -0,0 +1,18 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an array literal, it should be parsed
+    parsed as a DestructuringAssignmentPattern and evaluated as a destructuring
+    assignment.
+es6id: 12.14.5.4
+---*/
+
+var value = { x: [321] };
+var result, y;
+
+result = { x: [y] } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(y, 321);
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-nested-obj-invalid.js b/test/language/expressions/assignment/destructuring/obj-prop-nested-obj-invalid.js
new file mode 100644
index 0000000000000000000000000000000000000000..e1388ff867f92e14342941d17a32661805786032
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-nested-obj-invalid.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    It is a Syntax Error if LeftHandSideExpression is either
+    an ObjectLiteral or an ArrayLiteral and if the lexical
+    token sequence matched by LeftHandSideExpression cannot be
+    parsed with no tokens left over using AssignmentPattern as
+    the goal symbol.
+es6id: 12.14.5.1
+negative: SyntaxError
+---*/
+
+({ x: { get x() {} } } = { x: {} });
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-nested-obj-null.js b/test/language/expressions/assignment/destructuring/obj-prop-nested-obj-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..7806305a64792bc5a732f8302b51743f05621620
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-nested-obj-null.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an object literal and the value is
+    `null`, a TypeError should be thrown.
+es6id: 12.14.5.4
+---*/
+
+var x;
+
+assert.throws(TypeError, function() {
+  ({ x: { x } } = { x: null });
+});
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-nested-obj-undefined-own.js b/test/language/expressions/assignment/destructuring/obj-prop-nested-obj-undefined-own.js
new file mode 100644
index 0000000000000000000000000000000000000000..771e90e4ec8995bc6bad7aea5faaabcc7c997cfd
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-nested-obj-undefined-own.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an object literal and the value is
+    `undefined`, a TypeError should be thrown.
+es6id: 12.14.5.4
+---*/
+
+var x;
+
+assert.throws(TypeError, function() {
+  ({ x: { x } } = { x: undefined });
+});
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-nested-obj-undefined.js b/test/language/expressions/assignment/destructuring/obj-prop-nested-obj-undefined.js
new file mode 100644
index 0000000000000000000000000000000000000000..ac0ff673a0aabe3da65ee62c005e05484d1c806d
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-nested-obj-undefined.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an object literal and the value is
+    not defined, a TypeError should be thrown.
+es6id: 12.14.5.4
+---*/
+
+var x;
+
+assert.throws(TypeError, function() {
+  ({ x: { x } } = {});
+});
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-nested-obj-yield-expr.js b/test/language/expressions/assignment/destructuring/obj-prop-nested-obj-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..3d89a89736fa3c457831817d38659f885699e49f
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-nested-obj-yield-expr.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the Initializer of a nested
+    destructuring assignment and within a generator function body, it should
+    behave as a YieldExpression.
+es6id: 12.14.5.4
+features: [generators]
+---*/
+
+var value = { x: {} };
+var assignmentResult, iterationResult, iter, x;
+
+iter = (function*() {
+  assignmentResult = { x: { x = yield } } = value;
+}());
+
+iterationResult = iter.next();
+
+assert.sameValue(assignmentResult, undefined);
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, false);
+assert.sameValue(x, undefined);
+
+iterationResult = iter.next(4);
+
+assert.sameValue(assignmentResult, value);
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, true);
+assert.sameValue(x, 4);
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-nested-obj-yield-ident-invalid.js b/test/language/expressions/assignment/destructuring/obj-prop-nested-obj-yield-ident-invalid.js
new file mode 100644
index 0000000000000000000000000000000000000000..3a4b44df7de4a6b4f8ed6adfa8d5834c35e9120e
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-nested-obj-yield-ident-invalid.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the Initializer of a nested
+    destructuring assignment and outside of a generator function body, it
+    should behave as an IdentifierReference.
+es6id: 12.14.5.4
+flags: [onlyStrict]
+negative: SyntaxError
+---*/
+
+var x;
+0, { x: { x = yield } } = { x: {} };
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-nested-obj-yield-ident-valid.js b/test/language/expressions/assignment/destructuring/obj-prop-nested-obj-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..7261d722e17bddca2d7861ab97c95539948b5422
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-nested-obj-yield-ident-valid.js
@@ -0,0 +1,20 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When a `yield` token appears within the Initializer of a nested
+    destructuring assignment and outside of a generator function body, it
+    should behave as an IdentifierReference.
+es6id: 12.14.5.4
+flags: [noStrict]
+---*/
+
+var value = { x: {} };
+var yield = 2;
+var result, x;
+
+result = { x: { x = yield } } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 2);
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-nested-obj.js b/test/language/expressions/assignment/destructuring/obj-prop-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..a47fdaccb21504a62b0448b5e7f5f3f90bbacd02
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-nested-obj.js
@@ -0,0 +1,18 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    When DestructuringAssignmentTarget is an object literal, it should be
+    parsed as a DestructuringAssignmentPattern and evaluated as a destructuring
+    assignment.
+es6id: 12.14.5.4
+---*/
+
+var value = { x: { y: 2 } };
+var result, y;
+
+result = { x: { y } } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(y, 2);
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-put-const.js b/test/language/expressions/assignment/destructuring/obj-prop-put-const.js
new file mode 100644
index 0000000000000000000000000000000000000000..d17289a0aca35f025c4aa4a6aa28665b283c7aa0
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-put-const.js
@@ -0,0 +1,15 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    The assignment target should obey `const` semantics.
+es6id: 12.14.5.4
+features: [const]
+---*/
+
+const c = 1;
+
+assert.throws(TypeError, function() {
+  ({ a: c } = { a: 2 });
+});
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-put-let.js b/test/language/expressions/assignment/destructuring/obj-prop-put-let.js
new file mode 100644
index 0000000000000000000000000000000000000000..98080dced963c2f458b510d78ecd99c89253f4a7
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-put-let.js
@@ -0,0 +1,14 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    The assignment target should obey `let` semantics.
+es6id: 12.14.5.4
+features: [let]
+---*/
+
+assert.throws(ReferenceError, function() {
+  ({ a: x } = {});
+  let x;
+});
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-put-order.js b/test/language/expressions/assignment/destructuring/obj-prop-put-order.js
new file mode 100644
index 0000000000000000000000000000000000000000..e6e360f8789287afe04c657be7adfa0229cf5989
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-put-order.js
@@ -0,0 +1,17 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    The AssignmentElements in an AssignmentElementList are evaluated in left-
+    to-right order.
+es6id: 12.14.5.4
+---*/
+
+var value = { a: 2, z: 1 };
+var x, result;
+
+result = { z: x, a: x } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x, 2);
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-put-prop-ref-no-get.js b/test/language/expressions/assignment/destructuring/obj-prop-put-prop-ref-no-get.js
new file mode 100644
index 0000000000000000000000000000000000000000..9f036e6c7d599e8cd955fb5a692d97e7e5a7e91e
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-put-prop-ref-no-get.js
@@ -0,0 +1,25 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    If the DestructuringAssignmentTarget of an AssignmentElement is a
+    PropertyReference, it should not be evaluated.
+es6id: 12.14.5.4
+---*/
+
+var value = { a: 23 };
+var x, setValue, result;
+x = {
+  get y() {
+    $ERROR('The property should not be accessed.');
+  },
+  set y(val) {
+    setValue = val;
+  }
+};
+
+result = { a: x.y } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(setValue, 23);
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-put-prop-ref-user-err.js b/test/language/expressions/assignment/destructuring/obj-prop-put-prop-ref-user-err.js
new file mode 100644
index 0000000000000000000000000000000000000000..dafa8026c0d55a99c6b147d359fbac48cf9bac8a
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-put-prop-ref-user-err.js
@@ -0,0 +1,20 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    Any error raised as a result of setting the value should be forwarded to
+    the runtime.
+es6id: 12.14.5.4
+---*/
+
+var value = { a: 23 };
+var x = {
+  set y(val) {
+    throw new Test262Error();
+  }
+};
+
+assert.throws(Test262Error, function() {
+  ({ a: x.y } = value);
+});
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-put-prop-ref.js b/test/language/expressions/assignment/destructuring/obj-prop-put-prop-ref.js
new file mode 100644
index 0000000000000000000000000000000000000000..163cc9ff8c6acbac6b4809e144ffedcfcd3dcfc8
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-put-prop-ref.js
@@ -0,0 +1,18 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    The DestructuringAssignmentTarget of an AssignmentElement may be a
+    PropertyReference.
+es6id: 12.14.5.4
+---*/
+
+var value = { xy: 4 };
+var x = {};
+var result;
+
+result = { xy: x.y } = value;
+
+assert.sameValue(result, value);
+assert.sameValue(x.y, 4);
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-put-unresolvable-no-strict.js b/test/language/expressions/assignment/destructuring/obj-prop-put-unresolvable-no-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..0ed86512281233b14e317a213ab32391f0d4606e
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-put-unresolvable-no-strict.js
@@ -0,0 +1,16 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    Outside of strict mode, if the the assignment target is an unresolvable
+    reference, a new `var` binding should be created in the environment record.
+es6id: 12.14.5.4
+flags: [noStrict]
+---*/
+
+{
+  ({ x: unresolvable } = {});
+}
+
+assert.sameValue(unresolvable, undefined);
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-put-unresolvable-strict.js b/test/language/expressions/assignment/destructuring/obj-prop-put-unresolvable-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..f75a6927c5885cf3d32a7c0f8eb235cf881ed7ec
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-put-unresolvable-strict.js
@@ -0,0 +1,14 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    In strict mode, if the the assignment target is an unresolvable reference,
+    a ReferenceError should be thrown.
+es6id: 12.14.5.4
+flags: [onlyStrict]
+---*/
+
+assert.throws(ReferenceError, function() {
+  ({ x: unresolvable } = {});
+});
diff --git a/test/language/expressions/assignment/destructuring/object-empty.js b/test/language/expressions/assignment/destructuring/object-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..9658156eb7bb8b6e170f008650ec5347feabf1ed
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/object-empty.js
@@ -0,0 +1,41 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    An ObjectAssignmentPattern without an AssignmentPropertyList requires
+    object-coercible values and throws for other values.
+es6id: 12.14.5.2
+---*/
+
+var value, result;
+
+assert.throws(TypeError, function() {
+  0, {} = undefined;
+});
+
+assert.throws(TypeError, function() {
+  0, {} = null;
+});
+
+result = {} = true;
+
+assert.sameValue(result, true);
+
+result = {} = 1;
+
+assert.sameValue(result, 1);
+
+result = {} = 'string literal';
+
+assert.sameValue(result, 'string literal');
+
+value = Symbol('s');
+result = {} = value;
+
+assert.sameValue(result, value);
+
+value = {};
+result = {} = value;
+
+assert.sameValue(result, value);