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

#include <ctype.h>

    15

    16

#define DUMP_STR_BUF 1024

    17

#define DUMP_STR_COUNT 8

    18

#define DUMP_STR_TAIL 10

    19

    20

char *dump_str_append (char *buf, const char *str)

    21

{

    22

    while (*str)

    23

        *buf++ = *str++;

    24

    25

    return buf;

    26

}

    27

    28

/**

    29

 * This re-formats the given string to escape values, and returns a pointer to an internal static buffer.

    30

 *

    31

 * If len is given as >= 0, only the given number of chars will be dumped from str

    32

 *

    33

 * The buffer cycles a bit, so you pointers remain valid across DUMP_STR_COUNT calls.

    36

 */

    37

const char *dump_strn (const char *str, ssize_t len)

    38

{

    39

    static char dump_buf[DUMP_STR_COUNT][DUMP_STR_BUF];

    40

    static size_t dump_idx = 0;

    41

    42

    // pick a buffer to use

    43

    const char *str_ptr = str;

    44

    char *buf_ptr = dump_buf[dump_idx++], *buf = buf_ptr;

    45

    46

    // cycle

    47

    if (dump_idx >= DUMP_STR_COUNT)

    48

        dump_idx = 0;

    49

    50

    // NULL?

    51

    if (str == NULL) {

    52

        buf = dump_str_append(buf, "NULL");

    53

        *buf = '\0';

    54

    55

        return buf_ptr;

    56

    }

    57

    58

    // quote

    59

    *buf++ = '\'';

    60

    61

    // dump each char

    73

        if (*str == '\'') {

    80

    81

        } else if (isprint(*str)) {

    83

            *buf++ = *str;

    84

    85

        } else {

    87

            switch (*str) {

    88

                case '\r':

    89

                    buf = dump_str_append(buf, "\\r"); break;

    90

    91

                case '\n':

    92

                    buf = dump_str_append(buf, "\\n"); break;

    93

    94

                default:

    96

                    buf += snprintf(buf, (DUMP_STR_BUF - (buf - buf_ptr)), "\\x%02x", *str);

    97

                    break;

    98

            }

    99

        }

   100

    }

   101

   103

    *buf++ = '\'';

   104

   105

    // overflow?

   106

    if ((size_t)(buf - buf_ptr) == DUMP_STR_BUF - DUMP_STR_TAIL)

   107

        buf = dump_str_append(buf, "...");

   108

   109

    // terminate

   110

    *buf = '\0';

   111

   112

    // ok

   113

    return buf_ptr;

   114

}

   115

   116

const char *dump_str (const char *str) 

   117

{

   118

    return dump_strn(str, -1);

   119

}

   120

   121

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

   122

{

   123

    if (strcmp(is, should_be))

   124

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

   125

}

   126

   127

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

   128

{   

   129

    if (strncmp(is, should_be, n))

   130

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

   131

}

   132

   133

void assert_strlen (const char *str, size_t n)

   134

{

   135

    if (strlen(str) != n)

   136

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

   137

}

   138

   139

void assert_strnull (const char *str)

   140

{

   141

    if (str != NULL)

   142

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

   143

}

   144

   145

void assert_success (err_t err)

   146

{

   147

    if (err != SUCCESS)

   148

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

   149

   150

}

   151

   152

void assert_err (err_t err, err_t target)

   153

{

   154

    if (err != target)

   155

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

   156

}

   157

   158

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

   159

{

   160

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

   161

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

   162

}

   163

   164

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

   165

{

   166

    char buf[strlen(str)];

   167

   168

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

   169

   170

    // read it

   171

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

   172

   173

    // cmp

   174

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

   175

}

   176

   177

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

   178

{

   179

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

   180

   181

    // write it

   182

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

   183

}

   184

   185

void assert_sock_eof (struct sock_stream *sock)

   186

{

   187

    char buf;

   188

   189

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

   190

   191

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

   192

}

   193

   194

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

   195

