Merge #628: Fix ability to compile tests without -DVERIFY.

dcf3920 Fix ability to compile tests without -DVERIFY. (Gregory Maxwell)

Pull request description:

  Broken by 3f3964e4.

  It's important that the tests are also run without -DVERIFY due to
   the possibility that side-effects of a VERIFY_CHECK fix a bug that
   would otherwise be detected.

  Use of the verify_check macro in tests isn't sufficient.

ACKs for commit dcf392:

Tree-SHA512: ff7ca0e89e33f845656a4d7d18c0195d1378b020d67f89e900b18cf3d702aa81dd91ffd05a98953a481b83e4247eaf0c484bea12eab020efb3c966a456e8129f

diff --combined src/tests.c
index 33e69e2d00bae4b395b57e03c964550aa5519afd,d95b3609d54121439a2130ccbb55fc31694bc6c1..132df9ba9caab6d7076faaebc6935b2ed63eb4f0
--- 1/src/tests.c
--- 2/src/tests.c
+++ b/src/tests.c
@@@ -83,7 -83,9 +83,9 @@@ void random_field_element_magnitude(sec
      secp256k1_fe_negate(&zero, &zero, 0);
      secp256k1_fe_mul_int(&zero, n - 1);
      secp256k1_fe_add(fe, &zero);
-     VERIFY_CHECK(fe->magnitude == n);
+ #ifdef VERIFY
+     CHECK(fe->magnitude == n);
+ #endif
  }
  
  void random_group_element_test(secp256k1_ge *ge) {
@@@ -333,73 -335,40 +335,73 @@@ void run_context_tests(int use_prealloc
  }
  
  void run_scratch_tests(void) {
 +    const size_t adj_alloc = ((500 + ALIGNMENT - 1) / ALIGNMENT) * ALIGNMENT;
 +
      int32_t ecount = 0;
 +    size_t checkpoint;
 +    size_t checkpoint_2;
      secp256k1_context *none = secp256k1_context_create(SECP256K1_CONTEXT_NONE);
      secp256k1_scratch_space *scratch;
 +    secp256k1_scratch_space local_scratch;
  
      /* Test public API */
      secp256k1_context_set_illegal_callback(none, counting_illegal_callback_fn, &ecount);
 +    secp256k1_context_set_error_callback(none, counting_illegal_callback_fn, &ecount);
  
      scratch = secp256k1_scratch_space_create(none, 1000);
      CHECK(scratch != NULL);
      CHECK(ecount == 0);
  
      /* Test internal API */
 -    CHECK(secp256k1_scratch_max_allocation(scratch, 0) == 1000);
 -    CHECK(secp256k1_scratch_max_allocation(scratch, 1) < 1000);
 -
 -    /* Allocating 500 bytes with no frame fails */
 -    CHECK(secp256k1_scratch_alloc(scratch, 500) == NULL);
 -    CHECK(secp256k1_scratch_max_allocation(scratch, 0) == 1000);
 -
 -    /* ...but pushing a new stack frame does affect the max allocation */
 -    CHECK(secp256k1_scratch_allocate_frame(scratch, 500, 1 == 1));
 -    CHECK(secp256k1_scratch_max_allocation(scratch, 1) < 500); /* 500 - ALIGNMENT */
 -    CHECK(secp256k1_scratch_alloc(scratch, 500) != NULL);
 -    CHECK(secp256k1_scratch_alloc(scratch, 500) == NULL);
 -
 -    CHECK(secp256k1_scratch_allocate_frame(scratch, 500, 1) == 0);
 +    CHECK(secp256k1_scratch_max_allocation(&none->error_callback, scratch, 0) == 1000);
 +    CHECK(secp256k1_scratch_max_allocation(&none->error_callback, scratch, 1) == 1000 - (ALIGNMENT - 1));
 +    CHECK(scratch->alloc_size == 0);
 +    CHECK(scratch->alloc_size % ALIGNMENT == 0);
 +
 +    /* Allocating 500 bytes succeeds */
 +    checkpoint = secp256k1_scratch_checkpoint(&none->error_callback, scratch);
 +    CHECK(secp256k1_scratch_alloc(&none->error_callback, scratch, 500) != NULL);
 +    CHECK(secp256k1_scratch_max_allocation(&none->error_callback, scratch, 0) == 1000 - adj_alloc);
 +    CHECK(secp256k1_scratch_max_allocation(&none->error_callback, scratch, 1) == 1000 - adj_alloc - (ALIGNMENT - 1));
 +    CHECK(scratch->alloc_size != 0);
 +    CHECK(scratch->alloc_size % ALIGNMENT == 0);
 +
 +    /* Allocating another 500 bytes fails */
 +    CHECK(secp256k1_scratch_alloc(&none->error_callback, scratch, 500) == NULL);
 +    CHECK(secp256k1_scratch_max_allocation(&none->error_callback, scratch, 0) == 1000 - adj_alloc);
 +    CHECK(secp256k1_scratch_max_allocation(&none->error_callback, scratch, 1) == 1000 - adj_alloc - (ALIGNMENT - 1));
 +    CHECK(scratch->alloc_size != 0);
 +    CHECK(scratch->alloc_size % ALIGNMENT == 0);
 +
 +    /* ...but it succeeds once we apply the checkpoint to undo it */
 +    secp256k1_scratch_apply_checkpoint(&none->error_callback, scratch, checkpoint);
 +    CHECK(scratch->alloc_size == 0);
 +    CHECK(secp256k1_scratch_max_allocation(&none->error_callback, scratch, 0) == 1000);
 +    CHECK(secp256k1_scratch_alloc(&none->error_callback, scratch, 500) != NULL);
 +    CHECK(scratch->alloc_size != 0);
 +
 +    /* try to apply a bad checkpoint */
 +    checkpoint_2 = secp256k1_scratch_checkpoint(&none->error_callback, scratch);
 +    secp256k1_scratch_apply_checkpoint(&none->error_callback, scratch, checkpoint);
 +    CHECK(ecount == 0);
 +    secp256k1_scratch_apply_checkpoint(&none->error_callback, scratch, checkpoint_2); /* checkpoint_2 is after checkpoint */
 +    CHECK(ecount == 1);
 +    secp256k1_scratch_apply_checkpoint(&none->error_callback, scratch, (size_t) -1); /* this is just wildly invalid */
 +    CHECK(ecount == 2);
  
 -    /* ...and this effect is undone by popping the frame */
 -    secp256k1_scratch_deallocate_frame(scratch);
 -    CHECK(secp256k1_scratch_max_allocation(scratch, 0) == 1000);
 -    CHECK(secp256k1_scratch_alloc(scratch, 500) == NULL);
 +    /* try to use badly initialized scratch space */
 +    secp256k1_scratch_space_destroy(none, scratch);
 +    memset(&local_scratch, 0, sizeof(local_scratch));
 +    scratch = &local_scratch;
 +    CHECK(!secp256k1_scratch_max_allocation(&none->error_callback, scratch, 0));
 +    CHECK(ecount == 3);
 +    CHECK(secp256k1_scratch_alloc(&none->error_callback, scratch, 500) == NULL);
 +    CHECK(ecount == 4);
 +    secp256k1_scratch_space_destroy(none, scratch);
 +    CHECK(ecount == 5);
  
      /* cleanup */
 -    secp256k1_scratch_space_destroy(scratch);
 +    secp256k1_scratch_space_destroy(none, NULL); /* no-op */
      secp256k1_context_destroy(none);
  }
  
@@@ -1819,24 -1788,32 +1821,32 @@@ void run_field_misc(void) 
          /* Test fe conditional move; z is not normalized here. */
          q = x;
          secp256k1_fe_cmov(&x, &z, 0);
-         VERIFY_CHECK(!x.normalized && x.magnitude == z.magnitude);
+ #ifdef VERIFY
+         CHECK(!x.normalized && x.magnitude == z.magnitude);
+ #endif
          secp256k1_fe_cmov(&x, &x, 1);
          CHECK(fe_memcmp(&x, &z) != 0);
          CHECK(fe_memcmp(&x, &q) == 0);
          secp256k1_fe_cmov(&q, &z, 1);
-         VERIFY_CHECK(!q.normalized && q.magnitude == z.magnitude);
+ #ifdef VERIFY
+         CHECK(!q.normalized && q.magnitude == z.magnitude);
+ #endif
          CHECK(fe_memcmp(&q, &z) == 0);
          secp256k1_fe_normalize_var(&x);
          secp256k1_fe_normalize_var(&z);
          CHECK(!secp256k1_fe_equal_var(&x, &z));
          secp256k1_fe_normalize_var(&q);
          secp256k1_fe_cmov(&q, &z, (i&1));
-         VERIFY_CHECK(q.normalized && q.magnitude == 1);
+ #ifdef VERIFY
+         CHECK(q.normalized && q.magnitude == 1);
+ #endif
          for (j = 0; j < 6; j++) {
              secp256k1_fe_negate(&z, &z, j+1);
              secp256k1_fe_normalize_var(&q);
              secp256k1_fe_cmov(&q, &z, (j&1));
-             VERIFY_CHECK(!q.normalized && q.magnitude == (j+2));
+ #ifdef VERIFY
+             CHECK(!q.normalized && q.magnitude == (j+2));
+ #endif
          }
          secp256k1_fe_normalize_var(&z);
          /* Test storage conversion and conditional moves. */
@@@ -2682,13 -2659,14 +2692,13 @@@ void test_ecmult_multi(secp256k1_scratc
      secp256k1_gej r;
      secp256k1_gej r2;
      ecmult_multi_data data;
 -    secp256k1_scratch *scratch_empty;
  
      data.sc = sc;
      data.pt = pt;
      secp256k1_scalar_set_int(&szero, 0);
  
      /* No points to multiply */
 -    CHECK(ecmult_multi(&ctx->ecmult_ctx, scratch, &r, NULL, ecmult_multi_callback, &data, 0));
 +    CHECK(ecmult_multi(&ctx->error_callback, &ctx->ecmult_ctx, scratch, &r, NULL, ecmult_multi_callback, &data, 0));
  
      /* Check 1- and 2-point multiplies against ecmult */
      for (ncount = 0; ncount < count; ncount++) {
@@@ -2704,31 -2682,36 +2714,31 @@@
  
          /* only G scalar */
          secp256k1_ecmult(&ctx->ecmult_ctx, &r2, &ptgj, &szero, &sc[0]);
 -        CHECK(ecmult_multi(&ctx->ecmult_ctx, scratch, &r, &sc[0], ecmult_multi_callback, &data, 0));
 +        CHECK(ecmult_multi(&ctx->error_callback, &ctx->ecmult_ctx, scratch, &r, &sc[0], ecmult_multi_callback, &data, 0));
          secp256k1_gej_neg(&r2, &r2);
          secp256k1_gej_add_var(&r, &r, &r2, NULL);
          CHECK(secp256k1_gej_is_infinity(&r));
  
          /* 1-point */
          secp256k1_ecmult(&ctx->ecmult_ctx, &r2, &ptgj, &sc[0], &szero);
 -        CHECK(ecmult_multi(&ctx->ecmult_ctx, scratch, &r, &szero, ecmult_multi_callback, &data, 1));
 +        CHECK(ecmult_multi(&ctx->error_callback, &ctx->ecmult_ctx, scratch, &r, &szero, ecmult_multi_callback, &data, 1));
          secp256k1_gej_neg(&r2, &r2);
          secp256k1_gej_add_var(&r, &r, &r2, NULL);
          CHECK(secp256k1_gej_is_infinity(&r));
  
 -        /* Try to multiply 1 point, but scratch space is empty */
 -        scratch_empty = secp256k1_scratch_create(&ctx->error_callback, 0);
 -        CHECK(!ecmult_multi(&ctx->ecmult_ctx, scratch_empty, &r, &szero, ecmult_multi_callback, &data, 1));
 -        secp256k1_scratch_destroy(scratch_empty);
 -
          /* Try to multiply 1 point, but callback returns false */
 -        CHECK(!ecmult_multi(&ctx->ecmult_ctx, scratch, &r, &szero, ecmult_multi_false_callback, &data, 1));
 +        CHECK(!ecmult_multi(&ctx->error_callback, &ctx->ecmult_ctx, scratch, &r, &szero, ecmult_multi_false_callback, &data, 1));
  
          /* 2-point */
          secp256k1_ecmult(&ctx->ecmult_ctx, &r2, &ptgj, &sc[0], &sc[1]);
 -        CHECK(ecmult_multi(&ctx->ecmult_ctx, scratch, &r, &szero, ecmult_multi_callback, &data, 2));
 +        CHECK(ecmult_multi(&ctx->error_callback, &ctx->ecmult_ctx, scratch, &r, &szero, ecmult_multi_callback, &data, 2));
          secp256k1_gej_neg(&r2, &r2);
          secp256k1_gej_add_var(&r, &r, &r2, NULL);
          CHECK(secp256k1_gej_is_infinity(&r));
  
          /* 2-point with G scalar */
          secp256k1_ecmult(&ctx->ecmult_ctx, &r2, &ptgj, &sc[0], &sc[1]);
 -        CHECK(ecmult_multi(&ctx->ecmult_ctx, scratch, &r, &sc[1], ecmult_multi_callback, &data, 1));
 +        CHECK(ecmult_multi(&ctx->error_callback, &ctx->ecmult_ctx, scratch, &r, &sc[1], ecmult_multi_callback, &data, 1));
          secp256k1_gej_neg(&r2, &r2);
          secp256k1_gej_add_var(&r, &r, &r2, NULL);
          CHECK(secp256k1_gej_is_infinity(&r));
@@@ -2745,7 -2728,7 +2755,7 @@@
                  random_scalar_order(&sc[i]);
                  secp256k1_ge_set_infinity(&pt[i]);
              }
 -            CHECK(ecmult_multi(&ctx->ecmult_ctx, scratch, &r, &szero, ecmult_multi_callback, &data, sizes[j]));
 +            CHECK(ecmult_multi(&ctx->error_callback, &ctx->ecmult_ctx, scratch, &r, &szero, ecmult_multi_callback, &data, sizes[j]));
              CHECK(secp256k1_gej_is_infinity(&r));
          }
  
@@@ -2755,7 -2738,7 +2765,7 @@@
                  pt[i] = ptg;
                  secp256k1_scalar_set_int(&sc[i], 0);
              }
 -            CHECK(ecmult_multi(&ctx->ecmult_ctx, scratch, &r, &szero, ecmult_multi_callback, &data, sizes[j]));
 +            CHECK(ecmult_multi(&ctx->error_callback, &ctx->ecmult_ctx, scratch, &r, &szero, ecmult_multi_callback, &data, sizes[j]));
              CHECK(secp256k1_gej_is_infinity(&r));
          }
  
