From 3d4c0ec3d329e62219b1752a1d9faccbfaec4a5b Mon Sep 17 00:00:00 2001
From: John Alanbrook <john@pockle.world>
Date: Tue, 24 Feb 2026 17:51:36 -0600
Subject: [PATCH] more comprehensive C suite

---
 source/suite.c | 673 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 673 insertions(+)

diff --git a/source/suite.c b/source/suite.c
index fced5dc0..003cd3c6 100644
--- a/source/suite.c
+++ b/source/suite.c
@@ -2605,6 +2605,571 @@ TEST(cell_splat_record) {
   JS_RETURN(JS_NewInt32(ctx, 1));
 }
 
+/* ============================================================================
+   Comprehensive Intrinsic Edge Case Tests
+   ============================================================================ */
+
+/* --- text() edge cases --- */
+
+TEST(cell_text_from_float) {
+  JSValue r = JS_CellText(ctx, JS_NewFloat64(ctx, 3.14));
+  ASSERT(JS_IsText(r));
+  return 1;
+}
+
+TEST(cell_text_from_bool) {
+  JSValue r1 = JS_CellText(ctx, JS_TRUE);
+  ASSERT_STR(r1, "true");
+  JSValue r2 = JS_CellText(ctx, JS_FALSE);
+  ASSERT_STR(r2, "false");
+  return 1;
+}
+
+TEST(cell_text_from_null) {
+  JSValue r = JS_CellText(ctx, JS_NULL);
+  ASSERT_STR(r, "null");
+  return 1;
+}
+
+TEST(cell_text_substring) {
+  /* extract(text, from, to) — substring */
+  JSValue text = JS_NewString(ctx, "hello world");
+  JSValue r = JS_CellExtract(ctx, text, JS_NewInt32(ctx, 0), JS_NewInt32(ctx, 5));
+  ASSERT_STR(r, "hello");
+  return 1;
+}
+
+/* --- lower/upper edge cases --- */
+
+TEST(cell_lower_empty) {
+  JSValue r = JS_CellLower(ctx, JS_NewString(ctx, ""));
+  ASSERT_STR(r, "");
+  return 1;
+}
+
+TEST(cell_lower_already) {
+  JSValue r = JS_CellLower(ctx, JS_NewString(ctx, "hello"));
+  ASSERT_STR(r, "hello");
+  return 1;
+}
+
+TEST(cell_lower_non_text) {
+  JSValue r = JS_CellLower(ctx, JS_NewInt32(ctx, 42));
+  ASSERT_NULL(r);
+  return 1;
+}
+
+TEST(cell_upper_empty) {
+  JSValue r = JS_CellUpper(ctx, JS_NewString(ctx, ""));
+  ASSERT_STR(r, "");
+  return 1;
+}
+
+TEST(cell_upper_already) {
+  JSValue r = JS_CellUpper(ctx, JS_NewString(ctx, "HELLO"));
+  ASSERT_STR(r, "HELLO");
+  return 1;
+}
+
+TEST(cell_upper_non_text) {
+  JSValue r = JS_CellUpper(ctx, JS_NewInt32(ctx, 42));
+  ASSERT_NULL(r);
+  return 1;
+}
+
+/* --- trim edge cases --- */
+
+TEST(cell_trim_tabs) {
+  JSValue r = JS_CellTrim(ctx, JS_NewString(ctx, "\thello\t"), JS_NULL);
+  ASSERT_STR(r, "hello");
+  return 1;
+}
+
+TEST(cell_trim_empty) {
+  JSValue r = JS_CellTrim(ctx, JS_NewString(ctx, ""), JS_NULL);
+  ASSERT_STR(r, "");
+  return 1;
+}
+
+TEST(cell_trim_all_whitespace) {
+  JSValue r = JS_CellTrim(ctx, JS_NewString(ctx, "   "), JS_NULL);
+  ASSERT_STR(r, "");
+  return 1;
+}
+
+TEST(cell_trim_no_whitespace) {
+  JSValue r = JS_CellTrim(ctx, JS_NewString(ctx, "hello"), JS_NULL);
+  ASSERT_STR(r, "hello");
+  return 1;
+}
+
+TEST(cell_trim_non_text) {
+  JSValue r = JS_CellTrim(ctx, JS_NewInt32(ctx, 42), JS_NULL);
+  ASSERT_NULL(r);
+  return 1;
+}
+
+/* --- search edge cases --- */
+
+TEST(cell_search_beginning) {
+  JSValue r = JS_CellSearch(ctx, JS_NewString(ctx, "hello"), JS_NewString(ctx, "hello"), JS_NULL);
+  ASSERT_INT(r, 0);
+  return 1;
+}
+
+TEST(cell_search_with_from) {
+  JSValue r = JS_CellSearch(ctx, JS_NewString(ctx, "abcabc"), JS_NewString(ctx, "abc"), JS_NewInt32(ctx, 1));
+  ASSERT_INT(r, 3);
+  return 1;
+}
+
+TEST(cell_search_empty_pattern) {
+  JSValue r = JS_CellSearch(ctx, JS_NewString(ctx, "hello"), JS_NewString(ctx, ""), JS_NULL);
+  ASSERT_INT(r, 0);
+  return 1;
+}
+
+TEST(cell_search_non_text) {
+  JSValue r = JS_CellSearch(ctx, JS_NewInt32(ctx, 42), JS_NewString(ctx, "x"), JS_NULL);
+  ASSERT_NULL(r);
+  return 1;
+}
+
+/* --- replace (re-enable) --- */
+
+TEST(cell_replace_basic) {
+  JSValue r = JS_CellReplace(ctx, JS_NewString(ctx, "hello world"),
+                              JS_NewString(ctx, "world"),
+                              JS_NewString(ctx, "there"));
+  ASSERT_STR(r, "hello there");
+  return 1;
+}
+
+TEST(cell_replace_not_found) {
+  JSValue r = JS_CellReplace(ctx, JS_NewString(ctx, "hello"),
+                              JS_NewString(ctx, "xyz"),
+                              JS_NewString(ctx, "abc"));
+  ASSERT_STR(r, "hello");
+  return 1;
+}
+
+TEST(cell_replace_to_empty) {
+  JSValue r = JS_CellReplace(ctx, JS_NewString(ctx, "hello world"),
+                              JS_NewString(ctx, " world"),
+                              JS_NewString(ctx, ""));
+  ASSERT_STR(r, "hello");
+  return 1;
+}
+
+/* --- extract edge cases --- */
+
+TEST(cell_extract_negative_from) {
+  JSValue r = JS_CellExtract(ctx, JS_NewString(ctx, "hello"), JS_NewInt32(ctx, -3), JS_NULL);
+  ASSERT_STR(r, "llo");
+  return 1;
+}
+
+TEST(cell_extract_non_text) {
+  JSValue r = JS_CellExtract(ctx, JS_NewInt32(ctx, 42), JS_NewInt32(ctx, 0), JS_NewInt32(ctx, 1));
+  ASSERT_NULL(r);
+  return 1;
+}
+
+/* --- codepoint edge cases --- */
+
+TEST(cell_codepoint_empty) {
+  JSValue r = JS_CellCodepoint(ctx, JS_NewString(ctx, ""), JS_NewInt32(ctx, 0));
+  ASSERT_NULL(r);
+  return 1;
+}
+
+TEST(cell_codepoint_non_text) {
+  JSValue r = JS_CellCodepoint(ctx, JS_NewInt32(ctx, 65), JS_NewInt32(ctx, 0));
+  ASSERT_NULL(r);
+  return 1;
+}
+
+/* --- character edge cases --- */
+
+TEST(cell_character_text_input) {
+  /* character("hello") returns first char */
+  JSValue r = JS_CellCharacter(ctx, JS_NewString(ctx, "hello"));
+  ASSERT_STR(r, "h");
+  return 1;
+}
+
+TEST(cell_character_negative) {
+  JSValue r = JS_CellCharacter(ctx, JS_NewInt32(ctx, -1));
+  ASSERT_STR(r, "");
+  return 1;
+}
+
+/* --- number() edge cases --- */
+
+TEST(cell_number_from_bool) {
+  JSValue r1 = JS_CellNumber(ctx, JS_TRUE);
+  ASSERT_INT(r1, 1);
+  JSValue r2 = JS_CellNumber(ctx, JS_FALSE);
+  ASSERT_INT(r2, 0);
+  return 1;
+}
+
+TEST(cell_number_from_null) {
+  JSValue r = JS_CellNumber(ctx, JS_NULL);
+  ASSERT_NULL(r);
+  return 1;
+}
+
+TEST(cell_number_invalid_text) {
+  JSValue r = JS_CellNumber(ctx, JS_NewString(ctx, "abc"));
+  ASSERT_NULL(r);
+  return 1;
+}
+
+TEST(cell_number_empty_text) {
+  JSValue r = JS_CellNumber(ctx, JS_NewString(ctx, ""));
+  ASSERT_NULL(r);
+  return 1;
+}
+
+TEST(cell_number_float_text) {
+  JSValue r = JS_CellNumber(ctx, JS_NewString(ctx, "3.14"));
+  ASSERT_FLOAT(r, 3.14, 0.001);
+  return 1;
+}
+
+TEST(cell_number_negative_text) {
+  JSValue r = JS_CellNumber(ctx, JS_NewString(ctx, "-42"));
+  ASSERT_INT(r, -42);
+  return 1;
+}
+
+/* --- math function type validation --- */
+
+TEST(cell_abs_non_number) {
+  ASSERT_NULL(JS_CellAbs(ctx, JS_NewString(ctx, "hello")));
+  ASSERT_NULL(JS_CellAbs(ctx, JS_NULL));
+  return 1;
+}
+
+TEST(cell_abs_zero) {
+  JSValue r = JS_CellAbs(ctx, JS_NewInt32(ctx, 0));
+  ASSERT_INT(r, 0);
+  return 1;
+}
+
+TEST(cell_sign_non_number) {
+  ASSERT_NULL(JS_CellSign(ctx, JS_NewString(ctx, "hello")));
+  ASSERT_NULL(JS_CellSign(ctx, JS_NULL));
+  return 1;
+}
+
+TEST(cell_floor_non_number) {
+  ASSERT_NULL(JS_CellFloor(ctx, JS_NewString(ctx, "hello")));
+  ASSERT_NULL(JS_CellFloor(ctx, JS_NULL));
+  return 1;
+}
+
+TEST(cell_floor_integer_passthrough) {
+  JSValue r = JS_CellFloor(ctx, JS_NewInt32(ctx, 42));
+  ASSERT_FLOAT(r, 42.0, 0.001);
+  return 1;
+}
+
+TEST(cell_ceiling_non_number) {
+  ASSERT_NULL(JS_CellCeiling(ctx, JS_NewString(ctx, "hello")));
+  ASSERT_NULL(JS_CellCeiling(ctx, JS_NULL));
+  return 1;
+}
+
+TEST(cell_round_non_number) {
+  ASSERT_NULL(JS_CellRound(ctx, JS_NewString(ctx, "hello")));
+  return 1;
+}
+
+TEST(cell_trunc_non_number) {
+  ASSERT_NULL(JS_CellTrunc(ctx, JS_NewString(ctx, "hello")));
+  return 1;
+}
+
+TEST(cell_min_non_number) {
+  ASSERT_NULL(JS_CellMin(ctx, JS_NewInt32(ctx, 1), JS_NewString(ctx, "b")));
+  ASSERT_NULL(JS_CellMin(ctx, JS_NULL, JS_NewInt32(ctx, 5)));
+  return 1;
+}
+
+TEST(cell_max_non_number) {
+  ASSERT_NULL(JS_CellMax(ctx, JS_NULL, JS_NewInt32(ctx, 5)));
+  ASSERT_NULL(JS_CellMax(ctx, JS_NewInt32(ctx, 1), JS_NewString(ctx, "b")));
+  return 1;
+}
+
+TEST(cell_min_equal) {
+  JSValue r = JS_CellMin(ctx, JS_NewInt32(ctx, 3), JS_NewInt32(ctx, 3));
+  ASSERT_INT(r, 3);
+  return 1;
+}
+
+TEST(cell_max_equal) {
+  JSValue r = JS_CellMax(ctx, JS_NewInt32(ctx, 3), JS_NewInt32(ctx, 3));
+  ASSERT_INT(r, 3);
+  return 1;
+}
+
+TEST(cell_min_floats) {
+  JSValue r = JS_CellMin(ctx, JS_NewFloat64(ctx, 1.5), JS_NewFloat64(ctx, 2.5));
+  ASSERT_FLOAT(r, 1.5, 0.001);
+  return 1;
+}
+
+TEST(cell_max_floats) {
+  JSValue r = JS_CellMax(ctx, JS_NewFloat64(ctx, 1.5), JS_NewFloat64(ctx, 2.5));
+  ASSERT_FLOAT(r, 2.5, 0.001);
+  return 1;
+}
+
+TEST(cell_remainder_zero_divisor) {
+  JSValue r = JS_CellRemainder(ctx, JS_NewInt32(ctx, 10), JS_NewInt32(ctx, 0));
+  /* remainder by zero — NaN or null */
+  ASSERT(!JS_IsInt(r));
+  return 1;
+}
+
+TEST(cell_remainder_non_number) {
+  ASSERT_NULL(JS_CellRemainder(ctx, JS_NewString(ctx, "a"), JS_NewInt32(ctx, 3)));
+  return 1;
+}
+
+TEST(cell_modulo_zero_divisor) {
+  JSValue r = JS_CellModulo(ctx, JS_NewInt32(ctx, 10), JS_NewInt32(ctx, 0));
+  ASSERT(!JS_IsInt(r));
+  return 1;
+}
+
+TEST(cell_modulo_negative) {
+  JSValue r = JS_CellModulo(ctx, JS_NewInt32(ctx, -7), JS_NewInt32(ctx, 3));
+  ASSERT_INT(r, 2);
+  return 1;
+}
+
+TEST(cell_neg_non_number) {
+  ASSERT_NULL(JS_CellNeg(ctx, JS_NewString(ctx, "hello")));
+  ASSERT_NULL(JS_CellNeg(ctx, JS_NULL));
+  return 1;
+}
+
+TEST(cell_neg_zero) {
+  JSValue r = JS_CellNeg(ctx, JS_NewInt32(ctx, 0));
+  ASSERT_INT(r, 0);
+  return 1;
+}
+
+TEST(cell_not_non_logical) {
+  ASSERT_NULL(JS_CellNot(ctx, JS_NewInt32(ctx, 42)));
+  ASSERT_NULL(JS_CellNot(ctx, JS_NewString(ctx, "true")));
+  ASSERT_NULL(JS_CellNot(ctx, JS_NULL));
+  return 1;
+}
+
+/* --- length edge cases --- */
+
+TEST(cell_length_empty_string) {
+  JSValue r = JS_CellLength(ctx, JS_NewString(ctx, ""));
+  ASSERT_INT(r, 0);
+  return 1;
+}
+
+TEST(cell_length_empty_array) {
+  JSValue r = JS_CellLength(ctx, JS_NewArray(ctx));
+  ASSERT_INT(r, 0);
+  return 1;
+}
+
+/* --- reverse edge cases --- */
+
+TEST(cell_reverse_empty_string) {
+  JSValue r = JS_CellReverse(ctx, JS_NewString(ctx, ""));
+  ASSERT_STR(r, "");
+  return 1;
+}
+
+TEST(cell_reverse_single_char) {
+  JSValue r = JS_CellReverse(ctx, JS_NewString(ctx, "a"));
+  ASSERT_STR(r, "a");
+  return 1;
+}
+
+TEST(cell_reverse_non_text) {
+  JSValue r = JS_CellReverse(ctx, JS_NewInt32(ctx, 42));
+  ASSERT_NULL(r);
+  return 1;
+}
+
+/* --- stone / is_stone edge cases --- */
+
+TEST(cell_stone_primitives_already_stone) {
+  ASSERT(JS_IsStone(JS_NewInt32(ctx, 42)));
+  ASSERT(JS_IsStone(JS_NewString(ctx, "hello")));
+  ASSERT(JS_IsStone(JS_NULL));
+  ASSERT(JS_IsStone(JS_TRUE));
+  ASSERT(JS_IsStone(JS_FALSE));
+  return 1;
+}
+
+TEST(cell_stone_array) {
+  JS_FRAME(ctx);
+  JS_ROOT(arr, JS_NewArray(ctx));
+  ASSERT(!JS_IsStone(arr.val));
+  JSValue stoned = JS_CellStone(ctx, arr.val);
+  ASSERT(JS_IsStone(stoned));
+  JS_RETURN(JS_NewInt32(ctx, 1));
+}
+
+TEST(cell_stone_record) {
+  JS_FRAME(ctx);
+  JS_ROOT(obj, JS_NewObject(ctx));
+  JS_SetPropertyStr(ctx, obj.val, "x", JS_NewInt32(ctx, 1));
+  ASSERT(!JS_IsStone(obj.val));
+  JSValue stoned = JS_CellStone(ctx, obj.val);
+  ASSERT(JS_IsStone(stoned));
+  JS_RETURN(JS_NewInt32(ctx, 1));
+}
+
+TEST(cell_stone_idempotent) {
+  JS_FRAME(ctx);
+  JS_ROOT(arr, JS_NewArray(ctx));
+  JSValue s1 = JS_CellStone(ctx, arr.val);
+  JSValue s2 = JS_CellStone(ctx, s1);
+  ASSERT(JS_IsStone(s2));
+  JS_RETURN(JS_NewInt32(ctx, 1));
+}
+
+/* --- proto edge cases --- */
+
+TEST(cell_proto_object_literal) {
+  JSValue obj = JS_NewObject(ctx);
+  JSValue r = JS_CellProto(ctx, obj);
+  /* Object literal prototype — may be null or a base prototype */
+  ASSERT(!JS_IsException(r));
+  return 1;
+}
+
+TEST(cell_proto_non_object) {
+  JSValue r = JS_CellProto(ctx, JS_NewInt32(ctx, 42));
+  ASSERT_NULL(r);
+  return 1;
+}
+
+/* --- apply / call tests --- */
+
+TEST(cell_apply_single_arg) {
+  JS_FRAME(ctx);
+  JS_ROOT(fn, JS_NewCFunction(ctx, cfunc_double, "double", 1));
+  JSValue r = JS_CellApply(ctx, fn.val, JS_NewInt32(ctx, 21));
+  ASSERT_INT(r, 42);
+  JS_RETURN(JS_NewInt32(ctx, 1));
+}
+
+TEST(cell_apply_array_args) {
+  JS_FRAME(ctx);
+  JS_ROOT(fn, JS_NewCFunction(ctx, cfunc_add, "add", 2));
+  JS_ROOT(args, JS_NewArray(ctx));
+  JS_SetPropertyNumber(ctx, args.val, 0, JS_NewInt32(ctx, 10));
+  JS_SetPropertyNumber(ctx, args.val, 1, JS_NewInt32(ctx, 20));
+  JSValue r = JS_CellApply(ctx, fn.val, args.val);
+  ASSERT_INT(r, 30);
+  JS_RETURN(JS_NewInt32(ctx, 1));
+}
+
+TEST(cell_apply_non_function) {
+  JSValue r = JS_CellApply(ctx, JS_NewInt32(ctx, 42), JS_NewInt32(ctx, 1));
+  /* apply on non-function returns the value */
+  ASSERT_INT(r, 42);
+  return 1;
+}
+
+TEST(cell_call_basic) {
+  JS_FRAME(ctx);
+  JS_ROOT(fn, JS_NewCFunction(ctx, cfunc_double, "double", 1));
+  JS_ROOT(args, JS_NewArray(ctx));
+  JS_SetPropertyNumber(ctx, args.val, 0, JS_NewInt32(ctx, 5));
+  JSValue r = JS_CellCall(ctx, fn.val, JS_NULL, args.val);
+  ASSERT_INT(r, 10);
+  JS_RETURN(JS_NewInt32(ctx, 1));
+}
+
+/* --- every / some edge cases --- */
+
+static JSValue cfunc_gt_zero(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
+  if (argc < 1 || !JS_IsInt(argv[0])) return JS_FALSE;
+  return JS_NewBool(ctx, JS_VALUE_GET_INT(argv[0]) > 0);
+}
+
+TEST(cell_every_all_pass) {
+  JS_FRAME(ctx);
+  JS_ROOT(arr, JS_NewArray(ctx));
+  JS_SetPropertyNumber(ctx, arr.val, 0, JS_NewInt32(ctx, 1));
+  JS_SetPropertyNumber(ctx, arr.val, 1, JS_NewInt32(ctx, 2));
+  JS_SetPropertyNumber(ctx, arr.val, 2, JS_NewInt32(ctx, 3));
+  JS_ROOT(fn, JS_NewCFunction(ctx, cfunc_gt_zero, "gt0", 1));
+  JSValue r = JS_CellEvery(ctx, arr.val, fn.val);
+  ASSERT_TRUE(r);
+  JS_RETURN(JS_NewInt32(ctx, 1));
+}
+
+TEST(cell_every_one_fail) {
+  JS_FRAME(ctx);
+  JS_ROOT(arr, JS_NewArray(ctx));
+  JS_SetPropertyNumber(ctx, arr.val, 0, JS_NewInt32(ctx, 1));
+  JS_SetPropertyNumber(ctx, arr.val, 1, JS_NewInt32(ctx, -1));
+  JS_SetPropertyNumber(ctx, arr.val, 2, JS_NewInt32(ctx, 3));
+  JS_ROOT(fn, JS_NewCFunction(ctx, cfunc_gt_zero, "gt0", 1));
+  JSValue r = JS_CellEvery(ctx, arr.val, fn.val);
+  ASSERT_FALSE(r);
+  JS_RETURN(JS_NewInt32(ctx, 1));
+}
+
+TEST(cell_every_empty) {
+  JS_FRAME(ctx);
+  JS_ROOT(arr, JS_NewArray(ctx));
+  JS_ROOT(fn, JS_NewCFunction(ctx, cfunc_gt_zero, "gt0", 1));
+  JSValue r = JS_CellEvery(ctx, arr.val, fn.val);
+  ASSERT_TRUE(r);
+  JS_RETURN(JS_NewInt32(ctx, 1));
+}
+
+TEST(cell_some_one_match) {
+  JS_FRAME(ctx);
+  JS_ROOT(arr, JS_NewArray(ctx));
+  JS_SetPropertyNumber(ctx, arr.val, 0, JS_NewInt32(ctx, -1));
+  JS_SetPropertyNumber(ctx, arr.val, 1, JS_NewInt32(ctx, 2));
+  JS_SetPropertyNumber(ctx, arr.val, 2, JS_NewInt32(ctx, -3));
+  JS_ROOT(fn, JS_NewCFunction(ctx, cfunc_gt_zero, "gt0", 1));
+  JSValue r = JS_CellSome(ctx, arr.val, fn.val);
+  ASSERT_TRUE(r);
+  JS_RETURN(JS_NewInt32(ctx, 1));
+}
+
+TEST(cell_some_no_match) {
+  JS_FRAME(ctx);
+  JS_ROOT(arr, JS_NewArray(ctx));
+  JS_SetPropertyNumber(ctx, arr.val, 0, JS_NewInt32(ctx, -1));
+  JS_SetPropertyNumber(ctx, arr.val, 1, JS_NewInt32(ctx, -2));
+  JS_ROOT(fn, JS_NewCFunction(ctx, cfunc_gt_zero, "gt0", 1));
+  JSValue r = JS_CellSome(ctx, arr.val, fn.val);
+  ASSERT_FALSE(r);
+  JS_RETURN(JS_NewInt32(ctx, 1));
+}
+
+TEST(cell_some_empty) {
+  JS_FRAME(ctx);
+  JS_ROOT(arr, JS_NewArray(ctx));
+  JS_ROOT(fn, JS_NewCFunction(ctx, cfunc_gt_zero, "gt0", 1));
+  JSValue r = JS_CellSome(ctx, arr.val, fn.val);
+  ASSERT_FALSE(r);
+  JS_RETURN(JS_NewInt32(ctx, 1));
+}
+
 /* ============================================================================
    MAIN TEST RUNNER
    ============================================================================ */
