1

/**

     2

 * The main test code entry point

     3

 */

     5

#include "line_proto.h"

     6

#include "irc_queue.h"

     7

#include "irc_conn.h"

     8

#include "irc_net.h"

    10

#include "log.h"

    11

#include "str.h"

    12

#include "error.h"

    13

    14

#include <stdlib.h>

    15

#include <string.h>

    16

#include <getopt.h>

    17

#include <assert.h>

    18

#include <ctype.h>

    19

    20

#define DUMP_STR_BUF 1024

    21

#define DUMP_STR_COUNT 8

    22

#define DUMP_STR_TAIL 10

    23

    24

/**

    25

 * Global test-running state

    26

 */

    27

struct test_ctx {

    28

    /** The event_base that we have setup */

    29

    struct event_base *ev_base;

    30

    31

} _test_ctx;

    32

    33

    34

/**

    35

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

    36

 *

    37

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

    38

 *

    39

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

    40

 *

    41

 * The resulting string is truncated to (DUMP_STR_BUF - DUMP_STR_TAIL) bytes, not including the ending "...'\0".

    42

 *

    43

 * @param str the string to dump, should be NUL-terminated unless len is given

    44

 * @param len if negative, ignored, otherwise, only this many bytes are dumped from str

    45

 * @param return a pointer to a static buffer that remains valid across DUMP_STR_COUNT calls to this function

    46

 */

    47

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

    48

{

    49

    static char dump_buf[DUMP_STR_COUNT][DUMP_STR_BUF];

    50

    static size_t dump_idx = 0;

    51

    52

    // pick a buffer to use

    53

    char *buf = dump_buf[dump_idx++];

    54

    55

    // cycle

    56

    if (dump_idx >= DUMP_STR_COUNT)

    57

        dump_idx = 0;

    58

    59

    str_quote(buf, DUMP_STR_BUF, str, len);

    60

    61

    // ok

    62

    return buf;

    63

}

    64

    65

const char *dump_str (const char *str) 

    66

{

    67

    return dump_strn(str, -1);

    68

}

    69

    70

void assert_null (const void *ptr)

    71

{

    72

    if (ptr)

    73

        FATAL("%p != NULL", ptr);

    74

}

    75

    76

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

    77

{

    78

    if (!is || strcmp(is, should_be))

    79

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

    80

}

    81

    82

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

    83

{   

    84

    if (!is || strncmp(is, should_be, n))

    85

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

    86

}

    87

    88

void assert_strlen (const char *str, size_t n)

    89

{

    90

    if (!str || strlen(str) != n)

    91

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

    92

}

    93

    94

void assert_strnull (const char *str)

    95

{

    96

    if (str != NULL)

    97

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

    98

}

    99

   100

void assert_success (err_t err)

   101

{

   102

    if (err != SUCCESS)

   103

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

   104

}

   105

   106

void assert_err (err_t err, err_t target)

   107

{

   108

    if (err != target)

   109

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

   110

}

   111

   112

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

   113

{

   114

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

   115

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

   116

}

   117

   119

{

   123

   125

   126

    // read it

   128

   129

    // cmp

   131

}

   132

   134

{

   139

   140

    // write it

   142

}

   143

   145

{

   146

    char buf;

   148

   150

   152

}

   153

   155

{

   157

    va_list vargs;

   158

    size_t len;

   159

   160

    va_start(vargs, fmt);

   161

   163

        FATAL("input too long: %zu bytes", len);

   164

   165

    va_end(vargs);

   166

   167

    // get the data out

   168

    char *out;

   169

   171

   173

   174

    // should be the same

   175

    assert_strncmp(out, buf, len);

   176

    assert_strlen(buf, len);

   177

   178

    // cleanup

   179

    free(out);

   180

}

   181

   182

/**

   183

 * Setup the global sock_stream state

   184

 */

   185

struct event_base* setup_sock (void)

   186

