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

src/tests/test_comparicon.c
344 строки11 KB
Dmitrii Isaev
earliema: refactor: rewrite comparison and other tests
01 апр 2026, 14:37
01 апр 2026, 14:378f53bfd
#include "test_libs.h"

void test_is_equal(s21_decimal a, s21_decimal b, int expected) {
  ck_assert_int_eq(s21_is_equal(a, b), expected);
}
void test_is_not_equal(s21_decimal a, s21_decimal b, int expected) {
  ck_assert_int_eq(s21_is_not_equal(a, b), expected);
}
void test_is_less(s21_decimal a, s21_decimal b, int expected) {
  ck_assert_int_eq(s21_is_less(a, b), expected);
}
void test_is_less_or_equal(s21_decimal a, s21_decimal b, int expected) {
  ck_assert_int_eq(s21_is_less_or_equal(a, b), expected);
}
void test_is_greater(s21_decimal a, s21_decimal b, int expected) {
  ck_assert_int_eq(s21_is_greater(a, b), expected);
}
void test_is_greater_or_equal(s21_decimal a, s21_decimal b, int expected) {
  ck_assert_int_eq(s21_is_greater_or_equal(a, b), expected);
}

// ============================================================
// s21_is_less
// ============================================================

// positive, same scale: a < b
START_TEST(test_is_less_1) {
  s21_decimal a = {{1, 0, 0, 0}}, b = {{2, 0, 0, 0}};
  test_is_less(a, b, 1);
}
// positive, same scale: a > b
START_TEST(test_is_less_2) {
  s21_decimal a = {{2, 0, 0, 0}}, b = {{1, 0, 0, 0}};
  test_is_less(a, b, 0);
}
// positive, same scale: a == b
START_TEST(test_is_less_3) {
  s21_decimal a = {{5, 0, 0, 0}}, b = {{5, 0, 0, 0}};
  test_is_less(a, b, 0);
}
// negative: -2 < -1 (abs -2 > abs -1)
START_TEST(test_is_less_4) {
  s21_decimal a = {{2, 0, 0, 0x80000000}}, b = {{1, 0, 0, 0x80000000}};
  test_is_less(a, b, 1);
}
// negative: -1 < -2 -> false
START_TEST(test_is_less_5) {
  s21_decimal a = {{1, 0, 0, 0x80000000}}, b = {{2, 0, 0, 0x80000000}};
  test_is_less(a, b, 0);
}
// negative equal: -1 < -1 -> false
START_TEST(test_is_less_6) {
  s21_decimal a = {{1, 0, 0, 0x80000000}}, b = {{1, 0, 0, 0x80000000}};
  test_is_less(a, b, 0);
}
// different signs: neg < pos -> true
START_TEST(test_is_less_7) {
  s21_decimal a = {{1, 0, 0, 0x80000000}}, b = {{1, 0, 0, 0}};
  test_is_less(a, b, 1);
}
// different signs: pos < neg -> false
START_TEST(test_is_less_8) {
  s21_decimal a = {{1, 0, 0, 0}}, b = {{1, 0, 0, 0x80000000}};
  test_is_less(a, b, 0);
}
// different signs: +0 < -0 -> false (both mantissa zero)
START_TEST(test_is_less_9) {
  s21_decimal a = {{0, 0, 0, 0}}, b = {{0, 0, 0, 0x80000000}};
  test_is_less(a, b, 0);
}
// different scales, positive: 1.0 < 1.1 -> true
START_TEST(test_is_less_10) {
  s21_decimal a = {{10, 0, 0, 0x00010000}}, b = {{11, 0, 0, 0x00010000}};
  test_is_less(a, b, 1);
}
// different scales, positive: 1.1 < 1.0 -> false
START_TEST(test_is_less_11) {
  s21_decimal a = {{11, 0, 0, 0x00010000}}, b = {{10, 0, 0, 0x00010000}};
  test_is_less(a, b, 0);
}
// overflow val_2 when scaling (pos): 0.1 < MAX -> true
START_TEST(test_is_less_12) {
  s21_decimal a = {{1, 0, 0, 0x00010000}};
  s21_decimal b = {{0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0}};
  test_is_less(a, b, 1);
}
// overflow val_1 when scaling (pos): MAX < 0.1 -> false
START_TEST(test_is_less_13) {
  s21_decimal a = {{0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0}};
  s21_decimal b = {{1, 0, 0, 0x00010000}};
  test_is_less(a, b, 0);
}
// overflow val_1 when scaling (neg): -MAX < -0.1 -> true
START_TEST(test_is_less_14) {
  s21_decimal a = {{0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x80000000}};
  s21_decimal b = {{1, 0, 0, 0x80010000}};
  test_is_less(a, b, 1);
}
// zero: 0 < 1 -> true
START_TEST(test_is_less_15) {
  s21_decimal a = {{0, 0, 0, 0}}, b = {{1, 0, 0, 0}};
  test_is_less(a, b, 1);
}
// MAX < MAX -> false
START_TEST(test_is_less_16) {
  s21_decimal a = {{0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0}};
  s21_decimal b = {{0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0}};
  test_is_less(a, b, 0);
}

