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 (; (

    71

            // ...stop on NUL

    73

    74

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

    75

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

    76

    77

        ); str++

    78

    ) {

    79

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

    80

            // escape quotes

    81

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

    82

    83

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

    84

            // escape escapes

    85

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

    86

    87

        } else if (isprint(*str)) {

    88

            // normal char

    89

            *buf++ = *str;

    90

    91

        } else {

    92

            // something more special

    93

            switch (*str) {

    94

                case '\r':

    95

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

    96

    97

                case '\n':

    98

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

    99

   100

                default:

   101

                    // format as "\xFF"

   102

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

   103

                    break;

   104

            }

   105

        }

   106

    }

   107

   108

    // end quote

   109

    *buf++ = '\'';

   110

   111

    // overflow?

   112

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

   113

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

   114

   115

    // terminate

   116

    *buf = '\0';

   117

   118

    // ok

   119

    return buf_ptr;

   120

}

   121

   122

const char *dump_str (const char *str) 

   123

{

   124

    return dump_strn(str, -1);

   125

}

   126

   127

void assert_null (const void *ptr)

   128

{

   129

    if (ptr)

   130

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

   131

}

   132

   133

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

   134

{

   135

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

   136

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

   137

}

   138

   139

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

   140

{   

   141

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

   142

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

   143

}

   144

   145

void assert_strlen (const char *str, size_t n)

   146

{

   147

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

   148

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

   149

}

   150

   151

void assert_strnull (const char *str)

   152

{

   153

    if (str != NULL)

   154

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

   155

}

   156

   157

void assert_success (err_t err)

   158

{

   159

    if (err != SUCCESS)

   160

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

   161

}

   162

   163

void assert_err (err_t err, err_t target)

   164

{

   165

    if (err != target)

   166

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

   167

}

   168

   169

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

   170

{

   171

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

   172

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

   173

}

   174

   175

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

   176

{

   177

    char buf[strlen(str)];

   178

   179

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

   180

   181

    // read it

   182

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

   183

   184

    // cmp

   185

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

   186

}

   187

   188

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

   189

{

   190

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

   191

   192

    // write it

   193

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

   194

}

   195

   196

void assert_sock_eof (struct sock_stream *sock)

   197

{

   198

    char buf;

   199

   200

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

   201

   202

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

   203

}

   204

   205

/**

   206

 * Maximum amount that can be pushed using test_sock_push

   207

 */

   208

#define TEST_SOCK_FMT_MAX 1024

   209

   210

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

   211

{

   212

    char buf[TEST_SOCK_FMT_MAX];

   213

    va_list vargs;

   214

    size_t len;

   215

   216

    va_start(vargs, fmt);

   217

   218

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

   219

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

   220

   221

    va_end(vargs);

   222

   223

    // get the data out

   224

    char *out;

   225

   226

    sock_test_get_send_data(sock, &out, &len);

   227

   228

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

   229

   230

    // should be the same

   231

    assert_strncmp(out, buf, len);

   232

    assert_strlen(buf, len);

   233

   234

    // cleanup

   235

    free(out);

   236

}

   237

   238

/**

   239

 * Nicer name for test_sock_add_recv_str, also supports formatted data.

   240

 *

   241

 * The formatted result is limited to TEST_SOCK_PUSH_MAX bytes

   242

 */

   243

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

   244

{

   245

    char buf[TEST_SOCK_FMT_MAX];

   246

    va_list vargs;

   247

    size_t len;

   248

   249

    va_start(vargs, fmt);

   250

   251

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

   252

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

   253

   254

    va_end(vargs);

   255

   256

    return sock_test_add_recv_str(sock, buf);

   257

}

   258

   259

/**

   260

 * Create an empty sock_test

   261

 */

   262

struct sock_test* setup_sock_test (void)

   263

{

   264

    struct sock_test *sock;

   265

   266

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

   267

   268

    return sock;

   269

}

   270

   271

void test_dump_str (void)

   272

{

   273

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

   274

   275

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

   276

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

   277

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

   278

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

   279

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

   280

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

   281

}

   282

   283

void test_sock_test (void)

   284

