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 {

   244

    bool on_registered, on_TEST;

   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

   258

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

   259

{

   260

    struct _test_irc_conn_ctx *ctx = arg;

   261

   262

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

   263

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

   264

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

   265

    assert_strnull(line->args[1]);

   266

   267

    if (ctx) ctx->on_TEST = true;

   268

   269

    log_debug("on_TEST");

   270

}

   271

   272

static struct irc_conn_callbacks _conn_callbacks = {

   273

    .on_registered      = &_conn_on_registered,

   274

};

   275

   276

static struct irc_cmd_handler _conn_handlers[] = {

   277

    {   "TEST",         &_conn_on_TEST  },

   278

    {   NULL,           NULL            }

   279

};

   280

   281

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

   282

{

   283

    struct irc_conn *conn;

   284

    struct error_info err;

   285

    struct irc_conn_register_info register_info = {

   286

        "nick", "user", "realname"

   287

    };

   288

   289

    // create the irc_conn

   290

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

   291

   292

    // test register

   293

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

   294

    assert_success(irc_conn_register(conn, &register_info));

   295

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

   296

   297

    // test on_register callback    

   298

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

   299

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

   300

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

   301

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

   302

   303

    // ok

   304

    return conn;

   305

}

   306

   307

void test_irc_conn (void)

   308

{

   309

    struct sock_test *sock;

   310

    struct irc_conn *conn;

   311

    struct _test_irc_conn_ctx ctx = { false, false };

   312

   313

    // create the test socket

   314

    assert((sock = sock_test_create()));

   315

   316

    // setup the basic irc_conn

   317

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

   318

   319

    // add our test handlers

   320

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

   321

   322

    // test on_TEST handler

   323

    log_info("test irc_conn.handlers");

   324

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

   325

    assert(ctx.on_TEST);

   326

   327

    // test PING/PONG

   328

    log_info("test PING/PONG");

   329

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

   330

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

   331

   332

    // destroy it

   333

    irc_conn_destroy(conn);

   334

}

   335

   336

struct _test_net_ctx {

   337

    struct irc_chan *chan;

   338

   339

    bool on_chan_self_join;

   340

};

   341

   342

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

   343

{

   344

    struct _test_net_ctx *ctx = arg;

   345

   346

    assert(chan == ctx->chan);

   347

   348

    ctx->on_chan_self_join = true;

   349

   350

    log_debug("on_self_join");

   351

}

   352

   353

struct irc_chan_callbacks _chan_callbacks = {

   354

    .on_self_join       = &_on_chan_self_join,

   355

};

   356

   357

void test_irc_net (void)

   358

{

   359

    struct sock_test *sock;

   360

    struct irc_net *net;

   361

    struct irc_net_info net_info = {

   362

        .register_info = {

   363

            "nick", "user", "realname"

   364

        },

   365

    };

   366

    struct irc_chan *chan;

   367

    struct irc_chan_info chan_info = {

   368

        .channel        = "#test",

   369

    };

   370

    struct error_info err;

   371

    struct _test_net_ctx ctx = { NULL, false };

   372

   373

    // create the test socket

   374

    assert((sock = sock_test_create()));

   375

   376

    // create the irc_net

   377

    net_info.raw_sock = SOCK_TEST_BASE(sock);

   378

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

   379

   380

    // add a channel

   381

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

   383

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

   384

    ctx.chan = chan;

   385

   386

    // test register output

   387

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

   388

   389

    // registration reply

   390

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

   391

    assert(net->conn->registered);

   392

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

   393

   394

    // JOIN request

   396

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

   397

   398

    // JOIN reply

   399

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

   401

    assert(ctx.on_chan_self_join);

   402

}

   403

   404

/**

   405

 * Test definition

   406

 */

   407

static struct test {

   408

    /** Test name */

   409

    const char *name;

   410

   411

    /** Test func */

   412

    void (*func) (void);

   413

   414

} _tests[] = {

   415

    {   "sock_test",    &test_sock_test     },

   416

    {   "line_proto",   &test_line_proto    },

   417

    {   "irc_conn",     &test_irc_conn      },

   418

    {   "irc_net",      &test_irc_net       },

   419

    {   NULL,           NULL                }

   420

};

   421

   422

int main (int argc, char **argv)

   423

{

   424

    struct test *test;

   425

   426

    (void) argv;

   427

   428

    // no arguments

   429

    assert(argc == 1);

   430

   431

    // run tests

   432

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

   433

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

   434

   435

        test->func();

   436

    }

   437

}