Refactor: Deduplicate EXPECT macro to test_utils.h and use target_compile_definitions

Author: mrtcnk

CMakeLists.txt

@@ -1,20 +1,21 @@
 cmake_minimum_required(VERSION 3.16)
 project(mpt-crypto C CXX)
 
-# --- 1. Global Architecture Detection ---
+# --- Global Architecture Detection ---
 include(CheckTypeSize)
 check_type_size("unsigned __int128" HAVE_INT128_T)
 
+# Store definitions in a variable
 if (HAVE_INT128_T OR CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64" OR CMAKE_SYSTEM_PROCESSOR MATCHES "arm64"
     OR CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
-    message(STATUS "Build: Detected 64-bit system. Enforcing 64-bit arithmetic globally.")
-    add_compile_definitions(USE_SCALAR_4X64 USE_FIELD_5X52 HAVE___INT128)
+    message(STATUS "Build: Detected 64-bit system. Enforcing 64-bit arithmetic.")
+    set(MPT_ARCH_DEFS USE_SCALAR_4X64 USE_FIELD_5X52 HAVE___INT128)
 else ()
-    message(STATUS "Build: Detected 32-bit system. Enforcing generic arithmetic globally.")
-    add_compile_definitions(USE_SCALAR_8X32 USE_FIELD_10X26)
+    message(STATUS "Build: Detected 32-bit system. Enforcing generic arithmetic.")
+    set(MPT_ARCH_DEFS USE_SCALAR_8X32 USE_FIELD_10X26)
 endif ()
 
-# --- Find Dependencies (Maintainer's Way) ---
+# --- Find Dependencies ---
 find_package(OpenSSL REQUIRED)
 find_package(secp256k1 REQUIRED)
 
@@ -35,7 +36,7 @@ add_library(mpt-crypto
 target_include_directories(mpt-crypto PUBLIC include)
 
 # --- Set Compile Definitions ---
-target_compile_definitions(mpt-crypto PRIVATE ECMULT_WINDOW_SIZE=15 ECMULT_GEN_PREC_BITS=4)
+target_compile_definitions(mpt-crypto PRIVATE ECMULT_WINDOW_SIZE=15 ECMULT_GEN_PREC_BITS=4 PUBLIC ${MPT_ARCH_DEFS})
 
 # --- Link Dependencies ---
 target_link_libraries(mpt-crypto PUBLIC secp256k1::secp256k1 PUBLIC OpenSSL::Crypto)

src/mpt_scalar.c

@@ -44,7 +44,7 @@
 #include <private/int128.h>
 #include <private/int128_impl.h>
 
-/* 3. Include the actual scalar implementations */
+/* Include the actual scalar implementations */
 #include <private/scalar.h>
 #include <private/scalar_impl.h>
 

tests/test_bulletproof_agg.c

@@ -6,6 +6,7 @@
 #include <secp256k1.h>
 
 #include "secp256k1_mpt.h"
+#include "test_utils.h"
 
 /* ---- Aggregation parameters ---- */
 #define M 2
@@ -15,14 +16,6 @@
 /* ---- Benchmark parameters ---- */
 #define VERIFY_RUNS 5
 
-/* --- Macro: Persistent Assertion --- */
-#define EXPECT(cond, msg) do { \
-    if (!(cond)) { \
-        fprintf(stderr, "CRITICAL FAILURE: %s\nFile: %s, Line: %d\nCode: %s\n", \
-        msg, __FILE__, __LINE__, #cond); \
-        exit(EXIT_FAILURE); \
-    } \
-} while(0)
 
 /* ---- Helpers ---- */
 
@@ -50,7 +43,7 @@ int main(void) {
     /* ---- Context ---- */
     secp256k1_context* ctx =
             secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
-    EXPECT(ctx != NULL, "Failed to create context");
+    EXPECT(ctx != NULL);
 
     /* ---- Values ---- */
     uint64_t values[M] = { 5000, 123456 };
@@ -59,11 +52,11 @@ int main(void) {
 
     /* ---- Context Binding ---- */
     unsigned char context_id[32];
-    EXPECT(RAND_bytes(context_id, 32) == 1, "Failed to generate context_id");
+    EXPECT(RAND_bytes(context_id, 32) == 1);
 
     secp256k1_pubkey pk_base;
     /* Use the standard H generator from the library */
-    EXPECT(secp256k1_mpt_get_h_generator(ctx, &pk_base), "Failed to get H generator");
+    EXPECT(secp256k1_mpt_get_h_generator(ctx, &pk_base));
 
     /* ---- Commitments ---- */
     for (size_t i = 0; i < M; i++) {
@@ -73,19 +66,19 @@ int main(void) {
                 &commitments[i],
                 values[i],
                 blindings[i],
-                &pk_base), "Failed to create commitment");
+                &pk_base));
     }
 
     /* ---- Generator vectors ---- */
     const size_t n = BP_TOTAL_BITS(M);
     secp256k1_pubkey* G_vec = malloc(n * sizeof(secp256k1_pubkey));
     secp256k1_pubkey* H_vec = malloc(n * sizeof(secp256k1_pubkey));
-    EXPECT(G_vec && H_vec, "Malloc failed");
+    EXPECT(G_vec && H_vec);
 
     EXPECT(secp256k1_mpt_get_generator_vector(
-            ctx, G_vec, n, (const unsigned char*)"G", 1), "Failed to get G vector");
+            ctx, G_vec, n, (const unsigned char*)"G", 1));
     EXPECT(secp256k1_mpt_get_generator_vector(
-            ctx, H_vec, n, (const unsigned char*)"H", 1), "Failed to get H vector");
+            ctx, H_vec, n, (const unsigned char*)"H", 1));
 
     /* ---- Prove (timed) ---- */
     unsigned char proof[4096];
