Object-setProperty-01.js

// tests calling script functions via Debugger.Object.prototype.setProperty

"use strict";

var global = newGlobal({newCompartment: true});

var dbg = new Debugger(global);

dbg.onDebuggerStatement = onDebuggerStatement;

global.eval(`

const sym = Symbol("a symbol key");

const arr = [];

const obj = {

    set stringNormal(value) {

        this._stringNormal = value;

},

    set stringAbrupt(value) {

        throw value;

},

    set objectNormal(value) {

        this._objectNormal = value;

},

    set objectAbrupt(value) {

        throw value;

},

    set context(value) {

        this._context = this;

},

    set 1234(value) {

        this._1234 = value;

},

    set [sym](value) {

        this._sym = value;

},

    get getterOnly() {},

    readOnly: "",

    stringProp: "",

    objProp: {},

};

Object.defineProperty(obj, "readOnly", { writable: false });

const objChild = Object.create(obj);

const proxyChild = new Proxy(obj, {});

const testObj = { };

const testChildObj = { };

const testProxyObj = { };

debugger;

`);

function onDebuggerStatement(frame) {

    const { environment } = frame;

    const sym = environment.getVariable("sym");

    const arr = environment.getVariable("arr");

    const obj = environment.getVariable("obj");

    const objChild = environment.getVariable("objChild");

    const proxyChild = environment.getVariable("proxyChild");

    assertEq(arr.setProperty(1, "index 1").return, true);

    assertEq(arr.getProperty(1).return, "index 1");

    assertEq(arr.getProperty("1").return, "index 1");

    assertEq(arr.getProperty(0).return, undefined);

    assertEq(arr.getProperty("length").return, 2);

    assertEq(arr.setProperty("2", "index 2").return, true);

    assertEq(arr.getProperty(2).return, "index 2");

    assertEq(arr.getProperty("2").return, "index 2");

    assertEq(arr.getProperty(0).return, undefined);

    assertEq(arr.getProperty("length").return, 3);

    const testObj = environment.getVariable("testObj");

    assertEq(obj.setProperty("undefined", 123).return, true);

    assertEq(obj.getProperty("undefined").return, 123);

    assertEq(obj.setProperty().return, true);

    assertEq(obj.getProperty("undefined").return, undefined);

    assertEq(obj.setProperty("missing", 42).return, true);

    assertEq(obj.getProperty("missing").return, 42);

    assertEq(obj.setProperty("stringNormal", "a normal value").return, true);

    assertEq(obj.getProperty("_stringNormal").return, "a normal value");

    assertEq(obj.setProperty("stringAbrupt", "an abrupt value").throw, "an abrupt value");

    assertEq(obj.setProperty("objectNormal", testObj).return, true);

    assertEq(obj.getProperty("_objectNormal").return, testObj);

    assertEq(obj.setProperty("objectAbrupt", testObj).throw, testObj);

    assertEq(obj.setProperty("context", "a value").return, true);

    assertEq(obj.getProperty("_context").return, obj);

    assertEq(obj.setProperty(1234, "number value").return, true);

    assertEq(obj.getProperty("_1234").return, "number value");

    assertEq(obj.setProperty(sym, "symbol value").return, true);

    assertEq(obj.getProperty("_sym").return, "symbol value");

    assertEq(obj.setProperty("getterOnly", "a value").return, false);

    assertEq(obj.setProperty("readOnly", "a value").return, false);

    assertEq(obj.setProperty("stringProp", "a normal value").return, true);

    assertEq(obj.getProperty("stringProp").return, "a normal value");

    assertEq(obj.setProperty("objectProp", testObj).return, true);

    assertEq(obj.getProperty("objectProp").return, testObj);

    const testChildObj = environment.getVariable("testChildObj");

    assertEq(objChild.setProperty("undefined", 123).return, true);

    assertEq(objChild.getProperty("undefined").return, 123);

    assertEq(objChild.setProperty().return, true);

    assertEq(objChild.getProperty("undefined").return, undefined);

    assertEq(objChild.setProperty("missing", 42).return, true);

    assertEq(objChild.getProperty("missing").return, 42);

    assertEq(objChild.setProperty("stringNormal", "a normal child value").return, true);

    assertEq(objChild.getProperty("_stringNormal").return, "a normal child value");

    assertEq(objChild.setProperty("stringAbrupt", "an abrupt child value").throw, "an abrupt child value");

    assertEq(objChild.setProperty("objectNormal", testChildObj).return, true);

    assertEq(objChild.getProperty("_objectNormal").return, testChildObj);

    assertEq(objChild.setProperty("objectAbrupt", testChildObj).throw, testChildObj);

    assertEq(objChild.setProperty("context", "a value").return, true);

    assertEq(objChild.getProperty("_context").return, objChild);

    assertEq(objChild.setProperty(1234, "number value").return, true);

    assertEq(objChild.getProperty("_1234").return, "number value");

    assertEq(objChild.setProperty(sym, "symbol value").return, true);

    assertEq(objChild.getProperty("_sym").return, "symbol value");

    assertEq(objChild.setProperty("getterOnly", "a value").return, false);

    assertEq(objChild.setProperty("readOnly", "a value").return, false);

    assertEq(objChild.setProperty("stringProp", "a normal child value").return, true);

    assertEq(objChild.getProperty("stringProp").return, "a normal child value");

    assertEq(objChild.setProperty("objectProp", testChildObj).return, true);

    assertEq(objChild.getProperty("objectProp").return, testChildObj);

    const testProxyObj = environment.getVariable("testProxyObj");

    assertEq(proxyChild.setProperty("undefined", 123).return, true);

    assertEq(proxyChild.getProperty("undefined").return, 123);

    assertEq(proxyChild.setProperty().return, true);

    assertEq(proxyChild.getProperty("undefined").return, undefined);

    assertEq(proxyChild.setProperty("missing", 42).return, true);

    assertEq(proxyChild.getProperty("missing").return, 42);

    assertEq(proxyChild.setProperty("stringNormal", "a normal child value").return, true);

    assertEq(proxyChild.getProperty("_stringNormal").return, "a normal child value");

    assertEq(proxyChild.setProperty("stringAbrupt", "an abrupt child value").throw, "an abrupt child value");

    assertEq(proxyChild.setProperty("objectNormal", testProxyObj).return, true);

    assertEq(proxyChild.getProperty("_objectNormal").return, testProxyObj);

    assertEq(proxyChild.setProperty("objectAbrupt", testProxyObj).throw, testProxyObj);

    assertEq(proxyChild.setProperty("context", "a value").return, true);

    assertEq(proxyChild.getProperty("_context").return, proxyChild);

    assertEq(proxyChild.setProperty(1234, "number value").return, true);

    assertEq(proxyChild.getProperty("_1234").return, "number value");

    assertEq(proxyChild.setProperty(sym, "symbol value").return, true);

    assertEq(proxyChild.getProperty("_sym").return, "symbol value");

    assertEq(proxyChild.setProperty("getterOnly", "a value").return, false);

    assertEq(proxyChild.setProperty("readOnly", "a value").return, false);

    assertEq(proxyChild.setProperty("stringProp", "a normal child value").return, true);

    assertEq(proxyChild.getProperty("stringProp").return, "a normal child value");

    assertEq(proxyChild.setProperty("objectProp", testProxyObj).return, true);

    assertEq(proxyChild.getProperty("objectProp").return, testProxyObj);

};