@@@ -2768,7 -2751,7 +2778,7 @@@
                  pt[2 * i + 1] = ptg;
              }
  
 -            CHECK(ecmult_multi(&ctx->ecmult_ctx, scratch, &r, &szero, ecmult_multi_callback, &data, sizes[j]));
 +            CHECK(ecmult_multi(&ctx->error_callback, &ctx->ecmult_ctx, scratch, &r, &szero, ecmult_multi_callback, &data, sizes[j]));
              CHECK(secp256k1_gej_is_infinity(&r));
  
              random_scalar_order(&sc[0]);
@@@ -2781,7 -2764,7 +2791,7 @@@
                  secp256k1_ge_neg(&pt[2*i+1], &pt[2*i]);
              }
  
 -            CHECK(ecmult_multi(&ctx->ecmult_ctx, scratch, &r, &szero, ecmult_multi_callback, &data, sizes[j]));
 +            CHECK(ecmult_multi(&ctx->error_callback, &ctx->ecmult_ctx, scratch, &r, &szero, ecmult_multi_callback, &data, sizes[j]));
              CHECK(secp256k1_gej_is_infinity(&r));
          }
  
@@@ -2796,7 -2779,7 +2806,7 @@@
              secp256k1_scalar_negate(&sc[i], &sc[i]);
          }
  
 -        CHECK(ecmult_multi(&ctx->ecmult_ctx, scratch, &r, &szero, ecmult_multi_callback, &data, 32));
 +        CHECK(ecmult_multi(&ctx->error_callback, &ctx->ecmult_ctx, scratch, &r, &szero, ecmult_multi_callback, &data, 32));
          CHECK(secp256k1_gej_is_infinity(&r));
      }
  
