src/tests/test_helpers.c - develop - solidbase/C5_s21_decimal

src/tests/test_helpers.c
380 строк11 KB
Dmitrii Isaev
earliema: style: apply clang-format
15 мар 2026, 05:35
15 мар 2026, 05:354f24c02
#include <check.h>

#include "../s21_decimal_helpers.h"

// ================================================================
// add_mantissa
// ================================================================

START_TEST(test_add_mantissa_simple) {
  s21_decimal a = {{3, 0, 0, 0}};
  s21_decimal b = {{4, 0, 0, 0}};
  s21_decimal r = {{0}};
  int carry = s21_add_mantissa(a, b, &r);
  ck_assert_int_eq(carry, 0);
  ck_assert_int_eq(r.bits[0], 7);
  ck_assert_int_eq(r.bits[1], 0);
  ck_assert_int_eq(r.bits[2], 0);
}
END_TEST

START_TEST(test_add_mantissa_carry_word0_to_word1) {
  s21_decimal a = {{(int)0xFFFFFFFFu, 0, 0, 0}};
  s21_decimal b = {{1, 0, 0, 0}};
  s21_decimal r = {{0}};
  int carry = s21_add_mantissa(a, b, &r);
  ck_assert_int_eq(carry, 0);
  ck_assert_int_eq(r.bits[0], 0);
  ck_assert_int_eq(r.bits[1], 1);
}
END_TEST

START_TEST(test_add_mantissa_carry_word1_to_word2) {
  s21_decimal a = {{0, (int)0xFFFFFFFFu, 0, 0}};
  s21_decimal b = {{0, 1, 0, 0}};
  s21_decimal r = {{0}};
  s21_add_mantissa(a, b, &r);
  ck_assert_int_eq(r.bits[1], 0);
  ck_assert_int_eq(r.bits[2], 1);
}
END_TEST

START_TEST(test_add_mantissa_overflow) {
  s21_decimal a = {{(int)0xFFFFFFFFu, (int)0xFFFFFFFFu, (int)0xFFFFFFFFu, 0}};
  s21_decimal b = {{1, 0, 0, 0}};
  s21_decimal r = {{0}};
  int carry = s21_add_mantissa(a, b, &r);
  ck_assert_int_eq(carry, 1);
  ck_assert_int_eq(r.bits[0], 0);
  ck_assert_int_eq(r.bits[1], 0);
  ck_assert_int_eq(r.bits[2], 0);
}
END_TEST

START_TEST(test_add_mantissa_preserves_bits3) {
  // bits[3] of result is whatever was there — add_mantissa ignores it
  s21_decimal a = {{10, 0, 0, 0x00050000}};
  s21_decimal b = {{20, 0, 0, 0}};
  s21_decimal r = {{0}};
  s21_add_mantissa(a, b, &r);
  ck_assert_int_eq(r.bits[0], 30);
}
END_TEST

// ================================================================
// sub_mantissa
// ================================================================

START_TEST(test_sub_mantissa_simple) {
  s21_decimal a = {{10, 0, 0, 0}};
  s21_decimal b = {{3, 0, 0, 0}};
  s21_decimal r = {{0}};
  int borrow = s21_sub_mantissa(a, b, &r);
  ck_assert_int_eq(borrow, 0);
  ck_assert_int_eq(r.bits[0], 7);
}
END_TEST

START_TEST(test_sub_mantissa_borrow_word1) {
  // 0x1_00000000 - 1 = 0xFFFFFFFF
  s21_decimal a = {{0, 1, 0, 0}};
  s21_decimal b = {{1, 0, 0, 0}};
  s21_decimal r = {{0}};
  s21_sub_mantissa(a, b, &r);
  ck_assert_uint_eq((unsigned)r.bits[0], 0xFFFFFFFFu);
  ck_assert_int_eq(r.bits[1], 0);
}
END_TEST

