evirc: comparison src/test.c

equal deleted inserted replaced

-:cc61eaa841ef
+:97604efda1ce
 }
 /**
 * This re-formats the given string to escape values, and returns a pointer to an internal static buffer.
 *
-* If len is given as >= 0, only the given number of chars will be dumped from str
+* If len is given as >= 0, only the given number of chars will be dumped from str.
 *
-* The buffer cycles a bit, so you pointers remain valid across DUMP_STR_COUNT calls.
+* The buffer cycles a bit, so the returned pointers remain valid across DUMP_STR_COUNT calls.
 *
-* The resulting strings are truncated to (DUMP_STR_BUF - DUMP_STR_TAIL) bytes, not including the ending "...'\0"
+* The resulting string is truncated to (DUMP_STR_BUF - DUMP_STR_TAIL) bytes, not including the ending "...'\0".
+*
+* @param str the string to dump, should be NUL-terminated unless len is given
+* @param len if negative, ignored, otherwise, only this many bytes are dumped from str
+* @param return a pointer to a static buffer that remains valid across DUMP_STR_COUNT calls to this function
 */
 const char *dump_strn (const char *str, ssize_t len)
 {
 static char dump_buf[DUMP_STR_COUNT][DUMP_STR_BUF];
 static size_t dump_idx = 0;
 buf = dump_str_append(buf, "\\\\");
 } else if (isprint(*str)) {
 // normal char
 *buf++ = *str;
 } else {
 // something more special
 switch (*str) {
 case '\r':
 buf = dump_str_append(buf, "\\r"); break;
 return dump_strn(str, -1);
 }
 void assert_strcmp (const char *is, const char *should_be)
 {
-if (strcmp(is, should_be))
+if (!is || strcmp(is, should_be))
 FATAL("%s != %s", dump_str(is), dump_str(should_be));
 }
 void assert_strncmp (const char *is, const char *should_be, size_t n)
 {
-if (strncmp(is, should_be, n))
+if (!is || strncmp(is, should_be, n))
 FATAL("%s:%u != %s", dump_strn(is, n), (unsigned) n, dump_strn(should_be, n));
 }
 void assert_strlen (const char *str, size_t n)
 {
-if (strlen(str) != n)
+if (!str || strlen(str) != n)
 FATAL("strlen(%s) != %u", dump_str(str), (unsigned) n);
 }
 void assert_strnull (const char *str)
 {
 void assert_success (err_t err)
 {
 if (err != SUCCESS)
 FATAL("error: %s", error_name(err));
 }
 void assert_err (err_t err, err_t target)
 {
 if (err != target)
 assert_strncmp(buf, data, len);
 assert_strlen(data, len);
 // cleanup
 free(buf);
+}
+/**
+* Nicer name for test_sock_add_recv_str
+*/
+void test_sock_push (struct sock_test *sock, const char *str)
+{
+return sock_test_add_recv_str(sock, str);
 }
 void test_dump_str (void)
 {
 log_info("dumping example strings on stdout:");
 log_debug("expect: %s", dump_str(line_str));
 assert_success(line_proto_recv(lp, &line_buf));
 if (line_str) {
-assert(line_buf != NULL);
 assert_strcmp(line_buf, line_str);
 } else {
 assert_strnull(line_buf);
 assert_success(irc_conn_register(conn, &register_info));
 assert_sock_data(sock, "NICK nick\r\nUSER user 0 * realname\r\n");
 // test on_register callback
 if (noisy) log_info("test irc_conn_callbacks.on_register");
-sock_test_add_recv_str(sock, "001 mynick :Blaa blaa blaa\r\n");
+test_sock_push(sock, "001 mynick :Blaa blaa blaa\r\n");
 if (ctx) assert(ctx->on_registered);
 assert_strcmp(conn->nickname, "mynick");
 // ok
 return conn;
 // add our test handlers
 assert_success(irc_conn_add_cmd_handlers(conn, _conn_handlers, &ctx));
 // test on_TEST handler
 log_info("test irc_conn.handlers");
-sock_test_add_recv_str(sock, ":foobar-prefix TEST arg0\r\n");
+test_sock_push(sock, ":foobar-prefix TEST arg0\r\n");
 assert(ctx.on_TEST);
 // test PING/PONG
 log_info("test PING/PONG");
-sock_test_add_recv_str(sock, "PING foo\r\n");
+test_sock_push(sock, "PING foo\r\n");
 assert_sock_data(sock, "PONG foo\r\n");
 // quit nicely
 log_info("test QUIT");
 assert_success(irc_conn_QUIT(conn, "bye now"));
 assert_sock_data(sock, "QUIT :bye now\r\n");
 assert(conn->quitting);
-sock_test_add_recv_str(sock, "ERROR :Closing Link: Quit\r\n");
+test_sock_push(sock, "ERROR :Closing Link: Quit\r\n");
 sock_test_set_recv_eof(sock);
 assert(conn->quit && !conn->quitting && !conn->registered);
 assert(ctx.on_quit);
 assert(!ctx.on_error);
 // test register output
 assert_sock_data(sock, "NICK nick\r\nUSER user 0 * realname\r\n");
 // registration reply
 log_info("test irc_conn_on_RPL_WELCOME");
-sock_test_add_recv_str(sock, "001 mynick :Blaa blaa blaa\r\n");
+test_sock_push(sock, "001 mynick :Blaa blaa blaa\r\n");
 assert(net->conn->registered);
 assert_strcmp(net->conn->nickname, "mynick");
 // JOIN request
 log_info("test irc_net_conn_registered -> irc_chan_join");
 assert(chan->joining);
 assert_sock_data(sock, "JOIN #test\r\n");
 // JOIN reply
 log_info("test irc_chan_on_JOIN");
-sock_test_add_recv_str(sock, ":mynick!user@host JOIN #test\r\n");
+test_sock_push(sock, ":mynick!user@host JOIN #test\r\n");
 assert(!chan->joining && chan->joined);
 assert(ctx.on_chan_self_join);
 // test errors by setting EOF
 log_info("test irc_net_error");
 {   NULL,           NULL                }
 };
 int main (int argc, char **argv)
 {
+const char *filter;
 struct test *test;
-(void) argv;
+if (argc == 1) {
+// no arguments
-// no arguments
+filter = NULL;
-assert(argc == 1);
+} else if (argc == 2) {
+// filter
+filter = argv[1];
+log_info("only running tests: %s", filter);
+} else {
+FATAL("too many arguments");
+}
 // run tests
 for (test = _tests; test->name; test++) {
+if (filter && strcmp(test->name, filter))
+continue;
 log_info("Running test: %s", test->name);
 test->func();
 }

changeset 52	97604efda1ce
parent 51	cc61eaa841ef
child 72	43084f103c2a