1

/**

     2

 * The main test code entry point

     3

 */

     4

#include "sock_test.h"

     5

#include "line_proto.h"

     6

#include "irc_queue.h"

     7

#include "irc_conn.h"

     8

#include "irc_net.h"

     9

#include "log.h"

    10

#include "str.h"

    11

#include "error.h"

    12

    13

#include <stdlib.h>

    14

#include <string.h>

    15

#include <getopt.h>

    16

#include <assert.h>

    17

#include <ctype.h>

    18

    19

#define DUMP_STR_BUF 1024

    20

#define DUMP_STR_COUNT 8

    21

#define DUMP_STR_TAIL 10

    22

    23

/**

    24

 * Global test-running state

    25

 */

    26

struct test_ctx {

    27

    /** The event_base that we have setup */

    28

    struct event_base *ev_base;

    29

    30

} _test_ctx;

    31

    32

    33

/**

    34

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

    35

 *

    36

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

    37

 *

    38

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

    39

 *

    40

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

    41

 *

    42

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

    43

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

    44

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

    45

 */

    46

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

    47

{

    48

    static char dump_buf[DUMP_STR_COUNT][DUMP_STR_BUF];

    49

    static size_t dump_idx = 0;

    50

    51

    // pick a buffer to use

    52

    char *buf = dump_buf[dump_idx++];

    53

    54

    // cycle

    55

    if (dump_idx >= DUMP_STR_COUNT)

    56

        dump_idx = 0;

    57

    58

    str_quote(buf, DUMP_STR_BUF, str, len);

    59

    60

    // ok

    61

    return buf;

    62

}

    63

    64

const char *dump_str (const char *str) 

    65

{

    66

    return dump_strn(str, -1);

    67

}

    68

    69

void assert_null (const void *ptr)

    70

{

    71

    if (ptr)

    72

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

    73

}

    74

    75

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

    76

{

    77

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

    78

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

    79

}

    80

    81

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

    82

{   

    83

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

    84

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

    85

}

    86

    87

void assert_strlen (const char *str, size_t n)

    88

{

    89

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

    90

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

    91

}

    92

    93

void assert_strnull (const char *str)

    94

{

    95

    if (str != NULL)

    96

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

    97

}

    98

    99

void assert_success (err_t err)

   100

{

   101

    if (err != SUCCESS)

   102

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

   103

}

   104

   105

void assert_err (err_t err, err_t target)

   106

{

   107

    if (err != target)

   108

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

   109

}

   110

   111

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

   112

{

   113

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

   114

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

   115

}

   116

   117

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

   118

{

   119

    char buf[strlen(str)];

   120

   121

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

   122

   123

    // read it

   124

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

   125

   126

    // cmp

   127

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

   128

}

   129

   130

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

   131

{

   132

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

   133

   134

    // write it

   135

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

   136

}

   137

   138

void assert_sock_eof (struct sock_stream *sock)

   139

{

   140

    char buf;

   141

   142

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

   143

   144

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

   145

}

   146

   147

/**

   148

 * Maximum amount that can be pushed using test_sock_push

   149

 */

   150

#define TEST_SOCK_FMT_MAX 1024

   151

   152

void assert_sock_data (struct sock_test *sock, const char *fmt, ...)

   153

{

   154

    char buf[TEST_SOCK_FMT_MAX];

   155

    va_list vargs;

   156

    size_t len;

   157

   158

    va_start(vargs, fmt);

   159

   160

    if ((len = vsnprintf(buf, TEST_SOCK_FMT_MAX, fmt, vargs)) >= TEST_SOCK_FMT_MAX)

   161

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

   162

   163

    va_end(vargs);

   164

   165

    // get the data out

   166

    char *out;

   167

   168

    sock_test_get_send_data(sock, &out, &len);

   169

   170

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

   171

   172

    // should be the same

   173

    assert_strncmp(out, buf, len);

   174

    assert_strlen(buf, len);

   175

   176

    // cleanup

   177

    free(out);

   178

}

   179

   180

