tests/test-char.c

   1 #include "qemu/osdep.h"
   2 #include <glib/gstdio.h>
   3
   4 #include "qemu-common.h"
   5 #include "qemu/config-file.h"
   6 #include "qemu/sockets.h"
   7 #include "chardev/char-fe.h"
   8 #include "sysemu/sysemu.h"
   9 #include "qapi/error.h"
  10 #include "qom/qom-qobject.h"
  11 #include "qmp-commands.h"
  12
  13 static bool quit;
  14
  15 typedef struct FeHandler {
  16     int read_count;
  17     int last_event;
  18     char read_buf[128];
  19 } FeHandler;
  20
  21 static void main_loop(void)
  22 {
  23     quit = false;
  24     do {
  25         main_loop_wait(false);
  26     } while (!quit);
  27 }
  28
  29 static int fe_can_read(void *opaque)
  30 {
  31     FeHandler *h = opaque;
  32
  33     return sizeof(h->read_buf) - h->read_count;
  34 }
  35
  36 static void fe_read(void *opaque, const uint8_t *buf, int size)
  37 {
  38     FeHandler *h = opaque;
  39
  40     g_assert_cmpint(size, <=, fe_can_read(opaque));
  41
  42     memcpy(h->read_buf + h->read_count, buf, size);
  43     h->read_count += size;
  44     quit = true;
  45 }
  46
  47 static void fe_event(void *opaque, int event)
  48 {
  49     FeHandler *h = opaque;
  50
  51     h->last_event = event;
  52     if (event != CHR_EVENT_BREAK) {
  53         quit = true;
  54     }
  55 }
  56
  57 #ifdef CONFIG_HAS_GLIB_SUBPROCESS_TESTS
  58 #ifdef _WIN32
  59 static void char_console_test_subprocess(void)
  60 {
  61     QemuOpts *opts;
  62     Chardev *chr;
  63
  64     opts = qemu_opts_create(qemu_find_opts("chardev"), "console-label",
  65                             1, &error_abort);
  66     qemu_opt_set(opts, "backend", "console", &error_abort);
  67
  68     chr = qemu_chr_new_from_opts(opts, NULL);
  69     g_assert_nonnull(chr);
  70
  71     qemu_chr_write_all(chr, (const uint8_t *)"CONSOLE", 7);
  72
  73     qemu_opts_del(opts);
  74     object_unparent(OBJECT(chr));
  75 }
  76
  77 static void char_console_test(void)
  78 {
  79     g_test_trap_subprocess("/char/console/subprocess", 0, 0);
  80     g_test_trap_assert_passed();
  81     g_test_trap_assert_stdout("CONSOLE");
  82 }
  83 #endif
  84 static void char_stdio_test_subprocess(void)
  85 {
  86     Chardev *chr;
  87     CharBackend be;
  88     int ret;
  89
  90     chr = qemu_chr_new("label", "stdio");
  91     g_assert_nonnull(chr);
  92
  93     qemu_chr_fe_init(&be, chr, &error_abort);
  94     qemu_chr_fe_set_open(&be, true);
  95     ret = qemu_chr_fe_write(&be, (void *)"buf", 4);
  96     g_assert_cmpint(ret, ==, 4);
  97
  98     qemu_chr_fe_deinit(&be, true);
  99 }
 100
 101 static void char_stdio_test(void)
 102 {
 103     g_test_trap_subprocess("/char/stdio/subprocess", 0, 0);
 104     g_test_trap_assert_passed();
 105     g_test_trap_assert_stdout("buf");
 106 }
 107 #endif
 108
 109 static void char_ringbuf_test(void)
 110 {
 111     QemuOpts *opts;
 112     Chardev *chr;
 113     CharBackend be;
 114     char *data;
 115     int ret;
 116
 117     opts = qemu_opts_create(qemu_find_opts("chardev"), "ringbuf-label",
 118                             1, &error_abort);
 119     qemu_opt_set(opts, "backend", "ringbuf", &error_abort);
 120
 121     qemu_opt_set(opts, "size", "5", &error_abort);
 122     chr = qemu_chr_new_from_opts(opts, NULL);
 123     g_assert_null(chr);
 124     qemu_opts_del(opts);
 125
 126     opts = qemu_opts_create(qemu_find_opts("chardev"), "ringbuf-label",
 127                             1, &error_abort);
 128     qemu_opt_set(opts, "backend", "ringbuf", &error_abort);
 129     qemu_opt_set(opts, "size", "2", &error_abort);
 130     chr = qemu_chr_new_from_opts(opts, &error_abort);
 131     g_assert_nonnull(chr);
 132     qemu_opts_del(opts);
 133
 134     qemu_chr_fe_init(&be, chr, &error_abort);
 135     ret = qemu_chr_fe_write(&be, (void *)"buff", 4);
 136     g_assert_cmpint(ret, ==, 4);
 137
 138     data = qmp_ringbuf_read("ringbuf-label", 4, false, 0, &error_abort);
 139     g_assert_cmpstr(data, ==, "ff");
 140     g_free(data);
 141
 142     data = qmp_ringbuf_read("ringbuf-label", 4, false, 0, &error_abort);
 143     g_assert_cmpstr(data, ==, "");
 144     g_free(data);
 145
 146     qemu_chr_fe_deinit(&be, true);
 147
 148     /* check alias */
 149     opts = qemu_opts_create(qemu_find_opts("chardev"), "memory-label",
 150                             1, &error_abort);
 151     qemu_opt_set(opts, "backend", "memory", &error_abort);
 152     qemu_opt_set(opts, "size", "2", &error_abort);
 153     chr = qemu_chr_new_from_opts(opts, NULL);
 154     g_assert_nonnull(chr);
 155     object_unparent(OBJECT(chr));
 156     qemu_opts_del(opts);
 157 }
 158
 159 static void char_mux_test(void)
 160 {
 161     QemuOpts *opts;
 162     Chardev *chr, *base;
 163     char *data;
 164     FeHandler h1 = { 0, }, h2 = { 0, };
 165     CharBackend chr_be1, chr_be2;
 166
 167     opts = qemu_opts_create(qemu_find_opts("chardev"), "mux-label",
 168                             1, &error_abort);
 169     qemu_opt_set(opts, "backend", "ringbuf", &error_abort);
 170     qemu_opt_set(opts, "size", "128", &error_abort);
 171     qemu_opt_set(opts, "mux", "on", &error_abort);
 172     chr = qemu_chr_new_from_opts(opts, &error_abort);
 173     g_assert_nonnull(chr);
 174     qemu_opts_del(opts);
 175
 176     qemu_chr_fe_init(&chr_be1, chr, &error_abort);
 177     qemu_chr_fe_set_handlers(&chr_be1,
 178                              fe_can_read,
 179                              fe_read,
 180                              fe_event,
 181                              NULL,
 182                              &h1,
 183                              NULL, true);
 184
 185     qemu_chr_fe_init(&chr_be2, chr, &error_abort);
 186     qemu_chr_fe_set_handlers(&chr_be2,
 187                              fe_can_read,
 188                              fe_read,
 189                              fe_event,
 190                              NULL,
 191                              &h2,
 192                              NULL, true);
 193     qemu_chr_fe_take_focus(&chr_be2);
 194
 195     base = qemu_chr_find("mux-label-base");
 196     g_assert_cmpint(qemu_chr_be_can_write(base), !=, 0);
 197
 198     qemu_chr_be_write(base, (void *)"hello", 6);
 199     g_assert_cmpint(h1.read_count, ==, 0);
 200     g_assert_cmpint(h2.read_count, ==, 6);
 201     g_assert_cmpstr(h2.read_buf, ==, "hello");
 202     h2.read_count = 0;
 203
 204     /* switch focus */
 205     qemu_chr_be_write(base, (void *)"\1c", 2);
 206
 207     qemu_chr_be_write(base, (void *)"hello", 6);
 208     g_assert_cmpint(h2.read_count, ==, 0);
 209     g_assert_cmpint(h1.read_count, ==, 6);
 210     g_assert_cmpstr(h1.read_buf, ==, "hello");
 211     h1.read_count = 0;
 212
 213     /* remove first handler */
 214     qemu_chr_fe_set_handlers(&chr_be1, NULL, NULL, NULL, NULL,
 215                              NULL, NULL, true);
 216     qemu_chr_be_write(base, (void *)"hello", 6);
 217     g_assert_cmpint(h1.read_count, ==, 0);
 218     g_assert_cmpint(h2.read_count, ==, 0);
 219
 220     qemu_chr_be_write(base, (void *)"\1c", 2);
 221     qemu_chr_be_write(base, (void *)"hello", 6);
 222     g_assert_cmpint(h1.read_count, ==, 0);
 223     g_assert_cmpint(h2.read_count, ==, 6);
 224     g_assert_cmpstr(h2.read_buf, ==, "hello");
 225     h2.read_count = 0;
 226
 227     /* print help */
 228     qemu_chr_be_write(base, (void *)"\1?", 2);
 229     data = qmp_ringbuf_read("mux-label-base", 128, false, 0, &error_abort);
 230     g_assert_cmpint(strlen(data), !=, 0);
 231     g_free(data);
 232
 233     qemu_chr_fe_deinit(&chr_be1, false);
 234     qemu_chr_fe_deinit(&chr_be2, true);
 235 }
 236
 237 typedef struct SocketIdleData {
 238     GMainLoop *loop;
 239     Chardev *chr;
 240     bool conn_expected;
 241     CharBackend *be;
 242     CharBackend *client_be;
 243 } SocketIdleData;
 244
 245 static gboolean char_socket_test_idle(gpointer user_data)
 246 {
 247     SocketIdleData *data = user_data;
 248
 249     if (object_property_get_bool(OBJECT(data->chr), "connected", NULL)
 250         == data->conn_expected) {
 251         quit = true;
 252         return FALSE;
 253     }
 254
 255     return TRUE;
 256 }
 257
 258 static void socket_read(void *opaque, const uint8_t *buf, int size)
 259 {
 260     SocketIdleData *data = opaque;
 261
 262     g_assert_cmpint(size, ==, 1);
 263     g_assert_cmpint(*buf, ==, 'Z');
 264
 265     size = qemu_chr_fe_write(data->be, (const uint8_t *)"hello", 5);
 266     g_assert_cmpint(size, ==, 5);
 267 }
 268
 269 static int socket_can_read(void *opaque)
 270 {
 271     return 10;
 272 }
 273
 274 static void socket_read_hello(void *opaque, const uint8_t *buf, int size)
 275 {
 276     g_assert_cmpint(size, ==, 5);
 277     g_assert(strncmp((char *)buf, "hello", 5) == 0);
 278
 279     quit = true;
 280 }
 281
 282 static int socket_can_read_hello(void *opaque)
 283 {
 284     return 10;
 285 }
 286
 287 static void char_socket_test(void)
 288 {
 289     Chardev *chr = qemu_chr_new("server", "tcp:127.0.0.1:0,server,nowait");
 290     Chardev *chr_client;
 291     QObject *addr;
 292     QDict *qdict;
 293     const char *port;
 294     SocketIdleData d = { .chr = chr };
 295     CharBackend be;
 296     CharBackend client_be;
 297     char *tmp;
 298
 299     d.be = &be;
 300     d.client_be = &be;
 301
 302     g_assert_nonnull(chr);
 303     g_assert(!object_property_get_bool(OBJECT(chr), "connected", &error_abort));
 304
 305     addr = object_property_get_qobject(OBJECT(chr), "addr", &error_abort);
 306     qdict = qobject_to_qdict(addr);
 307     port = qdict_get_str(qdict, "port");
 308     tmp = g_strdup_printf("tcp:127.0.0.1:%s", port);
 309     QDECREF(qdict);
 310
 311     qemu_chr_fe_init(&be, chr, &error_abort);
 312     qemu_chr_fe_set_handlers(&be, socket_can_read, socket_read,
 313                              NULL, NULL, &d, NULL, true);
 314
 315     chr_client = qemu_chr_new("client", tmp);
 316     qemu_chr_fe_init(&client_be, chr_client, &error_abort);
 317     qemu_chr_fe_set_handlers(&client_be, socket_can_read_hello,
 318                              socket_read_hello,
 319                              NULL, NULL, &d, NULL, true);
 320     g_free(tmp);
 321
 322     d.conn_expected = true;
 323     guint id = g_idle_add(char_socket_test_idle, &d);
 324     g_source_set_name_by_id(id, "test-idle");
 325     g_assert_cmpint(id, >, 0);
 326     main_loop();
 327
 328     g_assert(object_property_get_bool(OBJECT(chr), "connected", &error_abort));
 329     g_assert(object_property_get_bool(OBJECT(chr_client),
 330                                       "connected", &error_abort));
 331
 332     qemu_chr_write_all(chr_client, (const uint8_t *)"Z", 1);
 333     main_loop();
 334
 335     object_unparent(OBJECT(chr_client));
 336
 337     d.conn_expected = false;
 338     g_idle_add(char_socket_test_idle, &d);
 339     main_loop();
 340
 341     object_unparent(OBJECT(chr));
 342 }
 343
 344 #ifndef _WIN32
 345 static void char_pipe_test(void)
 346 {
 347     gchar *tmp_path = g_dir_make_tmp("qemu-test-char.XXXXXX", NULL);
 348     gchar *tmp, *in, *out, *pipe = g_build_filename(tmp_path, "pipe", NULL);
 349     Chardev *chr;
 350     CharBackend be;
 351     int ret, fd;
 352     char buf[10];
 353     FeHandler fe = { 0, };
 354
 355     in = g_strdup_printf("%s.in", pipe);
 356     if (mkfifo(in, 0600) < 0) {
 357         abort();
 358     }
 359     out = g_strdup_printf("%s.out", pipe);
 360     if (mkfifo(out, 0600) < 0) {
 361         abort();
 362     }
 363
 364     tmp = g_strdup_printf("pipe:%s", pipe);
 365     chr = qemu_chr_new("pipe", tmp);
 366     g_assert_nonnull(chr);
 367     g_free(tmp);
 368
 369     qemu_chr_fe_init(&be, chr, &error_abort);
 370
 371     ret = qemu_chr_fe_write(&be, (void *)"pipe-out", 9);
 372     g_assert_cmpint(ret, ==, 9);
 373
 374     fd = open(out, O_RDWR);
 375     ret = read(fd, buf, sizeof(buf));
 376     g_assert_cmpint(ret, ==, 9);
 377     g_assert_cmpstr(buf, ==, "pipe-out");
 378     close(fd);
 379
 380     fd = open(in, O_WRONLY);
 381     ret = write(fd, "pipe-in", 8);
 382     g_assert_cmpint(ret, ==, 8);
 383     close(fd);
 384
 385     qemu_chr_fe_set_handlers(&be,
 386                              fe_can_read,
 387                              fe_read,
 388                              fe_event,
 389                              NULL,
 390                              &fe,
 391                              NULL, true);
 392
 393     main_loop();
 394
 395     g_assert_cmpint(fe.read_count, ==, 8);
 396     g_assert_cmpstr(fe.read_buf, ==, "pipe-in");
 397
 398     qemu_chr_fe_deinit(&be, true);
 399
 400     g_assert(g_unlink(in) == 0);
 401     g_assert(g_unlink(out) == 0);
 402     g_assert(g_rmdir(tmp_path) == 0);
 403     g_free(in);
 404     g_free(out);
 405     g_free(tmp_path);
 406     g_free(pipe);
 407 }
 408 #endif
 409
 410 static int make_udp_socket(int *port)
 411 {
 412     struct sockaddr_in addr = { 0, };
 413     socklen_t alen = sizeof(addr);
 414     int ret, sock = qemu_socket(PF_INET, SOCK_DGRAM, 0);
 415
 416     g_assert_cmpint(sock, >, 0);
 417     addr.sin_family = AF_INET ;
 418     addr.sin_addr.s_addr = htonl(INADDR_ANY);
 419     addr.sin_port = 0;
 420     ret = bind(sock, (struct sockaddr *)&addr, sizeof(addr));
 421     g_assert_cmpint(ret, ==, 0);
 422     ret = getsockname(sock, (struct sockaddr *)&addr, &alen);
 423     g_assert_cmpint(ret, ==, 0);
 424
 425     *port = ntohs(addr.sin_port);
 426     return sock;
 427 }
 428
 429 static void char_udp_test_internal(Chardev *reuse_chr, int sock)
 430 {
 431     struct sockaddr_in other;
 432     SocketIdleData d = { 0, };
 433     Chardev *chr;
 434     CharBackend *be;
 435     socklen_t alen = sizeof(other);
 436     int ret;
 437     char buf[10];
 438     char *tmp = NULL;
 439
 440     if (reuse_chr) {
 441         chr = reuse_chr;
 442         be = chr->be;
 443     } else {
 444         int port;
 445         sock = make_udp_socket(&port);
 446         tmp = g_strdup_printf("udp:127.0.0.1:%d", port);
 447         chr = qemu_chr_new("client", tmp);
 448         g_assert_nonnull(chr);
 449
 450         be = g_alloca(sizeof(CharBackend));
 451         qemu_chr_fe_init(be, chr, &error_abort);
 452     }
 453
 454     d.chr = chr;
 455     qemu_chr_fe_set_handlers(be, socket_can_read_hello, socket_read_hello,
 456                              NULL, NULL, &d, NULL, true);
 457     ret = qemu_chr_write_all(chr, (uint8_t *)"hello", 5);
 458     g_assert_cmpint(ret, ==, 5);
 459
 460     ret = recvfrom(sock, buf, sizeof(buf), 0,
 461                    (struct sockaddr *)&other, &alen);
 462     g_assert_cmpint(ret, ==, 5);
 463     ret = sendto(sock, buf, 5, 0, (struct sockaddr *)&other, alen);
 464     g_assert_cmpint(ret, ==, 5);
 465
 466     main_loop();
 467
 468     if (!reuse_chr) {
 469         close(sock);
 470         qemu_chr_fe_deinit(be, true);
 471     }
 472     g_free(tmp);
 473 }
 474
 475 static void char_udp_test(void)
 476 {
 477     char_udp_test_internal(NULL, 0);
 478 }
 479
 480 #ifdef HAVE_CHARDEV_SERIAL
 481 static void char_serial_test(void)
 482 {
 483     QemuOpts *opts;
 484     Chardev *chr;
 485
 486     opts = qemu_opts_create(qemu_find_opts("chardev"), "serial-id",
 487                             1, &error_abort);
 488     qemu_opt_set(opts, "backend", "serial", &error_abort);
 489     qemu_opt_set(opts, "path", "/dev/null", &error_abort);
 490
 491     chr = qemu_chr_new_from_opts(opts, NULL);
 492     g_assert_nonnull(chr);
 493     /* TODO: add more tests with a pty */
 494     object_unparent(OBJECT(chr));
 495
 496     /* test tty alias */
 497     qemu_opt_set(opts, "backend", "tty", &error_abort);
 498     chr = qemu_chr_new_from_opts(opts, NULL);
 499     g_assert_nonnull(chr);
 500     object_unparent(OBJECT(chr));
 501
 502     qemu_opts_del(opts);
 503 }
 504 #endif
 505
 506 static void char_file_test(void)
 507 {
 508     char *tmp_path = g_dir_make_tmp("qemu-test-char.XXXXXX", NULL);
 509     char *out = g_build_filename(tmp_path, "out", NULL);
 510     char *contents = NULL;
 511     ChardevFile file = { .out = out };
 512     ChardevBackend backend = { .type = CHARDEV_BACKEND_KIND_FILE,
 513                                .u.file.data = &file };
 514     Chardev *chr;
 515     gsize length;
 516     int ret;
 517
 518     chr = qemu_chardev_new(NULL, TYPE_CHARDEV_FILE, &backend,
 519                            &error_abort);
 520     ret = qemu_chr_write_all(chr, (uint8_t *)"hello!", 6);
 521     g_assert_cmpint(ret, ==, 6);
 522     object_unref(OBJECT(chr));
 523
 524     ret = g_file_get_contents(out, &contents, &length, NULL);
 525     g_assert(ret == TRUE);
 526     g_assert_cmpint(length, ==, 6);
 527     g_assert(strncmp(contents, "hello!", 6) == 0);
 528     g_free(contents);
 529
 530 #ifndef _WIN32
 531     {
 532         CharBackend be;
 533         FeHandler fe = { 0, };
 534         char *fifo = g_build_filename(tmp_path, "fifo", NULL);
 535         int fd;
 536
 537         if (mkfifo(fifo, 0600) < 0) {
 538             abort();
 539         }
 540
 541         fd = open(fifo, O_RDWR);
 542         ret = write(fd, "fifo-in", 8);
 543         g_assert_cmpint(ret, ==, 8);
 544
 545         file.in = fifo;
 546         file.has_in = true;
 547         chr = qemu_chardev_new("label-file", TYPE_CHARDEV_FILE, &backend,
 548                                &error_abort);
 549
 550         qemu_chr_fe_init(&be, chr, &error_abort);
 551         qemu_chr_fe_set_handlers(&be,
 552                                  fe_can_read,
 553                                  fe_read,
 554                                  fe_event,
 555                                  NULL,
 556                                  &fe, NULL, true);
 557
 558         g_assert_cmpint(fe.last_event, !=, CHR_EVENT_BREAK);
 559         qmp_chardev_send_break("label-foo", NULL);
 560         g_assert_cmpint(fe.last_event, !=, CHR_EVENT_BREAK);
 561         qmp_chardev_send_break("label-file", NULL);
 562         g_assert_cmpint(fe.last_event, ==, CHR_EVENT_BREAK);
 563
 564         main_loop();
 565
 566         close(fd);
 567
 568         g_assert_cmpint(fe.read_count, ==, 8);
 569         g_assert_cmpstr(fe.read_buf, ==, "fifo-in");
 570         qemu_chr_fe_deinit(&be, true);
 571         g_unlink(fifo);
 572         g_free(fifo);
 573     }
 574 #endif
 575
 576     g_unlink(out);
 577     g_rmdir(tmp_path);
 578     g_free(tmp_path);
 579     g_free(out);
 580 }
 581
 582 static void char_null_test(void)
 583 {
 584     Error *err = NULL;
 585     Chardev *chr;
 586     CharBackend be;
 587     int ret;
 588
 589     chr = qemu_chr_find("label-null");
 590     g_assert_null(chr);
 591
 592     chr = qemu_chr_new("label-null", "null");
 593     chr = qemu_chr_find("label-null");
 594     g_assert_nonnull(chr);
 595
 596     g_assert(qemu_chr_has_feature(chr,
 597                  QEMU_CHAR_FEATURE_FD_PASS) == false);
 598     g_assert(qemu_chr_has_feature(chr,
 599                  QEMU_CHAR_FEATURE_RECONNECTABLE) == false);
 600
 601     /* check max avail */
 602     qemu_chr_fe_init(&be, chr, &error_abort);
 603     qemu_chr_fe_init(&be, chr, &err);
 604     error_free_or_abort(&err);
 605
 606     /* deinit & reinit */
 607     qemu_chr_fe_deinit(&be, false);
 608     qemu_chr_fe_init(&be, chr, &error_abort);
 609
 610     qemu_chr_fe_set_open(&be, true);
 611
 612     qemu_chr_fe_set_handlers(&be,
 613                              fe_can_read,
 614                              fe_read,
 615                              fe_event,
 616                              NULL,
 617                              NULL, NULL, true);
 618
 619     ret = qemu_chr_fe_write(&be, (void *)"buf", 4);
 620     g_assert_cmpint(ret, ==, 4);
 621
 622     qemu_chr_fe_deinit(&be, true);
 623 }
 624
 625 static void char_invalid_test(void)
 626 {
 627     Chardev *chr;
 628
 629     chr = qemu_chr_new("label-invalid", "invalid");
 630     g_assert_null(chr);
 631 }
 632
 633 int main(int argc, char **argv)
 634 {
 635     qemu_init_main_loop(&error_abort);
 636     socket_init();
 637
 638     g_test_init(&argc, &argv, NULL);
 639
 640     module_call_init(MODULE_INIT_QOM);
 641     qemu_add_opts(&qemu_chardev_opts);
 642
 643     g_test_add_func("/char/null", char_null_test);
 644     g_test_add_func("/char/invalid", char_invalid_test);
 645     g_test_add_func("/char/ringbuf", char_ringbuf_test);
 646     g_test_add_func("/char/mux", char_mux_test);
 647 #ifdef CONFIG_HAS_GLIB_SUBPROCESS_TESTS
 648 #ifdef _WIN32
 649     g_test_add_func("/char/console/subprocess", char_console_test_subprocess);
 650     g_test_add_func("/char/console", char_console_test);
 651 #endif
 652     g_test_add_func("/char/stdio/subprocess", char_stdio_test_subprocess);
 653     g_test_add_func("/char/stdio", char_stdio_test);
 654 #endif
 655 #ifndef _WIN32
 656     g_test_add_func("/char/pipe", char_pipe_test);
 657 #endif
 658     g_test_add_func("/char/file", char_file_test);
 659     g_test_add_func("/char/socket", char_socket_test);
 660     g_test_add_func("/char/udp", char_udp_test);
 661 #ifdef HAVE_CHARDEV_SERIAL
 662     g_test_add_func("/char/serial", char_serial_test);
 663 #endif
 664
 665     return g_test_run();
 666 }