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 <getopt.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_null (const void *ptr)

   127

{

   128

    if (ptr)

   129

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

   130

}

   131

   132

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

   133

{

   134

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

   135

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

   136

}

   137

   138

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

   139

{   

   140

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

   141

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

   142

}

   143

   144

void assert_strlen (const char *str, size_t n)

   145

{

   146

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

   147

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

   148

}

   149

   150

void assert_strnull (const char *str)

   151

{

   152

    if (str != NULL)

   153

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

   154

}

   155

   156

void assert_success (err_t err)

   157

{

   158

    if (err != SUCCESS)

   159

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

   160

}

   161

   162

void assert_err (err_t err, err_t target)

   163

{

   164

    if (err != target)

   165

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

   166

}

   167

   168

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

   169

{

   170

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

   171

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

   172

}

   173

   174

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

   175

{

   176

    char buf[strlen(str)];

   177

   178

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

   179

   180

    // read it

   181

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

   182

   183

    // cmp

   184

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

   185

}

   186

   187

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

   188

{

   189

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

   190

   191

    // write it

   192

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

   193

}

   194

   195

void assert_sock_eof (struct sock_stream *sock)

   196

{

   197

    char buf;

   198

   199

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

   200

   201

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

   202

}

   203

   204

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

   205

{

   206

    // get the data out

   207

    char *buf;

   208

    size_t len;

   209

   210

    sock_test_get_send_data(sock, &buf, &len);

   211

   212

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

   213

   214

    // should be the same

   215

    assert_strncmp(buf, data, len);

   216

    assert_strlen(data, len);

   217

   218

    // cleanup

   219

    free(buf);

   220

}

   221

   222

/**

   223

 * Nicer name for test_sock_add_recv_str

   224

 */

   225

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

   226

{

   227

    return sock_test_add_recv_str(sock, str);

   228

}

   229

   230

/**

   231

 * Create an empty sock_test

   232

 */

   233

struct sock_test* setup_sock_test (void)

   234

{

   235

    struct sock_test *sock;

   236

   237

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

   238

   239

    return sock;

   240

}

   241

   242

void test_dump_str (void)

   243

{

   244

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

   245

   246

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

   247

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

   248

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

   249

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

   250

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

   251

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

   252

}

   253

   254

void test_sock_test (void)

   255

{

   256

    struct sock_test *sock = sock_test_create();

   257

    struct io_vec _read_data[] = {

   258

        {   "foo",      3   },

   259

        {   "barx",     4   }

   260

    };

   261

    const char *_write_data = "test data";

   262

   263

    // put the read data

   264

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

   265

    sock_test_set_recv_buffer(sock, _read_data, 2, true);

   266

   267

    // read it out

   268

    log_info("test sock_test_read");

   269

   270

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

   271

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

   272

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

   273

    assert_sock_eof(SOCK_TEST_BASE(sock));

   274

   275

    // write the data in

   276

    log_info("test sock_test_write");

   277

   278

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

   279

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

   280

   281

    // check output

   282

    assert_sock_data(sock, _write_data);

   283

   284

    // check output

   285

    assert_sock_data(sock, "");

   286

   287

    // cleanup

   288

    sock_test_destroy(sock);

   289

}

   290

   291

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

   292

{

   293

    char *line_buf;

   294

   295

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

   296

   297

    assert_success(line_proto_recv(lp, &line_buf));

   298

   299

    if (line_str) {

   300

        assert_strcmp(line_buf, line_str);

   301

   302

    } else {

   303

        assert_strnull(line_buf);

   304

   305

    }

   306

}

   307

   308

/**

   309

 * Context info for test_line_proto callbacks

   310

 */

   311

struct _lp_test_ctx {

   312

    /** Expected line */

   313

    const char *line;

   314

   315

    /** Expected error */

   316

    struct error_info err;

   317

};

   318

   319

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

   320