{

   187

    struct event_base *ev_base;

   188

    struct error_info err;

   189

   190

    assert((ev_base = event_base_new()));

   191

    assert_success(sock_init(ev_base, &err));

   192

   193

    return ev_base;

   194

}

   195

   196

/**

   198

 */

   200

{

   202

   204

   206

}

   207

   208

void assert_str_quote (size_t buf_size, const char *data, ssize_t len, const char *target, size_t out)

   209

{

   210

    char buf[buf_size];

   211

   212

    size_t ret = str_quote(buf, buf_size, data, len);

   213

   214

    log_debug("str_quote(%zu, %zd) -> %s:%zu / %s:%zu", buf_size, len, buf, ret, target, out);

   215

   216

    assert_strcmp(buf, target);

   217

    assert(ret == out);

   218

}

   219

   220

void test_str_quote (void)

   221

{

   222

    log_info("testing str_quote()");

   223

   224

    assert_str_quote(5,     NULL,           -1,     "NULL",         4   );

   225

    assert_str_quote(16,    "foo",          -1,     "'foo'",        5   );

   226

    assert_str_quote(16,    "foobar",       3,      "'foo'",        5   );

   227

    assert_str_quote(16,    "\r\n",         -1,     "'\\r\\n'",     6   );

   228

    assert_str_quote(16,    "\x13",         -1,     "'\\x13'",      6   );

   229

    assert_str_quote(16,    "x'y",          -1,     "'x\\'y'",      6   );

   230

    assert_str_quote(7,     "1234567890",   -1,     "'1'...",       12  );

   231

    assert_str_quote(9,     "1234567890",   -1,     "'123'...",     12  );

   232

}

   233

   234

struct str_format_ctx {

   235

    const char *name;

   236

   237

    const char *value;

   238

};

   239

   240

err_t test_str_format_cb (const char *name, const char **value, ssize_t *value_len, void *arg)

   241

{

   242

    struct str_format_ctx *ctx = arg;

   243

   244

    assert_strcmp(name, ctx->name);

   245

   246

    *value = ctx->value;

   247

    *value_len = -1;

   248

   249

    return SUCCESS;

   250

}

   251

   252

void assert_str_format (const char *format, const char *name, const char *value, const char *out)

   253

{

   254

    struct str_format_ctx ctx = { name, value };

   255

    char buf[512];

   256

   257

    assert_success(str_format(buf, sizeof(buf), format, test_str_format_cb, &ctx));

   258

   259

    log_debug("str_format(%s), { %s:%s } -> %s / %s", format, name, value, buf, out);

   260

   261

    assert_strcmp(buf, out);

   262

}

   263

   264

void test_str_format (void)

   265

{

   266

    log_info("test str_format()");

   267

   268

    assert_str_format("foo", NULL, NULL, "foo");

   269

    assert_str_format("foo {bar} quux", "bar", "XXX", "foo XXX quux");

   270

}

   271

   272

void test_dump_str (void)

   273

{

   274

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

   275

   276

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

   277

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

   278

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

   279

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

   280

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

   281

    log_debug("quote: %s", dump_str("foo\\bar'quux"));

   282

}

   283

   285

{

   290

    // put the read data

   296

   297

    // read it out

   299

   305

   308

   311

   312

    // check output

   314

   317

   318

    // cleanup

   320

}

   321

   322

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

   323

{

   324

    char *line_buf;

   325

   326

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

   327

   328

    assert_success(line_proto_recv(lp, &line_buf));

   329

   330

    if (line_str) {

   331

        assert_strcmp(line_buf, line_str);

   332

   333

    } else {

   334

        assert_strnull(line_buf);

   335

   336

    }

   337

}

   338

   339

/**

   340

 * Context info for test_line_proto callbacks

   341

 */

   342

struct _lp_test_ctx {

   343

    /** Expected line */

   344

    const char *line;

   345

   346

    /** Expected error */

   347

    struct error_info err;

   348

};

   349

   350

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

   351

