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

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

#include "../s21_decimal_core.h"

// --- Sign tests ---

START_TEST(test_sign_default_zero) {
  s21_decimal d = {{0}};
  ck_assert_int_eq(s21_get_sign(d), 0);
}
END_TEST

START_TEST(test_sign_set_negative) {
  s21_decimal d = {{0}};
  s21_set_sign(&d, 1);
  ck_assert_int_eq(s21_get_sign(d), 1);
}
END_TEST

START_TEST(test_sign_set_positive) {
  s21_decimal d = {{0}};
  s21_set_sign(&d, 1);
  s21_set_sign(&d, 0);
  ck_assert_int_eq(s21_get_sign(d), 0);
}
END_TEST

START_TEST(test_sign_preserves_scale) {
  s21_decimal d = {{0}};
  s21_set_scale(&d, 14);
  s21_set_sign(&d, 1);
  ck_assert_int_eq(s21_get_scale(d), 14);
  ck_assert_int_eq(s21_get_sign(d), 1);
}
END_TEST

START_TEST(test_sign_preserves_mantissa) {
  s21_decimal d = {{123, 456, 789, 0}};
  s21_set_sign(&d, 1);
  ck_assert_int_eq(d.bits[0], 123);
  ck_assert_int_eq(d.bits[1], 456);
  ck_assert_int_eq(d.bits[2], 789);
}
END_TEST

// --- Scale tests ---

START_TEST(test_scale_default_zero) {
  s21_decimal d = {{0}};
  ck_assert_int_eq(s21_get_scale(d), 0);
}
END_TEST

START_TEST(test_scale_set_values) {
  s21_decimal d = {{0}};
  int scales[] = {0, 1, 14, 28};
  for (int i = 0; i < 4; i++) {
    s21_set_scale(&d, scales[i]);
    ck_assert_int_eq(s21_get_scale(d), scales[i]);
  }
}
END_TEST

START_TEST(test_scale_preserves_sign) {
  s21_decimal d = {{0}};
  s21_set_sign(&d, 1);
  s21_set_scale(&d, 28);
  ck_assert_int_eq(s21_get_sign(d), 1);
  ck_assert_int_eq(s21_get_scale(d), 28);
}
END_TEST

START_TEST(test_scale_preserves_mantissa) {
  s21_decimal d = {{0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0}};
  s21_set_scale(&d, 15);
  ck_assert_uint_eq((unsigned)d.bits[0], 0xFFFFFFFF);
  ck_assert_uint_eq((unsigned)d.bits[1], 0xFFFFFFFF);
  ck_assert_uint_eq((unsigned)d.bits[2], 0xFFFFFFFF);
}
END_TEST

// --- Bit tests ---

START_TEST(test_bit_set_get_0) {
  s21_decimal d = {{0}};
  s21_set_bit(&d, 0, 1);
  ck_assert_int_eq(s21_get_bit(d, 0), 1);
  ck_assert_int_eq(d.bits[0], 1);
}
END_TEST

START_TEST(test_bit_set_get_31) {
  s21_decimal d = {{0}};
  s21_set_bit(&d, 31, 1);
  ck_assert_int_eq(s21_get_bit(d, 31), 1);
  ck_assert_uint_eq((unsigned)d.bits[0], 1u << 31);
}
END_TEST

START_TEST(test_bit_set_get_32) {
  s21_decimal d = {{0}};
  s21_set_bit(&d, 32, 1);
  ck_assert_int_eq(s21_get_bit(d, 32), 1);
  ck_assert_int_eq(d.bits[1], 1);
  ck_assert_int_eq(d.bits[0], 0);
}
END_TEST

START_TEST(test_bit_set_get_95) {
  s21_decimal d = {{0}};
  s21_set_bit(&d, 95, 1);
  ck_assert_int_eq(s21_get_bit(d, 95), 1);
  ck_assert_uint_eq((unsigned)d.bits[2], 1u << 31);
}
END_TEST

