ladybird/Libraries/LibJS/Tests/class-basic.js

load("test-common.js");

try {
    class X {
        constructor() {
            this.x = 3;
        }
        getX() {
            return 3;
        }

        init() {
            this.y = 3;
        }
    }

    assert(X.name === "X");
    assert(X.length === 0);

    class Y extends X {
        init() {
            super.init();
            this.y += 3;
        }
    }

    assert(new Y().getX() === 3);
    assert(new Y().x === 3);

    let x = new X();
    assert(x.x === 3);
    assert(x.getX() === 3);

    let y = new Y();
    assert(y.x === 3);
    assert(y.y === undefined);
    y.init();
    assert(y.y === 6);
    assert(y.hasOwnProperty("y"));

    class Foo {
        constructor(x) {
            this.x = x;
        }
    }
    assert(Foo.length === 1);

    class Bar extends Foo {
        constructor() {
            super(5);
        }
    }

    class Baz {
        "constructor"() {
            this.foo = 55;
            this._bar = 33;
        }

        get bar() {
            return this._bar;
        }

        set bar(value) {
            this._bar = value;
        }

        ["get" + "Foo"]() {
            return this.foo;
        }

        static get staticFoo() {
            assert(this === Baz);
            return 11;
        }
    }


    let barPropertyDescriptor = Object.getOwnPropertyDescriptor(Baz.prototype, "bar");
    assert(barPropertyDescriptor.get.name === "get bar");
    assert(barPropertyDescriptor.set.name === "set bar");

    let baz = new Baz();
    assert(baz.foo === 55);
    assert(baz.bar === 33);
    baz.bar = 22;
    assert(baz.bar === 22);

    assert(baz.getFoo() === 55);
    assert(Baz.staticFoo === 11);

    assert(new Bar().x === 5);

    class ExtendsFunction extends function () { this.foo = 22; } { }
    assert(new ExtendsFunction().foo === 22);

    class ExtendsString extends String { }
    assert(new ExtendsString() instanceof String);
    assert(new ExtendsString() instanceof ExtendsString);
    assert(new ExtendsString("abc").charAt(1) === "b");

    class MyWeirdString extends ExtendsString {
        charAt(i) {
            return "#" + super.charAt(i);
        }
    }
    assert(new MyWeirdString("abc").charAt(1) === "#b")

    class ExtendsNull extends null { }

    assertThrowsError(() => {
        new ExtendsNull();
    }, {
        error: ReferenceError
    });
    assert(Object.getPrototypeOf(ExtendsNull.prototype) === null);

    class ExtendsClassExpression extends class { constructor(x) { this.x = x; } } {
        constructor(y) {
            super(5);
            this.y = 6;
        }
    }
    let extendsClassExpression = new ExtendsClassExpression();
    assert(extendsClassExpression.x === 5);
    assert(extendsClassExpression.y === 6);

    class InStrictMode {
        constructor() {
            assert(isStrictMode());
        }

        method() {
            assert(isStrictMode());
        }
    }

    let resultOfAnExpression = new (class {
        constructor(x) {
            this.x = x;
        }
        getX() {
            return this.x + 10;
        }
    })(55);
    assert(resultOfAnExpression.x === 55);
    assert(resultOfAnExpression.getX() === 65);

    let ClassExpression = class Foo { };
    assert(ClassExpression.name === "Foo");

    new InStrictMode().method();
    assert(!isStrictMode());

    assertIsSyntaxError(`
        class GetterWithArgument {
            get foo(bar) {
                return 0;
            }
        }
    `);

    assertIsSyntaxError(`
        class SetterWithNoArgumetns {
            set foo() {
            }
        }
    `);

    assertIsSyntaxError(`
        class SetterWithMoreThanOneArgument {
            set foo(bar, baz) {
            }
        }
    `);

    assertIsSyntaxError(`
        class FooBase {}
        class IsASyntaxError extends FooBase {
            bar() {
                function f() { super.baz; }
            }
        }
    `);

    assertIsSyntaxError(`
        class NoBaseSuper {
            constructor() {
                super();
            }
        }
    `);

    assertThrowsError(() => {
        class BadExtends extends 3 { }

    }, {
        error: TypeError
    });

    assertThrowsError(() => {
        class BadExtends extends undefined { }
    }, {
        error: TypeError
    });

    class SuperNotASyntaxError {
        bar() {
            () => { super.baz };
        }
    }

    class SuperNoBasePropertyLookup {
        constructor() {
            super.foo;
        }
    }

    assertThrowsError(() => {
        class Base { }
        class DerivedDoesntCallSuper extends Base {
            constructor() {
                this;
            }
        }

        new DerivedDoesntCallSuper();
    }, {
        error: ReferenceError,
    });
    assertThrowsError(() => {
        class Base { }
        class CallsSuperTwice extends Base {
            constructor() {
                super();
                super();
            }
        }

        new CallsSuperTwice();
    }, {
        error: ReferenceError,
    });

    console.log("PASS");
} catch (e) {
    console.log("FAIL: " + e);
}