{

   321

    struct _lp_test_ctx *ctx = arg;

   322

   323

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

   324

   325

    assert_strcmp(line, ctx->line);

   326

   327

    ctx->line = NULL;

   328

}

   329

   330

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

   331

{

   332

    struct _lp_test_ctx *ctx = arg;

   333

   334

    assert_error_info(err, &ctx->err);

   335

}

   336

   337

static struct line_proto_callbacks _lp_callbacks = {

   338

    .on_line        = &_lp_on_line,

   339

    .on_error       = &_lp_on_error,

   340

};

   341

   342

void test_line_proto (void)

   343

{

   344

    struct sock_test *sock = sock_test_create();

   345

    struct io_vec _read_data[] = {

   346

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

   347

        {   "world\n",      6   },

   348

        {   "this ",        5   },

   349

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

   350

        {   "\nfragment",   9   },

   351

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

   352

    struct line_proto *lp;

   353

    struct _lp_test_ctx ctx;

   354

    struct error_info err;

   355

   356

    // put the read data

   357

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

   358

    sock_test_set_recv_buffer(sock, _read_data, 5, false);

   359

   360

    // create the lp

   361

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

   362

   363

    log_info("test line_proto_recv");

   364

   365

    // then read some lines from it

   366

    assert_read_line(lp, "hello");

   367

    assert_read_line(lp, "world");

   368

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

   369

    assert_read_line(lp, NULL);

   370

   371

    // then add a final bit to trigger on_line

   372

    log_info("test on_line");

   373

   374

    ctx.line = "fragment";

   375

    sock_test_add_recv_vec(sock, _trailing_data);

   376

    assert_strnull(ctx.line);

   377

   378

    // test writing

   379

    log_info("test line_proto_send");

   380

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

   381

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

   382

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

   383

   384

    // XXX: test partial writes

   385

   386

    // cleanup

   387

    line_proto_release(lp);

   388

}

   389

   392

    bool on_registered, on_TEST, on_error, on_quit;

   393

};

   394

   395

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

   396

{

   398

   399

    (void) conn;

   400

   401

    if (ctx) ctx->on_registered = true;

   402

   403

    log_debug("registered");

   404

}

   405

   406

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

   407

{

   409

   410

    (void) conn;

   411

    (void) err;

   412

   413

    if (ctx) ctx->on_error = true;

   414

   415

    log_debug("on_error");

   416

}

   417

   418

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

   419

{

   421

   422

    (void) conn;

   423

   424

    if (ctx) ctx->on_quit = true;

   425

   426

    log_debug("on_quit");

   427

}

   428

   429

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

   430

{

   432

   433

    assert_null(line->source);

   434

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

   435

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

   436

    assert_strnull(line->args[1]);

   437

   438

    if (ctx) ctx->on_TEST = true;

   439

   440

    log_debug("on_TEST");

   441

}

   442

   443

static struct irc_conn_callbacks _conn_callbacks = {

   444

    .on_registered      = &_conn_on_registered,

   445

    .on_error           = &_conn_on_error,

   446

    .on_quit            = &_conn_on_quit,

   447

};

   448

   449

static struct irc_cmd_handler _conn_handlers[] = {

   450

    {   "TEST",         &_conn_on_TEST  },

   451

    {   NULL,           NULL            }

   452

};

   453

   458

{

   459

    struct irc_conn *conn;

   460

    struct error_info err;

   461

    struct irc_conn_register_info register_info = {

   462

        "nick", "user", "realname"

   463

    };

   464

   468

    // create the irc_conn

   469

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

   470

   471

    // test register

   472

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

   473

    assert_success(irc_conn_register(conn, &register_info));

   474

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

   475

   476

    // test on_register callback    

   477

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

   478

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

   479

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

   480

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

   481

   482

    // ok

   483

    return conn;

   484

}

   485

   486

void test_irc_conn (void)

   487

{

   491