Diffusion Ant (master) Code

ant/tests/test_private_brands.cjs
7893bae4a360master

test_private_brands.cjs
View Options

			const assert = (cond, msg) => {
			if (!cond) throw new Error(msg);
			};

			const assertThrows = (fn, name, msg) => {
			let threw = false;
			try {
			fn();
			} catch (err) {
			threw = name === undefined \|\| (err && err.name === name);
			}
			if (!threw) throw new Error(msg);
			};

			class A {
			#x = 1;

			#m() {
			return this.#x + 1;
			}

			get #g() {
			return this.#x + 2;
			}

			set #g(value) {
			this.#x = value;
			}

			has(value) {
			return #x in value;
			}

			read(value) {
			return value.#x;
			}

			write(value) {
			this.#g = value;
			}

			call() {
			return this.#m();
			}

			get value() {
			return this.#g;
			}
			}

			class B {
			#x = 99;

			has(value) {
			return #x in value;
			}
			}

			const a = new A();
			const b = new B();

			assert(a.has(a) === true, "own private brand should be present");
			assert(a.has({}) === false, "plain object should not have private brand");
			assert(a.has(b) === false, "same spelling in another class should be distinct");
			assert(b.has(b) === true, "other class should keep its own private brand");
			assertThrows(() => a.has(1), "TypeError", "private brand check right operand should be object");
			assertThrows(() => a.read({}), "TypeError", "wrong receiver private get should throw");

			a.write(10);
			assert(a.value === 12, "private accessors should read and write hidden state");
			assert(a.call() === 11, "private methods should be callable");
			assert(a["#x"] === undefined, "private field should not be a public string property");
			assert(Object.keys(a).indexOf("#x") === -1, "private field should not be enumerable");
			assert(Reflect.ownKeys(a).indexOf("#x") === -1, "private field should not be reflected");

			class S {
			static #v = 3;

			static #inc() {
			return ++this.#v;
			}

			static has(value) {
			return #v in value;
			}

			static run() {
			return this.#inc();
			}
			}

			assert(S.has(S) === true, "static private brand should be on the constructor");
			assert(S.has(new S()) === false, "static private brand should not be on instances");
			assert(S.run() === 4, "static private methods should access static private fields");

			let baseSeen = false;

			class Base {
			#base = 1;

			constructor() {
			baseSeen = #base in this;
			}

			hasBase(value) {
			return #base in value;
			}
			}

			class Derived extends Base {
			#derived = 2;

			hasDerived(value) {
			return #derived in value;
			}
			}

			const d = new Derived();
			assert(baseSeen === true, "base private fields should be initialized during construction");
			assert(d.hasBase(d) === true, "derived instances should keep base private brands");
			assert(d.hasDerived(d) === true, "derived instances should keep derived private brands");

			assertThrows(() => Function("class Bad { #x; #x; }"), "SyntaxError", "duplicate private field should be syntax error");
			assertThrows(() => Function("class Bad { #constructor; }"), "SyntaxError", "#constructor should be rejected");
			assertThrows(() => Function("class Bad { m() { return this.#missing; } }"), "SyntaxError", "undeclared private name should be syntax error");

			const makeBox = Function("return class { #x = 1; has(value) { return #x in value; } read(value) { return value.#x; } };");
			const Box1 = makeBox();
			const Box2 = makeBox();
			const box1 = new Box1();
			const box2 = new Box2();
			assert(box1.has(box2) === false, "private brands from separately compiled classes should not collide");
			assertThrows(() => box1.read(box2), "TypeError", "same source offsets from separate compiles should stay distinct");

			class ReturnObjectBase {
			constructor(value) {
			return value;
			}
			}

			class OtherStamp extends ReturnObjectBase {
			#other = 1;
			}

			class OffsetStamp extends ReturnObjectBase {
			#x = 2;

			getX() {
			return this.#x;
			}
			}

			const offsetZero = new OffsetStamp({});
			const offsetOne = {};
			new OtherStamp(offsetOne);
			new OffsetStamp(offsetOne);

			assert(OffsetStamp.prototype.getX.call(offsetZero) === 2, "cached private lookup should work at offset 0");
			assert(OffsetStamp.prototype.getX.call(offsetOne) === 2, "cached private lookup should validate and recover at offset 1");
			assert(OffsetStamp.prototype.getX.call(offsetZero) === 2, "cached private lookup should validate when returning to offset 0");

			console.log("private brand tests ok");

Owner Packages

No Owners