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>

    14

#include <assert.h>

    15

#include <ctype.h>

    16

    17

#define DUMP_STR_BUF 1024

    18

#define DUMP_STR_COUNT 8

    19

#define DUMP_STR_TAIL 10

    20

    21

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

    22

{

    23

    while (*str)

    24

        *buf++ = *str++;

    25

    26

    return buf;

    27

}

    28

    29

/**

    30

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

    31

 *

    32

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

    33

 *

    34

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

    35

 *

    36

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

    37

 *

    38

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

    39

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

    40

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

    41

 */

    42

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

    43

{

    44

    static char dump_buf[DUMP_STR_COUNT][DUMP_STR_BUF];

    45

    static size_t dump_idx = 0;

    46

    47

    // pick a buffer to use

    48

    const char *str_ptr = str;

    49

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

    50

    51

    // cycle

    52

    if (dump_idx >= DUMP_STR_COUNT)

    53

        dump_idx = 0;

    54

    55

    // NULL?

    56

    if (str == NULL) {

    57

        buf = dump_str_append(buf, "NULL");

    58

        *buf = '\0';

    59

    60

        return buf_ptr;

    61

    }

    62

    63

    // quote

    64

    *buf++ = '\'';

    65

    66

    // dump each char

    67

    for (; (

    68

            // ...stop on NUL

    69

                *str 

    70

    71

            // ...leave DUMP_STR_TAIL bytes room at the end of buf

    72

            &&  (size_t) (buf - buf_ptr) < DUMP_STR_BUF - DUMP_STR_TAIL 

    73

    74

            // ...don't consume more than len bytes of str, unless len < 0

    75

            &&  (len < 0 || (size_t) (str - str_ptr) < (size_t) len)

    76

        ); str++

    77

    ) {

    78

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

    79

            // escape quotes

    80

            buf = dump_str_append(buf, "\\'");

    81

    82

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

    83

            // escape escapes

    84

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

    85

    86

        } else if (isprint(*str)) {

    87

            // normal char

    88

            *buf++ = *str;

    89

    90

        } else {

    91

            // something more special

    92

            switch (*str) {

    93

                case '\r':

    94

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

    95

    96

                case '\n':

    97

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

    98

    99

                default:

   100

                    // format as "\xFF"

   101

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

   102

                    break;

   103

            }

   104

        }

   105

    }

   106

   107

    // end quote

   108

    *buf++ = '\'';

   109

   110

    // overflow?

   111

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

   112

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

   113

   114

    // terminate

   115

    *buf = '\0';

   116

   117

    // ok

   118

    return buf_ptr;

   119

}

   120

   121

const char *dump_str (const char *str) 

   122

{

   123

    return dump_strn(str, -1);

   124

}

   125

   126

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

   127

{

   128

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

   129

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

   130

}

   131

   132

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

   133

{   

   134

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

   135

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

   136

}

   137

   138

void assert_strlen (const char *str, size_t n)

   139

{

   140

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

   141

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

   142

}

   143

   144

void assert_strnull (const char *str)

   145

{

   146

    if (str != NULL)

   147

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

   148

}

   149

   150

void assert_success (err_t err)

   151

{

   152

    if (err != SUCCESS)

   153

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

   154

}

   155

   156

void assert_err (err_t err, err_t target)

   157

{

   158

    if (err != target)

   159

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

   160

}

   161

   162

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

   163

{

   164

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

   165

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

   166

}

   167

   168

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

   169

{

   170

    char buf[strlen(str)];

   171

   172

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

   173

   174

    // read it

   175

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

   176

   177

    // cmp

   178

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

   179

}

   180

   181

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

   182

{

   183

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

   184

   185

    // write it

   186

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

   187

}

   188

   189

void assert_sock_eof (struct sock_stream *sock)

   190

{

   191

    char buf;

   192

   193

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

   194

   195

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

   196

}

   197

   198

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

   199

{

   200

    // get the data out

   201

    char *buf;

   202

    size_t len;

   203

   204

    sock_test_get_send_data(sock, &buf, &len);

   205

   206

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

   207

   208

    // should be the same

   209

    assert_strncmp(buf, data, len);

   210

    assert_strlen(data, len);

   211

   212

    // cleanup

   213

    free(buf);

   214

}

   215

   216

/**

   217

 * Nicer name for test_sock_add_recv_str

   218

 */

   219

void test_sock_push (struct sock_test *sock, const char *str)

   220

{

   221

    return sock_test_add_recv_str(sock, str);

   222

}

   223

   224

/**

   225

 * Create an empty sock_test

   226

 */

   227

struct sock_test* setup_sock_test (void)

   228

{

   229

    struct sock_test *sock;

   230

   231

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

   232

   233

    return sock;

   234

}

   235

   236

void test_dump_str (void)

   237

{

   238

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

   239

   240

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

   241

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

   242

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

   243

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

   244

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

   245

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

   246

}

   247

   248

void test_sock_test (void)

   249

{

   250

    struct sock_test *sock = sock_test_create();

   251

    struct io_vec _read_data[] = {

   252

        {   "foo",      3   },

   253

        {   "barx",     4   }

   254

    };

   255

    const char *_write_data = "test data";

   256

   257

    // put the read data

   258

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

   259

    sock_test_set_recv_buffer(sock, _read_data, 2, true);

   260

   261

    // read it out

   262

    log_info("test sock_test_read");

   263

   264

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

   265

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

   266

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

   267

    assert_sock_eof(SOCK_TEST_BASE(sock));

   268

   269

    // write the data in

   270

    log_info("test sock_test_write");

   271

   272

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

   273

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

   274

   275

    // check output

   276

    assert_sock_data(sock, _write_data);

   277

   278

    // check output

   279

    assert_sock_data(sock, "");

   280

   281

    // cleanup

   282

    sock_test_destroy(sock);

   283

}

   284

   285

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

   286