START_TEST(test_sub_mantissa_borrow_word2) {
  s21_decimal a = {{0, 0, 1, 0}};
  s21_decimal b = {{1, 0, 0, 0}};
  s21_decimal r = {{0}};
  s21_sub_mantissa(a, b, &r);
  ck_assert_uint_eq((unsigned)r.bits[0], 0xFFFFFFFFu);
  ck_assert_uint_eq((unsigned)r.bits[1], 0xFFFFFFFFu);
  ck_assert_int_eq(r.bits[2], 0);
}
END_TEST

START_TEST(test_sub_mantissa_underflow) {
  s21_decimal a = {{0, 0, 0, 0}};
  s21_decimal b = {{1, 0, 0, 0}};
  s21_decimal r = {{0}};
  int borrow = s21_sub_mantissa(a, b, &r);
  ck_assert_int_eq(borrow, 1);
}
END_TEST

START_TEST(test_sub_mantissa_equal) {
  s21_decimal a = {{42, 0, 0, 0}};
  s21_decimal r = {{0}};
  int borrow = s21_sub_mantissa(a, a, &r);
  ck_assert_int_eq(borrow, 0);
  ck_assert_int_eq(r.bits[0], 0);
  ck_assert_int_eq(r.bits[1], 0);
  ck_assert_int_eq(r.bits[2], 0);
}
END_TEST

// ================================================================
// compare_mantissa
// ================================================================

START_TEST(test_compare_mantissa_equal) {
  s21_decimal a = {{100, 200, 300, 0}};
  ck_assert_int_eq(s21_compare_mantissa(a, a), 0);
}
END_TEST

START_TEST(test_compare_mantissa_less_word0) {
  s21_decimal a = {{1, 0, 0, 0}};
  s21_decimal b = {{2, 0, 0, 0}};
  ck_assert_int_eq(s21_compare_mantissa(a, b), -1);
}
END_TEST

START_TEST(test_compare_mantissa_greater_word2) {
  s21_decimal a = {{0, 0, 2, 0}};
  s21_decimal b = {{(int)0xFFFFFFFFu, (int)0xFFFFFFFFu, 1, 0}};
  ck_assert_int_eq(s21_compare_mantissa(a, b), 1);
}
END_TEST

// ================================================================
// shift_left_mantissa / shift_right_mantissa
// ================================================================

START_TEST(test_shift_left_mantissa_1) {
  s21_decimal d = {{1, 0, 0, 0}};
  s21_shift_left_mantissa(&d, 1);
  ck_assert_int_eq(d.bits[0], 2);
}
END_TEST

START_TEST(test_shift_left_mantissa_crosses_word) {
  s21_decimal d = {{(int)0x80000000u, 0, 0, 0}};
  s21_shift_left_mantissa(&d, 1);
  ck_assert_int_eq(d.bits[0], 0);
  ck_assert_int_eq(d.bits[1], 1);
}
END_TEST

START_TEST(test_shift_left_mantissa_overflow) {
  s21_decimal d = {{0, 0, (int)0x80000000u, 0}};
  int ov = s21_shift_left_mantissa(&d, 1);
  ck_assert_int_eq(ov, 1);
}
END_TEST

START_TEST(test_shift_right_mantissa_1) {
  s21_decimal d = {{0, 1, 0, 0}};
  s21_shift_right_mantissa(&d, 1);
  ck_assert_uint_eq((unsigned)d.bits[0], 0x80000000u);
  ck_assert_int_eq(d.bits[1], 0);
}
END_TEST

START_TEST(test_shift_right_mantissa_32) {
  s21_decimal d = {{0, 0xABCDu, 0, 0}};
  s21_shift_right_mantissa(&d, 32);
  ck_assert_uint_eq((unsigned)d.bits[0], 0xABCDu);
  ck_assert_int_eq(d.bits[1], 0);
}
END_TEST

// ================================================================
// mul_by_10 / div_by_10
// ================================================================

START_TEST(test_mul_by_10_simple) {
  s21_decimal d = {{5, 0, 0, 0}};
  int ov = s21_mul_by_10(&d);
  ck_assert_int_eq(ov, 0);
  ck_assert_int_eq(d.bits[0], 50);
}
END_TEST