@@@ -2815,7 -2798,7 +2825,7 @@@
          }
  
          secp256k1_ecmult(&ctx->ecmult_ctx, &r2, &r, &sc[0], &szero);
 -        CHECK(ecmult_multi(&ctx->ecmult_ctx, scratch, &r, &szero, ecmult_multi_callback, &data, 20));
 +        CHECK(ecmult_multi(&ctx->error_callback, &ctx->ecmult_ctx, scratch, &r, &szero, ecmult_multi_callback, &data, 20));
          secp256k1_gej_neg(&r2, &r2);
          secp256k1_gej_add_var(&r, &r, &r2, NULL);
          CHECK(secp256k1_gej_is_infinity(&r));
@@@ -2838,7 -2821,7 +2848,7 @@@
  
          secp256k1_gej_set_ge(&p0j, &pt[0]);
          secp256k1_ecmult(&ctx->ecmult_ctx, &r2, &p0j, &rs, &szero);
 -        CHECK(ecmult_multi(&ctx->ecmult_ctx, scratch, &r, &szero, ecmult_multi_callback, &data, 20));
 +        CHECK(ecmult_multi(&ctx->error_callback, &ctx->ecmult_ctx, scratch, &r, &szero, ecmult_multi_callback, &data, 20));
          secp256k1_gej_neg(&r2, &r2);
          secp256k1_gej_add_var(&r, &r, &r2, NULL);
          CHECK(secp256k1_gej_is_infinity(&r));
