@@ -467,194 +467,6 @@ static void test_keypair_add(void) {
467
467
}
468
468
}
469
469
470
- static void test_hsort_is_sorted (int * ints , size_t n ) {
471
- size_t i ;
472
- for (i = 1 ; i < n ; i ++ ) {
473
- CHECK (ints [i - 1 ] <= ints [i ]);
474
- }
475
- }
476
-
477
- static int test_hsort_cmp (const void * i1 , const void * i2 , void * counter ) {
478
- * (size_t * )counter += 1 ;
479
- return * (int * )i1 - * (int * )i2 ;
480
- }
481
-
482
- #define NUM 64
483
- static void test_hsort (void ) {
484
- int ints [NUM ] = { 0 };
485
- size_t counter = 0 ;
486
- int i , j ;
487
-
488
- secp256k1_hsort (ints , 0 , sizeof (ints [0 ]), test_hsort_cmp , & counter );
489
- CHECK (counter == 0 );
490
- secp256k1_hsort (ints , 1 , sizeof (ints [0 ]), test_hsort_cmp , & counter );
491
- CHECK (counter == 0 );
492
- secp256k1_hsort (ints , NUM , sizeof (ints [0 ]), test_hsort_cmp , & counter );
493
- CHECK (counter > 0 );
494
- test_hsort_is_sorted (ints , NUM );
495
-
496
- /* Test hsort with length n array and random elements in
497
- * [-interval/2, interval/2] */
498
- for (i = 0 ; i < COUNT ; i ++ ) {
499
- int n = secp256k1_testrand_int (NUM );
500
- int interval = secp256k1_testrand_int (63 ) + 1 ;
501
- for (j = 0 ; j < n ; j ++ ) {
502
- ints [j ] = secp256k1_testrand_int (interval ) - interval /2 ;
503
- }
504
- secp256k1_hsort (ints , n , sizeof (ints [0 ]), test_hsort_cmp , & counter );
505
- test_hsort_is_sorted (ints , n );
506
- }
507
- }
508
- #undef NUM
509
-
510
- static void test_sort_helper (secp256k1_pubkey * pk , size_t * pk_order , size_t n_pk ) {
511
- size_t i ;
512
- const secp256k1_pubkey * pk_test [5 ];
513
-
514
- for (i = 0 ; i < n_pk ; i ++ ) {
515
- pk_test [i ] = & pk [pk_order [i ]];
516
- }
517
- secp256k1_pubkey_sort (CTX , pk_test , n_pk );
518
- for (i = 0 ; i < n_pk ; i ++ ) {
519
- CHECK (secp256k1_memcmp_var (pk_test [i ], & pk [i ], sizeof (* pk_test [i ])) == 0 );
520
- }
521
- }
522
-
523
- static void permute (size_t * arr , size_t n ) {
524
- size_t i ;
525
- for (i = n - 1 ; i >= 1 ; i -- ) {
526
- size_t tmp , j ;
527
- j = secp256k1_testrand_int (i + 1 );
528
- tmp = arr [i ];
529
- arr [i ] = arr [j ];
530
- arr [j ] = tmp ;
531
- }
532
- }
533
-
534
- static void rand_pk (secp256k1_pubkey * pk ) {
535
- unsigned char seckey [32 ];
536
- secp256k1_keypair keypair ;
537
- secp256k1_testrand256 (seckey );
538
- CHECK (secp256k1_keypair_create (CTX , & keypair , seckey ) == 1 );
539
- CHECK (secp256k1_keypair_pub (CTX , pk , & keypair ) == 1 );
540
- }
541
-
542
- static void test_sort_api (void ) {
543
- secp256k1_pubkey pks [2 ];
544
- const secp256k1_pubkey * pks_ptr [2 ];
545
-
546
- pks_ptr [0 ] = & pks [0 ];
547
- pks_ptr [1 ] = & pks [1 ];
548
-
549
- rand_pk (& pks [0 ]);
550
- rand_pk (& pks [1 ]);
551
-
552
- CHECK (secp256k1_pubkey_sort (CTX , pks_ptr , 2 ) == 1 );
553
- CHECK_ILLEGAL (CTX , secp256k1_pubkey_sort (CTX , NULL , 2 ));
554
- CHECK (secp256k1_pubkey_sort (CTX , pks_ptr , 0 ) == 1 );
555
- /* Test illegal public keys */
556
- memset (& pks [0 ], 0 , sizeof (pks [0 ]));
557
- CHECK_ILLEGAL_VOID (CTX , CHECK (secp256k1_pubkey_sort (CTX , pks_ptr , 2 ) == 1 ));
558
- memset (& pks [1 ], 0 , sizeof (pks [1 ]));
559
- {
560
- int32_t ecount = 0 ;
561
- secp256k1_context_set_illegal_callback (CTX , counting_callback_fn , & ecount );
562
- CHECK (secp256k1_pubkey_sort (CTX , pks_ptr , 2 ) == 1 );
563
- CHECK (ecount == 2 );
564
- secp256k1_context_set_illegal_callback (CTX , NULL , NULL );
565
- }
566
- }
567
-
568
- static void test_sort (void ) {
569
- secp256k1_pubkey pk [5 ];
570
- unsigned char pk_ser [5 ][33 ] = {
571
- { 0x02 , 0x08 },
572
- { 0x02 , 0x0b },
573
- { 0x02 , 0x0c },
574
- { 0x03 , 0x05 },
575
- { 0x03 , 0x0a },
576
- };
577
- int i ;
578
- size_t pk_order [5 ] = { 0 , 1 , 2 , 3 , 4 };
579
-
580
- for (i = 0 ; i < 5 ; i ++ ) {
581
- CHECK (secp256k1_ec_pubkey_parse (CTX , & pk [i ], pk_ser [i ], sizeof (pk_ser [i ])));
582
- }
583
-
584
- permute (pk_order , 1 );
585
- test_sort_helper (pk , pk_order , 1 );
586
- permute (pk_order , 2 );
587
- test_sort_helper (pk , pk_order , 2 );
588
- permute (pk_order , 3 );
589
- test_sort_helper (pk , pk_order , 3 );
590
- for (i = 0 ; i < COUNT ; i ++ ) {
591
- permute (pk_order , 4 );
592
- test_sort_helper (pk , pk_order , 4 );
593
- }
594
- for (i = 0 ; i < COUNT ; i ++ ) {
595
- permute (pk_order , 5 );
596
- test_sort_helper (pk , pk_order , 5 );
597
- }
598
- /* Check that sorting also works for random pubkeys */
599
- for (i = 0 ; i < COUNT ; i ++ ) {
600
- int j ;
601
- const secp256k1_pubkey * pk_ptr [5 ];
602
- for (j = 0 ; j < 5 ; j ++ ) {
603
- rand_pk (& pk [j ]);
604
- pk_ptr [j ] = & pk [j ];
605
- }
606
- secp256k1_pubkey_sort (CTX , pk_ptr , 5 );
607
- for (j = 1 ; j < 5 ; j ++ ) {
608
- CHECK (secp256k1_pubkey_sort_cmp (& pk_ptr [j - 1 ], & pk_ptr [j ], CTX ) <= 0 );
609
- }
610
- }
611
- }
612
-
613
- /* Test vectors from BIP-MuSig2 */
614
- static void test_sort_vectors (void ) {
615
- enum { N_PUBKEYS = 6 };
616
- unsigned char pk_ser [N_PUBKEYS ][33 ] = {
617
- { 0x02 , 0xDD , 0x30 , 0x8A , 0xFE , 0xC5 , 0x77 , 0x7E , 0x13 , 0x12 , 0x1F ,
618
- 0xA7 , 0x2B , 0x9C , 0xC1 , 0xB7 , 0xCC , 0x01 , 0x39 , 0x71 , 0x53 , 0x09 ,
619
- 0xB0 , 0x86 , 0xC9 , 0x60 , 0xE1 , 0x8F , 0xD9 , 0x69 , 0x77 , 0x4E , 0xB8 },
620
- { 0x02 , 0xF9 , 0x30 , 0x8A , 0x01 , 0x92 , 0x58 , 0xC3 , 0x10 , 0x49 , 0x34 ,
621
- 0x4F , 0x85 , 0xF8 , 0x9D , 0x52 , 0x29 , 0xB5 , 0x31 , 0xC8 , 0x45 , 0x83 ,
622
- 0x6F , 0x99 , 0xB0 , 0x86 , 0x01 , 0xF1 , 0x13 , 0xBC , 0xE0 , 0x36 , 0xF9 },
623
- { 0x03 , 0xDF , 0xF1 , 0xD7 , 0x7F , 0x2A , 0x67 , 0x1C , 0x5F , 0x36 , 0x18 ,
624
- 0x37 , 0x26 , 0xDB , 0x23 , 0x41 , 0xBE , 0x58 , 0xFE , 0xAE , 0x1D , 0xA2 ,
625
- 0xDE , 0xCE , 0xD8 , 0x43 , 0x24 , 0x0F , 0x7B , 0x50 , 0x2B , 0xA6 , 0x59 },
626
- { 0x02 , 0x35 , 0x90 , 0xA9 , 0x4E , 0x76 , 0x8F , 0x8E , 0x18 , 0x15 , 0xC2 ,
627
- 0xF2 , 0x4B , 0x4D , 0x80 , 0xA8 , 0xE3 , 0x14 , 0x93 , 0x16 , 0xC3 , 0x51 ,
628
- 0x8C , 0xE7 , 0xB7 , 0xAD , 0x33 , 0x83 , 0x68 , 0xD0 , 0x38 , 0xCA , 0x66 },
629
- { 0x02 , 0xDD , 0x30 , 0x8A , 0xFE , 0xC5 , 0x77 , 0x7E , 0x13 , 0x12 , 0x1F ,
630
- 0xA7 , 0x2B , 0x9C , 0xC1 , 0xB7 , 0xCC , 0x01 , 0x39 , 0x71 , 0x53 , 0x09 ,
631
- 0xB0 , 0x86 , 0xC9 , 0x60 , 0xE1 , 0x8F , 0xD9 , 0x69 , 0x77 , 0x4E , 0xFF },
632
- { 0x02 , 0xDD , 0x30 , 0x8A , 0xFE , 0xC5 , 0x77 , 0x7E , 0x13 , 0x12 , 0x1F ,
633
- 0xA7 , 0x2B , 0x9C , 0xC1 , 0xB7 , 0xCC , 0x01 , 0x39 , 0x71 , 0x53 , 0x09 ,
634
- 0xB0 , 0x86 , 0xC9 , 0x60 , 0xE1 , 0x8F , 0xD9 , 0x69 , 0x77 , 0x4E , 0xB8 }
635
- };
636
- secp256k1_pubkey pubkeys [N_PUBKEYS ];
637
- secp256k1_pubkey * sorted [N_PUBKEYS ];
638
- const secp256k1_pubkey * pks_ptr [N_PUBKEYS ];
639
- int i ;
640
-
641
- sorted [0 ] = & pubkeys [3 ];
642
- sorted [1 ] = & pubkeys [0 ];
643
- sorted [2 ] = & pubkeys [0 ];
644
- sorted [3 ] = & pubkeys [4 ];
645
- sorted [4 ] = & pubkeys [1 ];
646
- sorted [5 ] = & pubkeys [2 ];
647
-
648
- for (i = 0 ; i < N_PUBKEYS ; i ++ ) {
649
- CHECK (secp256k1_ec_pubkey_parse (CTX , & pubkeys [i ], pk_ser [i ], sizeof (pk_ser [i ])));
650
- pks_ptr [i ] = & pubkeys [i ];
651
- }
652
- CHECK (secp256k1_pubkey_sort (CTX , pks_ptr , N_PUBKEYS ) == 1 );
653
- for (i = 0 ; i < N_PUBKEYS ; i ++ ) {
654
- CHECK (secp256k1_memcmp_var (pks_ptr [i ], sorted [i ], sizeof (secp256k1_pubkey )) == 0 );
655
- }
656
- }
657
-
658
470
static void run_extrakeys_tests (void ) {
659
471
/* xonly key test cases */
660
472
test_xonly_pubkey ();
@@ -666,12 +478,6 @@ static void run_extrakeys_tests(void) {
666
478
/* keypair tests */
667
479
test_keypair ();
668
480
test_keypair_add ();
669
-
670
- /* sorting tests */
671
- test_hsort ();
672
- test_sort_api ();
673
- test_sort ();
674
- test_sort_vectors ();
675
481
}
676
482
677
483
#endif
0 commit comments