more comprehensive C suite
This commit is contained in:
673
source/suite.c
673
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");
|
||||
|
||||
Reference in New Issue
Block a user