{

   196

    // get the data out

   197

    char *buf;

   198

    size_t len;

   199

   200

    sock_test_get_send_data(sock, &buf, &len);

   201

   202

    log_debug("get_send_data: %s", dump_strn(buf, len));

   203

   204

    // should be the same

   205

    assert_strncmp(buf, data, len);

   206

    assert_strlen(data, len);

   207

   208

    // cleanup

   209

    free(buf);

   210

}

   211

   212

void test_dump_str (void)

   213

{

   214

    log_info("dumping example strings on stdout:");

   215

   216

    log_debug("normal: %s", dump_str("Hello World"));

   217

    log_debug("escapes: %s", dump_str("foo\r\nbar\a\001"));

   218

    log_debug("length: %s", dump_strn("<-->**", 4));

   219

    log_debug("overflow: %s", dump_str( "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"));

   220

    log_debug("null: %s", dump_str(NULL));

   222

}

   223

   224

void test_sock_test (void)

   225

{

   226

    struct sock_test *sock = sock_test_create();

   227

    struct io_vec _read_data[] = {

   228

        {   "foo",      3   },

   229

        {   "barx",     4   }

   230

    };

   231

    const char *_write_data = "test data";

   232

   233

    // put the read data

   234

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

   235

    sock_test_set_recv_buffer(sock, _read_data, 2, true);

   236

   237

    // read it out

   238

    log_info("test sock_test_read");

   239

   240

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

   241

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

   242

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

   243

    assert_sock_eof(SOCK_TEST_BASE(sock));

   244

   245

    // write the data in

   246

    log_info("test sock_test_write");

   247

   248

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

   249

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

   250

   251

    // check output

   252

    assert_sock_data(sock, _write_data);

   253

   254

    // check output

   255

    assert_sock_data(sock, "");

   256

   257

    // cleanup

   258

    sock_test_destroy(sock);

   259

}

   260

   261

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

   262

{

   263

    char *line_buf;

   264

   265

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

   266

   267

    assert_success(line_proto_recv(lp, &line_buf));

   268

   269

    if (line_str) {

   270

        assert(line_buf != NULL);

   271

        assert_strcmp(line_buf, line_str);

   272

   273

    } else {

   274

        assert_strnull(line_buf);

   275

   276

    }

   277

}

   278

   279

/**

   280

 * Context info for test_line_proto callbacks

   281

 */

   282

struct _lp_test_ctx {

   283

    /** Expected line */

   284

    const char *line;

   285

   286

    /** Expected error */

   287

    struct error_info err;

   288

};

   289

   290

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

   291

{

   292

    struct _lp_test_ctx *ctx = arg;

   293

   294

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

   295

   296

    assert_strcmp(line, ctx->line);

   297

   298

    ctx->line = NULL;

   299

}

   300

   301

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

   302

{

   303

    struct _lp_test_ctx *ctx = arg;

   304

   305

    assert_error_info(err, &ctx->err);

   306

}

   307

   308

static struct line_proto_callbacks _lp_callbacks = {

   309

    .on_line        = &_lp_on_line,

   310

    .on_error       = &_lp_on_error,

   311

};

   312

   313

void test_line_proto (void)

   314

