test("basic functionality", () => {
    var called = false;
    class A {
        static {
            expect(called).toBeFalse();
            expect(this.name).toBe("A");
            called = true;
        }
    }

    expect(called).toBeTrue();
    new A();
    expect(called).toBeTrue();
});

test("called in order", () => {
    var i = 0;
    class A {
        static {
            expect(i).toBe(0);
            i++;
        }

        static method() {
            return 2;
        }

        static {
            expect(i).toBe(1);
            i++;
        }
    }

    expect(i).toBe(2);
    new A();
    expect(i).toBe(2);
});

test("correct this", () => {
    var thisValue = null;
    class A {
        static {
            thisValue = this;
        }
    }

    expect(thisValue).toBe(A);
});

describe("class like constructs can be used inside", () => {
    test("can use new.target", () => {
        let value = 1;
        class C {
            static {
                value = new.target;
            }
        }
        expect(value).toBeUndefined();
    });

    test("can use super property lookup", () => {
        function parent() {}
        parent.val = 3;

        let hit = false;
        class C extends parent {
            static {
                hit = true;
                expect(super.val).toBe(3);
            }
        }
        expect(hit).toBeTrue();
    });
});

// https://github.com/LadybirdBrowser/ladybird/pull/4226
test("declaring variables", () => {
    class A {
        static {
            const a = 1;
            let b = 2;
            var c = 3;
            function d() {}

            expect(a).toBe(1);
            expect(b).toBe(2);
            expect(c).toBe(3);
            expect(typeof d).toBe("function");
        }
    }
});

test("await binding names in nested functions", () => {
    class A {
        static {
            const makeGenerator = function* await(await) {
                yield await;
            };

            const generator = makeGenerator(42);
            expect(generator.next()).toEqual({ value: 42, done: false });
            expect(generator.next()).toEqual({ value: undefined, done: true });

            (function await(await) {
                expect(await).toBe(42);
            })(42);
        }
    }
});

test("await binding names in static blocks without a function boundary", () => {
    expect(`class A { static { await => 0; } }`).not.toEval();
    expect(`class A { static { async function await() {} } }`).not.toEval();
});