// ============================================================
// s21_is_equal
// ============================================================

// equal, same scale -> true
START_TEST(test_is_equal_1) {
  s21_decimal a = {{42, 0, 0, 0}}, b = {{42, 0, 0, 0}};
  test_is_equal(a, b, 1);
}
// not equal, same scale -> false
START_TEST(test_is_equal_2) {
  s21_decimal a = {{1, 0, 0, 0}}, b = {{2, 0, 0, 0}};
  test_is_equal(a, b, 0);
}
// equal, different scales: 1.0 == 1.00 -> true
START_TEST(test_is_equal_3) {
  s21_decimal a = {{10, 0, 0, 0x00010000}}, b = {{100, 0, 0, 0x00020000}};
  test_is_equal(a, b, 1);
}
// overflow when scaling -> false
START_TEST(test_is_equal_4) {
  s21_decimal a = {{1, 0, 0, 0x00010000}};
  s21_decimal b = {{0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0}};
  test_is_equal(a, b, 0);
}
// different signs, both zero -> true
START_TEST(test_is_equal_5) {
  s21_decimal a = {{0, 0, 0, 0}}, b = {{0, 0, 0, 0x80000000}};
  test_is_equal(a, b, 1);
}
// different signs, non-zero -> false
START_TEST(test_is_equal_6) {
  s21_decimal a = {{1, 0, 0, 0}}, b = {{1, 0, 0, 0x80000000}};
  test_is_equal(a, b, 0);
}
// negative equal -> true
START_TEST(test_is_equal_7) {
  s21_decimal a = {{7, 0, 0, 0x80000000}}, b = {{7, 0, 0, 0x80000000}};
  test_is_equal(a, b, 1);
}
// MAX == MAX -> true
START_TEST(test_is_equal_8) {
  s21_decimal a = {{0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0}};
  s21_decimal b = {{0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0}};
  test_is_equal(a, b, 1);
}

// ============================================================
// s21_is_not_equal
// ============================================================

START_TEST(test_is_not_equal_1) {
  s21_decimal a = {{1, 0, 0, 0}}, b = {{2, 0, 0, 0}};
  test_is_not_equal(a, b, 1);
}
START_TEST(test_is_not_equal_2) {
  s21_decimal a = {{5, 0, 0, 0}}, b = {{5, 0, 0, 0}};
  test_is_not_equal(a, b, 0);
}
START_TEST(test_is_not_equal_3) {
  s21_decimal a = {{0, 0, 0, 0}}, b = {{0, 0, 0, 0x80000000}};
  test_is_not_equal(a, b, 0);
}
START_TEST(test_is_not_equal_4) {
  s21_decimal a = {{1, 0, 0, 0}}, b = {{1, 0, 0, 0x80000000}};
  test_is_not_equal(a, b, 1);
}

// ============================================================
// s21_is_less_or_equal
// ============================================================

// a < b -> true
START_TEST(test_is_less_or_equal_1) {
  s21_decimal a = {{1, 0, 0, 0}}, b = {{2, 0, 0, 0}};
  test_is_less_or_equal(a, b, 1);
}
// a == b -> true
START_TEST(test_is_less_or_equal_2) {
  s21_decimal a = {{3, 0, 0, 0}}, b = {{3, 0, 0, 0}};
  test_is_less_or_equal(a, b, 1);
}
// a > b -> false
START_TEST(test_is_less_or_equal_3) {
  s21_decimal a = {{2, 0, 0, 0}}, b = {{1, 0, 0, 0}};
  test_is_less_or_equal(a, b, 0);
}
// neg: -2 <= -1 -> true
START_TEST(test_is_less_or_equal_4) {
  s21_decimal a = {{2, 0, 0, 0x80000000}}, b = {{1, 0, 0, 0x80000000}};
  test_is_less_or_equal(a, b, 1);
}
// neg equal: -1 <= -1 -> true
START_TEST(test_is_less_or_equal_5) {
  s21_decimal a = {{1, 0, 0, 0x80000000}}, b = {{1, 0, 0, 0x80000000}};
  test_is_less_or_equal(a, b, 1);
}
// +0 <= -0 -> true
START_TEST(test_is_less_or_equal_6) {
  s21_decimal a = {{0, 0, 0, 0}}, b = {{0, 0, 0, 0x80000000}};
  test_is_less_or_equal(a, b, 1);
}

// ============================================================
// s21_is_greater
// ============================================================

// a > b -> true
START_TEST(test_is_greater_1) {
  s21_decimal a = {{2, 0, 0, 0}}, b = {{1, 0, 0, 0}};
  test_is_greater(a, b, 1);
}
// a < b -> false
START_TEST(test_is_greater_2) {
  s21_decimal a = {{1, 0, 0, 0}}, b = {{2, 0, 0, 0}};
  test_is_greater(a, b, 0);
}
// a == b -> false
START_TEST(test_is_greater_3) {
  s21_decimal a = {{4, 0, 0, 0}}, b = {{4, 0, 0, 0}};
  test_is_greater(a, b, 0);
}
// neg: -1 > -2 -> true
START_TEST(test_is_greater_4) {
  s21_decimal a = {{1, 0, 0, 0x80000000}}, b = {{2, 0, 0, 0x80000000}};
  test_is_greater(a, b, 1);
}

