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 "irc_net.h"

     8

#include "log.h"

     9

#include "error.h"

    10

    11

#include <stdlib.h>

    12

#include <string.h>

    13

#include <assert.h>

    14

    15

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

    16

{

    17

    if (strcmp(is, should_be))

    18

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

    19

}

    20

    21

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

    22

{

    23

    if (strncmp(is, should_be, n))

    24

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

    25

}

    26

    27

void assert_strlen (const char *str, size_t n)

    28

{

    29

    if (strlen(str) != n)

    30

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

    31

}

    32

    33

void assert_strnull (const char *str)

    34

{

    35

    if (str != NULL)

    36

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

    37

}

    38

    39

void assert_success (err_t err)

    40

{

    41

    if (err != SUCCESS)

    42

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

    43

    44

}

    45

    46

void assert_err (err_t err, err_t target)

    47

{

    48

    if (err != target)

    49

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

    50

}

    51

    52

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

    53

{

    54

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

    55

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

    56

}

    57

    58

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

    59

{

    60

    char buf[strlen(str)];

    61

    62

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

    63

    64

    // read it

    65

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

    66

    67

    // cmp

    68

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

    69

}

    70

    71

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

    72

{

    73

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

    74

    75

    // write it

    76

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

    77

}

    78

    79

void assert_sock_eof (struct sock_stream *sock)

    80

{

    81

    char buf;

    82

    83

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

    84

    85

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

    86

}

    87

    88

void assert_sock_data (struct sock_test *sock, const char *data)

    89

{

    90

    // get the data out

    91

    char *buf;

    92

    size_t len;

    93

    94

    sock_test_get_send_data(sock, &buf, &len);

    95

    96

    log_debug("get_send_data: '%.*s'", (int) len, buf);

    97

    98

    // should be the same

    99

    assert_strncmp(buf, data, len);

   100

    assert_strlen(data, len);

   101

   102

    // cleanup

   103

    free(buf);

   104

}

   105

   106

void test_sock_test (void)

   107

{

   108

    struct sock_test *sock = sock_test_create();

   109

    struct io_vec _read_data[] = {

   110

        {   "foo",      3   },

   111

        {   "barx",     4   }

   112

    };

   113

    const char *_write_data = "test data";

   114

   115

    // put the read data

   116

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

   117

    sock_test_set_recv_buffer(sock, _read_data, 2, true);

   118

   119

    // read it out

   120

    log_info("test sock_test_read");

   121

   122

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

   123

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

   124

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

   125

    assert_sock_eof(SOCK_TEST_BASE(sock));

   126

   127

    // write the data in

   128

    log_info("test sock_test_write");

   129

   130

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

   131

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

   132

   133

    // check output

   134

    assert_sock_data(sock, _write_data);

   135

   136

    // check output

   137

    assert_sock_data(sock, "");

   138

   139

    // cleanup

   140

    sock_test_destroy(sock);

   141

}

   142

   143

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

   144

{

   145

    char *line_buf;

   146

   147

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

   148

   149

    assert_success(line_proto_recv(lp, &line_buf));

   150

   151

    if (line_str) {

   152

        assert(line_buf != NULL);

   153

        assert_strcmp(line_buf, line_str);

   154

   155

    } else {

   156

        assert_strnull(line_buf);

   157

   158

    }

   159

}

   160

   161

/**

   162

 * Context info for test_line_proto callbacks

   163

 */

   164

struct _lp_test_ctx {

   165

    /** Expected line */

   166

    const char *line;

   167

   168

    /** Expected error */

   169

    struct error_info err;

   170

};

   171

   172

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

   173

{

   174

    struct _lp_test_ctx *ctx = arg;

   175

   176

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

   177

   178

    assert_strcmp(line, ctx->line);

   179

   180

    ctx->line = NULL;

   181

}

   182

   183

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

   184

{

   185

    struct _lp_test_ctx *ctx = arg;

   186

   187

    assert_error_info(err, &ctx->err);

   188

}

   189

   190

static struct line_proto_callbacks _lp_callbacks = {

   191

    .on_line        = &_lp_on_line,

   192

    .on_error       = &_lp_on_error,

   193

};

   194

   195

void test_line_proto (void)

   196