{

   285

    struct sock_test *sock = sock_test_create();

   286

    struct io_vec _read_data[] = {

   287

        {   "foo",      3   },

   288

        {   "barx",     4   }

   289

    };

   290

    const char *_write_data = "test data";

   291

   292

    // put the read data

   293

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

   294

    sock_test_set_recv_buffer(sock, _read_data, 2, true);

   295

   296

    // read it out

   297

    log_info("test sock_test_read");

   298

   299

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

   300

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

   301

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

   302

    assert_sock_eof(SOCK_TEST_BASE(sock));

   303

   304

    // write the data in

   305

    log_info("test sock_test_write");

   306

   307

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

   308

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

   309

   310

    // check output

   311

    assert_sock_data(sock, _write_data);

   312

   313

    // check output

   314

    assert_sock_data(sock, "");

   315

   316

    // cleanup

   317

    sock_test_destroy(sock);

   318

}

   319

   320

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

   321

{

   322

    char *line_buf;

   323

   324

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

   325

   326

    assert_success(line_proto_recv(lp, &line_buf));

   327

   328

    if (line_str) {

   329

        assert_strcmp(line_buf, line_str);

   330

   331

    } else {

   332

        assert_strnull(line_buf);

   333

   334

    }

   335

}

   336

   337

/**

   338

 * Context info for test_line_proto callbacks

   339

 */

   340

struct _lp_test_ctx {

   341

    /** Expected line */

   342

    const char *line;

   343

   344

    /** Expected error */

   345

    struct error_info err;

   346

};

   347

   348

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

   349

{

   350

    struct _lp_test_ctx *ctx = arg;

   351

   352

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

   353

   354

    assert_strcmp(line, ctx->line);

   355

   356

    ctx->line = NULL;

   357

}

   358

   359

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

   360

{

   361

    struct _lp_test_ctx *ctx = arg;

   362

   363

    assert_error_info(err, &ctx->err);

   364

}

   365

   366

static struct line_proto_callbacks _lp_callbacks = {

   367

    .on_line        = &_lp_on_line,

   368

    .on_error       = &_lp_on_error,

   369

};

   370

   371

void test_line_proto (void)

   372

{

   373

    struct sock_test *sock = sock_test_create();

   374

    struct io_vec _read_data[] = {

   375

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

   376

        {   "world\n",      6   },

   377

        {   "this ",        5   },

   378

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

   379

        {   "\nfragment",   9   },

   380

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

   381

    struct line_proto *lp;

   382

    struct _lp_test_ctx ctx;

   383

    struct error_info err;

   384

   385

    // put the read data

   386

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

   387

    sock_test_set_recv_buffer(sock, _read_data, 5, false);

   388

   389

    // create the lp

   390

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

   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";

   404

    sock_test_add_recv_vec(sock, _trailing_data);

   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"));

   411

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

   412

   413

    // XXX: test partial writes

   414

   415

    // cleanup

   416

    line_proto_release(lp);

   417

}

   418

   419

struct test_conn_ctx {

   420

    /** Callback flags */

   421

    bool on_registered, on_TEST, on_error, on_quit;

   422

};

   423

   424

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

   425

{

   426

    struct test_conn_ctx *ctx = arg;

   427

   428

    (void) conn;

   429

   430

    if (ctx) ctx->on_registered = true;

   431

   432

    log_debug("registered");

   433

}

   434

   435

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

   436

{

   437

    struct test_conn_ctx *ctx = arg;

   438

   439

    (void) conn;

   440

    (void) err;

   441

   442

    if (ctx) ctx->on_error = true;

   443

   444

    log_debug("on_error");

   445

}

   446

   447

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

   448

{

   449

    struct test_conn_ctx *ctx = arg;

   450

   451

    (void) conn;

   452

   453

    if (ctx) ctx->on_quit = true;

   454

   455

    log_debug("on_quit");

   456

}

   457

   458

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

   459

{

   460

    struct test_conn_ctx *ctx = arg;

   461

   462

    assert_null(line->source);

   463

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

   464

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

   465

    assert_strnull(line->args[1]);

   466

   467

    if (ctx) ctx->on_TEST = true;

   468

   469

    log_debug("on_TEST");

   470

}

   471

   472

static struct irc_conn_callbacks _conn_callbacks = {

   473

    .on_registered      = &_conn_on_registered,

   474

    .on_error           = &_conn_on_error,

   475

    .on_quit            = &_conn_on_quit,

   476

};

   477

   478

static struct irc_cmd_handler _conn_handlers[] = {

   479

    {   "TEST",         &_conn_on_TEST  },

   480

    {   NULL,           NULL            }

   481

};

   482

   483

/**

   484

 * Create and return a new irc_conn with the given ctx (will be initialized to zero).

   485

 */

   486

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

   487

{

   488

    struct irc_conn *conn;

   489

    struct error_info err;

   490

    struct irc_conn_register_info register_info = {

   491