{

   352

    struct _lp_test_ctx *ctx = arg;

   353

   354

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

   355

   356

    assert_strcmp(line, ctx->line);

   357

   358

    ctx->line = NULL;

   359

}

   360

   361

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

   362

{

   363

    struct _lp_test_ctx *ctx = arg;

   364

   365

    assert_error_info(err, &ctx->err);

   366

}

   367

   368

static struct line_proto_callbacks _lp_callbacks = {

   369

    .on_line        = &_lp_on_line,

   370

    .on_error       = &_lp_on_error,

   371

};

   372

   373

void test_line_proto (void)

   374

{

   377

    struct line_proto *lp;

   378

    struct _lp_test_ctx ctx;

   379

    struct error_info err;

   380

   381

    // put the read data

   389

    // create the lp

   391

   392

    log_info("test line_proto_recv");

   393

   394

    // then read some lines from it

   395

    assert_read_line(lp, "hello");

   396

    assert_read_line(lp, "world");

   397

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

   398

    assert_read_line(lp, NULL);

   399

   400

    // then add a final bit to trigger on_line

   401

    log_info("test on_line");

   402

   403

    ctx.line = "fragment";

   405

    assert_strnull(ctx.line);

   406

   407

    // test writing

   408

    log_info("test line_proto_send");

   409

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

   410

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

   412

   413

    // XXX: test partial writes

   414

   415

    // cleanup

   417

}

   418

   419

void test_irc_queue (void)

   420

{

   423

    struct line_proto *lp;

   424

    struct irc_queue *queue;

   425

    struct irc_queue_entry *queue_entry;

   426

    struct error_info err;

   427

   428

    // create the lp

   430

   431

    // create the queue

   433

   434

    struct irc_line line = {

   435

        NULL, "TEST", { "fooX" }

   436

    };

   437

   438

    // then test simple writes, we should be able to push five lines directly

   439

    log_info("test irc_queue_process (irc_queue_send_direct)");

   440

    line.args[0] = "foo0"; assert_success(irc_queue_process(queue, &line));

   441

    line.args[0] = "foo1"; assert_success(irc_queue_process(queue, &line));

   442

    line.args[0] = "foo2"; assert_success(irc_queue_process(queue, &line));

   443

    line.args[0] = "foo3"; assert_success(irc_queue_process(queue, &line));

   444

    line.args[0] = "foo4"; assert_success(irc_queue_process(queue, &line));

   445

   446

    // they should all be output

   448

            "TEST foo0\r\n"

   449

            "TEST foo1\r\n"

   450

            "TEST foo2\r\n"

   451

            "TEST foo3\r\n"

   452

            "TEST foo4\r\n"

   453

    );

   454

   455

    // then enqueue

   456

    log_info("test irc_queue_process (irc_queue_put)");

   457

    line.args[0] = "foo5"; assert_success(irc_queue_process(queue, &line));

   458

   459

    // ensure it was enqueued

   460

    assert((queue_entry = TAILQ_FIRST(&queue->list)) != NULL);

   461

    assert_strcmp(queue_entry->line_buf, "TEST foo5\r\n");

   462

   463

    // ensure timer is set

   464

    assert(event_pending(queue->ev, EV_TIMEOUT, NULL));

   465

   466

    // run the event loop to let the timer run

   467

    log_info("running the event loop once...");

   468

    assert(event_base_loop(_test_ctx.ev_base, EVLOOP_ONCE) == 0);

   469

   470

    // test to check that the line was now sent

   471

    log_info("checking that the delayed line was sent...");

   473

    assert(TAILQ_EMPTY(&queue->list));

   474

    assert(!event_pending(queue->ev, EV_TIMEOUT, NULL));

   475

   476

    // cleanup

   477

    irc_queue_destroy(queue);

   478

}

   479

   480

struct test_conn_ctx {

   481

    /** Callback flags */

   482

    bool on_registered, on_TEST, on_error, on_quit;

   483

};

   484

   485

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

   486

{

   487

    struct test_conn_ctx *ctx = arg;