START_TEST(test_bit_clear) {
  s21_decimal d = {{0xFFFFFFFF, 0, 0, 0}};
  s21_set_bit(&d, 0, 0);
  ck_assert_int_eq(s21_get_bit(d, 0), 0);
  ck_assert_uint_eq((unsigned)d.bits[0], 0xFFFFFFFE);
}
END_TEST

START_TEST(test_bit_out_of_range) {
  s21_decimal d = {{0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0}};
  ck_assert_int_eq(s21_get_bit(d, 96), 0);
  ck_assert_int_eq(s21_get_bit(d, -1), 0);
}
END_TEST

// --- Init tests ---

START_TEST(test_init_decimal) {
  s21_decimal d = {{0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}};
  s21_init_decimal(&d);
  ck_assert_int_eq(d.bits[0], 0);
  ck_assert_int_eq(d.bits[1], 0);
  ck_assert_int_eq(d.bits[2], 0);
  ck_assert_int_eq(d.bits[3], 0);
}
END_TEST

// --- Is zero tests ---

START_TEST(test_is_zero_true) {
  s21_decimal d = {{0}};
  ck_assert_int_eq(s21_is_zero(d), 1);
}
END_TEST

START_TEST(test_is_zero_negative_zero) {
  s21_decimal d = {{0}};
  s21_set_sign(&d, 1);
  ck_assert_int_eq(s21_is_zero(d), 1);
}
END_TEST

START_TEST(test_is_zero_with_scale) {
  s21_decimal d = {{0}};
  s21_set_scale(&d, 10);
  ck_assert_int_eq(s21_is_zero(d), 1);
}
END_TEST

START_TEST(test_is_zero_false) {
  s21_decimal d = {{1, 0, 0, 0}};
  ck_assert_int_eq(s21_is_zero(d), 0);
}
END_TEST

START_TEST(test_is_zero_false_high_word) {
  s21_decimal d = {{0, 0, 1, 0}};
  ck_assert_int_eq(s21_is_zero(d), 0);
}
END_TEST

// --- Suite ---

Suite* suite_core(void) {
  Suite* s = suite_create("core");

  TCase* tc_sign = tcase_create("sign");
  tcase_add_test(tc_sign, test_sign_default_zero);
  tcase_add_test(tc_sign, test_sign_set_negative);
  tcase_add_test(tc_sign, test_sign_set_positive);
  tcase_add_test(tc_sign, test_sign_preserves_scale);
  tcase_add_test(tc_sign, test_sign_preserves_mantissa);
  suite_add_tcase(s, tc_sign);

  TCase* tc_scale = tcase_create("scale");
  tcase_add_test(tc_scale, test_scale_default_zero);
  tcase_add_test(tc_scale, test_scale_set_values);
  tcase_add_test(tc_scale, test_scale_preserves_sign);
  tcase_add_test(tc_scale, test_scale_preserves_mantissa);
  suite_add_tcase(s, tc_scale);

  TCase* tc_bit = tcase_create("bit");
  tcase_add_test(tc_bit, test_bit_set_get_0);
  tcase_add_test(tc_bit, test_bit_set_get_31);
  tcase_add_test(tc_bit, test_bit_set_get_32);
  tcase_add_test(tc_bit, test_bit_set_get_95);
  tcase_add_test(tc_bit, test_bit_clear);
  tcase_add_test(tc_bit, test_bit_out_of_range);
  suite_add_tcase(s, tc_bit);

  TCase* tc_init = tcase_create("init");
  tcase_add_test(tc_init, test_init_decimal);
  suite_add_tcase(s, tc_init);

  TCase* tc_zero = tcase_create("is_zero");
  tcase_add_test(tc_zero, test_is_zero_true);
  tcase_add_test(tc_zero, test_is_zero_negative_zero);
  tcase_add_test(tc_zero, test_is_zero_with_scale);
  tcase_add_test(tc_zero, test_is_zero_false);
  tcase_add_test(tc_zero, test_is_zero_false_high_word);
  suite_add_tcase(s, tc_zero);

  return s;
}