tests: +30 across broadcasting / f-strings / regex

test_broadcasting_extras.omc (10):
  scalar broadcast lhs/rhs, elementwise sub/mul, 2D add same shape,
  2D + row-vector broadcast, arr_neg with negative, arr_scale,
  arr_div_int with division-by-zero handling, outer-product
  composition.

test_fstring_extras.omc (10):
  simple int interp, arithmetic in subst, no-subs literal,
  empty f-string, multiple subs, escaped braces, function call
  in subst, float interp, string interp.

test_regex_extras.omc (10):
  anchored ^...$, basic substring match, find_all digits, replace
  basic + all-occurrences, find first, split CSV, special chars
  (literal dot, shorthand classes), optional ?, one-or-more +.

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

Author: RandomCoder-lab

examples/tests/test_broadcasting_extras.omc

@@ -0,0 +1,85 @@
+# More broadcasting + 2D array op coverage.
+
+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); } }
+
+# Scalar broadcast on arr_add
+fn test_arr_add_scalar_lhs() {
+    h r = arr_add(10, [1, 2, 3]);
+    assert_eq(arr_get(r, 0), 11, "10+1");
+    assert_eq(arr_get(r, 2), 13, "10+3");
+}
+
+fn test_arr_add_scalar_rhs() {
+    h r = arr_add([1, 2, 3], 10);
+    assert_eq(arr_get(r, 0), 11, "1+10");
+}
+
+# Elementwise 1D
+fn test_arr_sub_elementwise() {
+    h r = arr_sub([10, 20, 30], [1, 2, 3]);
+    assert_eq(arr_get(r, 0), 9, "10-1");
+    assert_eq(arr_get(r, 1), 18, "20-2");
+    assert_eq(arr_get(r, 2), 27, "30-3");
+}
+
+fn test_arr_mul_elementwise() {
+    h r = arr_mul([1, 2, 3], [4, 5, 6]);
+    assert_eq(arr_get(r, 0), 4, "1*4");
+    assert_eq(arr_get(r, 2), 18, "3*6");
+}
+
+# 2D add
+fn test_2d_add_same_shape() {
+    h A = [[1, 2], [3, 4]];
+    h B = [[10, 20], [30, 40]];
+    h C = arr_add(A, B);
+    h r0 = arr_get(C, 0);
+    h r1 = arr_get(C, 1);
+    assert_eq(arr_get(r0, 0), 11, "(0,0)");
+    assert_eq(arr_get(r1, 1), 44, "(1,1)");
+}
+
+# 2D broadcast 1D row
+fn test_2d_plus_row_broadcast() {
+    h A = [[1, 2, 3], [10, 20, 30]];
+    h bias = [100, 200, 300];
+    h C = arr_add(A, bias);
+    h r0 = arr_get(C, 0);
+    assert_eq(arr_get(r0, 0), 101, "broadcast row");
+}
+
+# arr_neg
+fn test_arr_neg() {
+    h r = arr_neg([1, 0 - 2, 3]);
+    assert_eq(arr_get(r, 0), 0 - 1, "neg 1");
+    assert_eq(arr_get(r, 1), 2, "neg -2");
+}
+
+# arr_scale
+fn test_arr_scale() {
+    h r = arr_scale([1, 2, 3], 10);
+    assert_eq(arr_get(r, 0), 10, "1*10");
+    assert_eq(arr_get(r, 2), 30, "3*10");
+}
+
+# arr_div_int with zero
+fn test_arr_div_int_with_zero() {
+    h r = arr_div_int([10, 20, 30], [2, 0, 3]);
+    assert_eq(arr_get(r, 0), 5, "10/2");
+    assert_eq(arr_get(r, 1), 0, "div by 0 = 0");
+    assert_eq(arr_get(r, 2), 10, "30/3");
+}
+
+# Composition: outer-product-then-sum
+fn test_outer_sum_composition() {
+    h o = arr_outer([1.0, 2.0], [3.0, 4.0]);
+    h r0 = arr_get(o, 0);  # [3, 4]
+    h sum0 = arr_sum_int([arr_get(r0, 0), arr_get(r0, 1)]);
+    assert_eq(sum0, 7, "row sum");
+}

