tests: +33 across canonical / classes / exceptions

test_canonical_extras.omc (11):
  explicit-parens preservation, multi-fn order, nested-fn
  canonicalization, recursive-call name preservation, try/catch
  err-var rename, class-method param rename, lambda param rename,
  arithmetic-through-rename, indentation/newline invariance,
  inline-comment stripping, empty-body.

test_classes_extras.omc (11):
  basic construction, method dispatch, self.field access,
  inheritance override (Dog.speak vs Animal.speak), inherited
  method (Animal.name_str), two-level chain (Puppy → Dog → Animal),
  is_instance self / parent / grandparent / unrelated / non-instance.

test_exceptions_extras.omc (11):
  try-no-throw, basic throw/catch, finally on success and on
  failure, dict / array typed exceptions, nested inner/outer
  catch, rethrow propagation, throw across function boundary,
  catch by class via is_instance, most-specific class wins.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: RandomCoder-lab

examples/tests/test_canonical_extras.omc

@@ -0,0 +1,95 @@
+# More canonical / structural-equivalence tests.
+
+fn assert_eq(actual, expected, msg) {
+    if actual != expected {
+        test_record_failure(msg + ": expected " + to_string(expected) + " got " + to_string(actual));
+    }
+}
+
+fn assert_true(cond, msg) { if !cond { test_record_failure(msg); } }
+
+# Operator precedence preserved by canonical (parens are explicit)
+fn test_canonical_parens_explicit() {
+    h c1 = omc_code_canonical("h x = a + b * c;");
+    h c2 = omc_code_canonical("h x = a + (b * c);");
+    # Canonical inserts explicit parens, so both should match.
+    assert_eq(c1, c2, "canonical adds explicit parens");
+}
+
+# Multiple functions preserve order.
+fn test_canonical_multi_fn_order() {
+    h c1 = omc_code_canonical("fn a() { return 1; } fn b() { return 2; }");
+    h c2 = omc_code_canonical("fn a() { return 1; } fn b() { return 2; }");
+    assert_eq(c1, c2, "order preserved");
+}
+
+# Nested function definitions canonicalize independently.
+fn test_canonical_nested_fn() {
+    h c1 = omc_code_canonical("fn outer() { fn inner(x) { return x; } return inner(1); }");
+    h c2 = omc_code_canonical("fn outer() { fn inner(y) { return y; } return inner(1); }");
+    assert_eq(c1, c2, "nested params normalize");
+}
+
+# Recursive calls preserve name.
+fn test_canonical_recursive() {
+    h c1 = omc_code_canonical("fn fact(n) { if n <= 1 { return 1; } return n * fact(n - 1); }");
+    h c2 = omc_code_canonical("fn fact(m) { if m <= 1 { return 1; } return m * fact(m - 1); }");
+    assert_eq(c1, c2, "recursive call name preserved");
+}
+
+# Try/catch/finally invariance.
+fn test_canonical_try_catch() {
+    h c1 = omc_code_canonical("fn f() { try { return 1; } catch e { return 0; } }");
+    h c2 = omc_code_canonical("fn f() { try { return 1; } catch err { return 0; } }");
+    assert_eq(c1, c2, "catch var renamed");
+}
+
+# Class definitions canonicalize methods independently.
+fn test_canonical_class_methods() {
+    h c1 = omc_code_canonical("class P { x; fn get(self) { return dict_get(self, \"x\"); } }");
+    h c2 = omc_code_canonical("class P { x; fn get(this) { return dict_get(this, \"x\"); } }");
+    assert_eq(c1, c2, "method params canonicalize");
+}
+
+# Lambda invariance.
+fn test_canonical_lambda_in_call() {
+    h c1 = omc_code_canonical("h ys = arr_map(xs, fn(v) { return v * 2; });");
+    h c2 = omc_code_canonical("h ys = arr_map(xs, fn(x) { return x * 2; });");
+    assert_eq(c1, c2, "lambda param renamed");
+}
+
+# Match canonical with bind patterns (skipped — parser doesn't accept return
+# directly as arm body in this position; tested elsewhere).
+
+# Arithmetic semantics preserved.
+fn test_canonical_arith() {
+    h c1 = omc_code_canonical("fn f(x) { return x * 2 + 1; }");
+    h c2 = omc_code_canonical("fn f(y) { return y * 2 + 1; }");
+    assert_eq(c1, c2, "rename through arithmetic");
+
+    h c3 = omc_code_canonical("fn f(x) { return x * 3 + 1; }");
+    assert_true(c1 != c3, "literal change matters");
+}
+
+# Multi-line whitespace differences.
+fn test_canonical_indentation() {
+    h c1 = omc_code_canonical("fn f(x) {\n    return x;\n}");
+    h c2 = omc_code_canonical("fn f(x){\nreturn x;\n}");
+    h c3 = omc_code_canonical("fn f(x) {return x;}");
+    assert_eq(c1, c2, "indentation ignored");
+    assert_eq(c1, c3, "newlines ignored");
+}
+
+# Comments stripped consistently.
+fn test_canonical_inline_comments() {
+    h c1 = omc_code_canonical("fn f(x) { return x; }");
+    h c2 = omc_code_canonical("fn f(x) { # comment\n return x; # trailing\n}");
+    assert_eq(c1, c2, "inline comments stripped");
+}
+
+# Empty function body.
+fn test_canonical_empty_fn() {
+    h c1 = omc_code_canonical("fn empty() {}");
+    h c2 = omc_code_canonical("fn empty() {\n\n\n}");
+    assert_eq(c1, c2, "empty body");
+}