{

   287

    char *line_buf;

   288

   289

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

   290

   291

    assert_success(line_proto_recv(lp, &line_buf));

   292

   293

    if (line_str) {

   294

        assert_strcmp(line_buf, line_str);

   295

   296

    } else {

   297

        assert_strnull(line_buf);

   298

   299

    }

   300

}

   301

   302

/**

   303

 * Context info for test_line_proto callbacks

   304

 */

   305

struct _lp_test_ctx {

   306

    /** Expected line */

   307

    const char *line;

   308

   309

    /** Expected error */

   310

    struct error_info err;

   311

};

   312

   313

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

   314

{

   315

    struct _lp_test_ctx *ctx = arg;

   316

   317

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

   318

   319

    assert_strcmp(line, ctx->line);

   320

   321

    ctx->line = NULL;

   322

}

   323

   324

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

   325

{

   326

    struct _lp_test_ctx *ctx = arg;

   327

   328

    assert_error_info(err, &ctx->err);

   329

}

   330

   331

static struct line_proto_callbacks _lp_callbacks = {

   332

    .on_line        = &_lp_on_line,

   333

    .on_error       = &_lp_on_error,

   334

};

   335

   336

void test_line_proto (void)

   337

{

   338

    struct sock_test *sock = sock_test_create();

   339

    struct io_vec _read_data[] = {

   340

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

   341

        {   "world\n",      6   },

   342

        {   "this ",        5   },

   343

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

   344

        {   "\nfragment",   9   },

   345

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

   346

    struct line_proto *lp;

   347

    struct _lp_test_ctx ctx;

   348

    struct error_info err;

   349

   350

    // put the read data

   351

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

   352

    sock_test_set_recv_buffer(sock, _read_data, 5, false);

   353

   354

    // create the lp

   355

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

   356

   357

    log_info("test line_proto_recv");

   358

   359

    // then read some lines from it

   360

    assert_read_line(lp, "hello");

   361

    assert_read_line(lp, "world");

   362

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

   363

    assert_read_line(lp, NULL);

   364

   365

    // then add a final bit to trigger on_line

   366

    log_info("test on_line");

   367

   368

    ctx.line = "fragment";

   369

    sock_test_add_recv_vec(sock, _trailing_data);

   370

    assert_strnull(ctx.line);

   371

   372

    // test writing

   373

    log_info("test line_proto_send");

   374

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

   375

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

   376

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

   377

   378

    // XXX: test partial writes

   379

   380

    // cleanup

   381

    line_proto_release(lp);

   382

}

   383

   384

struct _test_irc_conn_ctx {

   385

    bool on_registered, on_TEST, on_error, on_quit;

   386

};

   387

   388

static void _conn_on_registered (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_registered = true;

   395

   396

    log_debug("registered");

   397

}

   398

   399

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

   400

{

   401

    struct _test_irc_conn_ctx *ctx = arg;

   402

   403

    (void) conn;

   404

    (void) err;

   405

   406

    if (ctx) ctx->on_error = true;

   407

   408

    log_debug("on_error");

   409

}

   410

   411

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

   412

{

   413

    struct _test_irc_conn_ctx *ctx = arg;

   414

   415

    (void) conn;

   416

   417

    if (ctx) ctx->on_quit = true;

   418

   419

    log_debug("on_quit");

   420

}

   421

   422

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

   423

{

   424

    struct _test_irc_conn_ctx *ctx = arg;

   425

   426

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

   427

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

   428

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

   429

    assert_strnull(line->args[1]);

   430

   431

    if (ctx) ctx->on_TEST = true;

   432

   433

    log_debug("on_TEST");

   434

}

   435

   436

static struct irc_conn_callbacks _conn_callbacks = {

   437

    .on_registered      = &_conn_on_registered,

   438

    .on_error           = &_conn_on_error,

   439

    .on_quit            = &_conn_on_quit,

   440

};

   441

   442

static struct irc_cmd_handler _conn_handlers[] = {

   443

    {   "TEST",         &_conn_on_TEST  },

   444

    {   NULL,           NULL            }

   445

};

   446

   447

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

   448

{

   449

    struct irc_conn *conn;

   450

    struct error_info err;

   451

    struct irc_conn_register_info register_info = {

   452

        "nick", "user", "realname"

   453

    };

   454

   455

    // create the irc_conn

   456

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

   457

   458

    // test register

   459

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

   460

    assert_success(irc_conn_register(conn, &register_info));

   461

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

   462

   463

    // test on_register callback    

   464

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

   465

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

   466

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

   467

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

   468

   469

    // ok

   470

    return conn;

   471

}

   472

   473

void test_irc_conn (void)

   474

{

   475

    struct sock_test *sock;

   476

    struct irc_conn *conn;

   477

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

   478

   479

    // create the test socket

   480

    assert((sock = sock_test_create()));

   481

   482

    // setup the basic irc_conn

   483

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

   484

   485

    // add our test handlers

   486

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

   487

   488

    // test on_TEST handler

   489

    log_info("test irc_conn.handlers");

   490

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

   491

    assert(ctx.on_TEST);

   492