diff --git a/test/language/expressions/assignment/S11.13.1_A5_T1.js b/test/language/expressions/assignment/S11.13.1_A5_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..9f32fe4e1f1a4e96e59c672ada6cf30377a863b0
--- /dev/null
+++ b/test/language/expressions/assignment/S11.13.1_A5_T1.js
@@ -0,0 +1,30 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Assignment Operator calls PutValue(lref, rval)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, rval) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding function environment record is not changed.
+flags: [noStrict]
+---*/
+
+function testFunction() {
+ var x = 0;
+ var scope = {x: 1};
+
+ with (scope) {
+ x = (delete scope.x, 2);
+ }
+
+ if (scope.x !== 2) {
+ $ERROR('#1: scope.x === 2. Actual: ' + (scope.x));
+ }
+ if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+ }
+}
+testFunction();
diff --git a/test/language/expressions/assignment/S11.13.1_A5_T2.js b/test/language/expressions/assignment/S11.13.1_A5_T2.js
new file mode 100755
index 0000000000000000000000000000000000000000..4850d96810568136f59f46ba0b027b9643f12657
--- /dev/null
+++ b/test/language/expressions/assignment/S11.13.1_A5_T2.js
@@ -0,0 +1,27 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Assignment Operator calls PutValue(lref, rval)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, rval) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding global environment record is not changed.
+flags: [noStrict]
+---*/
+
+var x = 0;
+var scope = {x: 1};
+
+with (scope) {
+ x = (delete scope.x, 2);
+}
+
+if (scope.x !== 2) {
+ $ERROR('#1: scope.x === 2. Actual: ' + (scope.x));
+}
+if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+}
diff --git a/test/language/expressions/assignment/S11.13.1_A5_T3.js b/test/language/expressions/assignment/S11.13.1_A5_T3.js
new file mode 100755
index 0000000000000000000000000000000000000000..874579c684aa16636cfb1702ca20a71a7dcfba41
--- /dev/null
+++ b/test/language/expressions/assignment/S11.13.1_A5_T3.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Assignment Operator calls PutValue(lref, rval)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, rval) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding object environment record is not changed.
+flags: [noStrict]
+---*/
+
+var outerScope = {x: 0};
+var innerScope = {x: 1};
+
+with (outerScope) {
+ with (innerScope) {
+ x = (delete innerScope.x, 2);
+ }
+}
+
+if (innerScope.x !== 2) {
+ $ERROR('#1: innerScope.x === 2. Actual: ' + (innerScope.x));
+}
+if (outerScope.x !== 0) {
+ $ERROR('#2: outerScope.x === 0. Actual: ' + (outerScope.x));
+}
diff --git a/test/language/expressions/assignment/S11.13.1_A5_T4.js b/test/language/expressions/assignment/S11.13.1_A5_T4.js
new file mode 100755
index 0000000000000000000000000000000000000000..74924f150f493fae0ae529c027ccd17ec7b4f52c
--- /dev/null
+++ b/test/language/expressions/assignment/S11.13.1_A5_T4.js
@@ -0,0 +1,27 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Assignment Operator calls PutValue(lref, rval)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, rval) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when assignment is in strict-mode code and the
+ original binding is no longer present.
+flags: [noStrict]
+---*/
+
+var scope = {x: 1};
+
+with (scope) {
+ (function() {
+ "use strict";
+ x = (delete scope.x, 2);
+ })();
+}
+
+if (scope.x !== 2) {
+ $ERROR('#1: scope.x === 2. Actual: ' + (scope.x));
+}
diff --git a/test/language/expressions/assignment/S11.13.1_A5_T5.js b/test/language/expressions/assignment/S11.13.1_A5_T5.js
new file mode 100755
index 0000000000000000000000000000000000000000..b6a339361493501dbe2af39ab3025529c876da42
--- /dev/null
+++ b/test/language/expressions/assignment/S11.13.1_A5_T5.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Assignment Operator calls PutValue(lref, rval)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, rval) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when assignment is in strict-mode code and the
+ original binding is no longer present.
+includes:
+ - fnGlobalObject.js
+---*/
+
+Object.defineProperty(fnGlobalObject(), "x", {
+ configurable: true,
+ value: 1
+});
+
+(function() {
+ "use strict";
+ x = (delete fnGlobalObject().x, 2);
+})();
+
+if (fnGlobalObject().x !== 2) {
+ $ERROR('#1: fnGlobalObject().x === 2. Actual: ' + (fnGlobalObject().x));
+}
diff --git a/test/language/expressions/assignment/S11.13.1_A6_T1.js b/test/language/expressions/assignment/S11.13.1_A6_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..e1fc3f73131be273fe2213fa6453a483005b8c6c
--- /dev/null
+++ b/test/language/expressions/assignment/S11.13.1_A6_T1.js
@@ -0,0 +1,28 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Assignment Operator calls PutValue(lref, rval)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ declarative environment record. PutValue(lref, rval) uses the initially
+ created Reference even if a more local binding is available.
+flags: [noStrict]
+---*/
+
+function testAssignment() {
+ var x = 0;
+ var innerX = (function() {
+ x = (eval("var x;"), 1);
+ return x;
+ })();
+
+ if (innerX !== undefined) {
+ $ERROR('#1: innerX === undefined. Actual: ' + (innerX));
+ }
+ if (x !== 1) {
+ $ERROR('#2: x === 1. Actual: ' + (x));
+ }
+}
+testAssignment();
diff --git a/test/language/expressions/assignment/S11.13.1_A6_T2.js b/test/language/expressions/assignment/S11.13.1_A6_T2.js
new file mode 100755
index 0000000000000000000000000000000000000000..2c244ac6ea89471f61bb0b68bcf8a1de8b6df807
--- /dev/null
+++ b/test/language/expressions/assignment/S11.13.1_A6_T2.js
@@ -0,0 +1,28 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Assignment Operator calls PutValue(lref, rval)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ declarative environment record. PutValue(lref, rval) uses the initially
+ created Reference even if a more local binding is available.
+flags: [noStrict]
+---*/
+
+function testAssignment() {
+ var x = 0;
+ var innerX = (function() {
+ x = (eval("var x = 2;"), 1);
+ return x;
+ })();
+
+ if (innerX !== 2) {
+ $ERROR('#1: innerX === 2. Actual: ' + (innerX));
+ }
+ if (x !== 1) {
+ $ERROR('#2: x === 1. Actual: ' + (x));
+ }
+}
+testAssignment();
diff --git a/test/language/expressions/assignment/S11.13.1_A6_T3.js b/test/language/expressions/assignment/S11.13.1_A6_T3.js
new file mode 100755
index 0000000000000000000000000000000000000000..3717918a48e2145de48479768c58ec70539fca05
--- /dev/null
+++ b/test/language/expressions/assignment/S11.13.1_A6_T3.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Assignment Operator calls PutValue(lref, rval)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ declarative environment record. PutValue(lref, rval) uses the initially
+ created Reference even if a more local binding is available.
+flags: [noStrict]
+---*/
+
+function testAssignment() {
+ var x = 0;
+ var scope = {};
+
+ with (scope) {
+ x = (scope.x = 2, 1);
+ }
+
+ if (scope.x !== 2) {
+ $ERROR('#1: scope.x === 2. Actual: ' + (scope.x));
+ }
+ if (x !== 1) {
+ $ERROR('#2: x === 1. Actual: ' + (x));
+ }
+}
+testAssignment();
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.10_T1.js b/test/language/expressions/compound-assignment/S11.13.2_A5.10_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..cafb27cf36aaa74af79c26757d1840cb65ac8e8e
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.10_T1.js
@@ -0,0 +1,36 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding function environment record is not changed.
+ Check operator is "x ^= y".
+flags: [noStrict]
+---*/
+
+function testFunction() {
+ var x = 0;
+ var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+ };
+
+ with (scope) {
+ x ^= 3;
+ }
+
+ if (scope.x !== 1) {
+ $ERROR('#1: scope.x === 1. Actual: ' + (scope.x));
+ }
+ if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+ }
+}
+testFunction();
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.10_T2.js b/test/language/expressions/compound-assignment/S11.13.2_A5.10_T2.js
new file mode 100755
index 0000000000000000000000000000000000000000..2822744526997ffbf11acc62b7727b8753704918
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.10_T2.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding global environment record is not changed.
+ Check operator is "x ^= y".
+flags: [noStrict]
+---*/
+
+var x = 0;
+var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (scope) {
+ x ^= 3;
+}
+
+if (scope.x !== 1) {
+ $ERROR('#1: scope.x === 1. Actual: ' + (scope.x));
+}
+if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.10_T3.js b/test/language/expressions/compound-assignment/S11.13.2_A5.10_T3.js
new file mode 100755
index 0000000000000000000000000000000000000000..7c9393436258f0ac97a404abb682c2e5c84a544c
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.10_T3.js
@@ -0,0 +1,37 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding object environment record is not changed.
+ Check operator is "x ^= y".
+flags: [noStrict]
+---*/
+
+var outerScope = {
+ x: 0
+};
+var innerScope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (outerScope) {
+ with (innerScope) {
+ x ^= 3;
+ }
+}
+
+if (innerScope.x !== 1) {
+ $ERROR('#1: innerScope.x === 1. Actual: ' + (innerScope.x));
+}
+if (outerScope.x !== 0) {
+ $ERROR('#2: outerScope.x === 0. Actual: ' + (outerScope.x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.10_T4.js b/test/language/expressions/compound-assignment/S11.13.2_A5.10_T4.js
new file mode 100755
index 0000000000000000000000000000000000000000..7860a32a19b6f99b050ef02c21127bf1b3f25140
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.10_T4.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when 'x ^= y' is in strict-mode code and the
+ original binding is no longer present.
+ Check operator is "x ^= y".
+flags: [noStrict]
+---*/
+
+var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (scope) {
+ (function() {
+ "use strict";
+ x ^= 3;
+ })();
+}
+
+if (scope.x !== 1) {
+ $ERROR('#1: scope.x === 1. Actual: ' + (scope.x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.10_T5.js b/test/language/expressions/compound-assignment/S11.13.2_A5.10_T5.js
new file mode 100755
index 0000000000000000000000000000000000000000..2e44feabc049939d6550c9548824082796b65bcb
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.10_T5.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when 'x ^= y' is in strict-mode code and the
+ original binding is no longer present.
+ Check operator is "x ^= y".
+includes:
+ - fnGlobalObject.js
+---*/
+
+Object.defineProperty(fnGlobalObject(), "x", {
+ configurable: true,
+ get: function() {
+ delete this.x;
+ return 2;
+ }
+});
+
+(function() {
+ "use strict";
+ x ^= 3;
+})();
+
+if (fnGlobalObject().x !== 1) {
+ $ERROR('#1: fnGlobalObject().x === 1. Actual: ' + (fnGlobalObject().x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.11_T1.js b/test/language/expressions/compound-assignment/S11.13.2_A5.11_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..84bdc34fd47632807db2e407332badc33c7b7264
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.11_T1.js
@@ -0,0 +1,36 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding function environment record is not changed.
+ Check operator is "x |= y".
+flags: [noStrict]
+---*/
+
+function testFunction() {
+ var x = 0;
+ var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+ };
+
+ with (scope) {
+ x |= 4;
+ }
+
+ if (scope.x !== 6) {
+ $ERROR('#1: scope.x === 6. Actual: ' + (scope.x));
+ }
+ if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+ }
+}
+testFunction();
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.11_T2.js b/test/language/expressions/compound-assignment/S11.13.2_A5.11_T2.js
new file mode 100755
index 0000000000000000000000000000000000000000..2d9af20b7c3eb92d49e9532bbdfaf9acab3e969d
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.11_T2.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding global environment record is not changed.
+ Check operator is "x |= y".
+flags: [noStrict]
+---*/
+
+var x = 0;
+var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (scope) {
+ x |= 4;
+}
+
+if (scope.x !== 6) {
+ $ERROR('#1: scope.x === 6. Actual: ' + (scope.x));
+}
+if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.11_T3.js b/test/language/expressions/compound-assignment/S11.13.2_A5.11_T3.js
new file mode 100755
index 0000000000000000000000000000000000000000..82a1831c2fb6ddb52e6e3cab58ae30cae73befe8
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.11_T3.js
@@ -0,0 +1,37 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding object environment record is not changed.
+ Check operator is "x |= y".
+flags: [noStrict]
+---*/
+
+var outerScope = {
+ x: 0
+};
+var innerScope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (outerScope) {
+ with (innerScope) {
+ x |= 4;
+ }
+}
+
+if (innerScope.x !== 6) {
+ $ERROR('#1: innerScope.x === 6. Actual: ' + (innerScope.x));
+}
+if (outerScope.x !== 0) {
+ $ERROR('#2: outerScope.x === 0. Actual: ' + (outerScope.x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.11_T4.js b/test/language/expressions/compound-assignment/S11.13.2_A5.11_T4.js
new file mode 100755
index 0000000000000000000000000000000000000000..25edd063f71abdffb8b9167994ef9e814b2c1e65
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.11_T4.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when 'x |= y' is in strict-mode code and the
+ original binding is no longer present.
+ Check operator is "x |= y".
+flags: [noStrict]
+---*/
+
+var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (scope) {
+ (function() {
+ "use strict";
+ x |= 4;
+ })();
+}
+
+if (scope.x !== 6) {
+ $ERROR('#1: scope.x === 6. Actual: ' + (scope.x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.11_T5.js b/test/language/expressions/compound-assignment/S11.13.2_A5.11_T5.js
new file mode 100755
index 0000000000000000000000000000000000000000..37ff88d6952dedf2e27a360c186a84db3cb55c33
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.11_T5.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when 'x |= y' is in strict-mode code and the
+ original binding is no longer present.
+ Check operator is "x |= y".
+includes:
+ - fnGlobalObject.js
+---*/
+
+Object.defineProperty(fnGlobalObject(), "x", {
+ configurable: true,
+ get: function() {
+ delete this.x;
+ return 2;
+ }
+});
+
+(function() {
+ "use strict";
+ x |= 4;
+})();
+
+if (fnGlobalObject().x !== 6) {
+ $ERROR('#1: fnGlobalObject().x === 6. Actual: ' + (fnGlobalObject().x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.1_T1.js b/test/language/expressions/compound-assignment/S11.13.2_A5.1_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..b84848127ca8558d379befff0e119817ba151558
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.1_T1.js
@@ -0,0 +1,36 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding function environment record is not changed.
+ Check operator is "x *= y".
+flags: [noStrict]
+---*/
+
+function testFunction() {
+ var x = 0;
+ var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+ };
+
+ with (scope) {
+ x *= 3;
+ }
+
+ if (scope.x !== 6) {
+ $ERROR('#1: scope.x === 6. Actual: ' + (scope.x));
+ }
+ if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+ }
+}
+testFunction();
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.1_T2.js b/test/language/expressions/compound-assignment/S11.13.2_A5.1_T2.js
new file mode 100755
index 0000000000000000000000000000000000000000..dc36113412289f292937d341062fd797a25ac3d2
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.1_T2.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding global environment record is not changed.
+ Check operator is "x *= y".
+flags: [noStrict]
+---*/
+
+var x = 0;
+var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (scope) {
+ x *= 3;
+}
+
+if (scope.x !== 6) {
+ $ERROR('#1: scope.x === 6. Actual: ' + (scope.x));
+}
+if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.1_T3.js b/test/language/expressions/compound-assignment/S11.13.2_A5.1_T3.js
new file mode 100755
index 0000000000000000000000000000000000000000..38281089464f7204f71e47a64f7458fb2b800a85
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.1_T3.js
@@ -0,0 +1,37 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding object environment record is not changed.
+ Check operator is "x *= y".
+flags: [noStrict]
+---*/
+
+var outerScope = {
+ x: 0
+};
+var innerScope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (outerScope) {
+ with (innerScope) {
+ x *= 3;
+ }
+}
+
+if (innerScope.x !== 6) {
+ $ERROR('#1: innerScope.x === 6. Actual: ' + (innerScope.x));
+}
+if (outerScope.x !== 0) {
+ $ERROR('#2: outerScope.x === 0. Actual: ' + (outerScope.x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.1_T4.js b/test/language/expressions/compound-assignment/S11.13.2_A5.1_T4.js
new file mode 100755
index 0000000000000000000000000000000000000000..6271b1f05d459e8736e79826d2a428b279188906
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.1_T4.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when 'x *= y' is in strict-mode code and the
+ original binding is no longer present.
+ Check operator is "x *= y".
+flags: [noStrict]
+---*/
+
+var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (scope) {
+ (function() {
+ "use strict";
+ x *= 3;
+ })();
+}
+
+if (scope.x !== 6) {
+ $ERROR('#1: scope.x === 6. Actual: ' + (scope.x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.1_T5.js b/test/language/expressions/compound-assignment/S11.13.2_A5.1_T5.js
new file mode 100755
index 0000000000000000000000000000000000000000..1e78dd1a35d3d1123681e59ced82b4dbe0f5dcb6
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.1_T5.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when 'x *= y' is in strict-mode code and the
+ original binding is no longer present.
+ Check operator is "x *= y".
+includes:
+ - fnGlobalObject.js
+---*/
+
+Object.defineProperty(fnGlobalObject(), "x", {
+ configurable: true,
+ get: function() {
+ delete this.x;
+ return 2;
+ }
+});
+
+(function() {
+ "use strict";
+ x *= 3;
+})();
+
+if (fnGlobalObject().x !== 6) {
+ $ERROR('#1: fnGlobalObject().x === 6. Actual: ' + (fnGlobalObject().x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.2_T1.js b/test/language/expressions/compound-assignment/S11.13.2_A5.2_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..b0601e9a580c8c5c36001011b9858e9b6e2bb6a5
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.2_T1.js
@@ -0,0 +1,36 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding function environment record is not changed.
+ Check operator is "x /= y".
+flags: [noStrict]
+---*/
+
+function testFunction() {
+ var x = 0;
+ var scope = {
+ get x() {
+ delete this.x;
+ return 6;
+ }
+ };
+
+ with (scope) {
+ x /= 3;
+ }
+
+ if (scope.x !== 2) {
+ $ERROR('#1: scope.x === 2. Actual: ' + (scope.x));
+ }
+ if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+ }
+}
+testFunction();
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.2_T2.js b/test/language/expressions/compound-assignment/S11.13.2_A5.2_T2.js
new file mode 100755
index 0000000000000000000000000000000000000000..452f06fcb1fdb48bc881313c32703831c95cdb63
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.2_T2.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding global environment record is not changed.
+ Check operator is "x /= y".
+flags: [noStrict]
+---*/
+
+var x = 0;
+var scope = {
+ get x() {
+ delete this.x;
+ return 6;
+ }
+};
+
+with (scope) {
+ x /= 3;
+}
+
+if (scope.x !== 2) {
+ $ERROR('#1: scope.x === 2. Actual: ' + (scope.x));
+}
+if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.2_T3.js b/test/language/expressions/compound-assignment/S11.13.2_A5.2_T3.js
new file mode 100755
index 0000000000000000000000000000000000000000..d31665890d14a73ce5e178bd70051340ec57569b
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.2_T3.js
@@ -0,0 +1,37 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding object environment record is not changed.
+ Check operator is "x /= y".
+flags: [noStrict]
+---*/
+
+var outerScope = {
+ x: 0
+};
+var innerScope = {
+ get x() {
+ delete this.x;
+ return 6;
+ }
+};
+
+with (outerScope) {
+ with (innerScope) {
+ x /= 3;
+ }
+}
+
+if (innerScope.x !== 2) {
+ $ERROR('#1: innerScope.x === 2. Actual: ' + (innerScope.x));
+}
+if (outerScope.x !== 0) {
+ $ERROR('#2: outerScope.x === 0. Actual: ' + (outerScope.x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.2_T4.js b/test/language/expressions/compound-assignment/S11.13.2_A5.2_T4.js
new file mode 100755
index 0000000000000000000000000000000000000000..e860d2a4563821833485413372a9f825ad2be547
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.2_T4.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when 'x /= y' is in strict-mode code and the
+ original binding is no longer present.
+ Check operator is "x /= y".
+flags: [noStrict]
+---*/
+
+var scope = {
+ get x() {
+ delete this.x;
+ return 6;
+ }
+};
+
+with (scope) {
+ (function() {
+ "use strict";
+ x /= 3;
+ })();
+}
+
+if (scope.x !== 2) {
+ $ERROR('#1: scope.x === 2. Actual: ' + (scope.x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.2_T5.js b/test/language/expressions/compound-assignment/S11.13.2_A5.2_T5.js
new file mode 100755
index 0000000000000000000000000000000000000000..8b255af103829a4e2b05c5067a43c90c0b905bde
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.2_T5.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when 'x /= y' is in strict-mode code and the
+ original binding is no longer present.
+ Check operator is "x /= y".
+includes:
+ - fnGlobalObject.js
+---*/
+
+Object.defineProperty(fnGlobalObject(), "x", {
+ configurable: true,
+ get: function() {
+ delete this.x;
+ return 6;
+ }
+});
+
+(function() {
+ "use strict";
+ x /= 3;
+})();
+
+if (fnGlobalObject().x !== 2) {
+ $ERROR('#1: fnGlobalObject().x === 2. Actual: ' + (fnGlobalObject().x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.3_T1.js b/test/language/expressions/compound-assignment/S11.13.2_A5.3_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..176689d6874f035998db54f0099e44df527eba53
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.3_T1.js
@@ -0,0 +1,36 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding function environment record is not changed.
+ Check operator is "x %= y".
+flags: [noStrict]
+---*/
+
+function testFunction() {
+ var x = 0;
+ var scope = {
+ get x() {
+ delete this.x;
+ return 5;
+ }
+ };
+
+ with (scope) {
+ x %= 3;
+ }
+
+ if (scope.x !== 2) {
+ $ERROR('#1: scope.x === 2. Actual: ' + (scope.x));
+ }
+ if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+ }
+}
+testFunction();
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.3_T2.js b/test/language/expressions/compound-assignment/S11.13.2_A5.3_T2.js
new file mode 100755
index 0000000000000000000000000000000000000000..f969c365d5353255d843a7f6084b7c47e6e4369d
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.3_T2.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding global environment record is not changed.
+ Check operator is "x %= y".
+flags: [noStrict]
+---*/
+
+var x = 0;
+var scope = {
+ get x() {
+ delete this.x;
+ return 5;
+ }
+};
+
+with (scope) {
+ x %= 3;
+}
+
+if (scope.x !== 2) {
+ $ERROR('#1: scope.x === 2. Actual: ' + (scope.x));
+}
+if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.3_T3.js b/test/language/expressions/compound-assignment/S11.13.2_A5.3_T3.js
new file mode 100755
index 0000000000000000000000000000000000000000..153c8d5e4e2602bf2db5dde598e2f9f559b9b611
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.3_T3.js
@@ -0,0 +1,37 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding object environment record is not changed.
+ Check operator is "x %= y".
+flags: [noStrict]
+---*/
+
+var outerScope = {
+ x: 0
+};
+var innerScope = {
+ get x() {
+ delete this.x;
+ return 5;
+ }
+};
+
+with (outerScope) {
+ with (innerScope) {
+ x %= 3;
+ }
+}
+
+if (innerScope.x !== 2) {
+ $ERROR('#1: innerScope.x === 2. Actual: ' + (innerScope.x));
+}
+if (outerScope.x !== 0) {
+ $ERROR('#2: outerScope.x === 0. Actual: ' + (outerScope.x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.3_T4.js b/test/language/expressions/compound-assignment/S11.13.2_A5.3_T4.js
new file mode 100755
index 0000000000000000000000000000000000000000..f2f918bd19924efd8b73db8a2d1252349d02bd5b
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.3_T4.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when 'x %= y' is in strict-mode code and the
+ original binding is no longer present.
+ Check operator is "x %= y".
+flags: [noStrict]
+---*/
+
+var scope = {
+ get x() {
+ delete this.x;
+ return 5;
+ }
+};
+
+with (scope) {
+ (function() {
+ "use strict";
+ x %= 3;
+ })();
+}
+
+if (scope.x !== 2) {
+ $ERROR('#1: scope.x === 2. Actual: ' + (scope.x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.3_T5.js b/test/language/expressions/compound-assignment/S11.13.2_A5.3_T5.js
new file mode 100755
index 0000000000000000000000000000000000000000..f7b844e8bb24919ba178b9b7f8c40c50f4bdfc3e
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.3_T5.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when 'x %= y' is in strict-mode code and the
+ original binding is no longer present.
+ Check operator is "x %= y".
+includes:
+ - fnGlobalObject.js
+---*/
+
+Object.defineProperty(fnGlobalObject(), "x", {
+ configurable: true,
+ get: function() {
+ delete this.x;
+ return 5;
+ }
+});
+
+(function() {
+ "use strict";
+ x %= 3;
+})();
+
+if (fnGlobalObject().x !== 2) {
+ $ERROR('#1: fnGlobalObject().x === 2. Actual: ' + (fnGlobalObject().x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.4_T1.js b/test/language/expressions/compound-assignment/S11.13.2_A5.4_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..844c3b07ca472a89565db9222523b94dd3570cef
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.4_T1.js
@@ -0,0 +1,36 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding function environment record is not changed.
+ Check operator is "x += y".
+flags: [noStrict]
+---*/
+
+function testFunction() {
+ var x = 0;
+ var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+ };
+
+ with (scope) {
+ x += 1;
+ }
+
+ if (scope.x !== 3) {
+ $ERROR('#1: scope.x === 3. Actual: ' + (scope.x));
+ }
+ if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+ }
+}
+testFunction();
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.4_T2.js b/test/language/expressions/compound-assignment/S11.13.2_A5.4_T2.js
new file mode 100755
index 0000000000000000000000000000000000000000..255288bd2d1cf65ed54cc7a815735d56b38c3d94
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.4_T2.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding global environment record is not changed.
+ Check operator is "x += y".
+flags: [noStrict]
+---*/
+
+var x = 0;
+var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (scope) {
+ x += 1;
+}
+
+if (scope.x !== 3) {
+ $ERROR('#1: scope.x === 3. Actual: ' + (scope.x));
+}
+if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.4_T3.js b/test/language/expressions/compound-assignment/S11.13.2_A5.4_T3.js
new file mode 100755
index 0000000000000000000000000000000000000000..54755f96d41eb7b13a039396fdbca10b928b0731
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.4_T3.js
@@ -0,0 +1,37 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding object environment record is not changed.
+ Check operator is "x += y".
+flags: [noStrict]
+---*/
+
+var outerScope = {
+ x: 0
+};
+var innerScope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (outerScope) {
+ with (innerScope) {
+ x += 1;
+ }
+}
+
+if (innerScope.x !== 3) {
+ $ERROR('#1: innerScope.x === 3. Actual: ' + (innerScope.x));
+}
+if (outerScope.x !== 0) {
+ $ERROR('#2: outerScope.x === 0. Actual: ' + (outerScope.x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.4_T4.js b/test/language/expressions/compound-assignment/S11.13.2_A5.4_T4.js
new file mode 100755
index 0000000000000000000000000000000000000000..22165d90556e2ead78c7273dcf00198dc20bfa0a
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.4_T4.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when 'x += y' is in strict-mode code and the
+ original binding is no longer present.
+ Check operator is "x += y".
+flags: [noStrict]
+---*/
+
+var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (scope) {
+ (function() {
+ "use strict";
+ x += 1;
+ })();
+}
+
+if (scope.x !== 3) {
+ $ERROR('#1: scope.x === 3. Actual: ' + (scope.x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.4_T5.js b/test/language/expressions/compound-assignment/S11.13.2_A5.4_T5.js
new file mode 100755
index 0000000000000000000000000000000000000000..3002cc9ebf7ad58fe99b55687d083fb32f0be2a5
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.4_T5.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when 'x += y' is in strict-mode code and the
+ original binding is no longer present.
+ Check operator is "x += y".
+includes:
+ - fnGlobalObject.js
+---*/
+
+Object.defineProperty(fnGlobalObject(), "x", {
+ configurable: true,
+ get: function() {
+ delete this.x;
+ return 2;
+ }
+});
+
+(function() {
+ "use strict";
+ x += 1;
+})();
+
+if (fnGlobalObject().x !== 3) {
+ $ERROR('#1: fnGlobalObject().x === 3. Actual: ' + (fnGlobalObject().x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.5_T1.js b/test/language/expressions/compound-assignment/S11.13.2_A5.5_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..93c7b9314d1393619044d27e1f5293a9a66ecbf4
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.5_T1.js
@@ -0,0 +1,36 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding function environment record is not changed.
+ Check operator is "x -= y".
+flags: [noStrict]
+---*/
+
+function testFunction() {
+ var x = 0;
+ var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+ };
+
+ with (scope) {
+ x -= 1;
+ }
+
+ if (scope.x !== 1) {
+ $ERROR('#1: scope.x === 1. Actual: ' + (scope.x));
+ }
+ if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+ }
+}
+testFunction();
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.5_T2.js b/test/language/expressions/compound-assignment/S11.13.2_A5.5_T2.js
new file mode 100755
index 0000000000000000000000000000000000000000..dbdccdb3038dc945d3d471dc07ef63ce8251035e
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.5_T2.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding global environment record is not changed.
+ Check operator is "x -= y".
+flags: [noStrict]
+---*/
+
+var x = 0;
+var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (scope) {
+ x -= 1;
+}
+
+if (scope.x !== 1) {
+ $ERROR('#1: scope.x === 1. Actual: ' + (scope.x));
+}
+if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.5_T3.js b/test/language/expressions/compound-assignment/S11.13.2_A5.5_T3.js
new file mode 100755
index 0000000000000000000000000000000000000000..de7874b0875fb6350a239713ead20a20ebf382f6
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.5_T3.js
@@ -0,0 +1,37 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding object environment record is not changed.
+ Check operator is "x -= y".
+flags: [noStrict]
+---*/
+
+var outerScope = {
+ x: 0
+};
+var innerScope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (outerScope) {
+ with (innerScope) {
+ x -= 1;
+ }
+}
+
+if (innerScope.x !== 1) {
+ $ERROR('#1: innerScope.x === 1. Actual: ' + (innerScope.x));
+}
+if (outerScope.x !== 0) {
+ $ERROR('#2: outerScope.x === 0. Actual: ' + (outerScope.x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.5_T4.js b/test/language/expressions/compound-assignment/S11.13.2_A5.5_T4.js
new file mode 100755
index 0000000000000000000000000000000000000000..295e6e2a8dcca89eacedb7ef3ad643b065808850
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.5_T4.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when 'x -= y' is in strict-mode code and the
+ original binding is no longer present.
+ Check operator is "x -= y".
+flags: [noStrict]
+---*/
+
+var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (scope) {
+ (function() {
+ "use strict";
+ x -= 1;
+ })();
+}
+
+if (scope.x !== 1) {
+ $ERROR('#1: scope.x === 1. Actual: ' + (scope.x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.5_T5.js b/test/language/expressions/compound-assignment/S11.13.2_A5.5_T5.js
new file mode 100755
index 0000000000000000000000000000000000000000..993cb3ea2e71c887bd7c29c59b898c99c802aca3
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.5_T5.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when 'x -= y' is in strict-mode code and the
+ original binding is no longer present.
+ Check operator is "x -= y".
+includes:
+ - fnGlobalObject.js
+---*/
+
+Object.defineProperty(fnGlobalObject(), "x", {
+ configurable: true,
+ get: function() {
+ delete this.x;
+ return 2;
+ }
+});
+
+(function() {
+ "use strict";
+ x -= 1;
+})();
+
+if (fnGlobalObject().x !== 1) {
+ $ERROR('#1: fnGlobalObject().x === 1. Actual: ' + (fnGlobalObject().x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.6_T1.js b/test/language/expressions/compound-assignment/S11.13.2_A5.6_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..71aeb004f04ed91a836be218a2b2c12cc298048c
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.6_T1.js
@@ -0,0 +1,36 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding function environment record is not changed.
+ Check operator is "x <<= y".
+flags: [noStrict]
+---*/
+
+function testFunction() {
+ var x = 0;
+ var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+ };
+
+ with (scope) {
+ x <<= 3;
+ }
+
+ if (scope.x !== 16) {
+ $ERROR('#1: scope.x === 16. Actual: ' + (scope.x));
+ }
+ if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+ }
+}
+testFunction();
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.6_T2.js b/test/language/expressions/compound-assignment/S11.13.2_A5.6_T2.js
new file mode 100755
index 0000000000000000000000000000000000000000..fe3b3276e635685bd0e947b7bdf87fee5e4aceed
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.6_T2.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding global environment record is not changed.
+ Check operator is "x <<= y".
+flags: [noStrict]
+---*/
+
+var x = 0;
+var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (scope) {
+ x <<= 3;
+}
+
+if (scope.x !== 16) {
+ $ERROR('#1: scope.x === 16. Actual: ' + (scope.x));
+}
+if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.6_T3.js b/test/language/expressions/compound-assignment/S11.13.2_A5.6_T3.js
new file mode 100755
index 0000000000000000000000000000000000000000..0e7f0d5498a156ea56eeb2fdf12f241c656196fa
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.6_T3.js
@@ -0,0 +1,37 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding object environment record is not changed.
+ Check operator is "x <<= y".
+flags: [noStrict]
+---*/
+
+var outerScope = {
+ x: 0
+};
+var innerScope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (outerScope) {
+ with (innerScope) {
+ x <<= 3;
+ }
+}
+
+if (innerScope.x !== 16) {
+ $ERROR('#1: innerScope.x === 16. Actual: ' + (innerScope.x));
+}
+if (outerScope.x !== 0) {
+ $ERROR('#2: outerScope.x === 0. Actual: ' + (outerScope.x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.6_T4.js b/test/language/expressions/compound-assignment/S11.13.2_A5.6_T4.js
new file mode 100755
index 0000000000000000000000000000000000000000..f09709a3b21d7ebbdfeac76cd9491041d4cf947a
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.6_T4.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when 'x <<= y' is in strict-mode code and the
+ original binding is no longer present.
+ Check operator is "x <<= y".
+flags: [noStrict]
+---*/
+
+var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (scope) {
+ (function() {
+ "use strict";
+ x <<= 3;
+ })();
+}
+
+if (scope.x !== 16) {
+ $ERROR('#1: scope.x === 16. Actual: ' + (scope.x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.6_T5.js b/test/language/expressions/compound-assignment/S11.13.2_A5.6_T5.js
new file mode 100755
index 0000000000000000000000000000000000000000..4097e36d53a0352acaf588900db2d8653d8d5aec
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.6_T5.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when 'x <<= y' is in strict-mode code and the
+ original binding is no longer present.
+ Check operator is "x <<= y".
+includes:
+ - fnGlobalObject.js
+---*/
+
+Object.defineProperty(fnGlobalObject(), "x", {
+ configurable: true,
+ get: function() {
+ delete this.x;
+ return 2;
+ }
+});
+
+(function() {
+ "use strict";
+ x <<= 3;
+})();
+
+if (fnGlobalObject().x !== 16) {
+ $ERROR('#1: fnGlobalObject().x === 16. Actual: ' + (fnGlobalObject().x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.7_T1.js b/test/language/expressions/compound-assignment/S11.13.2_A5.7_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..08be817e5d9b47ea1c954a2c7d5e01e7e7c3ef04
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.7_T1.js
@@ -0,0 +1,36 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding function environment record is not changed.
+ Check operator is "x >>= y".
+flags: [noStrict]
+---*/
+
+function testFunction() {
+ var x = 0;
+ var scope = {
+ get x() {
+ delete this.x;
+ return 16;
+ }
+ };
+
+ with (scope) {
+ x >>= 3;
+ }
+
+ if (scope.x !== 2) {
+ $ERROR('#1: scope.x === 2. Actual: ' + (scope.x));
+ }
+ if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+ }
+}
+testFunction();
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.7_T2.js b/test/language/expressions/compound-assignment/S11.13.2_A5.7_T2.js
new file mode 100755
index 0000000000000000000000000000000000000000..4cdb34e4756125773ba1bd64e4ebda20276ec625
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.7_T2.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding global environment record is not changed.
+ Check operator is "x >>= y".
+flags: [noStrict]
+---*/
+
+var x = 0;
+var scope = {
+ get x() {
+ delete this.x;
+ return 16;
+ }
+};
+
+with (scope) {
+ x >>= 3;
+}
+
+if (scope.x !== 2) {
+ $ERROR('#1: scope.x === 2. Actual: ' + (scope.x));
+}
+if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.7_T3.js b/test/language/expressions/compound-assignment/S11.13.2_A5.7_T3.js
new file mode 100755
index 0000000000000000000000000000000000000000..ae5880b76ad719e3bb6eeeda34280daa1af17ecb
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.7_T3.js
@@ -0,0 +1,37 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding object environment record is not changed.
+ Check operator is "x >>= y".
+flags: [noStrict]
+---*/
+
+var outerScope = {
+ x: 0
+};
+var innerScope = {
+ get x() {
+ delete this.x;
+ return 16;
+ }
+};
+
+with (outerScope) {
+ with (innerScope) {
+ x >>= 3;
+ }
+}
+
+if (innerScope.x !== 2) {
+ $ERROR('#1: innerScope.x === 2. Actual: ' + (innerScope.x));
+}
+if (outerScope.x !== 0) {
+ $ERROR('#2: outerScope.x === 0. Actual: ' + (outerScope.x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.7_T4.js b/test/language/expressions/compound-assignment/S11.13.2_A5.7_T4.js
new file mode 100755
index 0000000000000000000000000000000000000000..3a77770860d19b09fcd1bdb8faed643b038b9d42
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.7_T4.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when 'x >>= y' is in strict-mode code and the
+ original binding is no longer present.
+ Check operator is "x >>= y".
+flags: [noStrict]
+---*/
+
+var scope = {
+ get x() {
+ delete this.x;
+ return 16;
+ }
+};
+
+with (scope) {
+ (function() {
+ "use strict";
+ x >>= 3;
+ })();
+}
+
+if (scope.x !== 2) {
+ $ERROR('#1: scope.x === 2. Actual: ' + (scope.x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.7_T5.js b/test/language/expressions/compound-assignment/S11.13.2_A5.7_T5.js
new file mode 100755
index 0000000000000000000000000000000000000000..400adb454321e0fe4784c8fd04d2a52fd957b6c4
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.7_T5.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when 'x >>= y' is in strict-mode code and the
+ original binding is no longer present.
+ Check operator is "x >>= y".
+includes:
+ - fnGlobalObject.js
+---*/
+
+Object.defineProperty(fnGlobalObject(), "x", {
+ configurable: true,
+ get: function() {
+ delete this.x;
+ return 16;
+ }
+});
+
+(function() {
+ "use strict";
+ x >>= 3;
+})();
+
+if (fnGlobalObject().x !== 2) {
+ $ERROR('#1: fnGlobalObject().x === 2. Actual: ' + (fnGlobalObject().x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.8_T1.js b/test/language/expressions/compound-assignment/S11.13.2_A5.8_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..5f2f35bb0b00647e08dabd8c865cc9bedf2b66cb
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.8_T1.js
@@ -0,0 +1,36 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding function environment record is not changed.
+ Check operator is "x >>>= y".
+flags: [noStrict]
+---*/
+
+function testFunction() {
+ var x = 0;
+ var scope = {
+ get x() {
+ delete this.x;
+ return 16;
+ }
+ };
+
+ with (scope) {
+ x >>>= 3;
+ }
+
+ if (scope.x !== 2) {
+ $ERROR('#1: scope.x === 2. Actual: ' + (scope.x));
+ }
+ if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+ }
+}
+testFunction();
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.8_T2.js b/test/language/expressions/compound-assignment/S11.13.2_A5.8_T2.js
new file mode 100755
index 0000000000000000000000000000000000000000..bcc8cfec5f43edea8c6c40f8e932b0095ed207b2
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.8_T2.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding global environment record is not changed.
+ Check operator is "x >>>= y".
+flags: [noStrict]
+---*/
+
+var x = 0;
+var scope = {
+ get x() {
+ delete this.x;
+ return 16;
+ }
+};
+
+with (scope) {
+ x >>>= 3;
+}
+
+if (scope.x !== 2) {
+ $ERROR('#1: scope.x === 2. Actual: ' + (scope.x));
+}
+if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.8_T3.js b/test/language/expressions/compound-assignment/S11.13.2_A5.8_T3.js
new file mode 100755
index 0000000000000000000000000000000000000000..8dee0779c00507ba1bee7b6312ff2c61cb5eea17
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.8_T3.js
@@ -0,0 +1,37 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding object environment record is not changed.
+ Check operator is "x >>>= y".
+flags: [noStrict]
+---*/
+
+var outerScope = {
+ x: 0
+};
+var innerScope = {
+ get x() {
+ delete this.x;
+ return 16;
+ }
+};
+
+with (outerScope) {
+ with (innerScope) {
+ x >>>= 3;
+ }
+}
+
+if (innerScope.x !== 2) {
+ $ERROR('#1: innerScope.x === 2. Actual: ' + (innerScope.x));
+}
+if (outerScope.x !== 0) {
+ $ERROR('#2: outerScope.x === 0. Actual: ' + (outerScope.x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.8_T4.js b/test/language/expressions/compound-assignment/S11.13.2_A5.8_T4.js
new file mode 100755
index 0000000000000000000000000000000000000000..67e2de3a63d8007fb19e64931aba8b28c2c939bc
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.8_T4.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when 'x >>>= y' is in strict-mode code and the
+ original binding is no longer present.
+ Check operator is "x >>>= y".
+flags: [noStrict]
+---*/
+
+var scope = {
+ get x() {
+ delete this.x;
+ return 16;
+ }
+};
+
+with (scope) {
+ (function() {
+ "use strict";
+ x >>>= 3;
+ })();
+}
+
+if (scope.x !== 2) {
+ $ERROR('#1: scope.x === 2. Actual: ' + (scope.x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.8_T5.js b/test/language/expressions/compound-assignment/S11.13.2_A5.8_T5.js
new file mode 100755
index 0000000000000000000000000000000000000000..3982a1d6d3cfc936e917a23528c68c22eff42bd3
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.8_T5.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when 'x >>>= y' is in strict-mode code and the
+ original binding is no longer present.
+ Check operator is "x >>>= y".
+includes:
+ - fnGlobalObject.js
+---*/
+
+Object.defineProperty(fnGlobalObject(), "x", {
+ configurable: true,
+ get: function() {
+ delete this.x;
+ return 16;
+ }
+});
+
+(function() {
+ "use strict";
+ x >>>= 3;
+})();
+
+if (fnGlobalObject().x !== 2) {
+ $ERROR('#1: fnGlobalObject().x === 2. Actual: ' + (fnGlobalObject().x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.9_T1.js b/test/language/expressions/compound-assignment/S11.13.2_A5.9_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..be6ee5e30ea286f5457910bd04f26e739b91fac4
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.9_T1.js
@@ -0,0 +1,36 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding function environment record is not changed.
+ Check operator is "x &= y".
+flags: [noStrict]
+---*/
+
+function testFunction() {
+ var x = 0;
+ var scope = {
+ get x() {
+ delete this.x;
+ return 5;
+ }
+ };
+
+ with (scope) {
+ x &= 3;
+ }
+
+ if (scope.x !== 1) {
+ $ERROR('#1: scope.x === 1. Actual: ' + (scope.x));
+ }
+ if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+ }
+}
+testFunction();
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.9_T2.js b/test/language/expressions/compound-assignment/S11.13.2_A5.9_T2.js
new file mode 100755
index 0000000000000000000000000000000000000000..01f7fd62399f3f0ed5fd629e31d84b290ec14de8
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.9_T2.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding global environment record is not changed.
+ Check operator is "x &= y".
+flags: [noStrict]
+---*/
+
+var x = 0;
+var scope = {
+ get x() {
+ delete this.x;
+ return 5;
+ }
+};
+
+with (scope) {
+ x &= 3;
+}
+
+if (scope.x !== 1) {
+ $ERROR('#1: scope.x === 1. Actual: ' + (scope.x));
+}
+if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.9_T3.js b/test/language/expressions/compound-assignment/S11.13.2_A5.9_T3.js
new file mode 100755
index 0000000000000000000000000000000000000000..3ef60424c56adab8ddf72b14c02b153467b6605d
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.9_T3.js
@@ -0,0 +1,37 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding object environment record is not changed.
+ Check operator is "x &= y".
+flags: [noStrict]
+---*/
+
+var outerScope = {
+ x: 0
+};
+var innerScope = {
+ get x() {
+ delete this.x;
+ return 5;
+ }
+};
+
+with (outerScope) {
+ with (innerScope) {
+ x &= 3;
+ }
+}
+
+if (innerScope.x !== 1) {
+ $ERROR('#1: innerScope.x === 1. Actual: ' + (innerScope.x));
+}
+if (outerScope.x !== 0) {
+ $ERROR('#2: outerScope.x === 0. Actual: ' + (outerScope.x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.9_T4.js b/test/language/expressions/compound-assignment/S11.13.2_A5.9_T4.js
new file mode 100755
index 0000000000000000000000000000000000000000..eaedb8c7deb6c10bb7e1d98ff7dd80841e461a9c
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.9_T4.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when 'x &= y' is in strict-mode code and the
+ original binding is no longer present.
+ Check operator is "x &= y".
+flags: [noStrict]
+---*/
+
+var scope = {
+ get x() {
+ delete this.x;
+ return 5;
+ }
+};
+
+with (scope) {
+ (function() {
+ "use strict";
+ x &= 3;
+ })();
+}
+
+if (scope.x !== 1) {
+ $ERROR('#1: scope.x === 1. Actual: ' + (scope.x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A5.9_T5.js b/test/language/expressions/compound-assignment/S11.13.2_A5.9_T5.js
new file mode 100755
index 0000000000000000000000000000000000000000..dd0465397f25c78901fe6b76428856790b6fca05
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A5.9_T5.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lref, v) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when 'x &= y' is in strict-mode code and the
+ original binding is no longer present.
+ Check operator is "x &= y".
+includes:
+ - fnGlobalObject.js
+---*/
+
+Object.defineProperty(fnGlobalObject(), "x", {
+ configurable: true,
+ get: function() {
+ delete this.x;
+ return 5;
+ }
+});
+
+(function() {
+ "use strict";
+ x &= 3;
+})();
+
+if (fnGlobalObject().x !== 1) {
+ $ERROR('#1: fnGlobalObject().x === 1. Actual: ' + (fnGlobalObject().x));
+}
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A6.10_T1.js b/test/language/expressions/compound-assignment/S11.13.2_A6.10_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..6806d2ea4651ca3b0501c30da9c1598416534115
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A6.10_T1.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ declarative environment record. PutValue(lref, v) uses the initially
+ created Reference even if a more local binding is available.
+ Check operator is "x ^= y".
+flags: [noStrict]
+---*/
+
+function testCompoundAssignment() {
+ var x = 1;
+ var innerX = (function() {
+ x ^= (eval("var x = 2;"), 4);
+ return x;
+ })();
+
+ if (innerX !== 2) {
+ $ERROR('#1: innerX === 2. Actual: ' + (innerX));
+ }
+ if (x !== 5) {
+ $ERROR('#2: x === 5. Actual: ' + (x));
+ }
+}
+testCompoundAssignment();
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A6.11_T1.js b/test/language/expressions/compound-assignment/S11.13.2_A6.11_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..64920b83c9b83000a3ef121f32f31d694b55df57
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A6.11_T1.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ declarative environment record. PutValue(lref, v) uses the initially
+ created Reference even if a more local binding is available.
+ Check operator is "x |= y".
+flags: [noStrict]
+---*/
+
+function testCompoundAssignment() {
+ var x = 1;
+ var innerX = (function() {
+ x |= (eval("var x = 2;"), 4);
+ return x;
+ })();
+
+ if (innerX !== 2) {
+ $ERROR('#1: innerX === 2. Actual: ' + (innerX));
+ }
+ if (x !== 5) {
+ $ERROR('#2: x === 5. Actual: ' + (x));
+ }
+}
+testCompoundAssignment();
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A6.1_T1.js b/test/language/expressions/compound-assignment/S11.13.2_A6.1_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..bc0814916fc4ae748b258bef0933fc126ee3bfef
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A6.1_T1.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ declarative environment record. PutValue(lref, v) uses the initially
+ created Reference even if a more local binding is available.
+ Check operator is "x *= y".
+flags: [noStrict]
+---*/
+
+function testCompoundAssignment() {
+ var x = 3;
+ var innerX = (function() {
+ x *= (eval("var x = 2;"), 4);
+ return x;
+ })();
+
+ if (innerX !== 2) {
+ $ERROR('#1: innerX === 2. Actual: ' + (innerX));
+ }
+ if (x !== 12) {
+ $ERROR('#2: x === 12. Actual: ' + (x));
+ }
+}
+testCompoundAssignment();
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A6.2_T1.js b/test/language/expressions/compound-assignment/S11.13.2_A6.2_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..fbb90b84540e3074406d93917aa839a4ac42ae73
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A6.2_T1.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ declarative environment record. PutValue(lref, v) uses the initially
+ created Reference even if a more local binding is available.
+ Check operator is "x /= y".
+flags: [noStrict]
+---*/
+
+function testCompoundAssignment() {
+ var x = 15;
+ var innerX = (function() {
+ x /= (eval("var x = 2;"), 3);
+ return x;
+ })();
+
+ if (innerX !== 2) {
+ $ERROR('#1: innerX === 2. Actual: ' + (innerX));
+ }
+ if (x !== 5) {
+ $ERROR('#2: x === 5. Actual: ' + (x));
+ }
+}
+testCompoundAssignment();
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A6.3_T1.js b/test/language/expressions/compound-assignment/S11.13.2_A6.3_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..d8fc7146f628a6a0be79e310e6957544ea338110
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A6.3_T1.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ declarative environment record. PutValue(lref, v) uses the initially
+ created Reference even if a more local binding is available.
+ Check operator is "x %= y".
+flags: [noStrict]
+---*/
+
+function testCompoundAssignment() {
+ var x = 7;
+ var innerX = (function() {
+ x %= (eval("var x = 2;"), 4);
+ return x;
+ })();
+
+ if (innerX !== 2) {
+ $ERROR('#1: innerX === 2. Actual: ' + (innerX));
+ }
+ if (x !== 3) {
+ $ERROR('#2: x === 3. Actual: ' + (x));
+ }
+}
+testCompoundAssignment();
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A6.4_T1.js b/test/language/expressions/compound-assignment/S11.13.2_A6.4_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..3bb0664ffc8a0ea70f0ac1519fb8f4a7936ba14a
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A6.4_T1.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ declarative environment record. PutValue(lref, v) uses the initially
+ created Reference even if a more local binding is available.
+ Check operator is "x += y".
+flags: [noStrict]
+---*/
+
+function testCompoundAssignment() {
+ var x = 3;
+ var innerX = (function() {
+ x += (eval("var x = 2;"), 1);
+ return x;
+ })();
+
+ if (innerX !== 2) {
+ $ERROR('#1: innerX === 2. Actual: ' + (innerX));
+ }
+ if (x !== 4) {
+ $ERROR('#2: x === 4. Actual: ' + (x));
+ }
+}
+testCompoundAssignment();
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A6.5_T1.js b/test/language/expressions/compound-assignment/S11.13.2_A6.5_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..0d1b98117facc6eab295cb14a27fc900ac730cd3
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A6.5_T1.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ declarative environment record. PutValue(lref, v) uses the initially
+ created Reference even if a more local binding is available.
+ Check operator is "x -= y".
+flags: [noStrict]
+---*/
+
+function testCompoundAssignment() {
+ var x = 5;
+ var innerX = (function() {
+ x -= (eval("var x = 2;"), 1);
+ return x;
+ })();
+
+ if (innerX !== 2) {
+ $ERROR('#1: innerX === 2. Actual: ' + (innerX));
+ }
+ if (x !== 4) {
+ $ERROR('#2: x === 4. Actual: ' + (x));
+ }
+}
+testCompoundAssignment();
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A6.6_T1.js b/test/language/expressions/compound-assignment/S11.13.2_A6.6_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..0e39ce67992d9b095caf6c5b9cb53cfbd670048b
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A6.6_T1.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ declarative environment record. PutValue(lref, v) uses the initially
+ created Reference even if a more local binding is available.
+ Check operator is "x <<= y".
+flags: [noStrict]
+---*/
+
+function testCompoundAssignment() {
+ var x = 1;
+ var innerX = (function() {
+ x <<= (eval("var x = 2;"), 3);
+ return x;
+ })();
+
+ if (innerX !== 2) {
+ $ERROR('#1: innerX === 2. Actual: ' + (innerX));
+ }
+ if (x !== 8) {
+ $ERROR('#2: x === 8. Actual: ' + (x));
+ }
+}
+testCompoundAssignment();
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A6.7_T1.js b/test/language/expressions/compound-assignment/S11.13.2_A6.7_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..9e24083772ca8c219ad5d08b37feaa4a910f143f
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A6.7_T1.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ declarative environment record. PutValue(lref, v) uses the initially
+ created Reference even if a more local binding is available.
+ Check operator is "x >>= y".
+flags: [noStrict]
+---*/
+
+function testCompoundAssignment() {
+ var x = 8;
+ var innerX = (function() {
+ x >>= (eval("var x = 2;"), 1);
+ return x;
+ })();
+
+ if (innerX !== 2) {
+ $ERROR('#1: innerX === 2. Actual: ' + (innerX));
+ }
+ if (x !== 4) {
+ $ERROR('#2: x === 4. Actual: ' + (x));
+ }
+}
+testCompoundAssignment();
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A6.8_T1.js b/test/language/expressions/compound-assignment/S11.13.2_A6.8_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..f5be57cdda7bd751d73c12fd0fc29dcd3a0b04f1
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A6.8_T1.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ declarative environment record. PutValue(lref, v) uses the initially
+ created Reference even if a more local binding is available.
+ Check operator is "x >>>= y".
+flags: [noStrict]
+---*/
+
+function testCompoundAssignment() {
+ var x = 8;
+ var innerX = (function() {
+ x >>>= (eval("var x = 2;"), 1);
+ return x;
+ })();
+
+ if (innerX !== 2) {
+ $ERROR('#1: innerX === 2. Actual: ' + (innerX));
+ }
+ if (x !== 4) {
+ $ERROR('#2: x === 4. Actual: ' + (x));
+ }
+}
+testCompoundAssignment();
diff --git a/test/language/expressions/compound-assignment/S11.13.2_A6.9_T1.js b/test/language/expressions/compound-assignment/S11.13.2_A6.9_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..df40895a809145b32a6f6397ec42511fdb8a7d4a
--- /dev/null
+++ b/test/language/expressions/compound-assignment/S11.13.2_A6.9_T1.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Compound Assignment Operator calls PutValue(lref, v)
+description: >
+ Evaluating LeftHandSideExpression lref returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ declarative environment record. PutValue(lref, v) uses the initially
+ created Reference even if a more local binding is available.
+ Check operator is "x &= y".
+flags: [noStrict]
+---*/
+
+function testCompoundAssignment() {
+ var x = 5;
+ var innerX = (function() {
+ x &= (eval("var x = 2;"), 3);
+ return x;
+ })();
+
+ if (innerX !== 2) {
+ $ERROR('#1: innerX === 2. Actual: ' + (innerX));
+ }
+ if (x !== 1) {
+ $ERROR('#2: x === 1. Actual: ' + (x));
+ }
+}
+testCompoundAssignment();
diff --git a/test/language/expressions/postfix-decrement/S11.3.2_A5_T1.js b/test/language/expressions/postfix-decrement/S11.3.2_A5_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..fb43d87f161c9a22221222a72b3a873ab0cd94bc
--- /dev/null
+++ b/test/language/expressions/postfix-decrement/S11.3.2_A5_T1.js
@@ -0,0 +1,35 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Operator x-- calls PutValue(lhs, newValue)
+description: >
+ Evaluating LeftHandSideExpression lhs returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lhs, newValue) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding function environment record is not changed.
+flags: [noStrict]
+---*/
+
+function testFunction() {
+ var x = 0;
+ var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+ };
+
+ with (scope) {
+ x--;
+ }
+
+ if (scope.x !== 1) {
+ $ERROR('#1: scope.x === 1. Actual: ' + (scope.x));
+ }
+ if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+ }
+}
+testFunction();
diff --git a/test/language/expressions/postfix-decrement/S11.3.2_A5_T2.js b/test/language/expressions/postfix-decrement/S11.3.2_A5_T2.js
new file mode 100755
index 0000000000000000000000000000000000000000..26f96a385544e8ba7181954d567e51a0ddeb5ba6
--- /dev/null
+++ b/test/language/expressions/postfix-decrement/S11.3.2_A5_T2.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Operator x-- calls PutValue(lhs, newValue)
+description: >
+ Evaluating LeftHandSideExpression lhs returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lhs, newValue) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding global environment record is not changed.
+flags: [noStrict]
+---*/
+
+var x = 0;
+var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (scope) {
+ x--;
+}
+
+if (scope.x !== 1) {
+ $ERROR('#1: scope.x === 1. Actual: ' + (scope.x));
+}
+if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+}
diff --git a/test/language/expressions/postfix-decrement/S11.3.2_A5_T3.js b/test/language/expressions/postfix-decrement/S11.3.2_A5_T3.js
new file mode 100755
index 0000000000000000000000000000000000000000..6446e8728758387cc0df3fabb763f4a21249fb91
--- /dev/null
+++ b/test/language/expressions/postfix-decrement/S11.3.2_A5_T3.js
@@ -0,0 +1,36 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Operator x-- calls PutValue(lhs, newValue)
+description: >
+ Evaluating LeftHandSideExpression lhs returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lhs, newValue) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding object environment record is not changed.
+flags: [noStrict]
+---*/
+
+var outerScope = {
+ x: 0
+};
+var innerScope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (outerScope) {
+ with (innerScope) {
+ x--;
+ }
+}
+
+if (innerScope.x !== 1) {
+ $ERROR('#1: innerScope.x === 1. Actual: ' + (innerScope.x));
+}
+if (outerScope.x !== 0) {
+ $ERROR('#2: outerScope.x === 0. Actual: ' + (outerScope.x));
+}
diff --git a/test/language/expressions/postfix-decrement/S11.3.2_A5_T4.js b/test/language/expressions/postfix-decrement/S11.3.2_A5_T4.js
new file mode 100755
index 0000000000000000000000000000000000000000..aa01013595e0e482c1bf92008de3bc83b268c1a3
--- /dev/null
+++ b/test/language/expressions/postfix-decrement/S11.3.2_A5_T4.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Operator x-- calls PutValue(lhs, newValue)
+description: >
+ Evaluating LeftHandSideExpression lhs returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lhs, newValue) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when 'x--' is in strict-mode code and the
+ original binding is no longer present.
+flags: [noStrict]
+---*/
+
+var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (scope) {
+ (function() {
+ "use strict";
+ x--;
+ })();
+}
+
+if (scope.x !== 1) {
+ $ERROR('#1: scope.x === 1. Actual: ' + (scope.x));
+}
diff --git a/test/language/expressions/postfix-decrement/S11.3.2_A5_T5.js b/test/language/expressions/postfix-decrement/S11.3.2_A5_T5.js
new file mode 100755
index 0000000000000000000000000000000000000000..6a6c183222dcdc9ca48db22358ab0b11f165cef4
--- /dev/null
+++ b/test/language/expressions/postfix-decrement/S11.3.2_A5_T5.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Operator x-- calls PutValue(lhs, newValue)
+description: >
+ Evaluating LeftHandSideExpression lhs returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lhs, newValue) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when 'x--' is in strict-mode code and the
+ original binding is no longer present.
+includes:
+ - fnGlobalObject.js
+---*/
+
+Object.defineProperty(fnGlobalObject(), "x", {
+ configurable: true,
+ get: function() {
+ delete this.x;
+ return 2;
+ }
+});
+
+(function() {
+ "use strict";
+ x--;
+})();
+
+if (fnGlobalObject().x !== 1) {
+ $ERROR('#1: fnGlobalObject().x === 1. Actual: ' + (fnGlobalObject().x));
+}
diff --git a/test/language/expressions/postfix-increment/S11.3.1_A5_T1.js b/test/language/expressions/postfix-increment/S11.3.1_A5_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..2b4bcd0532655eba61ad712a547e031bdc2ec7bb
--- /dev/null
+++ b/test/language/expressions/postfix-increment/S11.3.1_A5_T1.js
@@ -0,0 +1,35 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Operator x++ calls PutValue(lhs, newValue)
+description: >
+ Evaluating LeftHandSideExpression lhs returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lhs, newValue) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding function environment record is not changed.
+flags: [noStrict]
+---*/
+
+function testFunction() {
+ var x = 0;
+ var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+ };
+
+ with (scope) {
+ x++;
+ }
+
+ if (scope.x !== 3) {
+ $ERROR('#1: scope.x === 3. Actual: ' + (scope.x));
+ }
+ if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+ }
+}
+testFunction();
diff --git a/test/language/expressions/postfix-increment/S11.3.1_A5_T2.js b/test/language/expressions/postfix-increment/S11.3.1_A5_T2.js
new file mode 100755
index 0000000000000000000000000000000000000000..ade4a0a9b05b46098172b3154688ed6a2a77f351
--- /dev/null
+++ b/test/language/expressions/postfix-increment/S11.3.1_A5_T2.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Operator x++ calls PutValue(lhs, newValue)
+description: >
+ Evaluating LeftHandSideExpression lhs returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lhs, newValue) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding global environment record is not changed.
+flags: [noStrict]
+---*/
+
+var x = 0;
+var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (scope) {
+ x++;
+}
+
+if (scope.x !== 3) {
+ $ERROR('#1: scope.x === 3. Actual: ' + (scope.x));
+}
+if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+}
diff --git a/test/language/expressions/postfix-increment/S11.3.1_A5_T3.js b/test/language/expressions/postfix-increment/S11.3.1_A5_T3.js
new file mode 100755
index 0000000000000000000000000000000000000000..6e3c717193cd3b3c085a9ceb205199965ae6fe47
--- /dev/null
+++ b/test/language/expressions/postfix-increment/S11.3.1_A5_T3.js
@@ -0,0 +1,36 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Operator x++ calls PutValue(lhs, newValue)
+description: >
+ Evaluating LeftHandSideExpression lhs returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lhs, newValue) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding object environment record is not changed.
+flags: [noStrict]
+---*/
+
+var outerScope = {
+ x: 0
+};
+var innerScope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (outerScope) {
+ with (innerScope) {
+ x++;
+ }
+}
+
+if (innerScope.x !== 3) {
+ $ERROR('#1: innerScope.x === 3. Actual: ' + (innerScope.x));
+}
+if (outerScope.x !== 0) {
+ $ERROR('#2: outerScope.x === 0. Actual: ' + (outerScope.x));
+}
diff --git a/test/language/expressions/postfix-increment/S11.3.1_A5_T4.js b/test/language/expressions/postfix-increment/S11.3.1_A5_T4.js
new file mode 100755
index 0000000000000000000000000000000000000000..41468ff55318dc676d1958775184a8f289e034e7
--- /dev/null
+++ b/test/language/expressions/postfix-increment/S11.3.1_A5_T4.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Operator x++ calls PutValue(lhs, newValue)
+description: >
+ Evaluating LeftHandSideExpression lhs returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lhs, newValue) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when 'x++' is in strict-mode code and the
+ original binding is no longer present.
+flags: [noStrict]
+---*/
+
+var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (scope) {
+ (function() {
+ "use strict";
+ x++;
+ })();
+}
+
+if (scope.x !== 3) {
+ $ERROR('#1: scope.x === 3. Actual: ' + (scope.x));
+}
diff --git a/test/language/expressions/postfix-increment/S11.3.1_A5_T5.js b/test/language/expressions/postfix-increment/S11.3.1_A5_T5.js
new file mode 100755
index 0000000000000000000000000000000000000000..a078046187430da4f22b6010ee84ba230b7eeee9
--- /dev/null
+++ b/test/language/expressions/postfix-increment/S11.3.1_A5_T5.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Operator x++ calls PutValue(lhs, newValue)
+description: >
+ Evaluating LeftHandSideExpression lhs returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lhs, newValue) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when 'x++' is in strict-mode code and the
+ original binding is no longer present.
+includes:
+ - fnGlobalObject.js
+---*/
+
+Object.defineProperty(fnGlobalObject(), "x", {
+ configurable: true,
+ get: function() {
+ delete this.x;
+ return 2;
+ }
+});
+
+(function() {
+ "use strict";
+ x++;
+})();
+
+if (fnGlobalObject().x !== 3) {
+ $ERROR('#1: fnGlobalObject().x === 3. Actual: ' + (fnGlobalObject().x));
+}
diff --git a/test/language/expressions/prefix-decrement/S11.4.5_A5_T1.js b/test/language/expressions/prefix-decrement/S11.4.5_A5_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..a868280068a69d2912e732530332def8a50cdf84
--- /dev/null
+++ b/test/language/expressions/prefix-decrement/S11.4.5_A5_T1.js
@@ -0,0 +1,35 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Operator --x calls PutValue(lhs, newValue)
+description: >
+ Evaluating LeftHandSideExpression lhs returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lhs, newValue) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding function environment record is not changed.
+flags: [noStrict]
+---*/
+
+function testFunction() {
+ var x = 0;
+ var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+ };
+
+ with (scope) {
+ --x;
+ }
+
+ if (scope.x !== 1) {
+ $ERROR('#1: scope.x === 1. Actual: ' + (scope.x));
+ }
+ if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+ }
+}
+testFunction();
diff --git a/test/language/expressions/prefix-decrement/S11.4.5_A5_T2.js b/test/language/expressions/prefix-decrement/S11.4.5_A5_T2.js
new file mode 100755
index 0000000000000000000000000000000000000000..a501cb6308204492a9c3b0a27721d9afd24a6633
--- /dev/null
+++ b/test/language/expressions/prefix-decrement/S11.4.5_A5_T2.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Operator --x calls PutValue(lhs, newValue)
+description: >
+ Evaluating LeftHandSideExpression lhs returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lhs, newValue) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding global environment record is not changed.
+flags: [noStrict]
+---*/
+
+var x = 0;
+var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (scope) {
+ --x;
+}
+
+if (scope.x !== 1) {
+ $ERROR('#1: scope.x === 1. Actual: ' + (scope.x));
+}
+if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+}
diff --git a/test/language/expressions/prefix-decrement/S11.4.5_A5_T3.js b/test/language/expressions/prefix-decrement/S11.4.5_A5_T3.js
new file mode 100755
index 0000000000000000000000000000000000000000..0925e780dc76342be1557966271afceb8f861c71
--- /dev/null
+++ b/test/language/expressions/prefix-decrement/S11.4.5_A5_T3.js
@@ -0,0 +1,36 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Operator --x calls PutValue(lhs, newValue)
+description: >
+ Evaluating LeftHandSideExpression lhs returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lhs, newValue) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding object environment record is not changed.
+flags: [noStrict]
+---*/
+
+var outerScope = {
+ x: 0
+};
+var innerScope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (outerScope) {
+ with (innerScope) {
+ --x;
+ }
+}
+
+if (innerScope.x !== 1) {
+ $ERROR('#1: innerScope.x === 1. Actual: ' + (innerScope.x));
+}
+if (outerScope.x !== 0) {
+ $ERROR('#2: outerScope.x === 0. Actual: ' + (outerScope.x));
+}
diff --git a/test/language/expressions/prefix-decrement/S11.4.5_A5_T4.js b/test/language/expressions/prefix-decrement/S11.4.5_A5_T4.js
new file mode 100755
index 0000000000000000000000000000000000000000..58476799a391c4bb634884cd5dfab1e6e3a7b2c0
--- /dev/null
+++ b/test/language/expressions/prefix-decrement/S11.4.5_A5_T4.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Operator --x calls PutValue(lhs, newValue)
+description: >
+ Evaluating LeftHandSideExpression lhs returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lhs, newValue) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when '--x' is in strict-mode code and the
+ original binding is no longer present.
+flags: [noStrict]
+---*/
+
+var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (scope) {
+ (function() {
+ "use strict";
+ --x;
+ })();
+}
+
+if (scope.x !== 1) {
+ $ERROR('#1: scope.x === 1. Actual: ' + (scope.x));
+}
diff --git a/test/language/expressions/prefix-decrement/S11.4.5_A5_T5.js b/test/language/expressions/prefix-decrement/S11.4.5_A5_T5.js
new file mode 100755
index 0000000000000000000000000000000000000000..2bfe66d60602baef967957d6285b7c630fce93e8
--- /dev/null
+++ b/test/language/expressions/prefix-decrement/S11.4.5_A5_T5.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Operator --x calls PutValue(lhs, newValue)
+description: >
+ Evaluating LeftHandSideExpression lhs returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lhs, newValue) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when '--x' is in strict-mode code and the
+ original binding is no longer present.
+includes:
+ - fnGlobalObject.js
+---*/
+
+Object.defineProperty(fnGlobalObject(), "x", {
+ configurable: true,
+ get: function() {
+ delete this.x;
+ return 2;
+ }
+});
+
+(function() {
+ "use strict";
+ --x;
+})();
+
+if (fnGlobalObject().x !== 1) {
+ $ERROR('#1: fnGlobalObject().x === 1. Actual: ' + (fnGlobalObject().x));
+}
diff --git a/test/language/expressions/prefix-increment/S11.4.4_A5_T1.js b/test/language/expressions/prefix-increment/S11.4.4_A5_T1.js
new file mode 100755
index 0000000000000000000000000000000000000000..f01ee32aba330d474ec2fe516a1c006e31cb771f
--- /dev/null
+++ b/test/language/expressions/prefix-increment/S11.4.4_A5_T1.js
@@ -0,0 +1,35 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Operator ++x calls PutValue(lhs, newValue)
+description: >
+ Evaluating LeftHandSideExpression lhs returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lhs, newValue) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding function environment record is not changed.
+flags: [noStrict]
+---*/
+
+function testFunction() {
+ var x = 0;
+ var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+ };
+
+ with (scope) {
+ ++x;
+ }
+
+ if (scope.x !== 3) {
+ $ERROR('#1: scope.x === 3. Actual: ' + (scope.x));
+ }
+ if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+ }
+}
+testFunction();
diff --git a/test/language/expressions/prefix-increment/S11.4.4_A5_T2.js b/test/language/expressions/prefix-increment/S11.4.4_A5_T2.js
new file mode 100755
index 0000000000000000000000000000000000000000..09f0d48a438a3022de7f30ad9ff8d2cd3c5f8136
--- /dev/null
+++ b/test/language/expressions/prefix-increment/S11.4.4_A5_T2.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Operator ++x calls PutValue(lhs, newValue)
+description: >
+ Evaluating LeftHandSideExpression lhs returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lhs, newValue) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding global environment record is not changed.
+flags: [noStrict]
+---*/
+
+var x = 0;
+var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (scope) {
+ ++x;
+}
+
+if (scope.x !== 3) {
+ $ERROR('#1: scope.x === 3. Actual: ' + (scope.x));
+}
+if (x !== 0) {
+ $ERROR('#2: x === 0. Actual: ' + (x));
+}
diff --git a/test/language/expressions/prefix-increment/S11.4.4_A5_T3.js b/test/language/expressions/prefix-increment/S11.4.4_A5_T3.js
new file mode 100755
index 0000000000000000000000000000000000000000..f9cf3cebed0aa7be791f49a90fb69734dc2cd57e
--- /dev/null
+++ b/test/language/expressions/prefix-increment/S11.4.4_A5_T3.js
@@ -0,0 +1,36 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Operator ++x calls PutValue(lhs, newValue)
+description: >
+ Evaluating LeftHandSideExpression lhs returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lhs, newValue) uses the initially
+ created Reference even if the environment binding is no longer present.
+ Binding in surrounding object environment record is not changed.
+flags: [noStrict]
+---*/
+
+var outerScope = {
+ x: 0
+};
+var innerScope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (outerScope) {
+ with (innerScope) {
+ ++x;
+ }
+}
+
+if (innerScope.x !== 3) {
+ $ERROR('#1: innerScope.x === 3. Actual: ' + (innerScope.x));
+}
+if (outerScope.x !== 0) {
+ $ERROR('#2: outerScope.x === 0. Actual: ' + (outerScope.x));
+}
diff --git a/test/language/expressions/prefix-increment/S11.4.4_A5_T4.js b/test/language/expressions/prefix-increment/S11.4.4_A5_T4.js
new file mode 100755
index 0000000000000000000000000000000000000000..12178597b8bab4f5255af8325d1ac83014181cc1
--- /dev/null
+++ b/test/language/expressions/prefix-increment/S11.4.4_A5_T4.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Operator ++x calls PutValue(lhs, newValue)
+description: >
+ Evaluating LeftHandSideExpression lhs returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lhs, newValue) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when '++x' is in strict-mode code and the
+ original binding is no longer present.
+flags: [noStrict]
+---*/
+
+var scope = {
+ get x() {
+ delete this.x;
+ return 2;
+ }
+};
+
+with (scope) {
+ (function() {
+ "use strict";
+ ++x;
+ })();
+}
+
+if (scope.x !== 3) {
+ $ERROR('#1: scope.x === 3. Actual: ' + (scope.x));
+}
diff --git a/test/language/expressions/prefix-increment/S11.4.4_A5_T5.js b/test/language/expressions/prefix-increment/S11.4.4_A5_T5.js
new file mode 100755
index 0000000000000000000000000000000000000000..8702266b9b4c507a55b006ac51dd47ca99cc411c
--- /dev/null
+++ b/test/language/expressions/prefix-increment/S11.4.4_A5_T5.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2014 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+info: Operator ++x calls PutValue(lhs, newValue)
+description: >
+ Evaluating LeftHandSideExpression lhs returns Reference type; Reference
+ base value is an environment record and environment record kind is
+ object environment record. PutValue(lhs, newValue) uses the initially
+ created Reference even if the environment binding is no longer present.
+ No ReferenceError is thrown when '++x' is in strict-mode code and the
+ original binding is no longer present.
+includes:
+ - fnGlobalObject.js
+---*/
+
+Object.defineProperty(fnGlobalObject(), "x", {
+ configurable: true,
+ get: function() {
+ delete this.x;
+ return 2;
+ }
+});
+
+(function() {
+ "use strict";
+ ++x;
+})();
+
+if (fnGlobalObject().x !== 3) {
+ $ERROR('#1: fnGlobalObject().x === 3. Actual: ' + (fnGlobalObject().x));
+}