@@@ -2851,13 -2834,13 +2861,13 @@@
      }
  
      secp256k1_scalar_clear(&sc[0]);
 -    CHECK(ecmult_multi(&ctx->ecmult_ctx, scratch, &r, &szero, ecmult_multi_callback, &data, 20));
 +    CHECK(ecmult_multi(&ctx->error_callback, &ctx->ecmult_ctx, scratch, &r, &szero, ecmult_multi_callback, &data, 20));
      secp256k1_scalar_clear(&sc[1]);
      secp256k1_scalar_clear(&sc[2]);
      secp256k1_scalar_clear(&sc[3]);
      secp256k1_scalar_clear(&sc[4]);
 -    CHECK(ecmult_multi(&ctx->ecmult_ctx, scratch, &r, &szero, ecmult_multi_callback, &data, 6));
 -    CHECK(ecmult_multi(&ctx->ecmult_ctx, scratch, &r, &szero, ecmult_multi_callback, &data, 5));
 +    CHECK(ecmult_multi(&ctx->error_callback, &ctx->ecmult_ctx, scratch, &r, &szero, ecmult_multi_callback, &data, 6));
 +    CHECK(ecmult_multi(&ctx->error_callback, &ctx->ecmult_ctx, scratch, &r, &szero, ecmult_multi_callback, &data, 5));
      CHECK(secp256k1_gej_is_infinity(&r));
  
      /* Run through s0*(t0*P) + s1*(t1*P) exhaustively for many small values of s0, s1, t0, t1 */