@@ -2897,6 +3462,114 @@ int run_c_test_suite(JSContext *ctx)
   RUN_TEST(cell_splat_null);
   RUN_TEST(cell_splat_record);
 
+  printf("\nText Edge Cases:\n");
+  RUN_TEST(cell_text_from_float);
+  RUN_TEST(cell_text_from_bool);
+  RUN_TEST(cell_text_from_null);
+  RUN_TEST(cell_text_substring);
+
+  printf("\nLower/Upper Edge Cases:\n");
+  RUN_TEST(cell_lower_empty);
+  RUN_TEST(cell_lower_already);
+  RUN_TEST(cell_lower_non_text);
+  RUN_TEST(cell_upper_empty);
+  RUN_TEST(cell_upper_already);
+  RUN_TEST(cell_upper_non_text);
+
+  printf("\nTrim Edge Cases:\n");
+  RUN_TEST(cell_trim_tabs);
+  RUN_TEST(cell_trim_empty);
+  RUN_TEST(cell_trim_all_whitespace);
+  RUN_TEST(cell_trim_no_whitespace);
+  RUN_TEST(cell_trim_non_text);
+
+  printf("\nSearch Edge Cases:\n");
+  RUN_TEST(cell_search_beginning);
+  RUN_TEST(cell_search_with_from);
+  RUN_TEST(cell_search_empty_pattern);
+  RUN_TEST(cell_search_non_text);
+
+  printf("\nReplace:\n");
+  RUN_TEST(cell_replace_basic);
+  RUN_TEST(cell_replace_not_found);
+  RUN_TEST(cell_replace_to_empty);
+
+  printf("\nExtract Edge Cases:\n");
+  RUN_TEST(cell_extract_negative_from);
+  RUN_TEST(cell_extract_non_text);
+
+  printf("\nCodepoint Edge Cases:\n");
+  RUN_TEST(cell_codepoint_empty);
+  RUN_TEST(cell_codepoint_non_text);
+
+  printf("\nCharacter Edge Cases:\n");
+  RUN_TEST(cell_character_text_input);
+  RUN_TEST(cell_character_negative);
+
+  printf("\nNumber Edge Cases:\n");
+  RUN_TEST(cell_number_from_bool);
+  RUN_TEST(cell_number_from_null);
+  RUN_TEST(cell_number_invalid_text);
+  RUN_TEST(cell_number_empty_text);
+  RUN_TEST(cell_number_float_text);
+  RUN_TEST(cell_number_negative_text);
+
+  printf("\nMath Type Validation:\n");
+  RUN_TEST(cell_abs_non_number);
+  RUN_TEST(cell_abs_zero);
+  RUN_TEST(cell_sign_non_number);
+  RUN_TEST(cell_floor_non_number);
+  RUN_TEST(cell_floor_integer_passthrough);
+  RUN_TEST(cell_ceiling_non_number);
+  RUN_TEST(cell_round_non_number);
+  RUN_TEST(cell_trunc_non_number);
+  RUN_TEST(cell_min_non_number);
+  RUN_TEST(cell_max_non_number);
+  RUN_TEST(cell_min_equal);
+  RUN_TEST(cell_max_equal);
+  RUN_TEST(cell_min_floats);
+  RUN_TEST(cell_max_floats);
+  RUN_TEST(cell_remainder_zero_divisor);
+  RUN_TEST(cell_remainder_non_number);
+  RUN_TEST(cell_modulo_zero_divisor);
+  RUN_TEST(cell_modulo_negative);
+  RUN_TEST(cell_neg_non_number);
+  RUN_TEST(cell_neg_zero);
+  RUN_TEST(cell_not_non_logical);
+
+  printf("\nLength Edge Cases:\n");
+  RUN_TEST(cell_length_empty_string);
+  RUN_TEST(cell_length_empty_array);
+
+  printf("\nReverse Edge Cases:\n");
+  RUN_TEST(cell_reverse_empty_string);
+  RUN_TEST(cell_reverse_single_char);
+  RUN_TEST(cell_reverse_non_text);
+
+  printf("\nStone Edge Cases:\n");
+  RUN_TEST(cell_stone_primitives_already_stone);
+  RUN_TEST(cell_stone_array);
+  RUN_TEST(cell_stone_record);
+  RUN_TEST(cell_stone_idempotent);
+
+  printf("\nProto Edge Cases:\n");
+  RUN_TEST(cell_proto_object_literal);
+  RUN_TEST(cell_proto_non_object);
+
+  printf("\nApply/Call:\n");
+  RUN_TEST(cell_apply_single_arg);
+  RUN_TEST(cell_apply_array_args);
+  RUN_TEST(cell_apply_non_function);
+  RUN_TEST(cell_call_basic);
+
+  printf("\nEvery/Some Edge Cases:\n");
+  RUN_TEST(cell_every_all_pass);
+  RUN_TEST(cell_every_one_fail);
+  RUN_TEST(cell_every_empty);
+  RUN_TEST(cell_some_one_match);
+  RUN_TEST(cell_some_no_match);
+  RUN_TEST(cell_some_empty);
+
   printf("\n=================================\n");
   printf("Results: %d passed, %d failed\n", tests_passed, tests_failed);
   printf("=================================\n\n");