examples/tests/test_classes_extras.omc

@@ -0,0 +1,90 @@
+# More class / inheritance tests.
+
+fn assert_eq(actual, expected, msg) {
+    if actual != expected {
+        test_record_failure(msg + ": expected " + to_string(expected) + " got " + to_string(actual));
+    }
+}
+
+fn assert_true(cond, msg) { if !cond { test_record_failure(msg); } }
+
+class Animal {
+    name;
+    fn speak(self) { return "generic"; }
+    fn name_str(self) { return dict_get(self, "name"); }
+}
+
+class Dog extends Animal {
+    name;
+    fn speak(self) { return "woof"; }
+}
+
+class Puppy extends Dog {
+    name;
+}
+
+# Basic construction
+fn test_class_construction() {
+    h a = Animal("zoe");
+    assert_eq(dict_get(a, "name"), "zoe", "name field set");
+}
+
+fn test_class_method_call() {
+    h a = Animal("zoe");
+    assert_eq(a.speak(), "generic", "Animal speaks generic");
+}
+
+fn test_class_method_self_access() {
+    h a = Animal("zoe");
+    assert_eq(a.name_str(), "zoe", "method reads self.name");
+}
+
+# Inheritance: child overrides parent
+fn test_inheritance_override() {
+    h d = Dog("rex");
+    assert_eq(d.speak(), "woof", "Dog overrides speak");
+}
+
+fn test_inheritance_inherits_method() {
+    h d = Dog("rex");
+    # Inherits name_str from Animal.
+    assert_eq(d.name_str(), "rex", "inherits Animal.name_str");
+}
+
+# Two-level inheritance
+fn test_inheritance_two_levels() {
+    h p = Puppy("tiny");
+    # Puppy inherits Dog.speak (which overrode Animal.speak).
+    assert_eq(p.speak(), "woof", "two-level dispatch");
+    # And Puppy inherits Animal.name_str transitively.
+    assert_eq(p.name_str(), "tiny", "transitive inheritance");
+}
+
+# is_instance walks the chain
+fn test_is_instance_self() {
+    h d = Dog("x");
+    assert_eq(is_instance(d, "Dog"), 1, "is Dog");
+}
+
+fn test_is_instance_parent() {
+    h d = Dog("x");
+    assert_eq(is_instance(d, "Animal"), 1, "is Animal too");
+}
+
+fn test_is_instance_grandparent() {
+    h p = Puppy("x");
+    assert_eq(is_instance(p, "Animal"), 1, "Puppy is Animal");
+    assert_eq(is_instance(p, "Dog"), 1, "Puppy is Dog");
+    assert_eq(is_instance(p, "Puppy"), 1, "Puppy is Puppy");
+}
+
+fn test_is_instance_unrelated() {
+    h p = Puppy("x");
+    assert_eq(is_instance(p, "Cat"), 0, "Puppy is not Cat");
+}
+
+fn test_is_instance_non_instance() {
+    assert_eq(is_instance(42, "Anything"), 0, "int is not class instance");
+    assert_eq(is_instance("hello", "Anything"), 0, "string is not class instance");
+    assert_eq(is_instance([1, 2], "Anything"), 0, "array is not class instance");
+}