{

   197

    struct sock_test *sock = sock_test_create();

   198

    struct io_vec _read_data[] = {

   199

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

   200

        {   "world\n",      6   },

   201

        {   "this ",        5   },

   202

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

   203

        {   "\nfragment",   9   },

   204

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

   205

    struct line_proto *lp;

   206

    struct _lp_test_ctx ctx;

   207

    struct error_info err;

   208

   209

    // put the read data

   210

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

   211

    sock_test_set_recv_buffer(sock, _read_data, 5, false);

   212

   213

    // create the lp

   214

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

   215

   216

    log_info("test line_proto_recv");

   217

   218

    // then read some lines from it

   219

    assert_read_line(lp, "hello");

   220

    assert_read_line(lp, "world");

   221

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

   222

    assert_read_line(lp, NULL);

   223

   224

    // then add a final bit to trigger on_line

   225

    log_info("test on_line");

   226

   227

    ctx.line = "fragment";

   228

    sock_test_add_recv_vec(sock, _trailing_data);

   229

    assert_strnull(ctx.line);

   230

   231

    // test writing

   232

    log_info("test line_proto_send");

   233

    assert_success(-line_proto_send(lp, "foobar\r\n"));

   234

    assert_success(-line_proto_send(lp, "quux\r\n"));

   235

    assert_sock_data(sock, "foobar\r\nquux\r\n");

   236

   237

    // XXX: test partial writes

   238

   239

    // cleanup

   240

    line_proto_release(lp);

   241

}

   242

   243

struct _test_irc_conn_ctx {

   245

};

   246

   247

static void _conn_on_registered (struct irc_conn *conn, void *arg)

   248

{

   249

    struct _test_irc_conn_ctx *ctx = arg;

   250

   251

    (void) conn;

   252

   253

    if (ctx) ctx->on_registered = true;

   254

   255

    log_debug("registered");

   256

}

   257

   281

static void _conn_on_TEST (const struct irc_line *line, void *arg)

   282

{

   283

    struct _test_irc_conn_ctx *ctx = arg;

   284

   285

    assert_strcmp(line->prefix, "foobar-prefix");

   286

    assert_strcmp(line->command, "TEST");

   287

    assert_strcmp(line->args[0], "arg0");

   288

    assert_strnull(line->args[1]);

   289

   290

    if (ctx) ctx->on_TEST = true;

   291

   292

    log_debug("on_TEST");

   293

}

   294

   295

static struct irc_conn_callbacks _conn_callbacks = {

   296

    .on_registered      = &_conn_on_registered,

   299

};

   300

   301

static struct irc_cmd_handler _conn_handlers[] = {

   302

    {   "TEST",         &_conn_on_TEST  },

   303

    {   NULL,           NULL            }

   304

};

   305

   306

struct irc_conn* setup_irc_conn (struct sock_test *sock, bool noisy, struct _test_irc_conn_ctx *ctx)

   307

{

   308

    struct irc_conn *conn;

   309

    struct error_info err;

   310

    struct irc_conn_register_info register_info = {

   311

        "nick", "user", "realname"

   312

    };

   313

   314

    // create the irc_conn

   315

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

   316

   317

    // test register

   318

    if (noisy) log_info("test irc_conn_register");

   319

    assert_success(irc_conn_register(conn, &register_info));

   320

    assert_sock_data(sock, "NICK nick\r\nUSER user 0 * realname\r\n");

   321

   322

    // test on_register callback    

   323

    if (noisy) log_info("test irc_conn_callbacks.on_register");

   324

    sock_test_add_recv_str(sock, "001 mynick :Blaa blaa blaa\r\n");

   325

    if (ctx) assert(ctx->on_registered);

   326

    assert_strcmp(conn->nickname, "mynick");

   327

   328

    // ok

   329

    return conn;

   330

}

   331

   332

void test_irc_conn (void)

   333

{

   334

    struct sock_test *sock;

   335

    struct irc_conn *conn;

   337

   338

    // create the test socket

   339

    assert((sock = sock_test_create()));

   340

   341

    // setup the basic irc_conn

   342

    conn = setup_irc_conn(sock, true, &ctx);

   343

   344

    // add our test handlers

   345

    assert_success(irc_conn_add_cmd_handlers(conn, _conn_handlers, &ctx));

   346

   347

    // test on_TEST handler

   348

    log_info("test irc_conn.handlers");

   349

    sock_test_add_recv_str(sock, ":foobar-prefix TEST arg0\r\n");

   350

    assert(ctx.on_TEST);

   351

   352

    // test PING/PONG

   353

    log_info("test PING/PONG");

   354

    sock_test_add_recv_str(sock, "PING foo\r\n");

   355

    assert_sock_data(sock, "PONG foo\r\n");

   356

   369

    // destroy it

   370

    irc_conn_destroy(conn);

   371

}

   372

   373

struct _test_net_ctx {

   374

    struct irc_chan *chan;

   375

   376

    bool on_chan_self_join;

   377

};

   378

   379

void _on_chan_self_join (struct irc_chan *chan, void *arg)

   380

{

   381

    struct _test_net_ctx *ctx = arg;

   382

   383

    assert(chan == ctx->chan);

   384

   385

    ctx->on_chan_self_join = true;

   386

   387

    log_debug("on_self_join");

   388

}

   389

   390

struct irc_chan_callbacks _chan_callbacks = {

   391

    .on_self_join       = &_on_chan_self_join,

   392

};

   393

   394

void test_irc_net (void)

   395

{

   396

    struct sock_test *sock;

   397

    struct irc_net *net;

   398

    struct irc_net_info net_info = {

   399

        .register_info = {

   400

            "nick", "user", "realname"

   401

        },

   402

    };

   403

    struct irc_chan *chan;

   404

    struct irc_chan_info chan_info = {

   405

        .channel        = "#test",

   406

    };

   407

    struct error_info err;

   408

    struct _test_net_ctx ctx = { NULL, false };

   409

   410

    // create the test socket

   411

    assert((sock = sock_test_create()));

   412

   413

    // create the irc_net

   414

    net_info.raw_sock = SOCK_TEST_BASE(sock);

   415

    assert_success(irc_net_create(&net, &net_info, &err));

   416

   417

    // add a channel

   418

    log_info("test offline irc_net_add_chan");

   419

    assert((chan = irc_net_add_chan(net, &chan_info)));

   420

    assert(!chan->joining && !chan->joined);

   421

    assert_success(irc_chan_add_callbacks(chan, &_chan_callbacks, &ctx));

   422

    ctx.chan = chan;

   423

   424

    // test register output

   425

    assert_sock_data(sock, "NICK nick\r\nUSER user 0 * realname\r\n");

   426

   427

    // registration reply

   428

    log_info("test irc_conn_on_RPL_WELCOME");

   429

    sock_test_add_recv_str(sock, "001 mynick :Blaa blaa blaa\r\n");

   430

    assert(net->conn->registered);

   431

    assert_strcmp(net->conn->nickname, "mynick");

   432

   433

    // JOIN request

   434

    log_info("test irc_net_conn_registered -> irc_chan_join");

   435

    assert(chan->joining);

   436

    assert_sock_data(sock, "JOIN #test\r\n");

   437

   438

    // JOIN reply

   439

    log_info("test irc_chan_on_JOIN");

   440

    sock_test_add_recv_str(sock, ":mynick!user@host JOIN #test\r\n");

   441

    assert(!chan->joining && chan->joined);

   442

    assert(ctx.on_chan_self_join);

   443

   444

    // test errors by setting EOF

   445

    log_info("test irc_net_error");

   446

    sock_test_set_recv_eof(sock);

   447

    assert(net->conn == NULL);

   448

   449

    // cleanup

   450

    irc_net_destroy(net);

   451

}

   452

   453

/**

   454

 * Test definition

   455

 */

   456

static struct test {

   457

    /** Test name */

   458

    const char *name;

   459

   460

    /** Test func */

   461

    void (*func) (void);

   462

   463

} _tests[] = {

   464

    {   "sock_test",    &test_sock_test     },

   465

    {   "line_proto",   &test_line_proto    },

   466

    {   "irc_conn",     &test_irc_conn      },

   467

    {   "irc_net",      &test_irc_net       },

   468

    {   NULL,           NULL                }

   469

};

   470

   471

int main (int argc, char **argv)

   472

{

   473

    struct test *test;

   474

   475

    (void) argv;

   476

   477

    // no arguments

   478

    assert(argc == 1);

   479

   480

    // run tests

   481

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

   482

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

   483

   484

        test->func();

   485

    }

   486

   487

    log_info("done");

   488

}