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

    15

{

    18

}

    19

    21

{

    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

    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)

    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

    87

void test_sock_test (void)

    88

{

    89

    struct sock_test *sock = sock_test_create();

    90

    struct io_vec _read_data[] = {

    91

        {   "foo",      3   },

    92

        {   "barx",     4   }

    93

    };

    94

    const char *_write_data = "test data";

    95

    96

    // put the read data

    97

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

    98

    sock_test_set_recv_buffer(sock, _read_data, 2, true);

    99

   100

    // read it out

   101

    log_info("test sock_test_read");

   102

   103

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

   104

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

   105

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

   106

    assert_sock_eof(SOCK_TEST_BASE(sock));

   107

   108

    // write the data in

   109

    log_info("test sock_test_write");

   110

   111

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

   112

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

   113

   114

    // get the data out

   115

    char *data;

   116

    size_t len;

   117

   118

    log_info("test get_send_data");

   119

   120

    sock_test_get_send_data(sock, &data, &len);

   121

   122

    // should be the same

   123

    assert_strlen(_write_data, len);

   124

    assert_strncmp(data, _write_data, len);

   125

   126

    // cleanup

   127

    free(data);

   128

    sock_test_destroy(sock);

   129

}

   130

   131

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

   132

{

   133

    char *line_buf;

   134

   135

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

   136

   137

    assert_success(line_proto_recv(lp, &line_buf));

   138

   139

    if (line_str) {

   140

        assert(line_buf != NULL);

   141

        assert_strcmp(line_buf, line_str);

   142

   143

    } else {

   145

   146

    }

   147

}

   148

   178

static struct line_proto_callbacks _lp_callbacks = {

   181

};

   182

   183

void test_line_proto (void)

   184

{

   185

    struct sock_test *sock = sock_test_create();

   186

    struct io_vec _read_data[] = {

   187

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

   188

        {   "world\n",      6   },

   189

        {   "this ",        5   },

   190

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

   191

        {   "\nfragment",   9   },

   192

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

   193

    struct line_proto *lp;

   195

    struct error_info err;

   196

   197

    // put the read data

   198

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

   199

    sock_test_set_recv_buffer(sock, _read_data, 5, false);

   200

   201

    // create the lp

   203

   204

    log_info("test line_proto_recv");

   205

   206

    // then read some lines from it

   207

    assert_read_line(lp, "hello");

   208

    assert_read_line(lp, "world");

   209

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

   210

    assert_read_line(lp, NULL);

   211

   216

    sock_test_add_recv_vec(sock, _trailing_data);

   218

   219

    // cleanup

   220

    line_proto_release(lp);

   221

}

   222

   223

static struct irc_conn_callbacks _conn_callbacks = {

   224

    .on_registered      = NULL,

   225

};

   226

   227

void test_irc_conn (void)

   228

{

   229

    struct sock_test *sock;

   230

    struct irc_conn *conn;

   231

    struct error_info err;

   232

   233

    // create the test socket

   234

    assert((sock = sock_test_create()));

   235

   236

    // create the irc_conn

   237

    assert_success(irc_conn_create(&conn, SOCK_TEST_BASE(sock), &_conn_callbacks, NULL, &err));

   238

   239

    // destroy it

   240

    irc_conn_destroy(conn);

   241

}

   242

   243

/**

   244

 * Test definition

   245

 */

   246

static struct test {

   247

    /** Test name */

   248

    const char *name;

   249

   250

    /** Test func */

   251

    void (*func) (void);

   252

   253

} _tests[] = {

   254

    {   "sock_test",    &test_sock_test     },

   255

    {   "line_proto",   &test_line_proto    },

   256

    {   "irc_conn",     &test_irc_conn      },

   257

    {   NULL,           NULL                }

   258

};

   259

   260

int main (int argc, char **argv)

   261

{

   262

    struct test *test;

   263

   264

    (void) argv;

   265

   266

    // no arguments

   267

    assert(argc == 1);

   268

   269

    // run tests

   270

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

   271

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

   272

   273

        test->func();

   274

    }

   275

}