/**

   181

 * Nicer name for test_sock_add_recv_str, also supports formatted data.

   182

 *

   183

 * The formatted result is limited to TEST_SOCK_PUSH_MAX bytes

   184

 */

   185

void test_sock_push (struct sock_test *sock, const char *fmt, ...)

   186

{

   187

    char buf[TEST_SOCK_FMT_MAX];

   188

    va_list vargs;

   189

    size_t len;

   190

   191

    va_start(vargs, fmt);

   192

   193

    if ((len = vsnprintf(buf, TEST_SOCK_FMT_MAX, fmt, vargs)) >= TEST_SOCK_FMT_MAX)

   194

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

   195

   196

    va_end(vargs);

   197

   198

    return sock_test_add_recv_str(sock, buf);

   199

}

   200

   201

/**

   202

 * Setup the global sock_stream state

   203

 */

   204

struct event_base* setup_sock (void)

   205

{

   206

    struct event_base *ev_base;

   207

    struct error_info err;

   208

   209

    assert((ev_base = event_base_new()));

   210

    assert_success(sock_init(ev_base, &err));

   211

   212

    return ev_base;

   213

}

   214

   215

/**

   216

 * Create an empty sock_test

   217

 */

   218

struct sock_test* setup_sock_test (void)

   219

{

   220

    struct sock_test *sock;

   221

   222

    assert ((sock = sock_test_create()) != NULL);

   223

   224

    return sock;

   225

}

   226

   227

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

   228

{

   229

    char buf[buf_size];

   230

   231

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

   232

   233

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

   234

   235

    assert_strcmp(buf, target);

   236

    assert(ret == out);

   237

}

   238

   239

void test_str_quote (void)

   240

{

   241

    log_info("testing str_quote()");

   242

   243

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

   244

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

   245

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

   246

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

   247

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

   248

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

   249

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

   250

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

   251

}

   252

   253

struct str_format_ctx {

   254

    const char *name;

   255

   256

    const char *value;

   257

};

   258

   259

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

   260

{

   261

    struct str_format_ctx *ctx = arg;

   262

   263

    assert_strcmp(name, ctx->name);

   264

   265

    *value = ctx->value;

   266

    *value_len = -1;

   267

   268

    return SUCCESS;

   269

}

   270

   271

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

   272

{

   273

    struct str_format_ctx ctx = { name, value };

   274

    char buf[512];

   275

   276

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

   277

   278

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

   279

   280

    assert_strcmp(buf, out);

   281

}

   282

   283

void test_str_format (void)

   284

{

   285

    log_info("test str_format()");

   286

   287

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

   288

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

   289

}

   290

   291

void test_dump_str (void)

   292

{

   293

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

   294

   295

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

   296

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

   297

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

   298

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

   299

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

   300

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

   301

}

   302

   303

void test_sock_test (void)

   304

{

   305

    struct sock_test *sock = sock_test_create();

   306

    struct io_vec _read_data[] = {

   307

        {   "foo",      3   },

   308

        {   "barx",     4   }

   309

    };

   310

    const char *_write_data = "test data";

   311

   312

    // put the read data

   313

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

   314

    sock_test_set_recv_buffer(sock, _read_data, 2, true);

   315

   316

    // read it out

   317

    log_info("test sock_test_read");

   318

   319

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

   320

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

   321

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

   322

    assert_sock_eof(SOCK_TEST_BASE(sock));

   323

   324

    // write the data in

   325

    log_info("test sock_test_write");

   326

   327

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

   328

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

   329

   330

    // check output

   331

    assert_sock_data(sock, _write_data);

   332

   333

    // check output

   334

    assert_sock_data(sock, "");

   335

   336

    // cleanup

   337

    sock_test_destroy(sock);

   338

}

   339

   340

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

   341

