Line data    Source code

       1             : //
       2             : //  test_coders.c
       3             : //  oc-runner
       4             : //
       5             : //  Created by Danny Goossen on 16/9/18.
       6             : //  Copyright (c) 2018 Danny Goossen. All rights reserved.
       7             : //
       8             : 
       9             : //LCOV_EXCL_START
      10             : #include <check.h>
      11             : //LCOV_EXCL_STOP
      12             : 
      13             : #include "../src/b64.h"
      14             : #include "../src/openssl.h"
      15             : 
      16             : struct test_data_b64_t
      17             : {
      18             :         char * in;
      19             :         int len;
      20             :         char * out;
      21             : } ;
      22             : 
      23             : static const struct test_data_b64_t testlist_b64[3] = {
      24             :         { NULL,0,""},
      25             :         { "",0,""},
      26             :         { "a*_/+?-%^&()!@#=[|/?.<,.09zZ",28,"YSpfLys/LSVeJigpIUAjPVt8Lz8uPCwuMDl6Wg=="}
      27             : };
      28             : 
      29           3 : START_TEST(check_b64)
      30             : {
      31           3 :         char * result=NULL;
      32           3 :         size_t len_out=0;
      33           3 :         base64_encode((uint8_t *)testlist_b64[_i].in, testlist_b64[_i].len, &result, &len_out, NULL);
      34           3 :         ck_assert_str_eq(result, testlist_b64[_i].out);
      35           3 :         unsigned char * dec=NULL;
      36           3 :         size_t dec_len=0;
      37           3 :         base64_decode(result, len_out, &dec, &dec_len, NULL);
      38           5 :         if (testlist_b64[_i].in ==NULL || testlist_b64[_i].len ==0)
      39           2 :                 ck_assert_int_eq(dec_len, 0);
      40             :         else
      41           1 :                 ck_assert_str_eq( testlist_b64[_i].in,(char *)dec);
      42           3 :         if (dec) free(dec);
      43           3 :         if(result) free(result);
      44             : }
      45           3 : END_TEST
      46             : 
      47             : 
      48             : struct test_data_b64_v_t
      49             : {
      50             :         char * prefix;
      51             :         char * format;
      52             :         char * in;
      53             :         char * out;
      54             : } ;
      55             : 
      56             : static const struct test_data_b64_v_t testlist_b64_v[4] = {
      57             :         { NULL,"%s","",""},
      58             :         { "",NULL,NULL,NULL},
      59             :         { NULL,"%s","a*_/+?-%^&()!@#=[|/?.<,.09zZ","YSpfLys/LSVeJigpIUAjPVt8Lz8uPCwuMDl6Wg=="},
      60             :         { "pref : ","%s","a*_/+?-%^&()!@#=[|/?.<,.09zZ","pref : YSpfLys/LSVeJigpIUAjPVt8Lz8uPCwuMDl6Wg=="}
      61             : };
      62             : 
      63           4 : START_TEST(check_b64_v)
      64             : {
      65           4 :         char * result=Base64Encode_v(testlist_b64_v[_i].prefix, testlist_b64_v[_i].format,testlist_b64_v[_i].in);
      66             :         
      67           4 :         if (result!=NULL)
      68           3 :                 ck_assert_str_eq(result, testlist_b64_v[_i].out);
      69             :         else
      70           1 :                 ck_assert_ptr_null(testlist_b64_v[_i].out);
      71             :         
      72           4 :         if (result) free(result);
      73             :         
      74             : }
      75           4 : END_TEST
      76             : 
      77             : 
      78           8 : Suite * coders_suite(void)
      79             : {
      80             :         Suite *s;
      81             :         TCase *tc_core;
      82             :         //TCase *tc_progress;
      83           8 :         s = suite_create("test_error");
      84             :         /* Core test case */
      85           8 :         tc_core = tcase_create("Core");
      86             :         //tcase_add_checked_fixture(tc_core, setup, teardown);
      87             : 
      88           8 :         tcase_add_loop_test (tc_core,check_b64,0,3);
      89           8 :         tcase_add_loop_test (tc_core,check_b64_v,0,4);
      90           8 :         tcase_add_unchecked_fixture(tc_core, NULL, NULL);
      91           8 :         tcase_set_timeout(tc_core,15);
      92           8 :         suite_add_tcase(s, tc_core);
      93           8 :         return s;
      94             : }
      95             : 
      96             : 
      97           8 : int main(void)
      98             : {
      99             :         int number_failed;
     100             :         Suite *s;
     101             :         SRunner *sr;
     102             :         
     103           8 :         s = coders_suite();
     104           8 :         sr = srunner_create(s);
     105           8 :         srunner_run_all(sr, CK_NORMAL);
     106           1 :         number_failed = srunner_ntests_failed(sr);
     107           1 :         srunner_free(sr);
     108           1 :         return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
     109             : }
     110             :