examples/tests/test_fstring_extras.omc

@@ -0,0 +1,67 @@
+# More f-string interpolation 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); } }
+
+fn test_fstring_simple_int() {
+    h x = 42;
+    h s = f"answer is {x}";
+    assert_eq(s, "answer is 42", "simple int interp");
+}
+
+fn test_fstring_arithmetic() {
+    h x = 5;
+    h s = f"x*2 = {x * 2}";
+    assert_eq(s, "x*2 = 10", "arithmetic in f-string");
+}
+
+fn test_fstring_no_subst() {
+    h s = f"no substitutions";
+    assert_eq(s, "no substitutions", "literal f-string");
+}
+
+fn test_fstring_empty() {
+    h s = f"";
+    assert_eq(s, "", "empty f-string");
+}
+
+fn test_fstring_multiple_subs() {
+    h a = 1;
+    h b = 2;
+    h c = 3;
+    h s = f"{a}+{b}={c}";
+    assert_eq(s, "1+2=3", "multiple subs");
+}
+
+fn test_fstring_with_braces_escape() {
+    h s = f"literal {{ brace }}";
+    assert_eq(s, "literal { brace }", "escaped braces");
+}
+
+fn test_fstring_with_quotes() {
+    h s = f"quoted text";
+    assert_true(str_len(s) > 0, "quotes work");
+}
+
+fn test_fstring_function_call() {
+    h xs = [1, 2, 3];
+    h s = f"len = {arr_len(xs)}";
+    assert_eq(s, "len = 3", "function call in subst");
+}
+
+fn test_fstring_float() {
+    h x = 3.14;
+    h s = f"pi = {x}";
+    assert_true(re_match("pi = ", s) == 1, "float interpolated");
+}
+
+fn test_fstring_with_strings() {
+    h name = "world";
+    h s = f"hello, {name}!";
+    assert_eq(s, "hello, world!", "string interpolation");
+}

examples/tests/test_regex_extras.omc

@@ -0,0 +1,59 @@
+# More regex 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); } }
+
+fn test_re_match_anchored() {
+    assert_eq(re_match("^[0-9]+$", "123"), 1, "all digits");
+    assert_eq(re_match("^[0-9]+$", "12a"), 0, "with letter");
+}
+
+fn test_re_match_basic() {
+    assert_eq(re_match("abc", "xabcy"), 1, "substring match");
+    assert_eq(re_match("xyz", "abc"), 0, "no match");
+}
+
+fn test_re_find_all_digits() {
+    h all = re_find_all("[0-9]+", "a1 b22 c333");
+    assert_eq(arr_len(all), 3, "3 matches");
+    assert_eq(arr_get(all, 0), "1", "first");
+    assert_eq(arr_get(all, 2), "333", "third");
+}
+
+fn test_re_replace_basic() {
+    assert_eq(re_replace("[0-9]+", "abc123def", "X"), "abcXdef", "digits replaced");
+}
+
+fn test_re_replace_all_occurrences() {
+    assert_eq(re_replace("a", "banana", "Z"), "bZnZnZ", "all replaced");
+}
+
+fn test_re_find_first() {
+    h s = re_find("[a-z]+", "ABC def GHI");
+    assert_eq(s, "def", "first lowercase run");
+}
+
+fn test_re_split_csv() {
+    h parts = re_split(",", "a,b,c");
+    assert_eq(arr_len(parts), 3, "3 parts");
+}
+
+fn test_re_match_special_chars() {
+    assert_eq(re_match("\\.", "a.b"), 1, "literal dot");
+    assert_eq(re_match("\\d", "x5"), 1, "shorthand class");
+}
+
+fn test_re_match_optional() {
+    assert_eq(re_match("colou?r", "color"), 1, "optional u");
+    assert_eq(re_match("colou?r", "colour"), 1, "optional u present");
+}
+
+fn test_re_match_one_or_more() {
+    assert_eq(re_match("a+", "aaa"), 1, "1+");
+    assert_eq(re_match("a+", "b"), 0, "no a");
+}