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

 *

    32

 *

    34

 *

    40

 */

    41

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

    42

{

    43

    static char dump_buf[DUMP_STR_COUNT][DUMP_STR_BUF];

    44

    static size_t dump_idx = 0;

    45

    46

    // pick a buffer to use

    47

    const char *str_ptr = str;

    48

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

    49

    50

    // cycle

    51

    if (dump_idx >= DUMP_STR_COUNT)

    52

        dump_idx = 0;

    53

    54

    // NULL?

    55

    if (str == NULL) {

    56

        buf = dump_str_append(buf, "NULL");

    57

        *buf = '\0';

    58

    59

        return buf_ptr;

    60

    }

    61

    62

    // quote

    63

    *buf++ = '\'';

    64

    65

    // dump each char

    66

    for (; (

    67

            // ...stop on NUL

    68

                *str 

    69

    70

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

    71

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

    72

    73

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

    74

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

    75

        ); str++

    76

    ) {

    77

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

    78

            // escape quotes

    79

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

    80

    81

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

    82

            // escape escapes

    83

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

    84

    85

        } else if (isprint(*str)) {

    86

            // normal char

    87

            *buf++ = *str;

    89

        } else {

    90

            // something more special

    91

            switch (*str) {

    92

                case '\r':

    93

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

    94

    95

                case '\n':

    96

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

    97

    98

                default:

    99

                    // format as "\xFF"

   100

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

   101

                    break;

   102

            }

   103

        }

   104

    }

   105

   106

    // end quote

   107

    *buf++ = '\'';

   108

   109

    // overflow?

   110

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

   111

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

   112

   113

    // terminate

   114

    *buf = '\0';

   115

   116

    // ok

   117

    return buf_ptr;

   118

}

   119

   120

const char *dump_str (const char *str) 

   121

{

   122

    return dump_strn(str, -1);

   123

}

   124

   125

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

   126

{

   128

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

   129

}

   130

   131

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

   132

{   

   134

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

   135

}

   136

   137

void assert_strlen (const char *str, size_t n)

   138

{

   140

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

   141

}

   142

   143

void assert_strnull (const char *str)

   144

{

   145

    if (str != NULL)

   146

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

   147

}

   148

   149

void assert_success (err_t err)

   150

{

   151

    if (err != SUCCESS)

   152

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

   153

}

   154

   155

void assert_err (err_t err, err_t target)

   156

{

   157

    if (err != target)

   158

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

   159

}

   160

   161

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

   162

{

   163

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

   164

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

   165

}

   166

   167

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

   168

{

   169

    char buf[strlen(str)];

   170

   171

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

   172

   173

    // read it

   174

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

   175

   176

    // cmp

   177

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

   178

}

   179

   180

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

   181

{

   182

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

   183

   184

    // write it

   185

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

   186

}

   187

   188

void assert_sock_eof (struct sock_stream *sock)

   189

{

   190

    char buf;

   191

   192

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

   193

   194

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

   195

}

   196

   197

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

   198

{

   199

    // get the data out

   200

    char *buf;

   201

    size_t len;

   202

   203

    sock_test_get_send_data(sock, &buf, &len);

   204

   205

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

   206

   207

    // should be the same

   208

    assert_strncmp(buf, data, len);

   209

    assert_strlen(data, len);

   210

   211

    // cleanup

   212

    free(buf);

   213

}

   214

   223

void test_dump_str (void)

   224

{

   225

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

   226

   227

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

   228

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

   229

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

   230

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

   231

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

   232

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

   233

}

   234

   235

void test_sock_test (void)

   236

{

   237

    struct sock_test *sock = sock_test_create();

   238

    struct io_vec _read_data[] = {

   239

        {   "foo",      3   },

   240

        {   "barx",     4   }

   241

    };

   242

    const char *_write_data = "test data";

   243

   244

    // put the read data

   245

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

   246

    sock_test_set_recv_buffer(sock, _read_data, 2, true);

   247

   248

    // read it out

   249

    log_info("test sock_test_read");

   250

   251

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

   252

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

   253

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

   254

    assert_sock_eof(SOCK_TEST_BASE(sock));

   255

   256

    // write the data in

   257

    log_info("test sock_test_write");

   258

   259

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

   260

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

   261

   262

    // check output

   263

    assert_sock_data(sock, _write_data);

   264

   265

    // check output

   266

    assert_sock_data(sock, "");

   267

   268

    // cleanup

   269

    sock_test_destroy(sock);

   270

}

   271

   272

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

   273

{

   274

    char *line_buf;

   275

   276

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

   277

   278

    assert_success(line_proto_recv(lp, &line_buf));

   279

   280

    if (line_str) {

   281

        assert_strcmp(line_buf, line_str);

   282

   283

    } else {

   284

        assert_strnull(line_buf);

   285

   286

    }

   287

}

   288

   289

/**

   290

 * Context info for test_line_proto callbacks

   291

 */

   292

struct _lp_test_ctx {

   293