// ============================================================
// s21_is_greater_or_equal
// ============================================================

// a > b -> true
START_TEST(test_is_greater_or_equal_1) {
  s21_decimal a = {{3, 0, 0, 0}}, b = {{1, 0, 0, 0}};
  test_is_greater_or_equal(a, b, 1);
}
// a == b -> true
START_TEST(test_is_greater_or_equal_2) {
  s21_decimal a = {{5, 0, 0, 0}}, b = {{5, 0, 0, 0}};
  test_is_greater_or_equal(a, b, 1);
}
// a < b -> false
START_TEST(test_is_greater_or_equal_3) {
  s21_decimal a = {{1, 0, 0, 0}}, b = {{3, 0, 0, 0}};
  test_is_greater_or_equal(a, b, 0);
}
// neg: -1 >= -2 -> true
START_TEST(test_is_greater_or_equal_4) {
  s21_decimal a = {{1, 0, 0, 0x80000000}}, b = {{2, 0, 0, 0x80000000}};
  test_is_greater_or_equal(a, b, 1);
}
// neg equal: -3 >= -3 -> true
START_TEST(test_is_greater_or_equal_5) {
  s21_decimal a = {{3, 0, 0, 0x80000000}}, b = {{3, 0, 0, 0x80000000}};
  test_is_greater_or_equal(a, b, 1);
}
// -0 >= +0 -> true
START_TEST(test_is_greater_or_equal_6) {
  s21_decimal a = {{0, 0, 0, 0x80000000}}, b = {{0, 0, 0, 0}};
  test_is_greater_or_equal(a, b, 1);
}

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

Suite* suite_comparison(void) {
  Suite* comp = suite_create("Test for comparicon");

  TCase* less = tcase_create("Less");
  tcase_add_test(less, test_is_less_1);
  tcase_add_test(less, test_is_less_2);
  tcase_add_test(less, test_is_less_3);
  tcase_add_test(less, test_is_less_4);
  tcase_add_test(less, test_is_less_5);
  tcase_add_test(less, test_is_less_6);
  tcase_add_test(less, test_is_less_7);
  tcase_add_test(less, test_is_less_8);
  tcase_add_test(less, test_is_less_9);
  tcase_add_test(less, test_is_less_10);
  tcase_add_test(less, test_is_less_11);
  tcase_add_test(less, test_is_less_12);
  tcase_add_test(less, test_is_less_13);
  tcase_add_test(less, test_is_less_14);
  tcase_add_test(less, test_is_less_15);
  tcase_add_test(less, test_is_less_16);
  suite_add_tcase(comp, less);

  TCase* equal = tcase_create("Equal");
  tcase_add_test(equal, test_is_equal_1);
  tcase_add_test(equal, test_is_equal_2);
  tcase_add_test(equal, test_is_equal_3);
  tcase_add_test(equal, test_is_equal_4);
  tcase_add_test(equal, test_is_equal_5);
  tcase_add_test(equal, test_is_equal_6);
  tcase_add_test(equal, test_is_equal_7);
  tcase_add_test(equal, test_is_equal_8);
  suite_add_tcase(comp, equal);

  TCase* not_equal = tcase_create("Not equal");
  tcase_add_test(not_equal, test_is_not_equal_1);
  tcase_add_test(not_equal, test_is_not_equal_2);
  tcase_add_test(not_equal, test_is_not_equal_3);
  tcase_add_test(not_equal, test_is_not_equal_4);
  suite_add_tcase(comp, not_equal);

  TCase* less_or_equal = tcase_create("Less or equal");
  tcase_add_test(less_or_equal, test_is_less_or_equal_1);
  tcase_add_test(less_or_equal, test_is_less_or_equal_2);
  tcase_add_test(less_or_equal, test_is_less_or_equal_3);
  tcase_add_test(less_or_equal, test_is_less_or_equal_4);
  tcase_add_test(less_or_equal, test_is_less_or_equal_5);
  tcase_add_test(less_or_equal, test_is_less_or_equal_6);
  suite_add_tcase(comp, less_or_equal);

  TCase* greater = tcase_create("Greater");
  tcase_add_test(greater, test_is_greater_1);
  tcase_add_test(greater, test_is_greater_2);
  tcase_add_test(greater, test_is_greater_3);
  tcase_add_test(greater, test_is_greater_4);
  suite_add_tcase(comp, greater);

  TCase* greater_or_equal = tcase_create("Greater or equal");
  tcase_add_test(greater_or_equal, test_is_greater_or_equal_1);
  tcase_add_test(greater_or_equal, test_is_greater_or_equal_2);
  tcase_add_test(greater_or_equal, test_is_greater_or_equal_3);
  tcase_add_test(greater_or_equal, test_is_greater_or_equal_4);
  tcase_add_test(greater_or_equal, test_is_greater_or_equal_5);
  tcase_add_test(greater_or_equal, test_is_greater_or_equal_6);
  suite_add_tcase(comp, greater_or_equal);

  return comp;
}