{

   315

    struct sock_test *sock = sock_test_create();

   316

    struct io_vec _read_data[] = {

   317

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

   318

        {   "world\n",      6   },

   319

        {   "this ",        5   },

   320

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

   321

        {   "\nfragment",   9   },

   322

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

   323

    struct line_proto *lp;

   324

    struct _lp_test_ctx ctx;

   325

    struct error_info err;

   326

   327

    // put the read data

   328

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

   329

    sock_test_set_recv_buffer(sock, _read_data, 5, false);

   330

   331

    // create the lp

   332

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

   333

   334

    log_info("test line_proto_recv");

   335

   336

    // then read some lines from it

   337

    assert_read_line(lp, "hello");

   338

    assert_read_line(lp, "world");

   339

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

   340

    assert_read_line(lp, NULL);

   341

   342

    // then add a final bit to trigger on_line

   343

    log_info("test on_line");

   344

   345

    ctx.line = "fragment";

   346

    sock_test_add_recv_vec(sock, _trailing_data);

   347

    assert_strnull(ctx.line);

   348

   349

    // test writing

   350

    log_info("test line_proto_send");

   351

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

   352

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

   353

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

   354

   355

    // XXX: test partial writes

   356

   357

    // cleanup

   358

    line_proto_release(lp);

   359

}

   360

   361

struct _test_irc_conn_ctx {

   362

    bool on_registered, on_TEST, on_error, on_quit;

   363

};

   364

   365

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

   366

{

   367

    struct _test_irc_conn_ctx *ctx = arg;

   368

   369

    (void) conn;

   370

   371

    if (ctx) ctx->on_registered = true;

   372

   373

    log_debug("registered");

   374

}

   375

   376

static void _conn_on_error (struct irc_conn *conn, struct error_info *err, void *arg)

   377

{

   378

    struct _test_irc_conn_ctx *ctx = arg;

   379

   380

    (void) conn;

   381

    (void) err;

   382

   383

    if (ctx) ctx->on_error = true;

   384

   385

    log_debug("on_error");

   386

}

   387

   388

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

   389

{

   390

    struct _test_irc_conn_ctx *ctx = arg;

   391

   392

    (void) conn;

   393

   394

    if (ctx) ctx->on_quit = true;

   395

   396

    log_debug("on_quit");

   397

}

   398

   399

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

   400

{

   401

    struct _test_irc_conn_ctx *ctx = arg;

   402

   403

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

   404

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

   405

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

   406

    assert_strnull(line->args[1]);

   407

   408

    if (ctx) ctx->on_TEST = true;

   409

   410

    log_debug("on_TEST");

   411

}

   412

   413

static struct irc_conn_callbacks _conn_callbacks = {

   414

    .on_registered      = &_conn_on_registered,

   415

    .on_error           = &_conn_on_error,

   416

    .on_quit            = &_conn_on_quit,

   417

};

   418

   419

static struct irc_cmd_handler _conn_handlers[] = {

   420

    {   "TEST",         &_conn_on_TEST  },

   421

    {   NULL,           NULL            }

   422

};

   423

   424

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

   425

{

   426

    struct irc_conn *conn;

   427

    struct error_info err;

   428

    struct irc_conn_register_info register_info = {

   429

        "nick", "user", "realname"

   430

    };

   431

   432

    // create the irc_conn

   433

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

   434

   435

    // test register

   436

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

   437

    assert_success(irc_conn_register(conn, &register_info));

   438

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

   439

   440

    // test on_register callback    

   441

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

   442

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

   443

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

   444

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

   445

   446

    // ok

   447

    return conn;

   448

}

   449

   450

void test_irc_conn (void)

   451

{

   452

    struct sock_test *sock;

   453

    struct irc_conn *conn;

   454

    struct _test_irc_conn_ctx ctx = { false, false, false, false };

   455

   456

    // create the test socket

   457

    assert((sock = sock_test_create()));

   458

   459

    // setup the basic irc_conn

   460

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

   461

   462

    // add our test handlers

   463

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

   464

   465

    // test on_TEST handler

   466

    log_info("test irc_conn.handlers");

   467

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

   468

    assert(ctx.on_TEST);

   469

   470

    // test PING/PONG

   471

    log_info("test PING/PONG");

   472

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

   473

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

   474

   475

    // quit nicely

   476

    log_info("test QUIT");

   477

    assert_success(irc_conn_QUIT(conn, "bye now"));

   478

    assert_sock_data(sock, "QUIT :bye now\r\n");

   479

    assert(conn->quitting);

   480

   481

    sock_test_add_recv_str(sock, "ERROR :Closing Link: Quit\r\n");

   482

    sock_test_set_recv_eof(sock);

   483

    assert(conn->quit && !conn->quitting && !conn->registered);

   484

    assert(ctx.on_quit);

   485

    assert(!ctx.on_error);

   486

   487

    // destroy it

   488

    irc_conn_destroy(conn);

   489

}

   490

   491

struct _test_net_ctx {

   492

    struct irc_chan *chan;

   493