tests/test-iov.c

   1 #include "qemu/osdep.h"
   2 #include "qemu-common.h"
   3 #include "qemu/iov.h"
   4 #include "qemu/sockets.h"
   5
   6 /* create a randomly-sized iovec with random vectors */
   7 static void iov_random(struct iovec **iovp, unsigned *iov_cntp)
   8 {
   9      unsigned niov = g_test_rand_int_range(3,8);
  10      struct iovec *iov = g_malloc(niov * sizeof(*iov));
  11      unsigned i;
  12      for (i = 0; i < niov; ++i) {
  13          iov[i].iov_len = g_test_rand_int_range(5,20);
  14          iov[i].iov_base = g_malloc(iov[i].iov_len);
  15      }
  16      *iovp = iov;
  17      *iov_cntp = niov;
  18 }
  19
  20 static void iov_free(struct iovec *iov, unsigned niov)
  21 {
  22     unsigned i;
  23     for (i = 0; i < niov; ++i) {
  24         g_free(iov[i].iov_base);
  25     }
  26     g_free(iov);
  27 }
  28
  29 static bool iov_equals(const struct iovec *a, const struct iovec *b,
  30                        unsigned niov)
  31 {
  32     return memcmp(a, b, sizeof(a[0]) * niov) == 0;
  33 }
  34
  35 static void test_iov_bytes(struct iovec *iov, unsigned niov,
  36                            size_t offset, size_t bytes)
  37 {
  38     unsigned i;
  39     size_t j, o;
  40     unsigned char *b;
  41     o = 0;
  42
  43     /* we walk over all elements, */
  44     for (i = 0; i < niov; ++i) {
  45         b = iov[i].iov_base;
  46         /* over each char of each element, */
  47         for (j = 0; j < iov[i].iov_len; ++j) {
  48             /* counting each of them and
  49              * verifying that the ones within [offset,offset+bytes)
  50              * range are equal to the position number (o) */
  51             if (o >= offset && o < offset + bytes) {
  52                 g_assert(b[j] == (o & 255));
  53             } else {
  54                 g_assert(b[j] == 0xff);
  55             }
  56             ++o;
  57         }
  58     }
  59 }
  60
  61 static void test_to_from_buf_1(void)
  62 {
  63      unsigned niov;
  64      struct iovec *iov;
  65      size_t sz;
  66      unsigned char *ibuf, *obuf;
  67      unsigned i, j, n;
  68
  69      iov_random(&iov, &niov);
  70
  71      sz = iov_size(iov, niov);
  72
  73      ibuf = g_malloc(sz + 8) + 4;
  74      memcpy(ibuf-4, "aaaa", 4); memcpy(ibuf + sz, "bbbb", 4);
  75      obuf = g_malloc(sz + 8) + 4;
  76      memcpy(obuf-4, "xxxx", 4); memcpy(obuf + sz, "yyyy", 4);
  77
  78      /* fill in ibuf with 0123456... */
  79      for (i = 0; i < sz; ++i) {
  80          ibuf[i] = i & 255;
  81      }
  82
  83      for (i = 0; i <= sz; ++i) {
  84
  85          /* Test from/to buf for offset(i) in [0..sz] up to the end of buffer.
  86           * For last iteration with offset == sz, the procedure should
  87           * skip whole vector and process exactly 0 bytes */
  88
  89          /* first set bytes [i..sz) to some "random" value */
  90          n = iov_memset(iov, niov, 0, 0xff, sz);
  91          g_assert(n == sz);
  92
  93          /* next copy bytes [i..sz) from ibuf to iovec */
  94          n = iov_from_buf(iov, niov, i, ibuf + i, sz - i);
  95          g_assert(n == sz - i);
  96
  97          /* clear part of obuf */
  98          memset(obuf + i, 0, sz - i);
  99          /* and set this part of obuf to values from iovec */
 100          n = iov_to_buf(iov, niov, i, obuf + i, sz - i);
 101          g_assert(n == sz - i);
 102
 103          /* now compare resulting buffers */
 104          g_assert(memcmp(ibuf, obuf, sz) == 0);
 105
 106          /* test just one char */
 107          n = iov_to_buf(iov, niov, i, obuf + i, 1);
 108          g_assert(n == (i < sz));
 109          if (n) {
 110              g_assert(obuf[i] == (i & 255));
 111          }
 112
 113          for (j = i; j <= sz; ++j) {
 114              /* now test num of bytes cap up to byte no. j,
 115               * with j in [i..sz]. */
 116
 117              /* clear iovec */
 118              n = iov_memset(iov, niov, 0, 0xff, sz);
 119              g_assert(n == sz);
 120
 121              /* copy bytes [i..j) from ibuf to iovec */
 122              n = iov_from_buf(iov, niov, i, ibuf + i, j - i);
 123              g_assert(n == j - i);
 124
 125              /* clear part of obuf */
 126              memset(obuf + i, 0, j - i);
 127
 128              /* copy bytes [i..j) from iovec to obuf */
 129              n = iov_to_buf(iov, niov, i, obuf + i, j - i);
 130              g_assert(n == j - i);
 131
 132              /* verify result */
 133              g_assert(memcmp(ibuf, obuf, sz) == 0);
 134
 135              /* now actually check if the iovec contains the right data */
 136              test_iov_bytes(iov, niov, i, j - i);
 137          }
 138     }
 139     g_assert(!memcmp(ibuf-4, "aaaa", 4) && !memcmp(ibuf+sz, "bbbb", 4));
 140     g_free(ibuf-4);
 141     g_assert(!memcmp(obuf-4, "xxxx", 4) && !memcmp(obuf+sz, "yyyy", 4));
 142     g_free(obuf-4);
 143     iov_free(iov, niov);
 144 }
 145
 146 static void test_to_from_buf(void)
 147 {
 148     int x;
 149     for (x = 0; x < 4; ++x) {
 150         test_to_from_buf_1();
 151     }
 152 }
 153
 154 static void test_io(void)
 155 {
 156 #ifndef _WIN32
 157 /* socketpair(PF_UNIX) which does not exist on windows */
 158
 159     int sv[2];
 160     int r;
 161     unsigned i, j, k, s, t;
 162     fd_set fds;
 163     unsigned niov;
 164     struct iovec *iov, *siov;
 165     unsigned char *buf;
 166     size_t sz;
 167
 168     iov_random(&iov, &niov);
 169     sz = iov_size(iov, niov);
 170     buf = g_malloc(sz);
 171     for (i = 0; i < sz; ++i) {
 172         buf[i] = i & 255;
 173     }
 174     iov_from_buf(iov, niov, 0, buf, sz);
 175
 176     siov = g_memdup(iov, sizeof(*iov) * niov);
 177
 178     if (socketpair(PF_UNIX, SOCK_STREAM, 0, sv) < 0) {
 179        perror("socketpair");
 180        exit(1);
 181     }
 182
 183     FD_ZERO(&fds);
 184
 185     t = 0;
 186     if (fork() == 0) {
 187        /* writer */
 188
 189        close(sv[0]);
 190        FD_SET(sv[1], &fds);
 191        fcntl(sv[1], F_SETFL, O_RDWR|O_NONBLOCK);
 192        r = g_test_rand_int_range(sz / 2, sz);
 193        setsockopt(sv[1], SOL_SOCKET, SO_SNDBUF, &r, sizeof(r));
 194
 195        for (i = 0; i <= sz; ++i) {
 196            for (j = i; j <= sz; ++j) {
 197                k = i;
 198                do {
 199                    s = g_test_rand_int_range(0, j - k + 1);
 200                    r = iov_send(sv[1], iov, niov, k, s);
 201                    g_assert(memcmp(iov, siov, sizeof(*iov)*niov) == 0);
 202                    if (r >= 0) {
 203                        k += r;
 204                        t += r;
 205                        usleep(g_test_rand_int_range(0, 30));
 206                    } else if (errno == EAGAIN) {
 207                        select(sv[1]+1, NULL, &fds, NULL, NULL);
 208                        continue;
 209                    } else {
 210                        perror("send");
 211                        exit(1);
 212                    }
 213                } while(k < j);
 214            }
 215        }
 216        iov_free(iov, niov);
 217        g_free(buf);
 218        g_free(siov);
 219        exit(0);
 220
 221     } else {
 222        /* reader & verifier */
 223
 224        close(sv[1]);
 225        FD_SET(sv[0], &fds);
 226        fcntl(sv[0], F_SETFL, O_RDWR|O_NONBLOCK);
 227        r = g_test_rand_int_range(sz / 2, sz);
 228        setsockopt(sv[0], SOL_SOCKET, SO_RCVBUF, &r, sizeof(r));
 229        usleep(500000);
 230
 231        for (i = 0; i <= sz; ++i) {
 232            for (j = i; j <= sz; ++j) {
 233                k = i;
 234                iov_memset(iov, niov, 0, 0xff, sz);
 235                do {
 236                    s = g_test_rand_int_range(0, j - k + 1);
 237                    r = iov_recv(sv[0], iov, niov, k, s);
 238                    g_assert(memcmp(iov, siov, sizeof(*iov)*niov) == 0);
 239                    if (r > 0) {
 240                        k += r;
 241                        t += r;
 242                    } else if (!r) {
 243                        if (s) {
 244                            break;
 245                        }
 246                    } else if (errno == EAGAIN) {
 247                        select(sv[0]+1, &fds, NULL, NULL, NULL);
 248                        continue;
 249                    } else {
 250                        perror("recv");
 251                        exit(1);
 252                    }
 253                } while(k < j);
 254                test_iov_bytes(iov, niov, i, j - i);
 255            }
 256         }
 257
 258        iov_free(iov, niov);
 259        g_free(buf);
 260        g_free(siov);
 261      }
 262 #endif
 263 }
 264
 265 static void test_discard_front(void)
 266 {
 267     struct iovec *iov;
 268     struct iovec *iov_tmp;
 269     unsigned int iov_cnt;
 270     unsigned int iov_cnt_tmp;
 271     void *old_base;
 272     size_t size;
 273     size_t ret;
 274
 275     /* Discard zero bytes */
 276     iov_random(&iov, &iov_cnt);
 277     iov_tmp = iov;
 278     iov_cnt_tmp = iov_cnt;
 279     ret = iov_discard_front(&iov_tmp, &iov_cnt_tmp, 0);
 280     g_assert(ret == 0);
 281     g_assert(iov_tmp == iov);
 282     g_assert(iov_cnt_tmp == iov_cnt);
 283     iov_free(iov, iov_cnt);
 284
 285     /* Discard more bytes than vector size */
 286     iov_random(&iov, &iov_cnt);
 287     iov_tmp = iov;
 288     iov_cnt_tmp = iov_cnt;
 289     size = iov_size(iov, iov_cnt);
 290     ret = iov_discard_front(&iov_tmp, &iov_cnt_tmp, size + 1);
 291     g_assert(ret == size);
 292     g_assert(iov_cnt_tmp == 0);
 293     iov_free(iov, iov_cnt);
 294
 295     /* Discard entire vector */
 296     iov_random(&iov, &iov_cnt);
 297     iov_tmp = iov;
 298     iov_cnt_tmp = iov_cnt;
 299     size = iov_size(iov, iov_cnt);
 300     ret = iov_discard_front(&iov_tmp, &iov_cnt_tmp, size);
 301     g_assert(ret == size);
 302     g_assert(iov_cnt_tmp == 0);
 303     iov_free(iov, iov_cnt);
 304
 305     /* Discard within first element */
 306     iov_random(&iov, &iov_cnt);
 307     iov_tmp = iov;
 308     iov_cnt_tmp = iov_cnt;
 309     old_base = iov->iov_base;
 310     size = g_test_rand_int_range(1, iov->iov_len);
 311     ret = iov_discard_front(&iov_tmp, &iov_cnt_tmp, size);
 312     g_assert(ret == size);
 313     g_assert(iov_tmp == iov);
 314     g_assert(iov_cnt_tmp == iov_cnt);
 315     g_assert(iov_tmp->iov_base == old_base + size);
 316     iov_tmp->iov_base = old_base; /* undo before g_free() */
 317     iov_free(iov, iov_cnt);
 318
 319     /* Discard entire first element */
 320     iov_random(&iov, &iov_cnt);
 321     iov_tmp = iov;
 322     iov_cnt_tmp = iov_cnt;
 323     ret = iov_discard_front(&iov_tmp, &iov_cnt_tmp, iov->iov_len);
 324     g_assert(ret == iov->iov_len);
 325     g_assert(iov_tmp == iov + 1);
 326     g_assert(iov_cnt_tmp == iov_cnt - 1);
 327     iov_free(iov, iov_cnt);
 328
 329     /* Discard within second element */
 330     iov_random(&iov, &iov_cnt);
 331     iov_tmp = iov;
 332     iov_cnt_tmp = iov_cnt;
 333     old_base = iov[1].iov_base;
 334     size = iov->iov_len + g_test_rand_int_range(1, iov[1].iov_len);
 335     ret = iov_discard_front(&iov_tmp, &iov_cnt_tmp, size);
 336     g_assert(ret == size);
 337     g_assert(iov_tmp == iov + 1);
 338     g_assert(iov_cnt_tmp == iov_cnt - 1);
 339     g_assert(iov_tmp->iov_base == old_base + (size - iov->iov_len));
 340     iov_tmp->iov_base = old_base; /* undo before g_free() */
 341     iov_free(iov, iov_cnt);
 342 }
 343
 344 static void test_discard_front_undo(void)
 345 {
 346     IOVDiscardUndo undo;
 347     struct iovec *iov;
 348     struct iovec *iov_tmp;
 349     struct iovec *iov_orig;
 350     unsigned int iov_cnt;
 351     unsigned int iov_cnt_tmp;
 352     size_t size;
 353
 354     /* Discard zero bytes */
 355     iov_random(&iov, &iov_cnt);
 356     iov_orig = g_memdup(iov, sizeof(iov[0]) * iov_cnt);
 357     iov_tmp = iov;
 358     iov_cnt_tmp = iov_cnt;
 359     iov_discard_front_undoable(&iov_tmp, &iov_cnt_tmp, 0, &undo);
 360     iov_discard_undo(&undo);
 361     assert(iov_equals(iov, iov_orig, iov_cnt));
 362     g_free(iov_orig);
 363     iov_free(iov, iov_cnt);
 364
 365     /* Discard more bytes than vector size */
 366     iov_random(&iov, &iov_cnt);
 367     iov_orig = g_memdup(iov, sizeof(iov[0]) * iov_cnt);
 368     iov_tmp = iov;
 369     iov_cnt_tmp = iov_cnt;
 370     size = iov_size(iov, iov_cnt);
 371     iov_discard_front_undoable(&iov_tmp, &iov_cnt_tmp, size + 1, &undo);
 372     iov_discard_undo(&undo);
 373     assert(iov_equals(iov, iov_orig, iov_cnt));
 374     g_free(iov_orig);
 375     iov_free(iov, iov_cnt);
 376
 377     /* Discard entire vector */
 378     iov_random(&iov, &iov_cnt);
 379     iov_orig = g_memdup(iov, sizeof(iov[0]) * iov_cnt);
 380     iov_tmp = iov;
 381     iov_cnt_tmp = iov_cnt;
 382     size = iov_size(iov, iov_cnt);
 383     iov_discard_front_undoable(&iov_tmp, &iov_cnt_tmp, size, &undo);
 384     iov_discard_undo(&undo);
 385     assert(iov_equals(iov, iov_orig, iov_cnt));
 386     g_free(iov_orig);
 387     iov_free(iov, iov_cnt);
 388
 389     /* Discard within first element */
 390     iov_random(&iov, &iov_cnt);
 391     iov_orig = g_memdup(iov, sizeof(iov[0]) * iov_cnt);
 392     iov_tmp = iov;
 393     iov_cnt_tmp = iov_cnt;
 394     size = g_test_rand_int_range(1, iov->iov_len);
 395     iov_discard_front_undoable(&iov_tmp, &iov_cnt_tmp, size, &undo);
 396     iov_discard_undo(&undo);
 397     assert(iov_equals(iov, iov_orig, iov_cnt));
 398     g_free(iov_orig);
 399     iov_free(iov, iov_cnt);
 400
 401     /* Discard entire first element */
 402     iov_random(&iov, &iov_cnt);
 403     iov_orig = g_memdup(iov, sizeof(iov[0]) * iov_cnt);
 404     iov_tmp = iov;
 405     iov_cnt_tmp = iov_cnt;
 406     iov_discard_front_undoable(&iov_tmp, &iov_cnt_tmp, iov->iov_len, &undo);
 407     iov_discard_undo(&undo);
 408     assert(iov_equals(iov, iov_orig, iov_cnt));
 409     g_free(iov_orig);
 410     iov_free(iov, iov_cnt);
 411
 412     /* Discard within second element */
 413     iov_random(&iov, &iov_cnt);
 414     iov_orig = g_memdup(iov, sizeof(iov[0]) * iov_cnt);
 415     iov_tmp = iov;
 416     iov_cnt_tmp = iov_cnt;
 417     size = iov->iov_len + g_test_rand_int_range(1, iov[1].iov_len);
 418     iov_discard_front_undoable(&iov_tmp, &iov_cnt_tmp, size, &undo);
 419     iov_discard_undo(&undo);
 420     assert(iov_equals(iov, iov_orig, iov_cnt));
 421     g_free(iov_orig);
 422     iov_free(iov, iov_cnt);
 423 }
 424
 425 static void test_discard_back(void)
 426 {
 427     struct iovec *iov;
 428     unsigned int iov_cnt;
 429     unsigned int iov_cnt_tmp;
 430     void *old_base;
 431     size_t size;
 432     size_t ret;
 433
 434     /* Discard zero bytes */
 435     iov_random(&iov, &iov_cnt);
 436     iov_cnt_tmp = iov_cnt;
 437     ret = iov_discard_back(iov, &iov_cnt_tmp, 0);
 438     g_assert(ret == 0);
 439     g_assert(iov_cnt_tmp == iov_cnt);
 440     iov_free(iov, iov_cnt);
 441
 442     /* Discard more bytes than vector size */
 443     iov_random(&iov, &iov_cnt);
 444     iov_cnt_tmp = iov_cnt;
 445     size = iov_size(iov, iov_cnt);
 446     ret = iov_discard_back(iov, &iov_cnt_tmp, size + 1);
 447     g_assert(ret == size);
 448     g_assert(iov_cnt_tmp == 0);
 449     iov_free(iov, iov_cnt);
 450
 451     /* Discard entire vector */
 452     iov_random(&iov, &iov_cnt);
 453     iov_cnt_tmp = iov_cnt;
 454     size = iov_size(iov, iov_cnt);
 455     ret = iov_discard_back(iov, &iov_cnt_tmp, size);
 456     g_assert(ret == size);
 457     g_assert(iov_cnt_tmp == 0);
 458     iov_free(iov, iov_cnt);
 459
 460     /* Discard within last element */
 461     iov_random(&iov, &iov_cnt);
 462     iov_cnt_tmp = iov_cnt;
 463     old_base = iov[iov_cnt - 1].iov_base;
 464     size = g_test_rand_int_range(1, iov[iov_cnt - 1].iov_len);
 465     ret = iov_discard_back(iov, &iov_cnt_tmp, size);
 466     g_assert(ret == size);
 467     g_assert(iov_cnt_tmp == iov_cnt);
 468     g_assert(iov[iov_cnt - 1].iov_base == old_base);
 469     iov_free(iov, iov_cnt);
 470
 471     /* Discard entire last element */
 472     iov_random(&iov, &iov_cnt);
 473     iov_cnt_tmp = iov_cnt;
 474     old_base = iov[iov_cnt - 1].iov_base;
 475     size = iov[iov_cnt - 1].iov_len;
 476     ret = iov_discard_back(iov, &iov_cnt_tmp, size);
 477     g_assert(ret == size);
 478     g_assert(iov_cnt_tmp == iov_cnt - 1);
 479     iov_free(iov, iov_cnt);
 480
 481     /* Discard within second-to-last element */
 482     iov_random(&iov, &iov_cnt);
 483     iov_cnt_tmp = iov_cnt;
 484     old_base = iov[iov_cnt - 2].iov_base;
 485     size = iov[iov_cnt - 1].iov_len +
 486            g_test_rand_int_range(1, iov[iov_cnt - 2].iov_len);
 487     ret = iov_discard_back(iov, &iov_cnt_tmp, size);
 488     g_assert(ret == size);
 489     g_assert(iov_cnt_tmp == iov_cnt - 1);
 490     g_assert(iov[iov_cnt - 2].iov_base == old_base);
 491     iov_free(iov, iov_cnt);
 492 }
 493
 494 static void test_discard_back_undo(void)
 495 {
 496     IOVDiscardUndo undo;
 497     struct iovec *iov;
 498     struct iovec *iov_orig;
 499     unsigned int iov_cnt;
 500     unsigned int iov_cnt_tmp;
 501     size_t size;
 502
 503     /* Discard zero bytes */
 504     iov_random(&iov, &iov_cnt);
 505     iov_orig = g_memdup(iov, sizeof(iov[0]) * iov_cnt);
 506     iov_cnt_tmp = iov_cnt;
 507     iov_discard_back_undoable(iov, &iov_cnt_tmp, 0, &undo);
 508     iov_discard_undo(&undo);
 509     assert(iov_equals(iov, iov_orig, iov_cnt));
 510     g_free(iov_orig);
 511     iov_free(iov, iov_cnt);
 512
 513     /* Discard more bytes than vector size */
 514     iov_random(&iov, &iov_cnt);
 515     iov_orig = g_memdup(iov, sizeof(iov[0]) * iov_cnt);
 516     iov_cnt_tmp = iov_cnt;
 517     size = iov_size(iov, iov_cnt);
 518     iov_discard_back_undoable(iov, &iov_cnt_tmp, size + 1, &undo);
 519     iov_discard_undo(&undo);
 520     assert(iov_equals(iov, iov_orig, iov_cnt));
 521     g_free(iov_orig);
 522     iov_free(iov, iov_cnt);
 523
 524     /* Discard entire vector */
 525     iov_random(&iov, &iov_cnt);
 526     iov_orig = g_memdup(iov, sizeof(iov[0]) * iov_cnt);
 527     iov_cnt_tmp = iov_cnt;
 528     size = iov_size(iov, iov_cnt);
 529     iov_discard_back_undoable(iov, &iov_cnt_tmp, size, &undo);
 530     iov_discard_undo(&undo);
 531     assert(iov_equals(iov, iov_orig, iov_cnt));
 532     g_free(iov_orig);
 533     iov_free(iov, iov_cnt);
 534
 535     /* Discard within last element */
 536     iov_random(&iov, &iov_cnt);
 537     iov_orig = g_memdup(iov, sizeof(iov[0]) * iov_cnt);
 538     iov_cnt_tmp = iov_cnt;
 539     size = g_test_rand_int_range(1, iov[iov_cnt - 1].iov_len);
 540     iov_discard_back_undoable(iov, &iov_cnt_tmp, size, &undo);
 541     iov_discard_undo(&undo);
 542     assert(iov_equals(iov, iov_orig, iov_cnt));
 543     g_free(iov_orig);
 544     iov_free(iov, iov_cnt);
 545
 546     /* Discard entire last element */
 547     iov_random(&iov, &iov_cnt);
 548     iov_orig = g_memdup(iov, sizeof(iov[0]) * iov_cnt);
 549     iov_cnt_tmp = iov_cnt;
 550     size = iov[iov_cnt - 1].iov_len;
 551     iov_discard_back_undoable(iov, &iov_cnt_tmp, size, &undo);
 552     iov_discard_undo(&undo);
 553     assert(iov_equals(iov, iov_orig, iov_cnt));
 554     g_free(iov_orig);
 555     iov_free(iov, iov_cnt);
 556
 557     /* Discard within second-to-last element */
 558     iov_random(&iov, &iov_cnt);
 559     iov_orig = g_memdup(iov, sizeof(iov[0]) * iov_cnt);
 560     iov_cnt_tmp = iov_cnt;
 561     size = iov[iov_cnt - 1].iov_len +
 562            g_test_rand_int_range(1, iov[iov_cnt - 2].iov_len);
 563     iov_discard_back_undoable(iov, &iov_cnt_tmp, size, &undo);
 564     iov_discard_undo(&undo);
 565     assert(iov_equals(iov, iov_orig, iov_cnt));
 566     g_free(iov_orig);
 567     iov_free(iov, iov_cnt);
 568 }
 569
 570 int main(int argc, char **argv)
 571 {
 572     g_test_init(&argc, &argv, NULL);
 573     g_test_rand_int();
 574     g_test_add_func("/basic/iov/from-to-buf", test_to_from_buf);
 575     g_test_add_func("/basic/iov/io", test_io);
 576     g_test_add_func("/basic/iov/discard-front", test_discard_front);
 577     g_test_add_func("/basic/iov/discard-back", test_discard_back);
 578     g_test_add_func("/basic/iov/discard-front-undo", test_discard_front_undo);
 579     g_test_add_func("/basic/iov/discard-back-undo", test_discard_back_undo);
 580     return g_test_run();
 581 }