fixup! improve tests

Author: jonasnick

src/tests.c

@@ -3675,6 +3675,77 @@ static void run_inverse_tests(void)
     }
 }
 
+/***** HSORT TESTS *****/
+
+static void test_heap_swap(void) {
+    unsigned char a[600];
+    unsigned char e[sizeof(a)];
+    memset(a,       21, 200);
+    memset(a + 200, 99, 200);
+    memset(a + 400, 42, 200);
+    memset(e,       42, 200);
+    memset(e + 200, 99, 200);
+    memset(e + 400, 21, 200);
+    secp256k1_heap_swap(a, 0, 2, 200);
+    CHECK(secp256k1_memcmp_var(a, e, sizeof(a)) == 0);
+}
+
+static void test_hsort_is_sorted(unsigned char *elements, size_t n, size_t len) {
+    size_t i;
+    for (i = 1; i < n; i++) {
+        CHECK(memcmp(&elements[(i-1) * len], &elements[i * len], len) <= 0);
+    }
+}
+
+struct test_hsort_cmp_data {
+    size_t counter;
+    size_t element_len;
+};
+
+static int test_hsort_cmp(const void *ele1, const void *ele2, void *data) {
+  struct test_hsort_cmp_data *d = (struct test_hsort_cmp_data *) data;
+  d->counter += 1;
+  return memcmp((unsigned char *)ele1, (unsigned char *)ele2, d->element_len);
+}
+
+#define NUM 65
+#define MAX_ELEMENT_LEN 65
+static void test_hsort(size_t element_len) {
+    unsigned char elements[NUM * MAX_ELEMENT_LEN] = { 0 };
+    struct test_hsort_cmp_data data;
+    int i;
+
+    VERIFY_CHECK(element_len <= MAX_ELEMENT_LEN);
+    data.counter = 0;
+    data.element_len = element_len;
+
+    secp256k1_hsort(elements, 0, element_len, test_hsort_cmp, &data);
+    CHECK(data.counter == 0);
+    secp256k1_hsort(elements, 1, element_len, test_hsort_cmp, &data);
+    CHECK(data.counter == 0);
+    secp256k1_hsort(elements, NUM, element_len, test_hsort_cmp, &data);
+    CHECK(data.counter >= NUM);
+    test_hsort_is_sorted(elements, NUM, element_len);
+
+    /* Test hsort with array of random length n */
+    for (i = 0; i < COUNT; i++) {
+        int n = secp256k1_testrand_int(NUM);
+        secp256k1_testrand_bytes_test(elements, n*element_len);
+        secp256k1_hsort(elements, n, element_len, test_hsort_cmp, &data);
+        test_hsort_is_sorted(elements, n, element_len);
+    }
+}
+#undef NUM
+#undef MAX_ELEMENT_LEN
+
+
+static void run_hsort_tests(void) {
+    test_heap_swap();
+    test_hsort(1);
+    test_hsort(64);
+    test_hsort(65);
+}
+
 /***** GROUP TESTS *****/
 
 /* This compares jacobian points including their Z, not just their geometric meaning. */
@@ -6607,59 +6678,6 @@ static void run_pubkey_comparison(void) {
     CHECK(secp256k1_ec_pubkey_cmp(CTX, &pk2, &pk1) > 0);
 }
 
-static void test_heap_swap(void) {
-    unsigned char a[600];
-    unsigned char e[sizeof(a)];
-    memset(a,       21, 200);
-    memset(a + 200, 99, 200);
-    memset(a + 400, 42, 200);
-    memset(e,       42, 200);
-    memset(e + 200, 99, 200);
-    memset(e + 400, 21, 200);
-    secp256k1_heap_swap(a, 0, 2, 200);
-    CHECK(secp256k1_memcmp_var(a, e, sizeof(a)) == 0);
-}
-
-static void test_hsort_is_sorted(int *ints, size_t n) {
-    size_t i;
-    for (i = 1; i < n; i++) {
-        CHECK(ints[i-1] <= ints[i]);
-    }
-}
-
-static int test_hsort_cmp(const void *i1, const void *i2, void *counter) {
-  *(size_t*)counter += 1;
-  return *(int*)i1 - *(int*)i2;
-}
-
-#define NUM 64
-static void test_hsort(void) {
-    int ints[NUM] = { 0 };
-    size_t counter = 0;
-    int i, j;
-
-    secp256k1_hsort(ints, 0, sizeof(ints[0]), test_hsort_cmp, &counter);
-    CHECK(counter == 0);
-    secp256k1_hsort(ints, 1, sizeof(ints[0]), test_hsort_cmp, &counter);
-    CHECK(counter == 0);
-    secp256k1_hsort(ints, NUM, sizeof(ints[0]), test_hsort_cmp, &counter);
-    CHECK(counter > 0);
-    test_hsort_is_sorted(ints, NUM);
-
-    /* Test hsort with length n array and random elements in
-     * [-interval/2, interval/2] */
-    for (i = 0; i < COUNT; i++) {
-        int n = secp256k1_testrand_int(NUM);
-        int interval = secp256k1_testrand_int(63) + 1;
-        for (j = 0; j < n; j++) {
-            ints[j] = secp256k1_testrand_int(interval) - interval/2;
-        }
-        secp256k1_hsort(ints, n, sizeof(ints[0]), test_hsort_cmp, &counter);
-        test_hsort_is_sorted(ints, n);
-    }
-}
-#undef NUM
-
 static void test_sort_helper(secp256k1_pubkey *pk, size_t *pk_order, size_t n_pk) {
     size_t i;
     const secp256k1_pubkey *pk_test[5];
@@ -6809,11 +6827,9 @@ static void test_sort_vectors(void) {
 }
 
 static void run_pubkey_sort(void) {
-    test_hsort();
     test_sort_api();
     test_sort();
     test_sort_vectors();
-    test_heap_swap();
 }
 
 
@@ -7776,6 +7792,9 @@ int main(int argc, char **argv) {
     run_modinv_tests();
     run_inverse_tests();
 
+    /* sorting tests */
+    run_hsort_tests();
+
     /* hash tests */
     run_sha256_known_output_tests();
     run_sha256_counter_tests();