@@ -105,7 +98,7 @@ int main(void) {
             (const unsigned char*)blindings,
             M,
             &pk_base,
-            context_id), "Proving failed");
+            context_id));
 
     clock_gettime(CLOCK_MONOTONIC, &t_p_end);
 
@@ -132,7 +125,7 @@ int main(void) {
 
     clock_gettime(CLOCK_MONOTONIC, &t_v_end);
 
-    EXPECT(ok, "Verification failed (single run)");
+    EXPECT(ok);
 
     printf("PASSED\n");
     printf("[BENCH] Verification time (single): %.3f ms\n",
@@ -158,7 +151,7 @@ int main(void) {
 
         clock_gettime(CLOCK_MONOTONIC, &te);
 
-        EXPECT(ok, "Verification failed during benchmark");
+        EXPECT(ok);
         total_ms += elapsed_ms(ts, te);
     }
 
@@ -178,9 +171,9 @@ int main(void) {
     EXPECT(secp256k1_bulletproof_create_commitment(
             ctx,
             &bad_commitments[1],
-            values[1] + 1,
+            values[M - 1] + 1,
             bad_blinding,
-            &pk_base), "Failed to create bad commitment");
+            &pk_base));
 
     ok = secp256k1_bulletproof_verify_agg(
             ctx,

tests/test_commitments.c

@@ -1,16 +1,9 @@
 #include <stdio.h>
 #include <string.h>
-#include <stdlib.h> // Required for abort()
+#include <stdlib.h>
 #include "secp256k1_mpt.h"
 #include <openssl/rand.h>
-
-/* --- Macro: Persistent Assertion --- */
-#define EXPECT(condition) do { \
-    if (!(condition)) { \
-        fprintf(stderr, "TEST FAILED: %s at line %d\n", #condition, __LINE__); \
-        abort(); \
-    } \
-} while(0)
+#include "test_utils.h"
 
 /* --- Helper: Safe Random Scalar Generation --- */
 /* Ensures the random bytes form a valid curve scalar (0 < scalar < order) */

tests/test_elgamal.c

@@ -4,14 +4,7 @@
 #include <secp256k1.h>
 #include <openssl/rand.h>
 #include "secp256k1_mpt.h"
-
-/* --- Macro: Persistent Assertion --- */
-#define EXPECT(condition) do { \
-    if (!(condition)) { \
-        fprintf(stderr, "TEST FAILED: %s at line %d\n", #condition, __LINE__); \
-        abort(); \
-    } \
-} while(0)
+#include "test_utils.h"
 
 // Forward declarations for all test functions
 static void test_key_generation(const secp256k1_context* ctx);

tests/test_elgamal_verify.c

@@ -4,14 +4,7 @@
 #include <secp256k1.h>
 #include "secp256k1_mpt.h"
 #include <openssl/rand.h>
-
-/* --- Macro: Persistent Assertion --- */
-#define EXPECT(condition) do { \
-    if (!(condition)) { \
-        fprintf(stderr, "TEST FAILED: %s at line %d\n", #condition, __LINE__); \
-        abort(); \
-    } \
-} while(0)
+#include "test_utils.h"
 
 void test_elgamal_verify_encryption() {
     // 1. Setup Context

tests/test_equality_proof.c

@@ -4,14 +4,7 @@
 #include <secp256k1.h>
 #include <openssl/rand.h>
 #include "secp256k1_mpt.h"
-
-/* --- Macro: Persistent Assertion --- */
-#define EXPECT(condition) do { \
-    if (!(condition)) { \
-        fprintf(stderr, "TEST FAILED: %s at line %d\n", #condition, __LINE__); \
-        abort(); \
-    } \
-} while(0)
+#include "test_utils.h"
 
 // Helper: Generates 32 random bytes (e.g., for randomness or tx_context_id)
 // Now returns void and uses EXPECT internally to enforce success.

tests/test_ipa.c

@@ -5,19 +5,12 @@
 #include <openssl/rand.h>
 #include <openssl/sha.h>
 #include "secp256k1_mpt.h"
+#include "test_utils.h"
 
 #define N_BITS 64
 /* log2(64) = 6 rounds */
 #define IPA_ROUNDS 6
 
-/* --- Macro: Persistent Assertion --- */
-#define EXPECT(condition) do { \
-    if (!(condition)) { \
-        fprintf(stderr, "TEST FAILED: %s at line %d\n", #condition, __LINE__); \
-        abort(); \
-    } \
-} while(0)
-
 /* ---- Helper Macros ---- */
 static int scalar_is_zero(const unsigned char s[32]) {
     unsigned char z[32] = {0};

tests/test_link_proof.c

@@ -4,14 +4,7 @@
 #include "secp256k1_mpt.h"
 #include <secp256k1.h>
 #include <openssl/rand.h>
-
-/* --- Macro: Persistent Assertion --- */
-#define EXPECT(condition) do { \
-    if (!(condition)) { \
-        fprintf(stderr, "TEST FAILED: %s at line %d\n", #condition, __LINE__); \
-        abort(); \
-    } \
-} while(0)
+#include "test_utils.h"
 
 /* --- Helper: Safe Random Scalar Generation --- */
 static void random_scalar(const secp256k1_context* ctx, unsigned char* out) {

tests/test_pok_sk.c

@@ -4,14 +4,7 @@
 #include "secp256k1_mpt.h"
 #include <secp256k1.h>
 #include <openssl/rand.h>
-
-/* --- Macro: Persistent Assertion --- */
-#define EXPECT(condition) do { \
-    if (!(condition)) { \
-        fprintf(stderr, "TEST FAILED: %s at line %d\n", #condition, __LINE__); \
-        abort(); \
-    } \
-} while(0)
+#include "test_utils.h"
 
 /* --- Helper: Safe Random Scalar Generation --- */
 static void random_scalar(const secp256k1_context* ctx, unsigned char* out) {