@@@ -2902,7 -2885,7 +2912,7 @@@
                          secp256k1_scalar_add(&tmp1, &tmp1, &tmp2);
  
                          secp256k1_ecmult(&ctx->ecmult_ctx, &expected, &ptgj, &tmp1, &szero);
 -                        CHECK(ecmult_multi(&ctx->ecmult_ctx, scratch, &actual, &szero, ecmult_multi_callback, &data, 2));
 +                        CHECK(ecmult_multi(&ctx->error_callback, &ctx->ecmult_ctx, scratch, &actual, &szero, ecmult_multi_callback, &data, 2));
                          secp256k1_gej_neg(&expected, &expected);
                          secp256k1_gej_add_var(&actual, &actual, &expected, NULL);
                          CHECK(secp256k1_gej_is_infinity(&actual));
@@@ -2913,24 -2896,6 +2923,24 @@@
      }
  }
  
 +void test_ecmult_multi_batch_single(secp256k1_ecmult_multi_func ecmult_multi) {
 +    secp256k1_scalar szero;
 +    secp256k1_scalar sc[32];
 +    secp256k1_ge pt[32];
 +    secp256k1_gej r;
 +    ecmult_multi_data data;
 +    secp256k1_scratch *scratch_empty;
 +
 +    data.sc = sc;
 +    data.pt = pt;
 +    secp256k1_scalar_set_int(&szero, 0);
 +
 +    /* Try to multiply 1 point, but scratch space is empty.*/
 +    scratch_empty = secp256k1_scratch_create(&ctx->error_callback, 0);
 +    CHECK(!ecmult_multi(&ctx->error_callback, &ctx->ecmult_ctx, scratch_empty, &r, &szero, ecmult_multi_callback, &data, 1));
 +    secp256k1_scratch_destroy(&ctx->error_callback, scratch_empty);
 +}
 +
  void test_secp256k1_pippenger_bucket_window_inv(void) {
      int i;
  
@@@ -2961,27 -2926,17 +2971,27 @@@ void test_ecmult_multi_pippenger_max_po
      int bucket_window = 0;
  
      for(; scratch_size < max_size; scratch_size+=256) {
 +        size_t i;
 +        size_t total_alloc;
 +        size_t checkpoint;
          scratch = secp256k1_scratch_create(&ctx->error_callback, scratch_size);
          CHECK(scratch != NULL);
 -        n_points_supported = secp256k1_pippenger_max_points(scratch);
 +        checkpoint = secp256k1_scratch_checkpoint(&ctx->error_callback, scratch);
 +        n_points_supported = secp256k1_pippenger_max_points(&ctx->error_callback, scratch);
          if (n_points_supported == 0) {
 -            secp256k1_scratch_destroy(scratch);
 +            secp256k1_scratch_destroy(&ctx->error_callback, scratch);
              continue;
          }
          bucket_window = secp256k1_pippenger_bucket_window(n_points_supported);
 -        CHECK(secp256k1_scratch_allocate_frame(scratch, secp256k1_pippenger_scratch_size(n_points_supported, bucket_window), PIPPENGER_SCRATCH_OBJECTS));
 -        secp256k1_scratch_deallocate_frame(scratch);
 -        secp256k1_scratch_destroy(scratch);
 +        /* allocate `total_alloc` bytes over `PIPPENGER_SCRATCH_OBJECTS` many allocations */
 +        total_alloc = secp256k1_pippenger_scratch_size(n_points_supported, bucket_window);
 +        for (i = 0; i < PIPPENGER_SCRATCH_OBJECTS - 1; i++) {
 +            CHECK(secp256k1_scratch_alloc(&ctx->error_callback, scratch, 1));
 +            total_alloc--;
 +        }
 +        CHECK(secp256k1_scratch_alloc(&ctx->error_callback, scratch, total_alloc));
 +        secp256k1_scratch_apply_checkpoint(&ctx->error_callback, scratch, checkpoint);
 +        secp256k1_scratch_destroy(&ctx->error_callback, scratch);
      }
      CHECK(bucket_window == PIPPENGER_MAX_BUCKET_WINDOW);
  }
