refactor: move benchmark directory under test and update all references

The benchmark directory is relocated from the project root into the test directory, and all scripts, documentation links, and gitignore paths are updated accordingly. The test runner is also refactored to explicitly walk subdirectories (core, io, language, limit) instead of using a single test root, and a new test/README.md is added to document the test suite structure. Additionally, the constructor test for the Foo class is updated to add a zero-arity constructor and adjust expected output strings.

test/language/super/call_different_arity.wren

@@ -0,0 +1,20 @@
+class Base {
+  foo { IO.print("Base.foo") }
+  foo(a) { IO.print("Base.foo(a)") }
+  foo(a, b) { IO.print("Base.foo(a, b)") }
+}
+
+class Derived is Base {
+  foo(a) {
+    IO.print("Derived.bar(a)")
+    super
+    super(1)
+    super(1, 2)
+  }
+}
+
+(new Derived).foo(1)
+// expect: Derived.bar(a)
+// expect: Base.foo
+// expect: Base.foo(a)
+// expect: Base.foo(a, b)

test/language/super/call_other_method.wren

@@ -0,0 +1,19 @@
+class Base {
+  foo {
+    IO.print("Base.foo")
+  }
+}
+
+class Derived is Base {
+  bar {
+    IO.print("Derived.bar")
+    super.foo
+  }
+}
+
+(new Derived).bar
+// expect: Derived.bar
+// expect: Base.foo
+
+// TODO: Super operator calls.
+// TODO: Super setter calls.

test/language/super/call_same_method.wren

@@ -0,0 +1,16 @@
+class Base {
+  foo {
+    IO.print("Base.foo")
+  }
+}
+
+class Derived is Base {
+  foo {
+    IO.print("Derived.foo")
+    super.foo
+  }
+}
+
+(new Derived).foo
+// expect: Derived.foo
+// expect: Base.foo

test/language/super/closure.wren

@@ -0,0 +1,11 @@
+class Base {
+  toString { "Base" }
+}
+
+class Derived is Base {
+  getClosure { new Fn { super.toString } }
+  toString { "Derived" }
+}
+
+var closure = (new Derived).getClosure
+IO.print(closure.call()) // expect: Base

test/language/super/implicit_name.wren

@@ -0,0 +1,16 @@
+class Base {
+  foo {
+    IO.print("Base.foo")
+  }
+}
+
+class Derived is Base {
+  foo {
+    IO.print("Derived.foo")
+    super
+  }
+}
+
+(new Derived).foo
+// expect: Derived.foo
+// expect: Base.foo

test/language/super/indirectly_inherited.wren

@@ -0,0 +1,18 @@
+class A {
+  foo {
+    IO.print("A.foo")
+  }
+}
+
+class B is A {}
+
+class C is B {
+  foo {
+    IO.print("C.foo")
+    super.foo
+  }
+}
+
+(new C).foo
+// expect: C.foo
+// expect: A.foo

test/language/super/no_superclass_method.wren

@@ -0,0 +1,7 @@
+class Base {}
+
+class Derived is Base {
+  foo { super.doesNotExist(1) } // expect runtime error: Base does not implement 'doesNotExist(_)'.
+}
+
+(new Derived).foo

test/language/super/super_at_top_level.wren

@@ -0,0 +1,4 @@
+super.foo // expect error
+super // expect error
+super.foo("bar") // expect error
+super("foo") // expect error

test/language/super/super_in_static_method.wren

@@ -0,0 +1,5 @@
+class Foo {
+  static method {
+    super // expect error
+  }
+}

test/language/super/super_in_top_level_function.wren

@@ -0,0 +1,3 @@
+new Fn {
+  super.foo // expect error
+}