START_TEST(test_mul_by_10_cross_word) {
  // 0xFFFFFFFF * 10 = 0x9_FFFFFFF6
  s21_decimal d = {{(int)0xFFFFFFFFu, 0, 0, 0}};
  int ov = s21_mul_by_10(&d);
  ck_assert_int_eq(ov, 0);
  ck_assert_uint_eq((unsigned)d.bits[0], 0xFFFFFFF6u);
  ck_assert_uint_eq((unsigned)d.bits[1], 9u);
}
END_TEST

START_TEST(test_mul_by_10_overflow) {
  s21_decimal d = {{0, 0, (int)0x80000000u, 0}};
  int ov = s21_mul_by_10(&d);
  ck_assert_int_eq(ov, 1);
}
END_TEST

START_TEST(test_mul_by_10_preserves_bits3) {
  s21_decimal d = {{3, 0, 0, 0x001C0000}};
  s21_mul_by_10(&d);
  ck_assert_int_eq(d.bits[3], 0x001C0000);
  ck_assert_int_eq(d.bits[0], 30);
}
END_TEST

START_TEST(test_div_by_10_simple) {
  s21_decimal d = {{50, 0, 0, 0}};
  int rem = s21_div_by_10(&d);
  ck_assert_int_eq(rem, 0);
  ck_assert_int_eq(d.bits[0], 5);
}
END_TEST

START_TEST(test_div_by_10_with_remainder) {
  s21_decimal d = {{7, 0, 0, 0}};
  int rem = s21_div_by_10(&d);
  ck_assert_int_eq(rem, 7);
  ck_assert_int_eq(d.bits[0], 0);
}
END_TEST

START_TEST(test_div_by_10_large) {
  // 1000000 / 10 = 100000 rem 0
  s21_decimal d = {{1000000, 0, 0, 0}};
  int rem = s21_div_by_10(&d);
  ck_assert_int_eq(rem, 0);
  ck_assert_int_eq(d.bits[0], 100000);
}
END_TEST

START_TEST(test_div_by_10_cross_word) {
  // 0x1_00000000 = 4294967296; / 10 = 429496729 rem 6
  s21_decimal d = {{0, 1, 0, 0}};
  int rem = s21_div_by_10(&d);
  ck_assert_int_eq(rem, 6);
  ck_assert_int_eq(d.bits[0], 429496729);
  ck_assert_int_eq(d.bits[1], 0);
}
END_TEST

START_TEST(test_mul_div_by_10_roundtrip) {
  s21_decimal d = {{12345, 0, 0, 0}};
  s21_mul_by_10(&d);
  int rem = s21_div_by_10(&d);
  ck_assert_int_eq(rem, 0);
  ck_assert_int_eq(d.bits[0], 12345);
}
END_TEST

// ================================================================
// big_mul_by_10 / big_div_by_10
// ================================================================

START_TEST(test_big_mul_by_10_simple) {
  s21_big_decimal d = {{7, 0, 0, 0, 0, 0}};
  int ov = s21_big_mul_by_10(&d);
  ck_assert_int_eq(ov, 0);
  ck_assert_uint_eq(d.bits[0], 70u);
}
END_TEST

START_TEST(test_big_mul_by_10_cross_word) {
  s21_big_decimal d = {{0xFFFFFFFFu, 0, 0, 0, 0, 0}};
  s21_big_mul_by_10(&d);
  ck_assert_uint_eq(d.bits[0], 0xFFFFFFF6u);
  ck_assert_uint_eq(d.bits[1], 9u);
}
END_TEST

START_TEST(test_big_mul_by_10_overflow) {
  s21_big_decimal d = {{0, 0, 0, 0, 0, 0x80000000u}};
  int ov = s21_big_mul_by_10(&d);
  ck_assert_int_eq(ov, 1);
}
END_TEST

START_TEST(test_big_div_by_10_simple) {
  s21_big_decimal d = {{100, 0, 0, 0, 0, 0}};
  int rem = s21_big_div_by_10(&d);
  ck_assert_int_eq(rem, 0);
  ck_assert_uint_eq(d.bits[0], 10u);
}
END_TEST

