Add delta roundtrip edge-case coverage

F/2271

Author: danielinux

tools/unit-tests/unit-delta.c

@@ -302,54 +302,213 @@ static void initialize_buffers(uint8_t *src_a, uint8_t *src_b, size_t size)
 
 }
 
-START_TEST(test_wb_patch_and_diff)
+static uint8_t pattern_byte(uint32_t seed, size_t index)
+{
+    uint32_t value = seed ^ (uint32_t)index;
+
+    value *= 1664525U;
+    value += 1013904223U;
+    value ^= (uint32_t)(index >> 8);
+    value ^= (uint32_t)(index >> 16);
+
+    if ((uint8_t)value == ESC) {
+        value ^= 0x55U;
+    }
+    return (uint8_t)value;
+}
+
+static void fill_pattern(uint8_t *dst, size_t size, uint32_t seed)
+{
+    size_t i;
+
+    for (i = 0; i < size; ++i) {
+        dst[i] = pattern_byte(seed, i);
+    }
+}
+
+static uint32_t run_roundtrip_case(const uint8_t *src_a, uint32_t size_a,
+    const uint8_t *src_b, uint32_t size_b, uint32_t patch_capacity)
 {
     WB_DIFF_CTX diff_ctx;
     WB_PATCH_CTX patch_ctx;
-    uint8_t src_a[SRC_SIZE];
-    uint8_t src_b[SRC_SIZE];
-    uint8_t patch[PATCH_SIZE];
-    uint8_t patched_dst[DST_SIZE];
-    int ret;
-    int i;
+    uint8_t *src_a_copy;
+    uint8_t *patch;
+    uint8_t *patched_dst;
+    uint8_t *new_patch;
+    uint8_t block[DELTA_BLOCK_SIZE] = {0};
     uint32_t p_written = 0;
+    uint32_t dst_written = 0;
+    int ret;
 
+    src_a_copy = malloc(size_a);
+    patch = malloc(patch_capacity);
+    patched_dst = malloc(size_b);
+    ck_assert_ptr_nonnull(src_a_copy);
+    ck_assert_ptr_nonnull(patch);
+    ck_assert_ptr_nonnull(patched_dst);
 
-    initialize_buffers(src_a, src_b, SRC_SIZE);
+    memcpy(src_a_copy, src_a, size_a);
 
-    ret = wb_diff_init(&diff_ctx, src_a, SRC_SIZE, src_b, SRC_SIZE);
+    ret = wb_diff_init(&diff_ctx, src_a_copy, size_a, (uint8_t *)src_b, size_b);
     ck_assert_int_eq(ret, 0);
 
-    /* Create the patch */
-    for (i = 0; i < SRC_SIZE; i += DELTA_BLOCK_SIZE) {
-        ret = wb_diff(&diff_ctx, patch + p_written, DELTA_BLOCK_SIZE);
-        ck_assert_int_ge(ret, 0); /* Should not be 0 until patch is over*/
-        if (ret == 0)
+    for (;;) {
+        uint32_t remaining = patch_capacity - p_written;
+
+        ck_assert_uint_ge(remaining, BLOCK_HDR_SIZE);
+        ret = wb_diff(&diff_ctx, patch + p_written,
+            remaining > DELTA_BLOCK_SIZE ? DELTA_BLOCK_SIZE : remaining);
+        ck_assert_int_ge(ret, 0);
+        if (ret == 0) {
+            if (diff_ctx.off_b < size_b) {
+                patch_capacity += DELTA_BLOCK_SIZE;
+                new_patch = realloc(patch, patch_capacity);
+                ck_assert_ptr_nonnull(new_patch);
+                patch = new_patch;
+                continue;
+            }
             break;
-        p_written += ret;
+        }
+        p_written += (uint32_t)ret;
+        ck_assert_uint_le(p_written, patch_capacity);
     }
-    ck_assert_int_gt(p_written, 0); /* Should not be 0 */
 
-    printf("patch size: %u\n", p_written);
-    ret = wb_patch_init(&patch_ctx, src_a, SRC_SIZE, patch, p_written);
+    ck_assert_uint_eq(diff_ctx.off_b, size_b);
+    ck_assert_uint_gt(p_written, 0);
+
+    ret = wb_patch_init(&patch_ctx, src_a_copy, size_a, patch, p_written);
     ck_assert_int_eq(ret, 0);
 
-    /* Apply the patch */
-    for (i = 0; i < SRC_SIZE;)
-    {
-        ret = wb_patch(&patch_ctx, patched_dst + i, DELTA_BLOCK_SIZE);
-        ck_assert_int_ge(ret, 0); /* Should not be 0 until patch is over*/
-        if (ret == 0)
+    for (;;) {
+        ret = wb_patch(&patch_ctx, block, sizeof(block));
+        ck_assert_int_ge(ret, 0);
+        if (ret == 0) {
             break;
-        i += ret;
+        }
+        ck_assert_uint_le(dst_written + (uint32_t)ret, size_b);
+        memcpy(patched_dst + dst_written, block, (uint32_t)ret);
+        dst_written += (uint32_t)ret;
     }
-    ck_assert_int_gt(i, 0); /* Should not be 0 */
-    ck_assert_int_eq(i, SRC_SIZE); // The patched length should match the buffer size
 
-    /* Verify that the patched destination matches src_b */
-    for (i = 0; i < SRC_SIZE; ++i) {
-        ck_assert_uint_eq(patched_dst[i], src_b[i]);
-    }
+    ck_assert_uint_eq(dst_written, size_b);
+    ck_assert_int_eq(memcmp(patched_dst, src_b, size_b), 0);
+
+    free(patched_dst);
+    free(patch);
+    free(src_a_copy);
+    return p_written;
+}
+
+START_TEST(test_wb_patch_and_diff)
+{
+    uint8_t src_a[SRC_SIZE];
+    uint8_t src_b[SRC_SIZE];
+    uint32_t p_written = 0;
+
+    initialize_buffers(src_a, src_b, SRC_SIZE);
+
+    p_written = run_roundtrip_case(src_a, SRC_SIZE, src_b, SRC_SIZE, PATCH_SIZE);
+    printf("patch size: %u\n", p_written);
+}
+END_TEST
+
+START_TEST(test_wb_patch_and_diff_identical_images)
+{
+    uint8_t src_a[SRC_SIZE];
+    uint32_t p_written;
+
+    fill_pattern(src_a, sizeof(src_a), 0x12345678U);
+
+    p_written = run_roundtrip_case(src_a, sizeof(src_a), src_a, sizeof(src_a),
+        PATCH_SIZE);
+    ck_assert_uint_lt(p_written, 64);
+}
+END_TEST
+
+START_TEST(test_wb_patch_and_diff_completely_different_images)
+{
+    uint8_t src_a[SRC_SIZE];
+    uint8_t src_b[SRC_SIZE];
+
+    fill_pattern(src_a, sizeof(src_a), 0x11111111U);
+    fill_pattern(src_b, sizeof(src_b), 0x22222222U);
+
+    (void)run_roundtrip_case(src_a, sizeof(src_a), src_b, sizeof(src_b),
+        sizeof(src_b) + DELTA_BLOCK_SIZE);
+}
+END_TEST
+
+START_TEST(test_wb_patch_and_diff_all_escape_images)
+{
+    uint8_t src_a[SRC_SIZE];
+    uint8_t src_b[SRC_SIZE];
+
+    memset(src_a, ESC, sizeof(src_a));
+    memset(src_b, ESC, sizeof(src_b));
+
+    (void)run_roundtrip_case(src_a, sizeof(src_a), src_b, sizeof(src_b),
+        PATCH_SIZE);
+}
+END_TEST
+
+START_TEST(test_wb_patch_and_diff_multi_sector_images)
+{
+    int sector_size_ret;
+    uint32_t size;
+    uint8_t *src_a;
+    uint8_t *src_b;
+
+    sector_size_ret = wb_diff_get_sector_size();
+    ck_assert_int_gt(sector_size_ret, BLOCK_HDR_SIZE);
+    size = (uint32_t)(3 * sector_size_ret + 37);
+
+    src_a = malloc(size);
+    src_b = malloc(size);
+    ck_assert_ptr_nonnull(src_a);
+    ck_assert_ptr_nonnull(src_b);
+
+    fill_pattern(src_a, size, 0xA5A5A5A5U);
+    memcpy(src_b, src_a, size);
+    src_b[sector_size_ret - 1] ^= 0x11;
+    src_b[sector_size_ret] ^= 0x22;
+    src_b[(2 * sector_size_ret) + 5] = ESC;
+
+    (void)run_roundtrip_case(src_a, size, src_b, size, size + DELTA_BLOCK_SIZE);
+
+    free(src_b);
+    free(src_a);
+}
+END_TEST
+
+START_TEST(test_wb_patch_and_diff_size_changing_update)
+{
+    uint8_t src_a[2048];
+    uint8_t src_b[3077];
+
+    fill_pattern(src_a, sizeof(src_a), 0x31415926U);
+    fill_pattern(src_b, sizeof(src_b), 0x27182818U);
+    memcpy(src_b + 512, src_a, sizeof(src_a));
+    src_b[0] = ESC;
+    src_b[sizeof(src_b) - 1] ^= 0x5A;
+
+    (void)run_roundtrip_case(src_a, sizeof(src_a), src_b, sizeof(src_b),
+        sizeof(src_b) + DELTA_BLOCK_SIZE);
+}
+END_TEST
+
+START_TEST(test_wb_patch_and_diff_single_byte_difference)
+{
+    uint8_t src_a[SRC_SIZE];
+    uint8_t src_b[SRC_SIZE];
+    uint32_t p_written;
+
+    fill_pattern(src_a, sizeof(src_a), 0x0BADB002U);
+    memcpy(src_b, src_a, sizeof(src_a));
+    src_b[1537] ^= 0x01;
+
+    p_written = run_roundtrip_case(src_a, sizeof(src_a), src_b, sizeof(src_b),
+        PATCH_SIZE);
+    ck_assert_uint_lt(p_written, 64);
 }
 END_TEST
 
@@ -376,6 +535,12 @@ Suite *patch_diff_suite(void)
     tcase_add_test(tc_wolfboot_delta, test_wb_diff_preserves_main_loop_header_margin_for_escape);
     tcase_add_test(tc_wolfboot_delta, test_wb_diff_rejects_match_offsets_beyond_24_bits);
     tcase_add_test(tc_wolfboot_delta, test_wb_patch_and_diff);
+    tcase_add_test(tc_wolfboot_delta, test_wb_patch_and_diff_identical_images);
+    tcase_add_test(tc_wolfboot_delta, test_wb_patch_and_diff_completely_different_images);
+    tcase_add_test(tc_wolfboot_delta, test_wb_patch_and_diff_all_escape_images);
+    tcase_add_test(tc_wolfboot_delta, test_wb_patch_and_diff_multi_sector_images);
+    tcase_add_test(tc_wolfboot_delta, test_wb_patch_and_diff_size_changing_update);
+    tcase_add_test(tc_wolfboot_delta, test_wb_patch_and_diff_single_byte_difference);
     suite_add_tcase(s, tc_wolfboot_delta);
 
     return s;