From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Sun, 7 Apr 2024 21:33:14 +0200
Subject: Adding upstream version 115.7.0esr.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 js/src/tests/non262/class/superPropHomeObject.js | 61 ++++++++++++++++++++++++
 1 file changed, 61 insertions(+)
 create mode 100644 js/src/tests/non262/class/superPropHomeObject.js

(limited to 'js/src/tests/non262/class/superPropHomeObject.js')

diff --git a/js/src/tests/non262/class/superPropHomeObject.js b/js/src/tests/non262/class/superPropHomeObject.js
new file mode 100644
index 0000000000..b23c115dd5
--- /dev/null
+++ b/js/src/tests/non262/class/superPropHomeObject.js
@@ -0,0 +1,61 @@
+// This is super weird. A super property reference in the spec contains two
+// things. The first is the object to do the lookup on, the super base. This
+// should be unchanged, no matter what's going on: I can move the method to
+// another object. I can pull it out as its own function. I can put it on my
+// head and run around the front yard. No changes. The other half, the |this|
+// for invoked calls, is the this at the time of referencing the property, which
+// means it's gonna vary wildly as stuff gets moved around.
+
+class base {
+    constructor() { }
+    test(expectedThis) { assertEq(this, expectedThis); }
+}
+
+class derived extends base {
+    constructor() { super(); }
+    test(expected) { super.test(expected); }
+    testArrow() { return (() => super.test(this)); }
+    ["testCPN"](expected) { super.test(expected); }
+}
+
+let derivedInstance = new derived();
+derivedInstance.test(derivedInstance);
+derivedInstance.testCPN(derivedInstance);
+
+let obj = { test: derivedInstance.test };
+obj.test(obj);
+
+// Classes are strict, so primitives are not boxed/turned into globals
+let testSolo = derivedInstance.test;
+testSolo(undefined);
+
+let anotherObject = { };
+derivedInstance.test.call(anotherObject, anotherObject);
+
+let strThis = "this is not an object!";
+derivedInstance.test.call(strThis, strThis);
+
+// You can take the arrow function out of the super, ... or something like that
+let arrowTest = derivedInstance.testArrow();
+arrowTest();
+
+// There's no magic "super script index" per code location.
+class base1 {
+    constructor() { }
+    test() { return "llama"; }
+}
+class base2 {
+    constructor() { }
+    test() { return "alpaca"; }
+}
+
+let animals = [];
+for (let exprBase of [base1, base2])
+    new class extends exprBase {
+        constructor() { super(); }
+        test() { animals.push(super["test"]()); }
+    }().test();
+assertDeepEq(animals, ["llama", "alpaca"]);
+
+if (typeof reportCompare === 'function')
+    reportCompare(0,0,"OK");
-- 
cgit v1.2.3