Few AI-generated unit tests to cover what is possible

Author: iartemov-ledger

unit-tests/CMakeLists.txt

@@ -53,22 +53,29 @@ add_executable(test_display_utils test_display_utils.c)
 add_executable(test_parser test_parser.c)
 add_executable(test_script test_script.c)
 add_executable(test_wallet test_wallet.c)
+add_executable(test_musig_zeroing test_musig_zeroing.c)
+add_executable(test_merkle_return_values test_merkle_return_values.c)
 
 # add_executable(test_crypto test_crypto.c)
 
 # Mock libraries
 add_library(crypto_mocks SHARED libs/crypto_mocks.c)
 add_library(sha256 SHARED libs/sha-256.c)
+add_library(musig_test_mocks SHARED libs/musig_test_mocks.c)
+add_library(merkle_test_mocks SHARED libs/merkle_test_mocks.c)
 
 # App's libraries
 add_library(base58 SHARED $ENV{BOLOS_SDK}/lib_standard_app/base58.c)
 add_library(bip32 SHARED $ENV{BOLOS_SDK}/lib_standard_app/bip32.c)
 add_library(buffer SHARED $ENV{BOLOS_SDK}/lib_standard_app/buffer.c)
 add_library(buffer_ext SHARED ../src/common/buffer_ext.c)
 add_library(display_utils SHARED ../src/ui/display_utils.c)
+add_library(musig SHARED ../src/musig/musig.c)
 add_library(parser SHARED ../src/common/parser_ext.c)
 add_library(read SHARED $ENV{BOLOS_SDK}/lib_standard_app/read.c)
 add_library(script SHARED ../src/common/script.c)
+add_library(secp256k1 SHARED ../src/secp256k1.c)
+add_library(get_merkleized_map_value SHARED ../src/handler/lib/get_merkleized_map_value.c)
 add_library(varint SHARED $ENV{BOLOS_SDK}/lib_standard_app/varint.c)
 add_library(wallet SHARED ../src/common/wallet.c)
 add_library(write SHARED $ENV{BOLOS_SDK}/lib_standard_app/write.c)
@@ -78,13 +85,23 @@ add_library(write SHARED $ENV{BOLOS_SDK}/lib_standard_app/write.c)
 # Mock libraries
 target_link_libraries(crypto_mocks PUBLIC sha256)
 
+# Musig library needs the mock crypto functions and secp256k1 constants
+target_link_libraries(musig PUBLIC musig_test_mocks secp256k1 write)
+
 # App's libraries
 target_link_libraries(test_bitvector PUBLIC cmocka gcov)
 target_link_libraries(test_buffer PUBLIC cmocka gcov buffer buffer_ext varint read write bip32)
 target_link_libraries(test_display_utils PUBLIC cmocka gcov display_utils)
 target_link_libraries(test_parser PUBLIC cmocka gcov parser buffer buffer_ext varint read write bip32)
 target_link_libraries(test_script PUBLIC cmocka gcov script buffer varint read write bip32)
 target_link_libraries(test_wallet PUBLIC cmocka gcov wallet script buffer buffer_ext varint read write bip32 base58 crypto_mocks)
+target_link_libraries(test_musig_zeroing PUBLIC cmocka gcov musig musig_test_mocks secp256k1)
+
+# Merkle return value test: compile get_merkleized_map_value.c against mock sub-functions
+target_include_directories(get_merkleized_map_value PRIVATE ../src/common ../src/handler/lib)
+target_include_directories(test_merkle_return_values PRIVATE ../src/common ../src/handler/lib)
+target_link_libraries(get_merkleized_map_value PUBLIC merkle_test_mocks read)
+target_link_libraries(test_merkle_return_values PUBLIC cmocka gcov get_merkleized_map_value merkle_test_mocks read)
 
 # target_link_libraries(test_crypto PUBLIC cmocka gcov crypto)
 add_test(test_bitvector test_bitvector)
@@ -93,5 +110,7 @@ add_test(test_display_utils test_display_utils)
 add_test(test_parser test_parser)
 add_test(test_script test_script)
 add_test(test_wallet test_wallet)
+add_test(test_musig_zeroing test_musig_zeroing)
+add_test(test_merkle_return_values test_merkle_return_values)
 
 # add_test(test_crypto test_crypto)

unit-tests/libs/merkle_test_mocks.c

