1

/**

     2

 * The main test code entry point

     3

 */

     4

#include "sock_test.h"

     5

#include "line_proto.h"

     6

#include "irc_conn.h"

     7

#include "log.h"

     8

#include "error.h"

     9

    10

#include <stdlib.h>

    11

#include <string.h>

    12

#include <assert.h>

    13

    14

void assert_strcmp (const char *is, const char *should_be)

    15

{

    16

    if (strcmp(is, should_be))

    17

        FATAL("'%s' != '%s'", is, should_be);

    18

}

    19

    20

void assert_strncmp (const char *is, const char *should_be, size_t n)

    21

{

    22

    if (strncmp(is, should_be, n))

    23

        FATAL("'%s':%d != '%s'", is, n, should_be);

    24

}

    25

    26

void assert_strlen (const char *str, size_t n)

    27

{

    28

    if (strlen(str) != n)

    29

        FATAL("strlen('%s') != %u", str, n);

    30

}

    31

    32

void assert_strnull (const char *str)

    33

{

    34

    if (str != NULL)

    35

        FATAL("'%s' != NULL", str);

    36

}

    37

    38

void assert_success (err_t err)

    39

{

    40

    if (err != SUCCESS)

    41

        FATAL("error: %s", error_name(err));

    42

    43

}

    44

    45

void assert_err (err_t err, err_t target)

    46

{

    47

    if (err != target)

    48

        FATAL("error: <%s> != <%s>", error_name(err), error_name(target));

    49

}

    50

    51

void assert_error_info (struct error_info *is, struct error_info *should_be)

    52

{

    53

    if (ERROR_CODE(is) != ERROR_CODE(should_be) || ERROR_EXTRA(is) != ERROR_EXTRA(should_be))

    54

        FATAL("error: <%s> != <%s>", error_msg(is), error_msg(should_be));

    55

}

    56

    57

void assert_sock_read (struct sock_stream *sock, const char *str)

    58

{

    59

    char buf[strlen(str)];

    60

    61

    log_debug("read: %p: '%s'", sock, str);

    62

    63

    // read it

    64

    assert(sock_stream_read(sock, buf, strlen(str)) == (int) strlen(str));

    65

    66

    // cmp

    67

    assert_strncmp(buf, str, strlen(str));

    68

}

    69

    70

void assert_sock_write (struct sock_stream *sock, const char *str)

    71

{

    72

    log_debug("write: %p: '%s'", sock, str);

    73

    74

    // write it

    75

    assert(sock_stream_write(sock, str, strlen(str)) == (int) strlen(str));

    76

}

    77

    78

void assert_sock_eof (struct sock_stream *sock)

    79

{

    80

    char buf;

    81

    82

    log_debug("eof: %p", sock);

    83

    84

    assert_err(-sock_stream_read(sock, &buf, 1), ERR_READ_EOF);

    85

}

    86

   105

void test_sock_test (void)

   106

{

   107

    struct sock_test *sock = sock_test_create();

   108

    struct io_vec _read_data[] = {

   109

        {   "foo",      3   },

   110

        {   "barx",     4   }

   111

    };

   112

    const char *_write_data = "test data";

   113

   114

    // put the read data

   115

    log_debug("set_recv_buffer: %p, %d", _read_data, 2);

   116

    sock_test_set_recv_buffer(sock, _read_data, 2, true);

   117

   118

    // read it out

   119

    log_info("test sock_test_read");

   120

   121

    assert_sock_read(SOCK_TEST_BASE(sock), "foo");

   122

    assert_sock_read(SOCK_TEST_BASE(sock), "ba");

   123

    assert_sock_read(SOCK_TEST_BASE(sock), "rx");

   124

    assert_sock_eof(SOCK_TEST_BASE(sock));

   125

   126

    // write the data in

   127

    log_info("test sock_test_write");

   128

   129

    assert_sock_write(SOCK_TEST_BASE(sock), "test ");

   130

    assert_sock_write(SOCK_TEST_BASE(sock), "data");

   134

   137

   138

    // cleanup

   139

    sock_test_destroy(sock);

   140

}

   141

   142

void assert_read_line (struct line_proto *lp, const char *line_str)

   143

