test(cleanup): better tests :)

cleanup and organize shit

Signed-off-by: Shashwat Agrawal <shashwatagrawal473@gmail.com>

Author: ShashwatAgrawal20

tec_showcase.cpp

@@ -1,12 +1,10 @@
 #define TEC_IMPLEMENTATION
-#include "./include/math_utils.h"
-#include "./tec.h"
-
-#ifdef __cplusplus
+#include "tec.h"
 #include <iostream>
 #include <memory>
 #include <vector>
-TEC(cpp_Style, Vector) {
+
+TEC(cpp_features, Vector) {
     std::vector<int> my_vector(100); // THIS WILL AUTOFREE CAUSE OF RAII(dest)
 
     // Dynamically allocated int (manual memory management).
@@ -30,131 +28,53 @@ TEC(cpp_Style, Vector) {
     TEC_ASSERT(1 == 1);
 }
 
-TEC(cpp_Style, SmartPointer) {
+TEC(cpp_features, SmartPointer) {
     std::unique_ptr<int[]> my_array(new int[100]);
     TEC_ASSERT(my_array != nullptr);
 }
-#else
-TEC_XFAIL(framework, teardown_with_cleanup) {
-    TEC_SKIP("Fails intentionally to demonstrate try/teardown.");
-    int *value = NULL;
-
-    // TRY BLOCK: Contains setup and assertions.
-    // If an assert fails, execution jumps past this block.
-    TEC_TRY_BLOCK {
-        value = malloc(sizeof(int));
-        TEC_ASSERT_NE(NULL, value);
-        *value = 69;
-        TEC_ASSERT_EQ(*value, 420);
-    }
-
-    // FINALLY BLOCK: This code is guaranteed to run.
-    // No keyword is needed; it's simply the code that follows the try block.
-    free(value);
-    // printf("Teardown complete: memory freed\n");
-}
-#endif
-
-TEC(numerical, test_comparisons) {
-    int a = 69;
-    int b = 420;
-    // TEC_ASSERT_GT(a, b); /* fails */
-    // TEC_ASSERT_GE(69, 420); /* fails */
-    TEC_ASSERT_LE(b, a);
-    TEC_ASSERT_LT(-5, 0);
-    TEC_ASSERT_GE(100, 100);
-    TEC_ASSERT_LE(-99, -99);
-}
-
-TEC(float, precision) {
-    TEC_ASSERT_NEAR(0.1 + 0.2, 0.3, 3e-15);
-    TEC_ASSERT_FLOAT_EQ(0.1 + 0.2, 0.3);
-}
-
-TEC(mathutils, addition) {
-    const int five = 5;
-    TEC_ASSERT_EQ(add(2, 3), five);
-    TEC_ASSERT_EQ(add(-10, 5), -5);
-
-    TEC_ASSERT_NE(add(2, 2), 5);
-}
-
-TEC(mathutils, numerical_comparisons) {
-    int five = multiply(5, 1);
-    int ten = multiply(5, 2);
-
-    TEC_ASSERT(ten > five);
-    TEC_ASSERT(five < ten);
-    TEC_ASSERT(ten >= ten);
-    TEC_ASSERT(five <= five);
-}
-
-TEC(mathutils, multiply) {
-    TEC_ASSERT_EQ(multiply(3, 4), 12);
-    TEC_ASSERT(multiply(5, 2) % 2 == 0);
-    TEC_ASSERT_NE(multiply(1, 1), 0);
-
-    int result = multiply(-2, 5);
-    TEC_ASSERT_EQ(result, -10);
-    TEC_ASSERT(result < 0);
-    TEC_ASSERT_NE(result, 0);
-
-    result = multiply(0, 100);
-    TEC_ASSERT_EQ(result, 0);
-    TEC_ASSERT(result <= 0);
-}
-
-TEC(mathutils, division) {
-    TEC_ASSERT_EQ(divide(10, 2), 5);
-    TEC_ASSERT(divide(9, 3) > 0);
-
-    int result = divide(15, 3);
-    TEC_ASSERT_EQ(result, 5);
-
-    result = divide(0, 5);
-    TEC_ASSERT_EQ(result, 0);
-
-    // Edge case: divide by zero
-    result = divide(7, 0);
-    TEC_ASSERT_EQ(result, 0);
-}
-
-TEC(mathutils, factorial) {
-    TEC_ASSERT_EQ(factorial(0), 1); // Edge case: 0! = 1
-    TEC_ASSERT_EQ(factorial(5), 120);
-    TEC_ASSERT_EQ(factorial(10), 3628800);
-
-    // Test for invalid input (negative numbers)
-    TEC_ASSERT_EQ(factorial(-5), 1);
-}
-
-TEC(logic, booleans_act_right) {
-    TEC_ASSERT(1);
-    TEC_ASSERT(!0);
-    TEC_ASSERT_EQ(1 == 1, 1);
-    TEC_ASSERT_NE(1 == 0, 1);
-}
-
-#ifdef __cplusplus
-#include <stdexcept>
-#endif
 
 void function_that_throws() {
-    throw std::runtime_error("Something went wrong!");
+    throw std::runtime_error("This is an expected exception.");
 }
-
 void function_that_doesnt_throw() {}
 
-TEC(Exceptions, CatchesCorrectType) {
+TEC(cpp_features, catches_correct_exception_type) {
     TEC_ASSERT_THROWS(function_that_throws(), std::runtime_error);
 }
-
-TEC(Exceptions, FailsOnWrongType) {
+TEC_XFAIL(cpp_features, fails_on_wrong_exception_type) {
     TEC_ASSERT_THROWS(function_that_throws(), std::invalid_argument);
 }
-
-TEC(Exceptions, FailsWhenNoThrow) {
+TEC_XFAIL(cpp_features, fails_when_no_exception_is_thrown) {
     TEC_ASSERT_THROWS(function_that_doesnt_throw(), std::runtime_error);
 }
 
-TEC_MAIN()
+static int raii_sentry_counter = 0;
+struct RaiiSentry {
+    RaiiSentry() { raii_sentry_counter++; }
+    ~RaiiSentry() { raii_sentry_counter--; }
+};
+
+TEC(cpp_features, assertion_failure_is_raii_safe) {
+    TEC_ASSERT_EQ(raii_sentry_counter, 0);
+    try {
+        RaiiSentry s;
+        TEC_ASSERT_EQ(raii_sentry_counter, 1);
+        TEC_ASSERT_EQ(1, 0); // This assertion throws
+    } catch (...) {
+        // THIS WILL PASS as the destructor would've restored the value so
+        // this assertion will be logged in the passed one's
+        TEC_ASSERT_EQ(raii_sentry_counter, 0);
+        // Exception was caught. If the destructor ran, the counter is 0.
+        // Rethrow the exception so that:
+        //   1) The test framework knows this block failed.
+        //   2) Execution stops here and other assertions won't run
+        //      after this failure (cause that's the intended behavior).
+        throw;
+    }
+
+    // THIS won't be logged cause we used throw in catch, this would've
+    // logged if we forgot that throw;
+    TEC_ASSERT_EQ(raii_sentry_counter, 0);
+}
+
+TEC_MAIN();

tests/core/assertion.c

@@ -0,0 +1,52 @@
+#include "../../tec.h"
+
+TEC(assertions, test_assert_success) {
+    TEC_ASSERT(1 == 1);
+    TEC_ASSERT(true);
+}
+
+TEC_XFAIL(assertions, test_assert_failure) { TEC_ASSERT(1 == 0); }
+
+TEC(assertions, test_equality_success) {
+    TEC_ASSERT_EQ(42, 42);
+    TEC_ASSERT_NE(42, 99);
+}
+
+TEC_XFAIL(assertions, test_equality_failure_eq) { TEC_ASSERT_EQ(42, 99); }
+TEC_XFAIL(assertions, test_equality_failure_ne) { TEC_ASSERT_NE(42, 42); }
+
+TEC(assertions, test_comparison_success) {
+    TEC_ASSERT_GT(10, 5);
+    TEC_ASSERT_GE(10, 10);
+    TEC_ASSERT_LT(5, 10);
+    TEC_ASSERT_LE(5, 5);
+}
+
+TEC_XFAIL(assertions, test_comparison_failure_gt) { TEC_ASSERT_GT(5, 10); }
+TEC_XFAIL(assertions, test_comparison_failure_le) { TEC_ASSERT_LE(10, 5); }
+
+TEC(assertions, test_string_and_pointer_success) {
+    const char *str = "hello";
+    const char *null_str = NULL;
+    TEC_ASSERT_STR_EQ("hello", str);
+    TEC_ASSERT_NOT_NULL(str);
+    TEC_ASSERT_NULL(null_str);
+}
+
+TEC_XFAIL(assertions, test_string_failure) {
+    TEC_ASSERT_STR_EQ("hello", "world");
+}
+
+TEC_XFAIL(assertions, test_pointer_failure) {
+    const char *str = "hello";
+    TEC_ASSERT_NULL(str);
+}
+
+TEC(assertions, test_float_near_success) {
+    TEC_ASSERT_FLOAT_EQ(0.1 + 0.2, 0.3);
+    TEC_ASSERT_NEAR(3.1415, 3.141, 0.01);
+}
+
+TEC_XFAIL(assertions, test_float_near_failure) {
+    TEC_ASSERT_NEAR(3.1415, 3.2, 0.01);
+}

tests/core/control_flow.c

@@ -0,0 +1,28 @@
+#include "../../tec.h"
+
+TEC(control_flow, this_test_should_be_skipped) {
+    TEC_SKIP("Testing the TEC_SKIP functionality.");
+    // This assertion should never run. If it does, the test fails.
+    TEC_ASSERT(false);
+}
+
+TEC_XFAIL(control_flow, this_xfail_should_fail_as_expected) {
+    // This is the correct use of XFAIL.
+    // The test fails, so the overall result for this test is a PASS.
+    TEC_ASSERT_EQ(1, 0);
+}
+
+// NOTE: The following test is INTENTIONALLY broken.
+// When you run the test suite, this test MUST be reported as FAILED.
+// This is the meta-test: it proves that XFAIL correctly reports an
+// unexpected success as a failure of the test suite.
+TEC_XFAIL(control_flow,
+          this_xfail_should_unexpectedly_pass_and_fail_the_suite) {
+    // This assertion passes...
+    TEC_ASSERT_EQ(1, 1);
+    // ...which means the XFAIL contract is broken, and the runner MUST
+    // report this specific test as a FAILURE.
+
+    // USING THIS SO THE SUMMARY DOESN'T LOOK THAT UGLY
+    // TEC_ASSERT_NE(1, 1);
+}

tests/core/formatter.c

@@ -0,0 +1,71 @@
+#include "../../tec.h"
+
+TEC(formatter_macros, test_signed_integers) {
+    int8_t i8 = INT8_MIN;
+    int16_t i16 = INT16_MIN;
+    int32_t i32 = INT32_MIN;
+    int64_t i64 = INT64_MIN;
+
+    TEC_ASSERT_EQ(i8, (int8_t)-128);
+    TEC_ASSERT_EQ(i16, (int16_t)-32768);
+    TEC_ASSERT_EQ(i32, (int32_t)-2147483648);
+    TEC_ASSERT_EQ(i64, (int64_t)(-9223372036854775807LL - 1LL));
+}
+
+TEC(formatter_macros, test_unsigned_integers) {
+    uint8_t u8 = UINT8_MAX;
+    uint16_t u16 = UINT16_MAX;
+    uint32_t u32 = UINT32_MAX;
+
+    TEC_ASSERT_EQ(u8, (uint8_t)255);
+    TEC_ASSERT_EQ(u16, (uint16_t)65535);
+    TEC_ASSERT_EQ(u32, (uint32_t)4294967295);
+}
+
+TEC(formatter_macros, test_large_unsigned_types) {
+    size_t s_t = (size_t)-1;
+    TEC_ASSERT_EQ(s_t, (size_t)-1);
+
+// The uint64_t type is only distinct from size_t on 32-bit systems.
+// On 64-bit systems, the _Generic macro omits this case, and a uint64_t
+// value will be correctly handled by the size_t case. This test ensures
+// it works on both architectures.
+#ifndef TEC_64BIT_SYSTEM_SIZE_T_CONFLICT_UINT64
+    uint64_t u64 = UINT64_MAX;
+    TEC_ASSERT_EQ(u64, (uint64_t)18446744073709551615ULL);
+#endif
+}
+
+TEC(formatter_macros, test_floating_point_types) {
+    float f = 3.14f;
+    double d = 2.71828;
+    long double ld = 1.61803398875L;
+
+    TEC_ASSERT_FLOAT_EQ(f, 3.14f);
+    TEC_ASSERT_FLOAT_EQ(d, 2.71828);
+    TEC_ASSERT_FLOAT_EQ(ld, 1.61803398875L);
+}
+
+TEC(formatter_macros, test_pointer_types) {
+    const char *cstr = "hello";
+    char buffer[] = "world";
+    char *pstr = buffer;
+    int x = 42;
+    void *vptr = &x;
+
+    TEC_ASSERT_STR_EQ(cstr, "hello");
+    TEC_ASSERT_STR_EQ(pstr, "world");
+    TEC_ASSERT_EQ(vptr, (void *)&x);
+}
+
+TEC_XFAIL(formatter_macros, verify_uint64_formatting_on_failure) {
+    uint64_t u64 = 18446744073709551615ULL; // UINT64_MAX
+    TEC_ASSERT_EQ(u64, (uint64_t)0);
+}
+
+TEC_XFAIL(formatter_macros, verify_default_case_formatting) {
+    struct SomeRandomStruct {
+        int a;
+    } my_struct = {1};
+    TEC_ASSERT_EQ(my_struct.a, 2);
+}

tests/core/setup_fixture.c

@@ -0,0 +1,29 @@
+#include "../../tec.h"
+static char *shared_buffer = NULL;
+
+// Runs once before all "buffer_tests"
+TEC_SETUP(buffer_tests) {
+    printf("  (Setting up suite...)\n");
+    shared_buffer = (char *)malloc(100);
+}
+
+// Runs once after all "buffer_tests"
+TEC_TEARDOWN(buffer_tests) {
+    printf("  (Tearing down suite...)\n");
+    free(shared_buffer);
+    shared_buffer = NULL;
+}
+
+// Runs before EACH test in this suite
+TEC_TEST_SETUP(buffer_tests) { strcpy(shared_buffer, "initial_state"); }
+
+TEC(buffer_tests, test_one) {
+    TEC_ASSERT_STR_EQ(shared_buffer, "initial_state");
+    strcpy(shared_buffer, "modified_by_one");
+    TEC_ASSERT_STR_EQ(shared_buffer, "modified_by_one");
+}
+
+TEC(buffer_tests, test_two) {
+    // This test gets a fresh state because TEC_TEST_SETUP ran again
+    TEC_ASSERT_STR_EQ(shared_buffer, "initial_state");
+}