@@@ -3064,25 -3019,19 +3074,25 @@@ void test_ecmult_multi_batching(void) 
      }
      data.sc = sc;
      data.pt = pt;
 +    secp256k1_gej_neg(&r2, &r2);
  
 -    /* Test with empty scratch space */
 +    /* Test with empty scratch space. It should compute the correct result using 
 +     * ecmult_mult_simple algorithm which doesn't require a scratch space. */
      scratch = secp256k1_scratch_create(&ctx->error_callback, 0);
 -    CHECK(!secp256k1_ecmult_multi_var(&ctx->ecmult_ctx, scratch, &r, &scG, ecmult_multi_callback, &data, 1));
 -    secp256k1_scratch_destroy(scratch);
 +    CHECK(secp256k1_ecmult_multi_var(&ctx->error_callback, &ctx->ecmult_ctx, scratch, &r, &scG, ecmult_multi_callback, &data, n_points));
 +    secp256k1_gej_add_var(&r, &r, &r2, NULL);
 +    CHECK(secp256k1_gej_is_infinity(&r));
 +    secp256k1_scratch_destroy(&ctx->error_callback, scratch);
  
      /* Test with space for 1 point in pippenger. That's not enough because
 -     * ecmult_multi selects strauss which requires more memory. */
 +     * ecmult_multi selects strauss which requires more memory. It should
 +     * therefore select the simple algorithm. */
      scratch = secp256k1_scratch_create(&ctx->error_callback, secp256k1_pippenger_scratch_size(1, 1) + PIPPENGER_SCRATCH_OBJECTS*ALIGNMENT);
 -    CHECK(!secp256k1_ecmult_multi_var(&ctx->ecmult_ctx, scratch, &r, &scG, ecmult_multi_callback, &data, 1));
 -    secp256k1_scratch_destroy(scratch);
 +    CHECK(secp256k1_ecmult_multi_var(&ctx->error_callback, &ctx->ecmult_ctx, scratch, &r, &scG, ecmult_multi_callback, &data, n_points));
 +    secp256k1_gej_add_var(&r, &r, &r2, NULL);
 +    CHECK(secp256k1_gej_is_infinity(&r));
 +    secp256k1_scratch_destroy(&ctx->error_callback, scratch);
  
 -    secp256k1_gej_neg(&r2, &r2);
      for(i = 1; i <= n_points; i++) {
          if (i > ECMULT_PIPPENGER_THRESHOLD) {
              int bucket_window = secp256k1_pippenger_bucket_window(i);
@@@ -3092,10 -3041,10 +3102,10 @@@
              size_t scratch_size = secp256k1_strauss_scratch_size(i);
              scratch = secp256k1_scratch_create(&ctx->error_callback, scratch_size + STRAUSS_SCRATCH_OBJECTS*ALIGNMENT);
          }
 -        CHECK(secp256k1_ecmult_multi_var(&ctx->ecmult_ctx, scratch, &r, &scG, ecmult_multi_callback, &data, n_points));
 +        CHECK(secp256k1_ecmult_multi_var(&ctx->error_callback, &ctx->ecmult_ctx, scratch, &r, &scG, ecmult_multi_callback, &data, n_points));
          secp256k1_gej_add_var(&r, &r, &r2, NULL);
          CHECK(secp256k1_gej_is_infinity(&r));
 -        secp256k1_scratch_destroy(scratch);
 +        secp256k1_scratch_destroy(&ctx->error_callback, scratch);
      }
      free(sc);
      free(pt);