examples/tests/test_exceptions_extras.omc

@@ -0,0 +1,114 @@
+# More exception / try-catch / typed-throw tests.
+
+fn assert_eq(actual, expected, msg) {
+    if actual != expected {
+        test_record_failure(msg + ": expected " + to_string(expected) + " got " + to_string(actual));
+    }
+}
+
+fn assert_true(cond, msg) { if !cond { test_record_failure(msg); } }
+
+# Basic try/catch flow
+fn test_try_no_throw() {
+    h ran = 0;
+    try { ran = 1; } catch e { ran = 99; }
+    assert_eq(ran, 1, "no throw → no catch");
+}
+
+fn test_try_with_throw() {
+    h caught = "";
+    try { throw "boom"; } catch e { caught = e; }
+    assert_eq(caught, "boom", "caught");
+}
+
+# Finally always runs
+fn test_finally_runs_on_success() {
+    h ran = 0;
+    try { } catch e { ran = 99; } finally { ran = 1; }
+    assert_eq(ran, 1, "finally ran on success");
+}
+
+fn test_finally_runs_on_failure() {
+    h c = 0;
+    h f = 0;
+    try { throw "x"; } catch e { c = 1; } finally { f = 1; }
+    assert_eq(c, 1, "catch ran");
+    assert_eq(f, 1, "finally ran");
+}
+
+# Typed exceptions
+fn test_dict_exception() {
+    h kind = "";
+    try {
+        h err = dict_new();
+        dict_set(err, "kind", "FileNotFound");
+        throw err;
+    } catch e {
+        kind = dict_get(e, "kind");
+    }
+    assert_eq(kind, "FileNotFound", "dict kind preserved");
+}
+
+fn test_array_exception() {
+    h len = 0;
+    try { throw [1, 2, 3, 4]; } catch e { len = arr_len(e); }
+    assert_eq(len, 4, "array preserved");
+}
+
+# Nested try
+fn test_nested_inner_catches() {
+    h inner = 0;
+    h outer = 0;
+    try {
+        try { throw "x"; } catch e { inner = 1; }
+    } catch e { outer = 99; }
+    assert_eq(inner, 1, "inner ran");
+    assert_eq(outer, 0, "outer didn't run");
+}
+
+fn test_nested_rethrow_to_outer() {
+    h outer_v = "";
+    try {
+        try { throw "first"; } catch e { throw "rethrow"; }
+    } catch e { outer_v = e; }
+    assert_eq(outer_v, "rethrow", "outer sees rethrow");
+}
+
+# Throw across function boundary
+fn raises_value(v) { throw v; }
+
+fn test_throw_across_call() {
+    h caught = 0;
+    try { raises_value(42); } catch e { caught = e; }
+    assert_eq(caught, "42", "stringified");
+}
+
+# Catch by class via is_instance
+class AppError {
+    message;
+}
+class HttpError extends AppError {
+    message;
+    status;
+}
+
+fn test_catch_by_class() {
+    h handled = 0;
+    try { throw AppError("oops"); }
+    catch e {
+        if is_instance(e, "AppError") { handled = 1; }
+    }
+    assert_eq(handled, 1, "AppError caught");
+}
+
+fn test_catch_subclass_as_parent() {
+    h handled_as = "";
+    try { throw HttpError("404", 404); }
+    catch e {
+        if is_instance(e, "HttpError") { handled_as = "http"; }
+        if handled_as == "" {
+            if is_instance(e, "AppError") { handled_as = "app"; }
+        }
+    }
+    assert_eq(handled_as, "http", "most specific wins");
+}