1 files changed, 248 insertions, 0 deletions
diff --git a/Libraries/LibJS/Tests/class-basic.js b/Libraries/LibJS/Tests/class-basic.js
new file mode 100644
index 0000000000..842efd472b
--- /dev/null
+++ b/Libraries/LibJS/Tests/class-basic.js
@@ -0,0 +1,248 @@
+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);
+}