@@@ -3110,15 -3059,13 +3120,15 @@@ void run_ecmult_multi_tests(void) 
      test_ecmult_multi(scratch, secp256k1_ecmult_multi_var);
      test_ecmult_multi(NULL, secp256k1_ecmult_multi_var);
      test_ecmult_multi(scratch, secp256k1_ecmult_pippenger_batch_single);
 +    test_ecmult_multi_batch_single(secp256k1_ecmult_pippenger_batch_single);
      test_ecmult_multi(scratch, secp256k1_ecmult_strauss_batch_single);
 -    secp256k1_scratch_destroy(scratch);
 +    test_ecmult_multi_batch_single(secp256k1_ecmult_strauss_batch_single);
 +    secp256k1_scratch_destroy(&ctx->error_callback, scratch);
  
      /* Run test_ecmult_multi with space for exactly one point */
      scratch = secp256k1_scratch_create(&ctx->error_callback, secp256k1_strauss_scratch_size(1) + STRAUSS_SCRATCH_OBJECTS*ALIGNMENT);
      test_ecmult_multi(scratch, secp256k1_ecmult_multi_var);
 -    secp256k1_scratch_destroy(scratch);
 +    secp256k1_scratch_destroy(&ctx->error_callback, scratch);
  
      test_ecmult_multi_batch_size_helper();
      test_ecmult_multi_batching();
@@@ -4455,7 -4402,7 +4465,7 @@@ int test_ecdsa_der_parse(const unsigne
      if (valid_der) {
          ret |= (!roundtrips_der_lax) << 12;
          ret |= (len_der != len_der_lax) << 13;
 -        ret |= (memcmp(roundtrip_der_lax, roundtrip_der, len_der) != 0) << 14;
 +        ret |= ((len_der != len_der_lax) || (memcmp(roundtrip_der_lax, roundtrip_der, len_der) != 0)) << 14;
      }
      ret |= (roundtrips_der != roundtrips_der_lax) << 15;
      if (parsed_der) {
@@@ -4496,7 -4443,7 +4506,7 @@@
      ret |= (roundtrips_der != roundtrips_openssl) << 7;
      if (roundtrips_openssl) {
          ret |= (len_der != (size_t)len_openssl) << 8;
 -        ret |= (memcmp(roundtrip_der, roundtrip_openssl, len_der) != 0) << 9;
 +        ret |= ((len_der != (size_t)len_openssl) || (memcmp(roundtrip_der, roundtrip_openssl, len_der) != 0)) << 9;
      }
  #endif
      return ret;