START_TEST(test_big_div_by_10_remainder) {
  s21_big_decimal d = {{9, 0, 0, 0, 0, 0}};
  int rem = s21_big_div_by_10(&d);
  ck_assert_int_eq(rem, 9);
  ck_assert_uint_eq(d.bits[0], 0u);
}
END_TEST

START_TEST(test_big_div_by_10_high_word) {
  // bits[5] = 1, rest 0 → value = 2^160; / 10 = 2^160/10
  // Just verify it doesn't crash and returns a valid remainder
  s21_big_decimal d = {{0, 0, 0, 0, 0, 10}};
  int rem = s21_big_div_by_10(&d);
  ck_assert_int_ge(rem, 0);
  ck_assert_int_le(rem, 9);
  ck_assert_uint_eq(d.bits[5], 1u);
}
END_TEST

// ================================================================
// Suite
// ================================================================

Suite* suite_helpers(void) {
  Suite* s = suite_create("helpers");

  TCase* tc_add = tcase_create("add_mantissa");
  tcase_add_test(tc_add, test_add_mantissa_simple);
  tcase_add_test(tc_add, test_add_mantissa_carry_word0_to_word1);
  tcase_add_test(tc_add, test_add_mantissa_carry_word1_to_word2);
  tcase_add_test(tc_add, test_add_mantissa_overflow);
  tcase_add_test(tc_add, test_add_mantissa_preserves_bits3);
  suite_add_tcase(s, tc_add);

  TCase* tc_sub = tcase_create("sub_mantissa");
  tcase_add_test(tc_sub, test_sub_mantissa_simple);
  tcase_add_test(tc_sub, test_sub_mantissa_borrow_word1);
  tcase_add_test(tc_sub, test_sub_mantissa_borrow_word2);
  tcase_add_test(tc_sub, test_sub_mantissa_underflow);
  tcase_add_test(tc_sub, test_sub_mantissa_equal);
  suite_add_tcase(s, tc_sub);

  TCase* tc_cmp = tcase_create("compare_mantissa");
  tcase_add_test(tc_cmp, test_compare_mantissa_equal);
  tcase_add_test(tc_cmp, test_compare_mantissa_less_word0);
  tcase_add_test(tc_cmp, test_compare_mantissa_greater_word2);
  suite_add_tcase(s, tc_cmp);

  TCase* tc_shift = tcase_create("shift_mantissa");
  tcase_add_test(tc_shift, test_shift_left_mantissa_1);
  tcase_add_test(tc_shift, test_shift_left_mantissa_crosses_word);
  tcase_add_test(tc_shift, test_shift_left_mantissa_overflow);
  tcase_add_test(tc_shift, test_shift_right_mantissa_1);
  tcase_add_test(tc_shift, test_shift_right_mantissa_32);
  suite_add_tcase(s, tc_shift);

  TCase* tc_scale = tcase_create("mul_div_10");
  tcase_add_test(tc_scale, test_mul_by_10_simple);
  tcase_add_test(tc_scale, test_mul_by_10_cross_word);
  tcase_add_test(tc_scale, test_mul_by_10_overflow);
  tcase_add_test(tc_scale, test_mul_by_10_preserves_bits3);
  tcase_add_test(tc_scale, test_div_by_10_simple);
  tcase_add_test(tc_scale, test_div_by_10_with_remainder);
  tcase_add_test(tc_scale, test_div_by_10_large);
  tcase_add_test(tc_scale, test_div_by_10_cross_word);
  tcase_add_test(tc_scale, test_mul_div_by_10_roundtrip);
  suite_add_tcase(s, tc_scale);

  TCase* tc_big_scale = tcase_create("big_mul_div_10");
  tcase_add_test(tc_big_scale, test_big_mul_by_10_simple);
  tcase_add_test(tc_big_scale, test_big_mul_by_10_cross_word);
  tcase_add_test(tc_big_scale, test_big_mul_by_10_overflow);
  tcase_add_test(tc_big_scale, test_big_div_by_10_simple);
  tcase_add_test(tc_big_scale, test_big_div_by_10_remainder);
  tcase_add_test(tc_big_scale, test_big_div_by_10_high_word);
  suite_add_tcase(s, tc_big_scale);

  return s;
}