{

   342

    char *line_buf;

   343

   344

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

   345

   346

    assert_success(line_proto_recv(lp, &line_buf));

   347

   348

    if (line_str) {

   349

        assert_strcmp(line_buf, line_str);

   350

   351

    } else {

   352

        assert_strnull(line_buf);

   353

   354

    }

   355

}

   356

   357

/**

   358

 * Context info for test_line_proto callbacks

   359

 */

   360

struct _lp_test_ctx {

   361

    /** Expected line */

   362

    const char *line;

   363

   364

    /** Expected error */

   365

    struct error_info err;

   366

};

   367

   368

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

   369

{

   370

    struct _lp_test_ctx *ctx = arg;

   371

   372

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

   373

   374

    assert_strcmp(line, ctx->line);

   375

   376

    ctx->line = NULL;

   377

}

   378

   379

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

   380

{

   381

    struct _lp_test_ctx *ctx = arg;

   382

   383

    assert_error_info(err, &ctx->err);

   384

}

   385

   386

static struct line_proto_callbacks _lp_callbacks = {

   387

    .on_line        = &_lp_on_line,

   388

    .on_error       = &_lp_on_error,

   389

};

   390

   391

void test_line_proto (void)

   392

{

   393

    struct sock_test *sock = sock_test_create();

   394

    struct io_vec _read_data[] = {

   395

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

   396

        {   "world\n",      6   },

   397

        {   "this ",        5   },

   398

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

   399

        {   "\nfragment",   9   },

   400

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

   401

    struct line_proto *lp;

   402

    struct _lp_test_ctx ctx;

   403

    struct error_info err;

   404

   405

    // put the read data

   406

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

   407

    sock_test_set_recv_buffer(sock, _read_data, 5, false);

   408

   409

    // create the lp

   410

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

   411

   412

    log_info("test line_proto_recv");

   413

   414

    // then read some lines from it

   415

    assert_read_line(lp, "hello");

   416

    assert_read_line(lp, "world");

   417

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

   418

    assert_read_line(lp, NULL);

   419

   420

    // then add a final bit to trigger on_line

   421

    log_info("test on_line");

   422

   423

    ctx.line = "fragment";

   424

    sock_test_add_recv_vec(sock, _trailing_data);

   425

    assert_strnull(ctx.line);

   426

   427

    // test writing

   428

    log_info("test line_proto_send");

   429

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

   430

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

   431

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

   432

   433

    // XXX: test partial writes

   434

   435

    // cleanup

   436

    line_proto_release(lp);

   437

}

   438

   439

void test_irc_queue (void)

   440

{

   441

    struct sock_test *sock = sock_test_create();

   442

    struct line_proto *lp;

   443

    struct irc_queue *queue;

   444

    struct irc_queue_entry *queue_entry;

   445

    struct error_info err;

   446

   447

    // create the lp

   448

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

   449

   450

    // create the queue

   451

    assert_success(irc_queue_create(&queue, lp, &err));

   452

   453

    struct irc_line line = {

   454

        NULL, "TEST", { "fooX" }

   455

    };

   456

   457

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

   458

    log_info("test irc_queue_process (irc_queue_send_direct)");

   459

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

   460

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

   461

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

   462

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

   463

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

   464

   465

    // they should all be output

   466

    assert_sock_data(sock, 

   467

            "TEST foo0\r\n"

   468

            "TEST foo1\r\n"

   469

            "TEST foo2\r\n"

   470

            "TEST foo3\r\n"

   471

            "TEST foo4\r\n"

   472

    );

   473

   474

    // then enqueue

   475

    log_info("test irc_queue_process (irc_queue_put)");

   476

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

   477

   478

    // ensure it was enqueued

   479

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

   480

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

   481

   482

    // ensure timer is set

   483

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

   484

   485

    // run the event loop to let the timer run

   486

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

   487

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

   488

   489

    // test to check that the line was now sent

   490

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

   491

    assert_sock_data(sock, "TEST foo5\r\n");

   492

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