@@ -0,0 +1,107 @@
+/**
+ * Mock implementations for merkle/map value unit tests.
+ *
+ * Provides controllable mock versions of:
+ *   - call_get_merkle_leaf_index()
+ *   - call_get_merkle_leaf_element()
+ *   - merkle_compute_element_hash()
+ *
+ * These are the three functions called by call_get_merkleized_map_value().
+ */
+
+#include <string.h>
+#include <stdint.h>
+#include <stddef.h>
+
+#include "merkle_test_mocks.h"
+
+/* Minimal type definitions needed - dispatcher_context_t is an opaque pointer here */
+typedef struct dispatcher_context_s dispatcher_context_t;
+
+/* ---------- Internal mock state ---------- */
+
+static int g_leaf_index_retval = 0;
+static int g_leaf_element_retval = 0;
+
+/* ---------- Mock control API ---------- */
+
+void merkle_mock_reset(void) {
+    g_leaf_index_retval = 0;
+    g_leaf_element_retval = 0;
+}
+
+void merkle_mock_set_leaf_index_retval(int retval) {
+    g_leaf_index_retval = retval;
+}
+
+void merkle_mock_set_leaf_element_retval(int retval) {
+    g_leaf_element_retval = retval;
+}
+
+/* ---------- Mocked functions ---------- */
+
+/**
+ * Mock merkle_compute_element_hash.
+ * Just fills the output with a dummy hash (no real SHA256 needed).
+ */
+void merkle_compute_element_hash(const uint8_t *in, size_t in_len, uint8_t out[32]) {
+    (void) in;
+    (void) in_len;
+    memset(out, 0xAA, 32);
+}
+
+/**
+ * Mock call_get_merkle_leaf_index.
+ * Returns whatever was configured via merkle_mock_set_leaf_index_retval().
+ *
+ * In real code, can return:
+ *   >= 0 on success (the index)
+ *   -1   parse failure
+ *   -2   invalid found value
+ *   -3   not found / interruption failure
+ *   -4   hash failure
+ *   -5   hash mismatch
+ */
+int call_get_merkle_leaf_index(dispatcher_context_t *dispatcher_context,
+                               size_t size,
+                               const uint8_t root[32],
+                               const uint8_t leaf_hash[32]) {
+    (void) dispatcher_context;
+    (void) size;
+    (void) root;
+    (void) leaf_hash;
+    return g_leaf_index_retval;
+}
+
+/**
+ * Mock call_get_merkle_leaf_element.
+ * Returns whatever was configured via merkle_mock_set_leaf_element_retval().
+ *
+ * When the configured return value is >= 0 (success), fills the output buffer
+ * with a pattern of that many bytes.
+ *
+ * In real code, can return:
+ *   >= 0  on success (the length of the element)
+ *   -1 through -10  from call_get_merkle_preimage (various error codes)
+ */
+int call_get_merkle_leaf_element(dispatcher_context_t *dispatcher_context,
+                                 const uint8_t merkle_root[32],
+                                 uint32_t tree_size,
+                                 uint32_t leaf_index,
+                                 uint8_t *out_ptr,
+                                 size_t out_ptr_len) {
+    (void) dispatcher_context;
+    (void) merkle_root;
+    (void) tree_size;
+    (void) leaf_index;
+
+    if (g_leaf_element_retval >= 0) {
+        /* Simulate a successful read: fill buffer with dummy data */
+        size_t fill_len = (size_t) g_leaf_element_retval;
+        if (fill_len > out_ptr_len) {
+            fill_len = out_ptr_len;
+        }
+        memset(out_ptr, 0xBB, fill_len);
+    }
+    return g_leaf_element_retval;
+}

unit-tests/libs/merkle_test_mocks.h

@@ -0,0 +1,27 @@
+#pragma once
+
+/**
+ * Mock control interface for merkle/map value unit tests.
+ *
+ * These allow configuring what call_get_merkle_leaf_index and
+ * call_get_merkle_leaf_element return, enabling us to test
+ * call_get_merkleized_map_value's error propagation behavior.
+ */
+
+/**
+ * Resets all mock state. Call before each test.
+ */
+void merkle_mock_reset(void);
+
+/**
+ * Set the return value that the mock call_get_merkle_leaf_index will return
+ * on the next call.
+ */
+void merkle_mock_set_leaf_index_retval(int retval);
+
+/**
+ * Set the return value that the mock call_get_merkle_leaf_element will return
+ * on the next call. When >= 0, the mock will also fill the output buffer
+ * with a dummy pattern.
+ */
+void merkle_mock_set_leaf_element_retval(int retval);