Changeset 525

Show
Ignore:
Timestamp:
12/10/07 17:51:16
Author:
rachel
Message:

Combined GPG tests and OPS tests into one.
Enforced use of --openpgp flag when using gpg.
Added in new tests to be written.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • openpgpsdk/trunk/tests/Makefile.template

    r521 r525  
    2121TESTOBJ= $(TESTSRC:.c=.o) 
    2222 
    23 GPGTESTSRC= tests_gpg.c 
    24 GPGTESTOBJ= $(GPGTESTSRC:.c=.o) 
    25  
    26 all: Makefile $(CUNIT_LIB) .depend tests tests_gpg 
     23all: Makefile $(CUNIT_LIB) .depend tests 
    2724 
    2825tests: $(CUNIT_LIB) $(TESTOBJ) $(COMMONTESTOBJ) $(LIBDEPS) 
    2926        $(CC) $(LDFLAGS) -o tests $(TESTOBJ) $(COMMONTESTOBJ) $(LIBS) 
    30  
    31 tests_gpg: $(CUNIT_LIB) $(GPGTESTOBJ) $(COMMONTESTOBJ) $(LIBDEPS) 
    32         $(CC) $(LDFLAGS) -o tests_gpg $(GPGTESTOBJ) $(COMMONTESTOBJ) $(LIBS) 
    3327 
    3428$(CUNIT_LIB): 
  • openpgpsdk/trunk/tests/test_common.c

    r523 r525  
    4949 
    5050    assert(strlen(dir)); 
    51     snprintf(gpgcmd,MAXBUF,"gpg --quiet --no-tty --homedir=%s",dir); 
     51    snprintf(gpgcmd,MAXBUF,"gpg --quiet --no-tty --homedir=%s --openpgp",dir); 
    5252 
    5353    setup_test_keys(); 
  • openpgpsdk/trunk/tests/test_rsa_encrypt.c

    r521 r525  
    1111 
    1212#include "tests.h" 
    13  
    14 static int do_gpgtest=0; 
    1513 
    1614static char *filename_rsa_noarmour_nopassphrase_singlekey="enc_rsa_noarmour_np_singlekey.txt"; 
     
    8684int init_suite_rsa_encrypt(void) 
    8785    { 
    88     do_gpgtest=0; 
    89  
    9086    // Create RSA test files 
    9187 
     
    9995 
    10096    // Return success 
    101     return 0; 
    102     } 
    103  
    104 int init_suite_rsa_encrypt_gpgtest(void) 
    105     { 
    106     init_suite_rsa_encrypt(); 
    107  
    108     do_gpgtest=1; 
    109  
    11097    return 0; 
    11198    } 
     
    170157    char decrypted_file[MAXBUF+1]; 
    171158    char *suffix= has_armour ? "asc" : "gpg"; 
    172     char *gpgtest = do_gpgtest ? "gpgtest_" : ""; 
     159    //    char *gpgtest = do_gpgtest ? "gpgtest_" : ""; 
    173160    int fd_in=0; 
    174161    int fd_out=0; 
     
    197184        } 
    198185     
    199     snprintf(encrypted_file,MAXBUF,"%s/%s%s.%s",dir,gpgtest,filename,suffix); 
     186    snprintf(encrypted_file,MAXBUF,"%s/%s.%s",dir,filename,suffix); 
    200187#ifdef WIN32 
    201188    fd_out=open(encrypted_file,O_WRONLY | O_CREAT | O_EXCL | O_BINARY, 0600); 
     
    258245     */ 
    259246 
    260     if (do_gpgtest) 
    261         { 
    262         // File contents should match - check with GPG 
     247    // File contents should match - check with GPG 
    263248         
    264         if (pub_key==alpha_pub_keydata) 
    265             pp[0]='\0'; 
    266         else if (pub_key==bravo_pub_keydata) 
    267             snprintf(pp,MAXBUF," --passphrase %s ", bravo_passphrase); 
    268         snprintf(decrypted_file,MAXBUF,"%s/decrypted_%s",dir,filename); 
    269         snprintf(cmd,MAXBUF,"gpg --quiet --no-tty --decrypt --output=%s --homedir %s %s %s",decrypted_file, dir, pp, encrypted_file); 
    270         //    printf("cmd: %s\n", cmd); 
    271         rtn=system(cmd); 
    272         CU_ASSERT(rtn==0); 
    273         CU_ASSERT(file_compare(myfile,decrypted_file)==0); 
    274         } 
    275     else 
    276         { 
    277         // File contents should match - checking with OPS 
     249    if (pub_key==alpha_pub_keydata) 
     250        pp[0]='\0'; 
     251    else if (pub_key==bravo_pub_keydata) 
     252        snprintf(pp,MAXBUF," --passphrase %s ", bravo_passphrase); 
     253    snprintf(decrypted_file,MAXBUF,"%s/decrypted_%s",dir,filename); 
     254    snprintf(cmd,MAXBUF,"%s --decrypt --output=%s %s %s",gpgcmd, decrypted_file, pp, encrypted_file); 
     255    //    printf("cmd: %s\n", cmd); 
     256    rtn=system(cmd); 
     257    CU_ASSERT(rtn==0); 
     258    CU_ASSERT(file_compare(myfile,decrypted_file)==0); 
     259 
     260    // File contents should match - checking with OPS 
    278261         
    279         testtext=create_testtext(filename); 
    280         test_rsa_decrypt(encrypted_file,testtext); 
    281         } 
     262    testtext=create_testtext(filename); 
     263    test_rsa_decrypt(encrypted_file,testtext); 
    282264    } 
    283265 
     
    359341    } 
    360342 
    361 CU_pSuite suite_rsa_encrypt_GPGtest() 
    362     { 
    363     CU_pSuite suite = NULL; 
    364  
    365     suite = CU_add_suite("RSA Encryption Suite (GPG interoperability)", init_suite_rsa_encrypt_gpgtest, clean_suite_rsa_encrypt); 
    366  
    367     if (!suite) 
    368             return NULL; 
    369  
    370     if (!add_tests(suite)) 
    371         return NULL; 
    372  
    373     return suite; 
    374     } 
    375  
    376343// EOF 
  • openpgpsdk/trunk/tests/test_rsa_signature.c

    r523 r525  
    1818 
    1919static int debug=0; 
    20 static int do_gpgtest=0; 
    2120 
    2221static char *filename_rsa_noarmour_nopassphrase="ops_rsa_signed_noarmour_nopassphrase.txt"; 
     
    2423static char *filename_rsa_armour_nopassphrase="ops_rsa_signed_armour_nopassphrase.txt"; 
    2524static char *filename_rsa_armour_passphrase="ops_rsa_signed_armour_passphrase.txt"; 
     25static char *filename_rsa_clearsign_nopassphrase="ops_rsa_signed_clearsign_nopassphrase.txt"; 
     26static char *filename_rsa_clearsign_passphrase="ops_rsa_signed_clearsign_passphrase.txt"; 
    2627 
    2728/* Signature suite initialization. 
     
    3233int init_suite_rsa_signature(void) 
    3334    { 
    34     do_gpgtest=0; 
    35  
    3635    // Create test files 
    3736 
     
    4039    create_testfile(filename_rsa_armour_nopassphrase); 
    4140    create_testfile(filename_rsa_armour_passphrase); 
     41    create_testfile(filename_rsa_clearsign_nopassphrase); 
     42    create_testfile(filename_rsa_clearsign_passphrase); 
    4243 
    4344    // Return success 
     
    4546    } 
    4647 
    47 int init_suite_rsa_signature_gpgtest(void) 
    48     { 
    49     init_suite_rsa_signature(); 
    50  
    51     do_gpgtest=1
     48int clean_suite_rsa_signature(void) 
     49    { 
     50    ops_finish(); 
     51 
     52    reset_vars()
    5253 
    5354    return 0; 
    5455    } 
    5556 
    56 int clean_suite_rsa_signature(void) 
    57     { 
    58     ops_finish(); 
    59  
    60     reset_vars(); 
    61  
    62     return 0; 
    63     } 
    64  
    65 static void test_rsa_signature(const int has_armour, const char *filename, const ops_secret_key_t *skey, ops_hash_algorithm_t hash_alg) 
     57static void test_rsa_signature_clearsign(const char *filename, const ops_secret_key_t *skey, ops_hash_algorithm_t hash_alg) 
    6658    { 
    6759    unsigned char keyid[OPS_KEY_ID_SIZE]; 
     
    7163    char myfile[MAXBUF+1]; 
    7264    char signed_file[MAXBUF+1]; 
    73     char *suffix= has_armour ? "asc" : "gpg"; 
     65    //    char *suffix= has_armour ? "asc" : "gpg"; 
     66    char *suffix= "asc"; 
    7467    int fd_in=0; 
    7568    int fd_out=0; 
     
    10699    // OPS code armours signatures by default 
    107100 
    108     assert(has_armour); 
     101    //    assert(has_armour); 
    109102     
    110103    // set up signature 
     
    189182    // Set up armour/passphrase options 
    190183     
    191     if (has_armour) 
     184    //    if (has_armour) 
    192185        ops_reader_push_dearmour(pinfo,ops_false,ops_false,ops_false); 
    193186    //    current_passphrase=has_passphrase ? passphrase : nopassphrase; 
     
    200193     
    201194    // Tidy up 
    202     if (has_armour) 
     195    //    if (has_armour) 
    203196        ops_reader_pop_dearmour(pinfo); 
    204197     
     
    217210    } 
    218211 
    219 void test_rsa_signature_noarmour_nopassphrase(void) 
    220     { 
     212static void test_rsa_signature_noarmour_nopassphrase(void) 
     213    { 
     214    CU_FAIL("Test TODO: Sign file with no armour and no passphrase"); 
     215#ifdef TBD 
     216 
    221217    int armour=0; 
    222218    assert(pub_keyring.nkeys); 
     
    229225    test_rsa_signature(armour,filename_rsa_noarmour_nopassphrase, alpha_skey, OPS_HASH_SHA512); 
    230226#endif 
    231     } 
    232  
    233 void test_rsa_signature_noarmour_passphrase(void) 
    234     { 
     227#endif 
     228    } 
     229 
     230static void test_rsa_signature_noarmour_passphrase(void) 
     231    { 
     232    CU_FAIL("Test TODO: Sign file with no armour and passphrase"); 
     233#ifdef TBD 
    235234    int armour=0; 
    236235    assert(pub_keyring.nkeys); 
    237236    test_rsa_signature(armour,filename_rsa_noarmour_passphrase, bravo_skey, OPS_HASH_SHA1); 
    238     } 
    239  
    240 void test_rsa_signature_armour_nopassphrase(void) 
    241     { 
     237#endif 
     238    } 
     239 
     240static void test_rsa_signature_armour_nopassphrase(void) 
     241    { 
     242    CU_FAIL("Test TODO: Sign file with armour and no passphrase"); 
     243#ifdef TBD 
    242244    int armour=1; 
    243245    assert(pub_keyring.nkeys); 
    244246    test_rsa_signature(armour,filename_rsa_armour_nopassphrase, alpha_skey, OPS_HASH_SHA1); 
    245     } 
    246  
    247 void test_rsa_signature_armour_passphrase(void) 
    248     { 
     247#endif 
     248    } 
     249 
     250static void test_rsa_signature_armour_passphrase(void) 
     251    { 
     252    CU_FAIL("Test TODO: Sign file with armour and passphrase"); 
     253#ifdef TBD 
    249254    int armour=1; 
    250255    assert(pub_keyring.nkeys); 
    251256    test_rsa_signature(armour,filename_rsa_armour_passphrase, bravo_skey, OPS_HASH_SHA1); 
     257#endif 
     258    } 
     259 
     260static void test_rsa_signature_clearsign_nopassphrase(void) 
     261    { 
     262    assert(pub_keyring.nkeys); 
     263    test_rsa_signature_clearsign(filename_rsa_armour_nopassphrase, alpha_skey, OPS_HASH_SHA1); 
     264    } 
     265 
     266static void test_rsa_signature_clearsign_passphrase(void) 
     267    { 
     268    assert(pub_keyring.nkeys); 
     269    test_rsa_signature_clearsign(filename_rsa_armour_passphrase, bravo_skey, OPS_HASH_SHA1); 
    252270    } 
    253271 
     
    262280    // add tests to suite 
    263281     
    264 #ifdef TBD 
    265282    if (NULL == CU_add_test(suite, "Unarmoured, no passphrase", test_rsa_signature_noarmour_nopassphrase)) 
    266283            return NULL; 
     
    268285    if (NULL == CU_add_test(suite, "Unarmoured, passphrase", test_rsa_signature_noarmour_passphrase)) 
    269286            return NULL; 
    270 #endif /*TBD*/ 
    271287     
    272288    if (NULL == CU_add_test(suite, "Armoured, no passphrase", test_rsa_signature_armour_nopassphrase)) 
    273289            return NULL; 
    274290     
    275 #ifdef TBD 
    276291    if (NULL == CU_add_test(suite, "Armoured, passphrase", test_rsa_signature_armour_passphrase)) 
    277292            return NULL; 
    278 #endif     
     293     
     294    if (NULL == CU_add_test(suite, "Clearsigned, no passphrase", test_rsa_signature_clearsign_nopassphrase)) 
     295            return NULL; 
     296     
     297    if (NULL == CU_add_test(suite, "Clearsigned, passphrase", test_rsa_signature_clearsign_passphrase)) 
     298            return NULL; 
    279299     
    280300    return suite; 
    281301} 
    282302 
    283 CU_pSuite suite_rsa_signature_GPGtest() 
    284 { 
    285     CU_pSuite suite = NULL; 
    286  
    287     suite = CU_add_suite("RSA Signature Suite (GPG interop)", init_suite_rsa_signature_gpgtest, clean_suite_rsa_signature); 
    288  
    289     if (!suite) 
    290             return NULL; 
    291  
    292     // add tests to suite 
    293      
    294 #ifdef TBD 
    295     if (NULL == CU_add_test(suite, "Unarmoured, no passphrase", test_rsa_signature_noarmour_nopassphrase)) 
    296             return NULL; 
    297      
    298     if (NULL == CU_add_test(suite, "Unarmoured, passphrase", test_rsa_signature_noarmour_passphrase)) 
    299             return NULL; 
    300 #endif /*TBD*/ 
    301      
    302     if (NULL == CU_add_test(suite, "Armoured, no passphrase", test_rsa_signature_armour_nopassphrase)) 
    303             return NULL; 
    304      
    305     if (NULL == CU_add_test(suite, "Armoured, passphrase", test_rsa_signature_armour_passphrase)) 
    306             return NULL; 
    307      
    308      
    309     return suite; 
    310 } 
    311  
    312303// EOF 
  • openpgpsdk/trunk/tests/test_rsa_verify.c

    r523 r525  
    1616#include "tests.h" 
    1717 
    18 static int do_gpgtest=0; 
    19  
    2018#ifndef ATTRIBUTE_UNUSED 
    2119 
     
    2826#endif /* ATTRIBUTE_UNUSED */ 
    2927 
     28static char *filename_rsa_armour_nopassphrase="gpg_signed_armour_nopassphrase.txt"; 
     29static char *filename_rsa_armour_passphrase="gpg_signed_armour_passphrase.txt"; 
     30 
    3031static char *filename_rsa_noarmour_nopassphrase="gpg_signed_noarmour_nopassphrase.txt"; 
    31 static char *filename_rsa_armour_nopassphrase="gpg_signed_armour_nopassphrase.txt"; 
    32 static char *filename_rsa_noarmour_passphrase="gpg_signed_armour_nopassphrase.txt"; 
    33 static char *filename_rsa_armour_passphrase="gpg_signed_armour_passphrase.txt"; 
    34  
    35 static char *filename_rsa_clearsign_armour_nopassphrase="gpg_clearsigned_armour_nopassphrase.txt"; 
     32static char *filename_rsa_noarmour_passphrase="gpg_signed_noarmour_passphrase.txt"; 
     33 
     34static char *filename_rsa_clearsign_nopassphrase="gpg_clearsigned_nopassphrase.txt"; 
     35static char *filename_rsa_clearsign_passphrase="gpg_clearsigned_passphrase.txt"; 
    3636 
    3737/* Signature verification suite initialization. 
     
    4343    char cmd[MAXBUF+1]; 
    4444 
    45     do_gpgtest=0; 
    46  
    4745    // Create SIGNED test files 
    4846 
     47    create_testfile(filename_rsa_armour_nopassphrase); 
     48    create_testfile(filename_rsa_armour_passphrase); 
     49 
    4950    create_testfile(filename_rsa_noarmour_nopassphrase); 
    50     create_testfile(filename_rsa_armour_nopassphrase); 
    5151    create_testfile(filename_rsa_noarmour_passphrase); 
    52     create_testfile(filename_rsa_armour_passphrase); 
    5352 
    5453    // Now sign the test files with GPG 
     
    5958        { return 1; } 
    6059 
    61     snprintf(cmd,MAXBUF,"%s --compress-level 0 --sign --local-user %s --armor %s/%s", 
     60    snprintf(cmd,MAXBUF,"%s --openpgp --compress-level 0 --sign --local-user %s --armor %s/%s", 
    6261             gpgcmd, alpha_name, dir, filename_rsa_armour_nopassphrase); 
    6362    if (system(cmd)) 
    6463        { return 1; } 
    6564 
    66     snprintf(cmd,MAXBUF,"%s --compress-level 0 --sign --local-user %s --passphrase %s %s/%s", 
     65    snprintf(cmd,MAXBUF,"%s --openpgp --compress-level 0 --sign --local-user %s --passphrase %s %s/%s", 
    6766             gpgcmd, bravo_name, bravo_passphrase, dir, filename_rsa_noarmour_passphrase); 
    6867    if (system(cmd)) 
    6968        { return 1; } 
    7069 
    71     snprintf(cmd,MAXBUF,"%s --compress-level 0 --sign --local-user %s --passphrase %s --armor %s/%s", 
     70    snprintf(cmd,MAXBUF,"%s --openpgp --compress-level 0 --sign --local-user %s --passphrase %s --armor %s/%s", 
    7271             gpgcmd, bravo_name, bravo_passphrase, dir, filename_rsa_armour_passphrase); 
    7372    if (system(cmd)) 
     
    7877     */ 
    7978 
    80     create_testfile(filename_rsa_clearsign_armour_nopassphrase); 
     79    create_testfile(filename_rsa_clearsign_nopassphrase); 
     80    create_testfile(filename_rsa_clearsign_passphrase); 
    8181 
    8282    // and sign them 
    8383 
    8484    snprintf(cmd,MAXBUF,"%s --openpgp --compress-level 0 --clearsign --local-user %s --armor %s/%s", 
    85              gpgcmd, alpha_name, dir, filename_rsa_clearsign_armour_nopassphrase); 
     85             gpgcmd, alpha_name, dir, filename_rsa_clearsign_nopassphrase); 
     86    if (system(cmd)) 
     87        { return 1; } 
     88 
     89    snprintf(cmd,MAXBUF,"%s --openpgp --compress-level 0 --clearsign --local-user %s --passphrase %s --armor %s/%s", 
     90             gpgcmd, bravo_name, bravo_passphrase, dir, filename_rsa_clearsign_passphrase); 
    8691    if (system(cmd)) 
    8792        { return 1; } 
    8893 
    8994    // Return success 
    90     return 0; 
    91     } 
    92  
    93 int init_suite_rsa_verify_gpgtest(void) 
    94     { 
    95     init_suite_rsa_verify(); 
    96  
    97     do_gpgtest=1; 
    98  
    9995    return 0; 
    10096    } 
     
    176172    } 
    177173 
    178 void test_rsa_verify_noarmour_nopassphrase(void) 
     174static void test_rsa_verify_noarmour_nopassphrase(void) 
    179175    { 
    180176    //    int clearsign=0; 
     
    187183    } 
    188184 
    189 void test_rsa_verify_clearsign_armour_nopassphrase(void) 
    190     { 
    191     //    int clearsign=1; 
    192     int armour=1; 
    193     int passphrase=0; 
    194     assert(pub_keyring.nkeys); 
    195  
    196     test_rsa_verify(armour,passphrase,filename_rsa_clearsign_armour_nopassphrase,NULL); 
    197     } 
    198  
    199 #ifdef TBD 
    200 void test_rsa_encrypt_armour_singlekey(void) 
    201     { 
    202     int armour=1; 
    203     char *user_id="Alpha (RSA, no passphrase) <alpha@test.com>"; 
    204     const ops_key_data_t *pub_key=ops_keyring_find_key_by_userid(&pub_keyring, user_id); 
    205     assert(pub_key); 
    206     test_rsa_encrypt(armour,pub_key,filename_rsa_armour_singlekey); 
    207     } 
    208  
    209 void test_rsa_encrypt_noarmour_passphrase(void) 
    210     { 
     185static void test_rsa_verify_noarmour_passphrase(void) 
     186    { 
     187    //    int clearsign=0; 
    211188    int armour=0; 
    212189    int passphrase=1; 
    213     test_rsa_encrypt(armour,passphrase,filename_rsa_noarmour_passphrase); 
    214     } 
    215  
    216 void test_rsa_encrypt_armour_passphrase(void) 
     190    assert(pub_keyring.nkeys); 
     191    test_rsa_verify(armour,passphrase,filename_rsa_noarmour_passphrase,NULL); 
     192    } 
     193 
     194static void test_rsa_verify_armour_nopassphrase(void) 
     195    { 
     196    int armour=1; 
     197    int passphrase=0; 
     198    assert(pub_keyring.nkeys); 
     199    test_rsa_verify(armour,passphrase,filename_rsa_armour_nopassphrase,NULL); 
     200    } 
     201 
     202static void test_rsa_verify_armour_passphrase(void) 
    217203    { 
    218204    int armour=1; 
    219205    int passphrase=1; 
    220     test_rsa_encrypt(armour,passphrase,filename_rsa_armour_passphrase); 
    221     } 
    222 #endif /*TBD*/ 
     206    assert(pub_keyring.nkeys); 
     207    test_rsa_verify(armour,passphrase,filename_rsa_armour_passphrase,NULL); 
     208    } 
     209 
     210static void test_rsa_verify_clearsign_nopassphrase(void) 
     211    { 
     212    //    int clearsign=1; 
     213    int armour=1; 
     214    int passphrase=0; 
     215    assert(pub_keyring.nkeys); 
     216 
     217    test_rsa_verify(armour,passphrase,filename_rsa_clearsign_nopassphrase,NULL); 
     218    } 
     219 
     220static void test_rsa_verify_clearsign_passphrase(void) 
     221    { 
     222    //    int clearsign=1; 
     223    int armour=1; 
     224    int passphrase=1; 
     225    assert(pub_keyring.nkeys); 
     226 
     227    test_rsa_verify(armour,passphrase,filename_rsa_clearsign_passphrase,NULL); 
     228    } 
     229 
    223230 
    224231CU_pSuite suite_rsa_verify() 
     
    232239    // add tests to suite 
    233240     
    234     if (NULL == CU_add_test(suite, "Clearsigned, armoured, no passphrase", test_rsa_verify_clearsign_armour_nopassphrase)) 
     241    if (NULL == CU_add_test(suite, "Clearsigned, no passphrase", test_rsa_verify_clearsign_nopassphrase)) 
     242            return NULL; 
     243     
     244    if (NULL == CU_add_test(suite, "Clearsigned, passphrase", test_rsa_verify_clearsign_passphrase)) 
     245            return NULL; 
     246     
     247    if (NULL == CU_add_test(suite, "Armoured, no passphrase", test_rsa_verify_armour_nopassphrase)) 
     248            return NULL; 
     249     
     250    if (NULL == CU_add_test(suite, "Armoured, passphrase", test_rsa_verify_armour_passphrase)) 
    235251            return NULL; 
    236252     
     
    238254            return NULL; 
    239255     
    240     /* 
    241256    if (NULL == CU_add_test(suite, "Unarmoured, passphrase", test_rsa_verify_noarmour_passphrase)) 
    242257            return NULL; 
    243     */ 
     258 
    244259    return suite; 
    245260} 
    246261 
    247 CU_pSuite suite_rsa_verify_GPGtest() 
    248 { 
    249     CU_pSuite suite = NULL; 
    250  
    251     suite = CU_add_suite("RSA Verification Suite (GPG interop)", init_suite_rsa_verify_gpgtest, clean_suite_rsa_verify); 
    252     if (!suite) 
    253             return NULL; 
    254  
    255     // add tests to suite 
    256      
    257     if (NULL == CU_add_test(suite, "Clearsigned, armoured, no passphrase", test_rsa_verify_clearsign_armour_nopassphrase)) 
    258             return NULL; 
    259      
    260     if (NULL == CU_add_test(suite, "Unarmoured, no passphrase", test_rsa_verify_noarmour_nopassphrase)) 
    261             return NULL; 
    262  
    263     /* 
    264     if (NULL == CU_add_test(suite, "Unarmoured, passphrase", test_rsa_verify_noarmour_passphrase)) 
    265             return NULL; 
    266     */ 
    267     return suite; 
    268 } 
    269  
    270262// EOF