Skip to content

Commit 9a93f48

Browse files
real-or-randomreal-or-random
committed
refactor: Rename STTC to STATIC_CTX in tests
1 parent 3385a26 commit 9a93f48

File tree

4 files changed

+35
-35
lines changed

4 files changed

+35
-35
lines changed

‎src/modules/extrakeys/tests_impl.h

+4-4
Original file line numberDiff line numberDiff line change
@@ -338,7 +338,7 @@ void test_keypair(void) {
338338
int ecount;
339339

340340
set_counting_callbacks(CTX, &ecount);
341-
set_counting_callbacks(STTC, &ecount);
341+
set_counting_callbacks(STATIC_CTX, &ecount);
342342

343343
CHECK(sizeof(zeros96) == sizeof(keypair));
344344
memset(overflows, 0xFF, sizeof(overflows));
@@ -359,7 +359,7 @@ void test_keypair(void) {
359359
CHECK(ecount == 2);
360360
CHECK(secp256k1_keypair_create(CTX, &keypair, sk) == 1);
361361
CHECK(ecount == 2);
362-
CHECK(secp256k1_keypair_create(STTC, &keypair, sk) == 0);
362+
CHECK(secp256k1_keypair_create(STATIC_CTX, &keypair, sk) == 0);
363363
CHECK(secp256k1_memcmp_var(zeros96, &keypair, sizeof(keypair)) == 0);
364364
CHECK(ecount == 3);
365365

@@ -440,8 +440,8 @@ void test_keypair(void) {
440440
CHECK(secp256k1_keypair_sec(CTX, sk_tmp, &keypair) == 1);
441441
CHECK(secp256k1_memcmp_var(zeros96, sk_tmp, sizeof(sk_tmp)) == 0);
442442

443-
secp256k1_context_set_error_callback(STTC, NULL, NULL);
444-
secp256k1_context_set_illegal_callback(STTC, NULL, NULL);
443+
secp256k1_context_set_error_callback(STATIC_CTX, NULL, NULL);
444+
secp256k1_context_set_illegal_callback(STATIC_CTX, NULL, NULL);
445445
}
446446

447447
void test_keypair_add(void) {

‎src/modules/recovery/tests_impl.h

+5-5
Original file line numberDiff line numberDiff line change
@@ -47,8 +47,8 @@ void test_ecdsa_recovery_api(void) {
4747

4848
secp256k1_context_set_error_callback(CTX, counting_illegal_callback_fn, &ecount);
4949
secp256k1_context_set_illegal_callback(CTX, counting_illegal_callback_fn, &ecount);
50-
secp256k1_context_set_error_callback(STTC, counting_illegal_callback_fn, &ecount);
51-
secp256k1_context_set_illegal_callback(STTC, counting_illegal_callback_fn, &ecount);
50+
secp256k1_context_set_error_callback(STATIC_CTX, counting_illegal_callback_fn, &ecount);
51+
secp256k1_context_set_illegal_callback(STATIC_CTX, counting_illegal_callback_fn, &ecount);
5252

5353
/* Construct and verify corresponding public key. */
5454
CHECK(secp256k1_ec_seckey_verify(CTX, privkey) == 1);
@@ -64,7 +64,7 @@ void test_ecdsa_recovery_api(void) {
6464
CHECK(ecount == 2);
6565
CHECK(secp256k1_ecdsa_sign_recoverable(CTX, &recsig, message, NULL, NULL, NULL) == 0);
6666
CHECK(ecount == 3);
67-
CHECK(secp256k1_ecdsa_sign_recoverable(STTC, &recsig, message, privkey, NULL, NULL) == 0);
67+
CHECK(secp256k1_ecdsa_sign_recoverable(STATIC_CTX, &recsig, message, privkey, NULL, NULL) == 0);
6868
CHECK(ecount == 4);
6969
/* This will fail or succeed randomly, and in either case will not ARG_CHECK failure */
7070
secp256k1_ecdsa_sign_recoverable(CTX, &recsig, message, privkey, recovery_test_nonce_function, NULL);
@@ -123,8 +123,8 @@ void test_ecdsa_recovery_api(void) {
123123
CHECK(ecount == 7);
124124

125125
/* cleanup */
126-
secp256k1_context_set_error_callback(STTC, NULL, NULL);
127-
secp256k1_context_set_illegal_callback(STTC, NULL, NULL);
126+
secp256k1_context_set_error_callback(STATIC_CTX, NULL, NULL);
127+
secp256k1_context_set_illegal_callback(STATIC_CTX, NULL, NULL);
128128
}
129129

130130
void test_ecdsa_recovery_end_to_end(void) {

‎src/modules/schnorrsig/tests_impl.h

+6-6
Original file line numberDiff line numberDiff line change
@@ -132,8 +132,8 @@ void test_schnorrsig_api(void) {
132132

133133
secp256k1_context_set_error_callback(CTX, counting_illegal_callback_fn, &ecount);
134134
secp256k1_context_set_illegal_callback(CTX, counting_illegal_callback_fn, &ecount);
135-
secp256k1_context_set_error_callback(STTC, counting_illegal_callback_fn, &ecount);
136-
secp256k1_context_set_illegal_callback(STTC, counting_illegal_callback_fn, &ecount);
135+
secp256k1_context_set_error_callback(STATIC_CTX, counting_illegal_callback_fn, &ecount);
136+
secp256k1_context_set_illegal_callback(STATIC_CTX, counting_illegal_callback_fn, &ecount);
137137

138138
secp256k1_testrand256(sk1);
139139
secp256k1_testrand256(sk2);
@@ -159,7 +159,7 @@ void test_schnorrsig_api(void) {
159159
CHECK(ecount == 3);
160160
CHECK(secp256k1_schnorrsig_sign32(CTX, sig, msg, &invalid_keypair, NULL) == 0);
161161
CHECK(ecount == 4);
162-
CHECK(secp256k1_schnorrsig_sign32(STTC, sig, msg, &keypairs[0], NULL) == 0);
162+
CHECK(secp256k1_schnorrsig_sign32(STATIC_CTX, sig, msg, &keypairs[0], NULL) == 0);
163163
CHECK(ecount == 5);
164164

165165
ecount = 0;
@@ -179,7 +179,7 @@ void test_schnorrsig_api(void) {
179179
CHECK(ecount == 4);
180180
CHECK(secp256k1_schnorrsig_sign_custom(CTX, sig, msg, sizeof(msg), &keypairs[0], &invalid_extraparams) == 0);
181181
CHECK(ecount == 5);
182-
CHECK(secp256k1_schnorrsig_sign_custom(STTC, sig, msg, sizeof(msg), &keypairs[0], &extraparams) == 0);
182+
CHECK(secp256k1_schnorrsig_sign_custom(STATIC_CTX, sig, msg, sizeof(msg), &keypairs[0], &extraparams) == 0);
183183
CHECK(ecount == 6);
184184

185185
ecount = 0;
@@ -197,8 +197,8 @@ void test_schnorrsig_api(void) {
197197
CHECK(secp256k1_schnorrsig_verify(CTX, sig, msg, sizeof(msg), &zero_pk) == 0);
198198
CHECK(ecount == 4);
199199

200-
secp256k1_context_set_error_callback(STTC, NULL, NULL);
201-
secp256k1_context_set_illegal_callback(STTC, NULL, NULL);
200+
secp256k1_context_set_error_callback(STATIC_CTX, NULL, NULL);
201+
secp256k1_context_set_illegal_callback(STATIC_CTX, NULL, NULL);
202202
}
203203

204204
/* Checks that hash initialized by secp256k1_schnorrsig_sha256_tagged has the

‎src/tests.c

+20-20
Original file line numberDiff line numberDiff line change
@@ -29,7 +29,7 @@
2929

3030
static int COUNT = 64;
3131
static secp256k1_context *CTX = NULL;
32-
static secp256k1_context *STTC = NULL;
32+
static secp256k1_context *STATIC_CTX = NULL;
3333

3434
static void counting_illegal_callback_fn(const char* str, void* data) {
3535
/* Dummy callback function that just counts. */
@@ -185,46 +185,46 @@ void run_ec_illegal_argument_tests(void) {
185185
unsigned char ctmp[32];
186186

187187
/* Setup */
188-
secp256k1_context_set_illegal_callback(STTC, counting_illegal_callback_fn, &ecount);
188+
secp256k1_context_set_illegal_callback(STATIC_CTX, counting_illegal_callback_fn, &ecount);
189189
secp256k1_context_set_illegal_callback(CTX, counting_illegal_callback_fn, &ecount2);
190190
memset(ctmp, 1, 32);
191191
memset(&zero_pubkey, 0, sizeof(zero_pubkey));
192192

193193
/* Verify context-type checking illegal-argument errors. */
194-
CHECK(secp256k1_ec_pubkey_create(STTC, &pubkey, ctmp) == 0);
194+
CHECK(secp256k1_ec_pubkey_create(STATIC_CTX, &pubkey, ctmp) == 0);
195195
CHECK(ecount == 1);
196196
VG_UNDEF(&pubkey, sizeof(pubkey));
197197
CHECK(secp256k1_ec_pubkey_create(CTX, &pubkey, ctmp) == 1);
198198
VG_CHECK(&pubkey, sizeof(pubkey));
199-
CHECK(secp256k1_ecdsa_sign(STTC, &sig, ctmp, ctmp, NULL, NULL) == 0);
199+
CHECK(secp256k1_ecdsa_sign(STATIC_CTX, &sig, ctmp, ctmp, NULL, NULL) == 0);
200200
CHECK(ecount == 2);
201201
VG_UNDEF(&sig, sizeof(sig));
202202
CHECK(secp256k1_ecdsa_sign(CTX, &sig, ctmp, ctmp, NULL, NULL) == 1);
203203
VG_CHECK(&sig, sizeof(sig));
204204
CHECK(ecount2 == 10);
205205
CHECK(secp256k1_ecdsa_verify(CTX, &sig, ctmp, &pubkey) == 1);
206206
CHECK(ecount2 == 10);
207-
CHECK(secp256k1_ecdsa_verify(STTC, &sig, ctmp, &pubkey) == 1);
207+
CHECK(secp256k1_ecdsa_verify(STATIC_CTX, &sig, ctmp, &pubkey) == 1);
208208
CHECK(ecount == 2);
209209
CHECK(secp256k1_ec_pubkey_tweak_add(CTX, &pubkey, ctmp) == 1);
210210
CHECK(ecount2 == 10);
211-
CHECK(secp256k1_ec_pubkey_tweak_add(STTC, &pubkey, ctmp) == 1);
211+
CHECK(secp256k1_ec_pubkey_tweak_add(STATIC_CTX, &pubkey, ctmp) == 1);
212212
CHECK(ecount == 2);
213213
CHECK(secp256k1_ec_pubkey_tweak_mul(CTX, &pubkey, ctmp) == 1);
214214
CHECK(ecount2 == 10);
215-
CHECK(secp256k1_ec_pubkey_negate(STTC, &pubkey) == 1);
215+
CHECK(secp256k1_ec_pubkey_negate(STATIC_CTX, &pubkey) == 1);
216216
CHECK(ecount == 2);
217217
CHECK(secp256k1_ec_pubkey_negate(CTX, &pubkey) == 1);
218218
CHECK(ecount == 2);
219-
CHECK(secp256k1_ec_pubkey_negate(STTC, &zero_pubkey) == 0);
219+
CHECK(secp256k1_ec_pubkey_negate(STATIC_CTX, &zero_pubkey) == 0);
220220
CHECK(ecount == 3);
221221
CHECK(secp256k1_ec_pubkey_negate(CTX, NULL) == 0);
222222
CHECK(ecount2 == 11);
223-
CHECK(secp256k1_ec_pubkey_tweak_mul(STTC, &pubkey, ctmp) == 1);
223+
CHECK(secp256k1_ec_pubkey_tweak_mul(STATIC_CTX, &pubkey, ctmp) == 1);
224224
CHECK(ecount == 3);
225225

226226
/* Clean up */
227-
secp256k1_context_set_illegal_callback(STTC, NULL, NULL);
227+
secp256k1_context_set_illegal_callback(STATIC_CTX, NULL, NULL);
228228
secp256k1_context_set_illegal_callback(CTX, NULL, NULL);
229229
}
230230

@@ -235,13 +235,13 @@ void run_static_context_tests(void) {
235235
CHECK(secp256k1_context_no_precomp == secp256k1_context_static);
236236

237237
/* check if sizes for cloning are consistent */
238-
CHECK(secp256k1_context_preallocated_clone_size(STTC) >= sizeof(secp256k1_context));
238+
CHECK(secp256k1_context_preallocated_clone_size(STATIC_CTX) >= sizeof(secp256k1_context));
239239

240240
/* Verify that setting and resetting illegal callback works */
241-
secp256k1_context_set_illegal_callback(STTC, counting_illegal_callback_fn, &dummy);
242-
CHECK(STTC->illegal_callback.fn == counting_illegal_callback_fn);
243-
secp256k1_context_set_illegal_callback(STTC, NULL, NULL);
244-
CHECK(STTC->illegal_callback.fn == secp256k1_default_illegal_callback_fn);
241+
secp256k1_context_set_illegal_callback(STATIC_CTX, counting_illegal_callback_fn, &dummy);
242+
CHECK(STATIC_CTX->illegal_callback.fn == counting_illegal_callback_fn);
243+
secp256k1_context_set_illegal_callback(STATIC_CTX, NULL, NULL);
244+
CHECK(STATIC_CTX->illegal_callback.fn == secp256k1_default_illegal_callback_fn);
245245
}
246246

247247
void run_proper_context_tests(int use_prealloc) {
@@ -7379,10 +7379,10 @@ int main(int argc, char **argv) {
73797379
that write to the context. The API does not support cloning the static context, so we use
73807380
memcpy instead. The user is not supposed to copy a context but we should still ensure that
73817381
the API functions handle copies of the static context gracefully. */
7382-
STTC = malloc(sizeof(*secp256k1_context_static));
7383-
CHECK(STTC != NULL);
7384-
memcpy(STTC, secp256k1_context_static, sizeof(secp256k1_context));
7385-
CHECK(!secp256k1_context_is_proper(STTC));
7382+
STATIC_CTX = malloc(sizeof(*secp256k1_context_static));
7383+
CHECK(STATIC_CTX != NULL);
7384+
memcpy(STATIC_CTX, secp256k1_context_static, sizeof(secp256k1_context));
7385+
CHECK(!secp256k1_context_is_proper(STATIC_CTX));
73867386

73877387
/*** Run actual tests ***/
73887388

@@ -7491,7 +7491,7 @@ int main(int argc, char **argv) {
74917491
run_cmov_tests();
74927492

74937493
/*** Tear down test environment ***/
7494-
free(STTC);
7494+
free(STATIC_CTX);
74957495
secp256k1_context_destroy(CTX);
74967496

74977497
secp256k1_testrand_finish();

0 commit comments

Comments
 (0)