    /** Expected line */

   294

    const char *line;

   295

   296

    /** Expected error */

   297

    struct error_info err;

   298

};

   299

   300

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

   301

{

   302

    struct _lp_test_ctx *ctx = arg;

   303

   304

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

   305

   306

    assert_strcmp(line, ctx->line);

   307

   308

    ctx->line = NULL;

   309

}

   310

   311

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

   312

{

   313

    struct _lp_test_ctx *ctx = arg;

   314

   315

    assert_error_info(err, &ctx->err);

   316

}

   317

   318

static struct line_proto_callbacks _lp_callbacks = {

   319

    .on_line        = &_lp_on_line,

   320

    .on_error       = &_lp_on_error,

   321

};

   322

   323

void test_line_proto (void)

   324

{

   325

    struct sock_test *sock = sock_test_create();

   326

    struct io_vec _read_data[] = {

   327

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

   328

        {   "world\n",      6   },

   329

        {   "this ",        5   },

   330

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

   331

        {   "\nfragment",   9   },

   332

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

   333

    struct line_proto *lp;

   334

    struct _lp_test_ctx ctx;

   335

    struct error_info err;

   336

   337

    // put the read data

   338

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

   339

    sock_test_set_recv_buffer(sock, _read_data, 5, false);

   340

   341

    // create the lp

   342

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

   343

   344

    log_info("test line_proto_recv");

   345

   346

    // then read some lines from it

   347

    assert_read_line(lp, "hello");

   348

    assert_read_line(lp, "world");

   349

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

   350

    assert_read_line(lp, NULL);

   351

   352

    // then add a final bit to trigger on_line

   353

    log_info("test on_line");

   354

   355

    ctx.line = "fragment";

   356

    sock_test_add_recv_vec(sock, _trailing_data);

   357

    assert_strnull(ctx.line);

   358

   359

    // test writing

   360

    log_info("test line_proto_send");

   361

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

   362

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

   363

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

   364

   365

    // XXX: test partial writes

   366

   367

    // cleanup

   368

    line_proto_release(lp);

   369

}

   370

   371

struct _test_irc_conn_ctx {

   372

    bool on_registered, on_TEST, on_error, on_quit;

   373

};

   374

   375

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

   376

{

   377

    struct _test_irc_conn_ctx *ctx = arg;

   378

   379

    (void) conn;

   380

   381

    if (ctx) ctx->on_registered = true;

   382

   383

    log_debug("registered");

   384

}

   385

   386

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

   387

{

   388

    struct _test_irc_conn_ctx *ctx = arg;

   389

   390

    (void) conn;

   391

    (void) err;

   392

   393

    if (ctx) ctx->on_error = true;

   394

   395

    log_debug("on_error");

   396

}

   397

   398

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

   399

{

   400

    struct _test_irc_conn_ctx *ctx = arg;

   401

   402

    (void) conn;

   403

   404

    if (ctx) ctx->on_quit = true;

   405

   406

    log_debug("on_quit");

   407

}

   408

   409

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

   410

{

   411

    struct _test_irc_conn_ctx *ctx = arg;

   412

   413

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

   414

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

   415

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

   416

    assert_strnull(line->args[1]);

   417

   418

    if (ctx) ctx->on_TEST = true;

   419

   420

    log_debug("on_TEST");

   421

}

   422

   423

static struct irc_conn_callbacks _conn_callbacks = {

   424

    .on_registered      = &_conn_on_registered,

   425

    .on_error           = &_conn_on_error,

   426

    .on_quit            = &_conn_on_quit,

   427

};

   428

   429

static struct irc_cmd_handler _conn_handlers[] = {

   430

    {   "TEST",         &_conn_on_TEST  },

   431

    {   NULL,           NULL            }

   432

};

   433

   434

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

   435

{

   436

    struct irc_conn *conn;

   437

    struct error_info err;

   438

    struct irc_conn_register_info register_info = {

   439

        "nick", "user", "realname"

   440

    };

   441

   442

    // create the irc_conn

   443

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

   444

   445

    // test register

   446

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

   447

    assert_success(irc_conn_register(conn, &register_info));

   448

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

   449

   450

    // test on_register callback    

   451

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

   453

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

   454

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

   455

   456

    // ok

   457

    return conn;

   458

}

   459

   460

void test_irc_conn (void)

   461

{

   462

    struct sock_test *sock;

   463

    struct irc_conn *conn;

   464

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

   465

   466

    // create the test socket

   467

    assert((sock = sock_test_create()));

   468

   469

    // setup the basic irc_conn

   470

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

   471

   472

    // add our test handlers

   473

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

   474

   475

    // test on_TEST handler

   476

    log_info("test irc_conn.handlers");

   478

    assert(ctx.on_TEST);

   479

   480

    // test PING/PONG

   481

    log_info("test PING/PONG");

   483

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

   484

   485

    // quit nicely

   486

    log_info("test QUIT");

   487

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

   488

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

   489

    assert(conn->quitting);

   490

   492