Changeset 922 in openpam


Ignore:
Timestamp:
Feb 19, 2017, 7:28:30 PM (4 years ago)
Author:
Dag-Erling Smørgrav
Message:

Switch to using the cryb.to project's test framework.

Location:
trunk
Files:
3 deleted
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/configure.ac

    r917 r922  
    122122AC_SUBST(SYSTEM_LIBPAM)
    123123
     124save_LIBS="${LIBS}"
     125LIBS=""
     126AC_SEARCH_LIBS([cryb_test_version], [cryb-test], [
     127  CRYB_TEST_LIBS="${LIBS}"
     128], [
     129  CRYB_TEST_LIBS=""
     130  AC_MSG_WARN([cryb-test library not available, unit tests disabled])
     131])
     132LIBS="${save_LIBS}"
     133AC_SUBST(CRYB_TEST_LIBS)
     134AM_CONDITIONAL([WITH_TEST], [ test x"$CRYB_TEST_LIBS" != x"" ])
     135
    124136AC_ARG_ENABLE([developer-warnings],
    125137    AS_HELP_STRING([--enable-developer-warnings], [enable strict warnings (default is NO)]),

  • trunk/t/Makefile.am

    r907 r922  
    11# $Id$
     2
     3if WITH_TEST
    24
    35AM_CPPFLAGS = -I$(top_srcdir)/include -I$(top_srcdir)/lib/libpam
    … …  
    68        PAM_RETURN_SO=$(abs_top_builddir)/modules/pam_return/.libs/pam_return.so
    79
    8 noinst_HEADERS = t.h t_pam_conv.h
     10noinst_HEADERS = t_pam_conv.h
    911
    1012# tests
    … …  
    1820# libt - common support code
    1921check_LIBRARIES = libt.a
    20 libt_a_SOURCES = t_main.c t_file.c t_pam_conv.c
     22libt_a_SOURCES = t_pam_conv.c
    2123
    22 # link with libpam and libt
    23 LDADD = libt.a
     24# link with libpam and test framework
     25LDADD = $(CRYB_TEST_LIBS) libt.a
    2426if WITH_SYSTEM_LIBPAM
    2527LDADD += $(SYSTEM_LIBPAM)
    … …  
    2729LDADD += $(top_builddir)/lib/libpam/libpam.la
    2830endif
     31
     32endif

  • trunk/t/t_openpam_ctype.c

    r890 r922  
    3434#endif
    3535
     36#include <stdint.h>
    3637#include <stdio.h>
    3738#include <string.h>
    3839
     40#include <cryb/test.h>
     41
    3942#include "openpam_ctype.h"
    40 
    41 #include "t.h"
    4243
    4344#define OC_DIGIT        "0123456789"
    … …  
    6263
    6364#define T_OC(set)                                                       \
    64         T_FUNC(t_oc_##set, "is_" #set)                                  \
     65        static int                                                      \
     66        t_oc_##set(char **desc, void *arg)                              \
    6567        {                                                               \
    6668                char crib[256];                                         \
    6769                unsigned int i, ret;                                    \
    6870                                                                        \
     71                (void)desc;                                             \
     72                (void)arg;                                              \
    6973                memset(crib, 0, sizeof crib);                           \
    7074                for (i = 0; oc_##set[i]; ++i)                           \
    … …  
    7983                return (ret == 0);                                      \
    8084        }
     85#define T_OC_ADD(set) t_add_test(&t_oc_##set, NULL, "is_"#set)
    8186
    8287T_OC(digit)
    … …  
    96101 */
    97102
    98 static struct t_test *t_plan[] = {
    99         T(t_oc_digit),
    100         T(t_oc_xdigit),
    101         T(t_oc_upper),
    102         T(t_oc_lower),
    103         T(t_oc_letter),
    104         T(t_oc_lws),
    105         T(t_oc_ws),
    106         T(t_oc_p),
    107         T(t_oc_pfcs),
    108         NULL
    109 };
    110 
    111 struct t_test **
     103static int
    112104t_prepare(int argc, char *argv[])
    113105{
    … …  
    115107        (void)argc;
    116108        (void)argv;
    117         return (t_plan);
     109        T_OC_ADD(digit);
     110        T_OC_ADD(xdigit);
     111        T_OC_ADD(upper);
     112        T_OC_ADD(lower);
     113        T_OC_ADD(letter);
     114        T_OC_ADD(lws);
     115        T_OC_ADD(ws);
     116        T_OC_ADD(p);
     117        T_OC_ADD(pfcs);
     118        return (0);
    118119}
    119120
    120 void
    121 t_cleanup(void)
     121int
     122main(int argc, char *argv[])
    122123{
     124
     125        t_main(t_prepare, NULL, argc, argv);
    123126}

  • trunk/t/t_openpam_dispatch.c

    r913 r922  
    3535
    3636#include <err.h>
     37#include <stdint.h>
    3738#include <stdio.h>
    3839#include <stdlib.h>
    3940#include <string.h>
     41#include <unistd.h>
     42
     43#include <cryb/test.h>
    4044
    4145#include <security/pam_appl.h>
    … …  
    4347
    4448#include "openpam_impl.h"
    45 #include "t.h"
    4649#include "t_pam_conv.h"
     50
     51#define T_FUNC(n, d)                                                    \
     52        static const char *t_ ## n ## _desc = d;                        \
     53        static int t_ ## n ## _func(OPENPAM_UNUSED(char **desc),        \
     54            OPENPAM_UNUSED(void *arg))
     55
     56#define T(n)                                                            \
     57        t_add_test(&t_ ## n ## _func, NULL, t_ ## n ## _desc)
    4758
    4859const char *pam_return_so;
    … …  
    7384        pam_err = pam_authenticate(pamh, 0);
    7485        t_verbose("pam_authenticate() returned %d\n", pam_err);
    75         ret = (pam_err != PAM_SUCCESS);
     86        ret = (pam_err == PAM_SYSTEM_ERR);
    7687        pam_err = pam_setcred(pamh, 0);
    7788        t_verbose("pam_setcred() returned %d\n", pam_err);
    78         ret |= (pam_err != PAM_SUCCESS);
     89        ret &= (pam_err == PAM_SYSTEM_ERR);
    7990        pam_err = pam_acct_mgmt(pamh, 0);
    8091        t_verbose("pam_acct_mgmt() returned %d\n", pam_err);
    81         ret |= (pam_err != PAM_SUCCESS);
     92        ret &= (pam_err == PAM_SYSTEM_ERR);
    8293        pam_err = pam_chauthtok(pamh, 0);
    8394        t_verbose("pam_chauthtok() returned %d\n", pam_err);
    84         ret |= (pam_err != PAM_SUCCESS);
     95        ret &= (pam_err == PAM_SYSTEM_ERR);
    8596        pam_err = pam_open_session(pamh, 0);
    8697        t_verbose("pam_open_session() returned %d\n", pam_err);
    87         ret |= (pam_err != PAM_SUCCESS);
     98        ret &= (pam_err == PAM_SYSTEM_ERR);
    8899        pam_err = pam_close_session(pamh, 0);
    89100        t_verbose("pam_close_session() returned %d\n", pam_err);
    90         ret |= (pam_err != PAM_SUCCESS);
    91         pam_err = pam_end(pamh, pam_err);
    92         ret |= (pam_err == PAM_SUCCESS);
     101        ret &= (pam_err == PAM_SYSTEM_ERR);
     102        pam_end(pamh, pam_err);
    93103        t_fclose(tf);
    94104        return (ret);
    … …  
    167177                t_verbose("%s returned %d\n",
    168178                    pam_func_name[tc->primitive], pam_err);
     179                pam_end(pamh, pam_err);
     180                t_verbose("here\n");
    169181                t_fclose(tf);
    170182        }
    … …  
    178190 */
    179191
    180 static struct t_test *t_plan[] = {
    181         T(empty_policy),
    182         T(mod_return),
    183 
    184         NULL
    185 };
    186 
    187 struct t_test **
     192static int
    188193t_prepare(int argc, char *argv[])
    189194{
    190195
    191         if ((pam_return_so = getenv("PAM_RETURN_SO")) == NULL)
    192                 return (NULL);
     196        (void)argc;
     197        (void)argv;
     198
     199        if ((pam_return_so = getenv("PAM_RETURN_SO")) == NULL) {
     200                t_verbose("define PAM_RETURN_SO before running these tests\n");
     201                return (0);
     202        }
    193203
    194204        openpam_set_feature(OPENPAM_RESTRICT_MODULE_NAME, 0);
    … …  
    198208        openpam_set_feature(OPENPAM_FALLBACK_TO_OTHER, 0);
    199209
    200         (void)argc;
    201         (void)argv;
    202         return (t_plan);
    203 }
    204 
    205 void
    206 t_cleanup(void)
    207 {
    208 }
     210        T(empty_policy);
     211        T(mod_return);
     212
     213        return (0);
     214}
     215
     216int
     217main(int argc, char *argv[])
     218{
     219
     220        t_main(t_prepare, NULL, argc, argv);
     221}

  • trunk/t/t_openpam_readlinev.c

    r890 r922  
    3535
    3636#include <err.h>
     37#include <stdint.h>
    3738#include <stdio.h>
    3839#include <stdlib.h>
    3940#include <string.h>
    4041
     42#include <cryb/test.h>
     43
    4144#include <security/pam_appl.h>
    4245#include <security/openpam.h>
    4346
    4447#include "openpam_impl.h"
    45 #include "t.h"
     48
     49#define T_FUNC(n, d)                                                    \
     50        static const char *t_ ## n ## _desc = d;                        \
     51        static int t_ ## n ## _func(OPENPAM_UNUSED(char **desc),        \
     52            OPENPAM_UNUSED(void *arg))
     53
     54#define T(n)                                                            \
     55        t_add_test(&t_ ## n ## _func, NULL, t_ ## n ## _desc)
    4656
    4757/*
    … …  
    5666        int expectedc, gotc, i, lineno = 0;
    5767        char **gotv;
    58 
     68        int ret;
     69
     70        ret = 1;
    5971        expectedc = 0;
    6072        if (expectedv != NULL)
    … …  
    6678        if (expectedv != NULL && gotv == NULL) {
    6779                t_verbose("expected %d words, got nothing\n", expectedc);
    68                 return (0);
    69         }
    70         if (expectedv == NULL && gotv != NULL) {
     80                ret = 0;
     81        } else if (expectedv == NULL && gotv != NULL) {
    7182                t_verbose("expected nothing, got %d words\n", gotc);
    72                 FREEV(gotc, gotv);
    73                 return (0);
    74         }
    75         if (expectedv != NULL && gotv != NULL) {
     83                ret = 0;
     84        } else if (expectedv != NULL && gotv != NULL) {
    7685                if (expectedc != gotc) {
    7786                        t_verbose("expected %d words, got %d\n",
    7887                            expectedc, gotc);
    79                         FREEV(gotc, gotv);
    80                         return (0);
     88                        ret = 0;
    8189                }
    8290                for (i = 0; i < gotc; ++i) {
    … …  
    8492                                t_verbose("word %d: expected <<%s>>, "
    8593                                    "got <<%s>>\n", i, expectedv[i], gotv[i]);
    86                                 FREEV(gotc, gotv);
    87                                 return (0);
     94                                ret = 0;
    8895                        }
    8996                }
    90                 FREEV(gotc, gotv);
    9197        }
     98        FREEV(gotc, gotv);
    9299        if (lineno != lines) {
    93100                t_verbose("expected to advance %d lines, advanced %d lines\n",
    94101                    lines, lineno);
    95                 return (0);
     102                ret = 0;
    96103        }
    97104        if (eof && !t_feof(tf)) {
    98105                t_verbose("expected EOF, but didn't get it\n");
    99                 return (0);
     106                ret = 0;
     107        } else if (!eof && t_feof(tf)) {
     108                t_verbose("didn't expect EOF, but got it anyway\n");
     109                ret = 0;
    100110        }
    101         if (!eof && t_feof(tf)) {
    102                 t_verbose("didn't expect EOF, but got it anyway\n");
    103                 return (0);
    104         }
    105         return (1);
     111        return (ret);
    106112}
    107113
    … …  
    307313 */
    308314
    309 static struct t_test *t_plan[] = {
    310         T(empty_input),
    311         T(empty_line),
    312         T(unterminated_empty_line),
    313         T(whitespace),
    314         T(comment),
    315         T(whitespace_before_comment),
    316         T(line_continuation_within_whitespace),
    317 
    318         T(one_word),
    319         T(two_words),
    320         T(many_words),
    321         T(unterminated_line),
    322 
    323         NULL
    324 };
    325 
    326 struct t_test **
     315static int
    327316t_prepare(int argc, char *argv[])
    328317{
    … …  
    330319        (void)argc;
    331320        (void)argv;
    332         return (t_plan);
    333 }
    334 
    335 void
    336 t_cleanup(void)
    337 {
    338 }
     321
     322        T(empty_input);
     323        T(empty_line);
     324        T(unterminated_empty_line);
     325        T(whitespace);
     326        T(comment);
     327        T(whitespace_before_comment);
     328        T(line_continuation_within_whitespace);
     329
     330        T(one_word);
     331        T(two_words);
     332        T(many_words);
     333        T(unterminated_line);
     334
     335        return (0);
     336}
     337
     338int
     339main(int argc, char *argv[])
     340{
     341
     342        t_main(t_prepare, NULL, argc, argv);
     343}

  • trunk/t/t_openpam_readword.c

    r890 r922  
    4040#include <unistd.h>
    4141
     42#include <cryb/test.h>
     43
    4244#include <security/pam_appl.h>
    4345#include <security/openpam.h>
    4446
    45 #include "t.h"
     47#define T_FUNC(n, d)                                                    \
     48        static const char *t_ ## n ## _desc = d;                        \
     49        static int t_ ## n ## _func(OPENPAM_UNUSED(char **desc),        \
     50            OPENPAM_UNUSED(void *arg))
     51
     52#define T(n)                                                            \
     53        t_add_test(&t_ ## n ## _func, NULL, t_ ## n ## _desc)
    4654
    4755/*
    … …  
    5765        char *got;
    5866        size_t len;
     67        int ret;
    5968
    6069        got = openpam_readword(tf->file, &lineno, &len);
     70        ret = 1;
    6171        if (t_ferror(tf))
    6272                err(1, "%s(): %s", __func__, tf->name);
    6373        if (expected != NULL && got == NULL) {
    6474                t_verbose("expected <<%s>>, got nothing\n", expected);
    65                 return (0);
     75                ret = 0;
     76        } else if (expected == NULL && got != NULL) {
     77                t_verbose("expected nothing, got <<%s>>\n", got);
     78                ret = 0;
     79        } else if (expected != NULL && got != NULL && strcmp(expected, got) != 0) {
     80                t_verbose("expected <<%s>>, got <<%s>>\n", expected, got);
     81                ret = 0;
    6682        }
    67         if (expected == NULL && got != NULL) {
    68                 t_verbose("expected nothing, got <<%s>>\n", got);
    69                 return (0);
    70         }
    71         if (expected != NULL && got != NULL && strcmp(expected, got) != 0) {
    72                 t_verbose("expected <<%s>>, got <<%s>>\n", expected, got);
    73                 return (0);
    74         }
     83        free(got);
    7584        if (lineno != lines) {
    7685                t_verbose("expected to advance %d lines, advanced %d lines\n",
    7786                    lines, lineno);
    78                 return (0);
     87                ret = 0;
    7988        }
    8089        if (eof && !t_feof(tf)) {
    8190                t_verbose("expected EOF, but didn't get it\n");
    82                 return (0);
     91                ret = 0;
    8392        }
    8493        if (!eof && t_feof(tf)) {
    8594                t_verbose("didn't expect EOF, but got it anyway\n");
    86                 return (0);
     95                ret = 0;
    8796        }
    8897        ch = fgetc(tf->file);
    … …  
    91100        if (eol && ch != '\n') {
    92101                t_verbose("expected EOL, but didn't get it\n");
    93                 return (0);
    94         }
    95         if (!eol && ch == '\n') {
     102                ret = 0;
     103        } else if (!eol && ch == '\n') {
    96104                t_verbose("didn't expect EOL, but got it anyway\n");
    97                 return (0);
     105                ret = 0;
    98106        }
    99107        if (ch != EOF)
    100108                ungetc(ch, tf->file);
    101         return (1);
     109        return (ret);
    102110}
    103111
    … …  
    958966 */
    959967
    960 static struct t_test *t_plan[] = {
    961         T(empty_input),
    962         T(empty_line),
    963         T(unterminated_line),
    964         T(single_whitespace),
    965         T(multiple_whitespace),
    966         T(comment),
    967         T(whitespace_before_comment),
    968         T(single_quoted_comment),
    969         T(double_quoted_comment),
    970         T(comment_at_eof),
    971 
    972         T(single_word),
    973         T(single_whitespace_before_word),
    974         T(double_whitespace_before_word),
    975         T(single_whitespace_after_word),
    976         T(double_whitespace_after_word),
    977         T(comment_after_word),
    978         T(word_containing_hash),
    979         T(two_words),
    980 
    981         T(naked_escape),
    982         T(escaped_escape),
    983         T(escaped_whitespace),
    984         T(escaped_newline_before_word),
    985         T(escaped_newline_within_word),
    986         T(escaped_newline_after_word),
    987         T(escaped_letter),
    988         T(escaped_comment),
    989         T(escape_at_eof),
    990 
    991         T(naked_single_quote),
    992         T(naked_double_quote),
    993         T(empty_single_quotes),
    994         T(empty_double_quotes),
    995         T(single_quotes_within_double_quotes),
    996         T(double_quotes_within_single_quotes),
    997         T(single_quoted_whitespace),
    998         T(double_quoted_whitespace),
    999         T(single_quoted_words),
    1000         T(double_quoted_words),
    1001 
    1002         T(single_quote_before_word),
    1003         T(double_quote_before_word),
    1004         T(single_quote_within_word),
    1005         T(double_quote_within_word),
    1006         T(single_quote_after_word),
    1007         T(double_quote_after_word),
    1008 
    1009         T(escaped_single_quote),
    1010         T(escaped_double_quote),
    1011         T(escaped_whitespace_within_single_quotes),
    1012         T(escaped_whitespace_within_double_quotes),
    1013         T(escaped_letter_within_single_quotes),
    1014         T(escaped_letter_within_double_quotes),
    1015         T(escaped_escape_within_single_quotes),
    1016         T(escaped_escape_within_double_quotes),
    1017         T(escaped_single_quote_within_single_quotes),
    1018         T(escaped_double_quote_within_single_quotes),
    1019         T(escaped_single_quote_within_double_quotes),
    1020         T(escaped_double_quote_within_double_quotes),
    1021 
    1022         T(line_continuation_within_whitespace),
    1023         T(line_continuation_before_whitespace),
    1024         T(line_continuation_after_whitespace),
    1025         T(line_continuation_within_word),
    1026 
    1027         NULL
    1028 };
    1029 
    1030 struct t_test **
     968static int
    1031969t_prepare(int argc, char *argv[])
    1032970{
    … …  
    1034972        (void)argc;
    1035973        (void)argv;
    1036         return (t_plan);
    1037 }
    1038 
    1039 void
    1040 t_cleanup(void)
    1041 {
    1042 }
     974
     975        T(empty_input);
     976        T(empty_line);
     977        T(unterminated_line);
     978        T(single_whitespace);
     979        T(multiple_whitespace);
     980        T(comment);
     981        T(whitespace_before_comment);
     982        T(single_quoted_comment);
     983        T(double_quoted_comment);
     984        T(comment_at_eof);
     985
     986        T(single_word);
     987        T(single_whitespace_before_word);
     988        T(double_whitespace_before_word);
     989        T(single_whitespace_after_word);
     990        T(double_whitespace_after_word);
     991        T(comment_after_word);
     992        T(word_containing_hash);
     993        T(two_words);
     994
     995        T(naked_escape);
     996        T(escaped_escape);
     997        T(escaped_whitespace);
     998        T(escaped_newline_before_word);
     999        T(escaped_newline_within_word);
     1000        T(escaped_newline_after_word);
     1001        T(escaped_letter);
     1002        T(escaped_comment);
     1003        T(escape_at_eof);
     1004
     1005        T(naked_single_quote);
     1006        T(naked_double_quote);
     1007        T(empty_single_quotes);
     1008        T(empty_double_quotes);
     1009        T(single_quotes_within_double_quotes);
     1010        T(double_quotes_within_single_quotes);
     1011        T(single_quoted_whitespace);
     1012        T(double_quoted_whitespace);
     1013        T(single_quoted_words);
     1014        T(double_quoted_words);
     1015
     1016        T(single_quote_before_word);
     1017        T(double_quote_before_word);
     1018        T(single_quote_within_word);
     1019        T(double_quote_within_word);
     1020        T(single_quote_after_word);
     1021        T(double_quote_after_word);
     1022
     1023        T(escaped_single_quote);
     1024        T(escaped_double_quote);
     1025        T(escaped_whitespace_within_single_quotes);
     1026        T(escaped_whitespace_within_double_quotes);
     1027        T(escaped_letter_within_single_quotes);
     1028        T(escaped_letter_within_double_quotes);
     1029        T(escaped_escape_within_single_quotes);
     1030        T(escaped_escape_within_double_quotes);
     1031        T(escaped_single_quote_within_single_quotes);
     1032        T(escaped_double_quote_within_single_quotes);
     1033        T(escaped_single_quote_within_double_quotes);
     1034        T(escaped_double_quote_within_double_quotes);
     1035
     1036        T(line_continuation_within_whitespace);
     1037        T(line_continuation_before_whitespace);
     1038        T(line_continuation_after_whitespace);
     1039        T(line_continuation_within_word);
     1040
     1041        return (0);
     1042}
     1043
     1044int
     1045main(int argc, char *argv[])
     1046{
     1047
     1048        t_main(t_prepare, NULL, argc, argv);
     1049}

  • trunk/t/t_pam_conv.c

    r863 r922  
    3636#include <err.h>
    3737#include <errno.h>
     38#include <stdint.h>
    3839#include <stdio.h>
    3940#include <stdlib.h>
    4041#include <string.h>
     42
     43#include <cryb/test.h>
    4144
    4245#include <security/pam_appl.h>
    … …  
    4548#include "openpam_impl.h"
    4649#include "openpam_asprintf.h"
    47 #include "t.h"
    4850
    4951#include "t_pam_conv.h"
Note: See TracChangeset for help on using the changeset viewer.