1

#include "test.h"

     2

     3

#include "../sock.h"

     4

     5

#include <getopt.h>

     6

     7

/**

     8

 * The global state

     9

 */

    10

struct test_ctx _test_ctx;

    11

    12

/**

    13

 * Setup the global sock_stream state

    14

 */

    15

static struct event_base* setup_sock (void)

    16

{

    17

    struct event_base *ev_base;

    18

    struct error_info err;

    19

    20

    assert((ev_base = event_base_new()));

    21

    assert_success(sock_init(ev_base, &err));

    22

    23

    return ev_base;

    24

}

    25

    26

/**

    27

 * Command-line option codes

    28

 */

    29

enum option_code {

    30

    OPT_HELP            = 'h',

    31

    OPT_DEBUG           = 'd',

    32

    OPT_QUIET           = 'q',

    33

    OPT_LIST            = 'l',

    34

    35

    /** Options without short names */

    36

    _OPT_EXT_BEGIN      = 0x00ff,

    37

};

    38

    39

/**

    40

 * Command-line option definitions

    41

 */

    42

static struct option options[] = {

    43

    {"help",            0,  NULL,   OPT_HELP        },

    44

    {"debug",           0,  NULL,   OPT_DEBUG       },

    45

    {"quiet",           0,  NULL,   OPT_QUIET       },

    46

    {"list",            0,  NULL,   OPT_LIST        },

    47

    {0,                 0,  0,      0               },

    48

};

    49

    50

/**

    51

 * Display --help output on stdout

    52

 */

    53

static void usage (const char *exe) 

    54

{

    55

    printf("Usage: %s [OPTIONS]\n", exe);

    56

    printf("\n");

    57

    printf(" --help / -h            display this message\n");

    58

    printf(" --debug / -d           display DEBUG log messages\n");

    59

    printf(" --quiet / -q           supress INFO log messages\n");

    60

    printf(" --list / -l            list all tests\n");

    61

}

    62

    63

/**

    64

 * Output the given list of tests on stdout

    65

 */

    66

static void list_tests (const struct test *tests)

    67

{

    68

    const struct test *test;

    69

    70

    printf("Available tests:\n");

    71

    72

    for (test = tests; test->name; test++) {

    73

        printf("\t%s\n", test->name);

    74

    }

    75

}

    76

    77

/**

    90

 * Run the given NULL-terminated list of tests, optionally filtering against the given filter.

    91

 *

    92

 * Returns the number of tests run, which may be zero.

    93

 */

    94

static size_t run_tests (const struct test tests[], const char *filter)

    95

{

    96

    size_t test_count = 0;

    97

    const struct test *test;

    98

    99

    // run each test in turn

   100

    for (test = tests; test->name; test++) {

   101

        // filter out if given

   102

        if ((filter && strcmp(test->name, filter)) || (!filter && test->optional))

   103

            continue;

   104

   107

    }

   108

   109

    return test_count;

   110

}

   111

   112

int main (int argc, char **argv)

   113

{

   114

    int opt, option_index;

   115

    const char *filter = NULL;

   116

   117

    size_t test_count;

   118

   119

    // parse options

   120

    while ((opt = getopt_long(argc, argv, "hdql", options, &option_index)) != -1) {

   121

        switch (opt) {

   122

            case OPT_HELP:

   123

                usage(argv[0]);

   124

                exit(EXIT_SUCCESS);

   125

   126

            case OPT_DEBUG:

   127

                set_log_level(LOG_DEBUG);

   128

                break;

   129

   130

            case OPT_QUIET:

   131

                set_log_level(LOG_WARN);

   132

                break;

   133

   134

            case OPT_LIST:

   135

                list_tests(_tests);

   136

                exit(EXIT_SUCCESS);

   137

   138

            case '?':

   139

                usage(argv[0]);

   140

                exit(EXIT_FAILURE);

   141

        }

   142

    }

   143

   144

    // parse positional arguments

   145

    if (optind < argc) {

   146

        if (optind == argc - 1) {

   147

            // filter

   148

            filter = argv[optind];

   149

   150

            log_info("only running tests: %s", filter);

   151

        } else {

   152

            FATAL("too many arguments");

   153

        }

   154

    }

   155

   156

    // setup the sockets stuff

   157

    _test_ctx.ev_base = setup_sock();

   158

   159

    // run tests

   160

    if ((test_count = run_tests(_tests, filter)) == 0)

   161

        FATAL("no tests run");

   162

   163

    // log

   164

    log_info("done, ran %zu tests", test_count);

   165

   166

    // ok

   167

    return EXIT_SUCCESS;

   168

}

   169