{

   144

    char *line_buf;

   145

   146

    log_debug("expect: '%s'", line_str);

   147

   148

    assert_success(line_proto_recv(lp, &line_buf));

   149

   150

    if (line_str) {

   151

        assert(line_buf != NULL);

   152

        assert_strcmp(line_buf, line_str);

   153

   154

    } else {

   155

        assert_strnull(line_buf);

   156

   157

    }

   158

}

   159

   160

/**

   161

 * Context info for test_line_proto callbacks

   162

 */

   163

struct _lp_test_ctx {

   164

    /** Expected line */

   165

    const char *line;

   166

   167

    /** Expected error */

   168

    struct error_info err;

   169

};

   170

   171

static void _lp_on_line (char *line, void *arg)

   172

{

   173

    struct _lp_test_ctx *ctx = arg;

   174

   175

    log_debug("'%s'", line);

   176

   177

    assert_strcmp(line, ctx->line);

   178

   179

    ctx->line = NULL;

   180

}

   181

   182

static void _lp_on_error (struct error_info *err, void *arg)

   183

{

   184

    struct _lp_test_ctx *ctx = arg;

   185

   186

    assert_error_info(err, &ctx->err);

   187

}

   188

   189

static struct line_proto_callbacks _lp_callbacks = {

   190

    .on_line        = &_lp_on_line,

   191

    .on_error       = &_lp_on_error,

   192

};

   193

   194

void test_line_proto (void)

   195

{

   196

    struct sock_test *sock = sock_test_create();

   197

    struct io_vec _read_data[] = {

   198

        {   "hello\r\n",    7   },

   199

        {   "world\n",      6   },

   200

        {   "this ",        5   },

   201

        {   "is a line\r",  10  },

   202

        {   "\nfragment",   9   },

   203

    }, _trailing_data = {   "\r\n",     2 };

   204

    struct line_proto *lp;

   205

    struct _lp_test_ctx ctx;

   206

    struct error_info err;

   207

   208

    // put the read data

   209

    log_debug("set_recv_buffer: %p, %d", _read_data, 5);

   210

    sock_test_set_recv_buffer(sock, _read_data, 5, false);

   211

   212

    // create the lp

   213

    assert_success(line_proto_create(&lp, SOCK_TEST_BASE(sock), 128, &_lp_callbacks, &ctx, &err));

   214

   215

    log_info("test line_proto_recv");

   216

   217

    // then read some lines from it

   218

    assert_read_line(lp, "hello");

   219

    assert_read_line(lp, "world");

   220

    assert_read_line(lp, "this is a line");

   221

    assert_read_line(lp, NULL);

   222

   223

    // then add a final bit to trigger on_line

   224

    log_info("test on_line");

   225

   226

    ctx.line = "fragment";

   227

    sock_test_add_recv_vec(sock, _trailing_data);

   228

    assert_strnull(ctx.line);

   229

   238

    // cleanup

   239

    line_proto_release(lp);

   240

}

   241

   271

static struct irc_conn_callbacks _conn_callbacks = {

   278

};

   279

   280

void test_irc_conn (void)

   281

{

   282

    struct sock_test *sock;

   283

    struct irc_conn *conn;

   284

    struct error_info err;

   289

   290

    // create the test socket

   291

    assert((sock = sock_test_create()));

   292

   293

    // create the irc_conn

   312

   313

    // destroy it

   314

    irc_conn_destroy(conn);

   315

}

   316

   317

/**

   318

 * Test definition

   319

 */

   320

static struct test {

   321

    /** Test name */

   322

    const char *name;

   323

   324

    /** Test func */

   325

    void (*func) (void);

   326

   327

} _tests[] = {

   328

    {   "sock_test",    &test_sock_test     },

   329

    {   "line_proto",   &test_line_proto    },

   330

    {   "irc_conn",     &test_irc_conn      },

   331

    {   NULL,           NULL                }

   332

};

   333

   334

int main (int argc, char **argv)

   335

{

   336

    struct test *test;

   337

   338

    (void) argv;

   339

   340

    // no arguments

   341

    assert(argc == 1);

   342

   343

    // run tests

   344

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

   345

        log_info("Running test: %s", test->name);

   346

   347

        test->func();

   348

    }

   349

}