test/quic_stream_test.c

   1 /*
   2  * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9 #include "internal/packet.h"
  10 #include "internal/quic_stream.h"
  11 #include "testutil.h"
  12
  13 static int compare_iov(const unsigned char *ref, size_t ref_len,
  14                        const OSSL_QTX_IOVEC *iov, size_t iov_len)
  15 {
  16     size_t i, total_len = 0;
  17     const unsigned char *cur = ref;
  18
  19     for (i = 0; i < iov_len; ++i)
  20         total_len += iov[i].buf_len;
  21
  22     if (ref_len != total_len)
  23         return 0;
  24
  25     for (i = 0; i < iov_len; ++i) {
  26         if (memcmp(cur, iov[i].buf, iov[i].buf_len))
  27             return 0;
  28
  29         cur += iov[i].buf_len;
  30     }
  31
  32     return 1;
  33 }
  34
  35 static const unsigned char data_1[] = {
  36     0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
  37     0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f
  38 };
  39
  40 static int test_sstream_simple(void)
  41 {
  42     int testresult = 0;
  43     QUIC_SSTREAM *sstream = NULL;
  44     OSSL_QUIC_FRAME_STREAM hdr;
  45     OSSL_QTX_IOVEC iov[2];
  46     size_t num_iov = 0, wr = 0, i, init_size = 8192;
  47
  48     if (!TEST_ptr(sstream = ossl_quic_sstream_new(init_size)))
  49         goto err;
  50
  51     /* A stream with nothing yet appended is totally acked */
  52     if (!TEST_true(ossl_quic_sstream_is_totally_acked(sstream)))
  53         goto err;
  54
  55     /* Should not have any data yet */
  56     num_iov = OSSL_NELEM(iov);
  57     if (!TEST_false(ossl_quic_sstream_get_stream_frame(sstream, 0, &hdr, iov,
  58                                                        &num_iov)))
  59         goto err;
  60
  61     /* Append data */
  62     if (!TEST_true(ossl_quic_sstream_append(sstream, data_1, sizeof(data_1),
  63                                             &wr))
  64         || !TEST_size_t_eq(wr, sizeof(data_1)))
  65         goto err;
  66
  67     /* No longer totally acked */
  68     if (!TEST_false(ossl_quic_sstream_is_totally_acked(sstream)))
  69         goto err;
  70
  71     /* Read data */
  72     num_iov = OSSL_NELEM(iov);
  73     if (!TEST_true(ossl_quic_sstream_get_stream_frame(sstream, 0, &hdr, iov,
  74                                                       &num_iov))
  75         || !TEST_size_t_gt(num_iov, 0)
  76         || !TEST_uint64_t_eq(hdr.offset, 0)
  77         || !TEST_uint64_t_eq(hdr.len, sizeof(data_1))
  78         || !TEST_false(hdr.is_fin))
  79         goto err;
  80
  81     if (!TEST_true(compare_iov(data_1, sizeof(data_1), iov, num_iov)))
  82         goto err;
  83
  84     /* Mark data as half transmitted */
  85     if (!TEST_true(ossl_quic_sstream_mark_transmitted(sstream, 0, 7)))
  86         goto err;
  87
  88     /* Read data */
  89     num_iov = OSSL_NELEM(iov);
  90     if (!TEST_true(ossl_quic_sstream_get_stream_frame(sstream, 0, &hdr, iov,
  91                                                       &num_iov))
  92         || !TEST_size_t_gt(num_iov, 0)
  93         || !TEST_uint64_t_eq(hdr.offset, 8)
  94         || !TEST_uint64_t_eq(hdr.len, sizeof(data_1) - 8)
  95         || !TEST_false(hdr.is_fin))
  96         goto err;
  97
  98     if (!TEST_true(compare_iov(data_1 + 8, sizeof(data_1) - 8, iov, num_iov)))
  99         goto err;
 100
 101     if (!TEST_true(ossl_quic_sstream_mark_transmitted(sstream, 8, 15)))
 102         goto err;
 103
 104     /* Read more data; should not be any more */
 105     num_iov = OSSL_NELEM(iov);
 106     if (!TEST_false(ossl_quic_sstream_get_stream_frame(sstream, 0, &hdr, iov,
 107                                                        &num_iov)))
 108         goto err;
 109
 110     /* Now we have lost bytes 4-6 */
 111     if (!TEST_true(ossl_quic_sstream_mark_lost(sstream, 4, 6)))
 112         goto err;
 113
 114     /* Should be able to read them */
 115     num_iov = OSSL_NELEM(iov);
 116     if (!TEST_true(ossl_quic_sstream_get_stream_frame(sstream, 0, &hdr, iov,
 117                                                       &num_iov))
 118         || !TEST_size_t_gt(num_iov, 0)
 119         || !TEST_uint64_t_eq(hdr.offset, 4)
 120         || !TEST_uint64_t_eq(hdr.len, 3)
 121         || !TEST_false(hdr.is_fin))
 122         goto err;
 123
 124     if (!TEST_true(compare_iov(data_1 + 4, 3, iov, num_iov)))
 125         goto err;
 126
 127     /* Retransmit */
 128     if (!TEST_true(ossl_quic_sstream_mark_transmitted(sstream, 4, 6)))
 129         goto err;
 130
 131     /* Read more data; should not be any more */
 132     num_iov = OSSL_NELEM(iov);
 133     if (!TEST_false(ossl_quic_sstream_get_stream_frame(sstream, 0, &hdr, iov,
 134                                                        &num_iov)))
 135         goto err;
 136
 137     if (!TEST_size_t_eq(ossl_quic_sstream_get_buffer_used(sstream), 16))
 138         goto err;
 139
 140     /* Data has been acknowledged, space should be not be freed yet */
 141     if (!TEST_true(ossl_quic_sstream_mark_acked(sstream, 1, 7))
 142         || !TEST_size_t_eq(ossl_quic_sstream_get_buffer_used(sstream), 16))
 143         goto err;
 144
 145     /* Now data should be freed */
 146     if (!TEST_true(ossl_quic_sstream_mark_acked(sstream, 0, 0))
 147         || !TEST_size_t_eq(ossl_quic_sstream_get_buffer_used(sstream), 8))
 148         goto err;
 149
 150     if (!TEST_true(ossl_quic_sstream_mark_acked(sstream, 0, 15))
 151         || !TEST_size_t_eq(ossl_quic_sstream_get_buffer_used(sstream), 0))
 152         goto err;
 153
 154     /* Now FIN */
 155     ossl_quic_sstream_fin(sstream);
 156
 157     /* Get FIN frame */
 158     for (i = 0; i < 2; ++i) {
 159         num_iov = OSSL_NELEM(iov);
 160         if (!TEST_true(ossl_quic_sstream_get_stream_frame(sstream, 0, &hdr, iov,
 161                                                           &num_iov))
 162             || !TEST_uint64_t_eq(hdr.offset, 16)
 163             || !TEST_uint64_t_eq(hdr.len, 0)
 164             || !TEST_true(hdr.is_fin)
 165             || !TEST_size_t_eq(num_iov, 0))
 166             goto err;
 167     }
 168
 169     if (!TEST_true(ossl_quic_sstream_mark_transmitted_fin(sstream, 16)))
 170         goto err;
 171
 172     /* Read more data; FIN should not be returned any more */
 173     num_iov = OSSL_NELEM(iov);
 174     if (!TEST_false(ossl_quic_sstream_get_stream_frame(sstream, 0, &hdr, iov,
 175                                                        &num_iov)))
 176         goto err;
 177
 178     /* Lose FIN frame */
 179     if (!TEST_true(ossl_quic_sstream_mark_lost_fin(sstream)))
 180         goto err;
 181
 182     /* Get FIN frame */
 183     for (i = 0; i < 2; ++i) {
 184         num_iov = OSSL_NELEM(iov);
 185         if (!TEST_true(ossl_quic_sstream_get_stream_frame(sstream, 0, &hdr, iov,
 186                                                           &num_iov))
 187             || !TEST_uint64_t_eq(hdr.offset, 16)
 188             || !TEST_uint64_t_eq(hdr.len, 0)
 189             || !TEST_true(hdr.is_fin)
 190             || !TEST_size_t_eq(num_iov, 0))
 191             goto err;
 192     }
 193
 194     if (!TEST_true(ossl_quic_sstream_mark_transmitted_fin(sstream, 16)))
 195         goto err;
 196
 197     /* Read more data; FIN should not be returned any more */
 198     num_iov = OSSL_NELEM(iov);
 199     if (!TEST_false(ossl_quic_sstream_get_stream_frame(sstream, 0, &hdr, iov,
 200                                                        &num_iov)))
 201         goto err;
 202
 203     /* Acknowledge fin. */
 204     if (!TEST_true(ossl_quic_sstream_mark_acked_fin(sstream)))
 205         goto err;
 206
 207     if (!TEST_true(ossl_quic_sstream_is_totally_acked(sstream)))
 208         goto err;
 209
 210     testresult = 1;
 211  err:
 212     ossl_quic_sstream_free(sstream);
 213     return testresult;
 214 }
 215
 216 static int test_sstream_bulk(int idx)
 217 {
 218     int testresult = 0;
 219     QUIC_SSTREAM *sstream = NULL;
 220     OSSL_QUIC_FRAME_STREAM hdr;
 221     OSSL_QTX_IOVEC iov[2];
 222     size_t i, j, num_iov = 0, init_size = 8192, l;
 223     size_t consumed = 0, total_written = 0, rd, cur_rd, expected = 0, start_at;
 224     unsigned char *src_buf = NULL, *dst_buf = NULL;
 225     unsigned char *ref_src_buf = NULL, *ref_dst_buf = NULL;
 226     unsigned char *ref_dst_cur, *ref_src_cur, *dst_cur;
 227
 228     if (!TEST_ptr(sstream = ossl_quic_sstream_new(init_size)))
 229         goto err;
 230
 231     if (!TEST_size_t_eq(ossl_quic_sstream_get_buffer_size(sstream), init_size))
 232         goto err;
 233
 234     if (!TEST_ptr(src_buf = OPENSSL_zalloc(init_size)))
 235         goto err;
 236
 237     if (!TEST_ptr(dst_buf = OPENSSL_malloc(init_size)))
 238         goto err;
 239
 240     if (!TEST_ptr(ref_src_buf = OPENSSL_malloc(init_size)))
 241         goto err;
 242
 243     if (!TEST_ptr(ref_dst_buf = OPENSSL_malloc(init_size)))
 244         goto err;
 245
 246     /*
 247      * Append a preliminary buffer to allow later code to exercise wraparound.
 248      */
 249     if (!TEST_true(ossl_quic_sstream_append(sstream, src_buf, init_size / 2,
 250                                             &consumed))
 251         || !TEST_size_t_eq(consumed, init_size / 2)
 252         || !TEST_true(ossl_quic_sstream_mark_transmitted(sstream, 0,
 253                                                          init_size / 2 - 1))
 254         || !TEST_true(ossl_quic_sstream_mark_acked(sstream, 0,
 255                                                    init_size / 2 - 1)))
 256         goto err;
 257
 258     start_at = init_size / 2;
 259
 260     /* Generate a random buffer. */
 261     for (i = 0; i < init_size; ++i)
 262         src_buf[i] = (unsigned char)(test_random() & 0xFF);
 263
 264     /* Append bytes into the buffer in chunks of random length. */
 265     ref_src_cur = ref_src_buf;
 266     do {
 267         l = (test_random() % init_size) + 1;
 268         if (!TEST_true(ossl_quic_sstream_append(sstream, src_buf, l, &consumed)))
 269             goto err;
 270
 271         memcpy(ref_src_cur, src_buf, consumed);
 272         ref_src_cur     += consumed;
 273         total_written   += consumed;
 274     } while (consumed > 0);
 275
 276     if (!TEST_size_t_eq(ossl_quic_sstream_get_buffer_used(sstream), init_size)
 277         || !TEST_size_t_eq(ossl_quic_sstream_get_buffer_avail(sstream), 0))
 278         goto err;
 279
 280     /*
 281      * Randomly select bytes out of the buffer by marking them as transmitted.
 282      * Record the remaining bytes, which should be the sequence of bytes
 283      * returned.
 284      */
 285     ref_src_cur = ref_src_buf;
 286     ref_dst_cur = ref_dst_buf;
 287     for (i = 0; i < total_written; ++i) {
 288         if ((test_random() & 1) != 0) {
 289             *ref_dst_cur++ = *ref_src_cur;
 290             ++expected;
 291         } else if (!TEST_true(ossl_quic_sstream_mark_transmitted(sstream,
 292                                                                  start_at + i,
 293                                                                  start_at + i)))
 294             goto err;
 295
 296         ++ref_src_cur;
 297     }
 298
 299     /* Exercise resize. */
 300     if (!TEST_true(ossl_quic_sstream_set_buffer_size(sstream, init_size * 2))
 301         || !TEST_true(ossl_quic_sstream_set_buffer_size(sstream, init_size)))
 302         goto err;
 303
 304     /* Readout and verification. */
 305     dst_cur = dst_buf;
 306     for (i = 0, rd = 0; rd < expected; ++i) {
 307         num_iov = OSSL_NELEM(iov);
 308         if (!TEST_true(ossl_quic_sstream_get_stream_frame(sstream, i, &hdr, iov,
 309                                                           &num_iov)))
 310             goto err;
 311
 312         cur_rd = 0;
 313         for (j = 0; j < num_iov; ++j) {
 314             if (!TEST_size_t_le(iov[j].buf_len + rd, expected))
 315                 goto err;
 316
 317             memcpy(dst_cur, iov[j].buf, iov[j].buf_len);
 318             dst_cur += iov[j].buf_len;
 319             cur_rd  += iov[j].buf_len;
 320         }
 321
 322         if (!TEST_uint64_t_eq(cur_rd, hdr.len))
 323             goto err;
 324
 325         rd += cur_rd;
 326     }
 327
 328     if (!TEST_mem_eq(dst_buf, rd, ref_dst_buf, expected))
 329         goto err;
 330
 331     testresult = 1;
 332  err:
 333     OPENSSL_free(src_buf);
 334     OPENSSL_free(dst_buf);
 335     OPENSSL_free(ref_src_buf);
 336     OPENSSL_free(ref_dst_buf);
 337     ossl_quic_sstream_free(sstream);
 338     return testresult;
 339 }
 340
 341 static int test_single_copy_read(QUIC_RSTREAM *qrs,
 342                                  unsigned char *buf, size_t size,
 343                                  size_t *readbytes, int *fin)
 344 {
 345     const unsigned char *record;
 346     size_t rec_len;
 347
 348     *readbytes = 0;
 349
 350     for (;;) {
 351         if (!ossl_quic_rstream_get_record(qrs, &record, &rec_len, fin))
 352             return 0;
 353         if (rec_len == 0)
 354             break;
 355         if (rec_len > size) {
 356             rec_len = size;
 357             *fin = 0;
 358         }
 359         memcpy(buf, record, rec_len);
 360         size -= rec_len;
 361         *readbytes += rec_len;
 362         buf += rec_len;
 363
 364         if (!ossl_quic_rstream_release_record(qrs, rec_len))
 365             return 0;
 366         if (*fin || size == 0)
 367             break;
 368     }
 369
 370     return 1;
 371 }
 372
 373 static const unsigned char simple_data[] =
 374     "Hello world! And thank you for all the fish!";
 375
 376 static int test_rstream_simple(int idx)
 377 {
 378     QUIC_RSTREAM *rstream = NULL;
 379     int ret = 0;
 380     unsigned char buf[sizeof(simple_data)];
 381     size_t readbytes = 0, avail = 0;
 382     int fin = 0;
 383     int use_rbuf = idx > 1;
 384     int use_sc = idx % 2;
 385     int (* read_fn)(QUIC_RSTREAM *, unsigned char *, size_t, size_t *,
 386                     int *) = use_sc ? test_single_copy_read
 387                                     : ossl_quic_rstream_read;
 388
 389     if (!TEST_ptr(rstream = ossl_quic_rstream_new(NULL, NULL, 0)))
 390         goto err;
 391
 392     if (!TEST_true(ossl_quic_rstream_queue_data(rstream, NULL, 5,
 393                                                 simple_data + 5, 10, 0))
 394         || !TEST_true(ossl_quic_rstream_queue_data(rstream, NULL,
 395                                                    sizeof(simple_data) - 1,
 396                                                    simple_data + sizeof(simple_data) - 1,
 397                                                    1, 1))
 398         || !TEST_true(ossl_quic_rstream_peek(rstream, buf, sizeof(buf),
 399                                              &readbytes, &fin))
 400         || !TEST_false(fin)
 401         || !TEST_size_t_eq(readbytes, 0)
 402         || !TEST_true(ossl_quic_rstream_queue_data(rstream, NULL,
 403                                                    sizeof(simple_data) - 10,
 404                                                    simple_data + sizeof(simple_data) - 10,
 405                                                    10, 1))
 406         || !TEST_true(ossl_quic_rstream_queue_data(rstream, NULL, 0,
 407                                                    simple_data, 1, 0))
 408         || !TEST_true(ossl_quic_rstream_peek(rstream, buf, sizeof(buf),
 409                                              &readbytes, &fin))
 410         || !TEST_false(fin)
 411         || !TEST_size_t_eq(readbytes, 1)
 412         || !TEST_mem_eq(buf, 1, simple_data, 1)
 413         || (use_rbuf && !TEST_false(ossl_quic_rstream_move_to_rbuf(rstream)))
 414         || (use_rbuf
 415             && !TEST_true(ossl_quic_rstream_resize_rbuf(rstream,
 416                                                         sizeof(simple_data))))
 417         || (use_rbuf && !TEST_true(ossl_quic_rstream_move_to_rbuf(rstream)))
 418         || !TEST_true(ossl_quic_rstream_queue_data(rstream, NULL,
 419                                                    0, simple_data,
 420                                                    10, 0))
 421         || !TEST_true(ossl_quic_rstream_queue_data(rstream, NULL,
 422                                                    sizeof(simple_data),
 423                                                    NULL,
 424                                                    0, 1))
 425         || !TEST_true(ossl_quic_rstream_peek(rstream, buf, sizeof(buf),
 426                                              &readbytes, &fin))
 427         || !TEST_false(fin)
 428         || !TEST_size_t_eq(readbytes, 15)
 429         || !TEST_mem_eq(buf, 15, simple_data, 15)
 430         || !TEST_true(ossl_quic_rstream_queue_data(rstream, NULL,
 431                                                    15,
 432                                                    simple_data + 15,
 433                                                    sizeof(simple_data) - 15, 1))
 434         || !TEST_true(ossl_quic_rstream_available(rstream, &avail, &fin))
 435         || !TEST_true(fin)
 436         || !TEST_size_t_eq(avail, sizeof(simple_data))
 437         || !TEST_true(read_fn(rstream, buf, 2, &readbytes, &fin))
 438         || !TEST_false(fin)
 439         || !TEST_size_t_eq(readbytes, 2)
 440         || !TEST_mem_eq(buf, 2, simple_data, 2)
 441         || !TEST_true(read_fn(rstream, buf + 2, 12, &readbytes, &fin))
 442         || !TEST_false(fin)
 443         || !TEST_size_t_eq(readbytes, 12)
 444         || !TEST_mem_eq(buf + 2, 12, simple_data + 2, 12)
 445         || !TEST_true(ossl_quic_rstream_queue_data(rstream, NULL,
 446                                                    sizeof(simple_data),
 447                                                    NULL,
 448                                                    0, 1))
 449         || (use_rbuf
 450             && !TEST_true(ossl_quic_rstream_resize_rbuf(rstream,
 451                                                         2 * sizeof(simple_data))))
 452         || (use_rbuf && !TEST_true(ossl_quic_rstream_move_to_rbuf(rstream)))
 453         || !TEST_true(read_fn(rstream, buf + 14, 5, &readbytes, &fin))
 454         || !TEST_false(fin)
 455         || !TEST_size_t_eq(readbytes, 5)
 456         || !TEST_mem_eq(buf, 14 + 5, simple_data, 14 + 5)
 457         || !TEST_true(read_fn(rstream, buf + 14 + 5, sizeof(buf) - 14 - 5,
 458                               &readbytes, &fin))
 459         || !TEST_true(fin)
 460         || !TEST_size_t_eq(readbytes, sizeof(buf) - 14 - 5)
 461         || !TEST_mem_eq(buf, sizeof(buf), simple_data, sizeof(simple_data))
 462         || (use_rbuf && !TEST_true(ossl_quic_rstream_move_to_rbuf(rstream)))
 463         || !TEST_true(read_fn(rstream, buf, sizeof(buf), &readbytes, &fin))
 464         || !TEST_true(fin)
 465         || !TEST_size_t_eq(readbytes, 0))
 466         goto err;
 467
 468     ret = 1;
 469
 470  err:
 471     ossl_quic_rstream_free(rstream);
 472     return ret;
 473 }
 474
 475 static int test_rstream_random(int idx)
 476 {
 477     unsigned char *bulk_data = NULL;
 478     unsigned char *read_buf = NULL;
 479     QUIC_RSTREAM *rstream = NULL;
 480     size_t i, read_off, queued_min, queued_max;
 481     const size_t data_size = 10000;
 482     int r, s, fin = 0, fin_set = 0;
 483     int ret = 0;
 484     size_t readbytes = 0;
 485
 486     if (!TEST_ptr(bulk_data = OPENSSL_malloc(data_size))
 487         || !TEST_ptr(read_buf = OPENSSL_malloc(data_size))
 488         || !TEST_ptr(rstream = ossl_quic_rstream_new(NULL, NULL, 0)))
 489         goto err;
 490
 491     if (idx % 3 == 0)
 492         ossl_quic_rstream_set_cleanse(rstream, 1);
 493
 494     for (i = 0; i < data_size; ++i)
 495         bulk_data[i] = (unsigned char)(test_random() & 0xFF);
 496
 497     read_off = queued_min = queued_max = 0;
 498     for (r = 0; r < 100; ++r) {
 499         for (s = 0; s < 10; ++s) {
 500             size_t off = (r * 10 + s) * 10, size = 10;
 501
 502             if (test_random() % 10 == 0)
 503                 /* drop packet */
 504                 continue;
 505
 506             if (off <= queued_min && off + size > queued_min)
 507                 queued_min = off + size;
 508
 509             if (!TEST_true(ossl_quic_rstream_queue_data(rstream, NULL, off,
 510                                                         bulk_data + off,
 511                                                         size, 0)))
 512                 goto err;
 513             if (queued_max < off + size)
 514                 queued_max = off + size;
 515
 516             if (test_random() % 5 != 0)
 517                continue;
 518
 519             /* random overlapping retransmit */
 520             off = read_off + test_random() % 50;
 521             if (off > 50)
 522                 off -= 50;
 523             size = test_random() % 100 + 1;
 524             if (off + size > data_size)
 525                 off = data_size - size;
 526             if (off <= queued_min && off + size > queued_min)
 527                 queued_min = off + size;
 528
 529             if (!TEST_true(ossl_quic_rstream_queue_data(rstream, NULL, off,
 530                                                         bulk_data + off,
 531                                                         size, 0)))
 532                 goto err;
 533             if (queued_max < off + size)
 534                 queued_max = off + size;
 535         }
 536         if (idx % 2 == 0) {
 537             if (!TEST_true(test_single_copy_read(rstream, read_buf, data_size,
 538                                                  &readbytes, &fin)))
 539                 goto err;
 540         } else if (!TEST_true(ossl_quic_rstream_read(rstream, read_buf,
 541                                                      data_size,
 542                                                      &readbytes, &fin))) {
 543             goto err;
 544         }
 545         if (!TEST_size_t_ge(readbytes, queued_min - read_off)
 546             || !TEST_size_t_le(readbytes + read_off, data_size)
 547             || (idx % 3 != 0
 548                 && !TEST_mem_eq(read_buf, readbytes, bulk_data + read_off,
 549                                 readbytes)))
 550             goto err;
 551         read_off += readbytes;
 552         queued_min = read_off;
 553         if (test_random() % 50 == 0)
 554             if (!TEST_true(ossl_quic_rstream_resize_rbuf(rstream,
 555                                                          queued_max - read_off + 1))
 556                 || !TEST_true(ossl_quic_rstream_move_to_rbuf(rstream)))
 557                 goto err;
 558         if (!fin_set && queued_max >= data_size - test_random() % 200) {
 559             fin_set = 1;
 560             /* Queue empty fin frame */
 561             if (!TEST_true(ossl_quic_rstream_queue_data(rstream, NULL, data_size,
 562                                                         NULL, 0, 1)))
 563                 goto err;
 564         }
 565     }
 566
 567     TEST_info("Total read bytes: %zu Fin rcvd: %d", read_off, fin);
 568
 569     if (idx % 3 == 0)
 570         for (i = 0; i < read_off; i++)
 571             if (!TEST_uchar_eq(bulk_data[i], 0))
 572                 goto err;
 573
 574     if (read_off == data_size && fin_set && !fin) {
 575         /* We might still receive the final empty frame */
 576         if (idx % 2 == 0) {
 577             if (!TEST_true(test_single_copy_read(rstream, read_buf, data_size,
 578                                                  &readbytes, &fin)))
 579                 goto err;
 580         } else if (!TEST_true(ossl_quic_rstream_read(rstream, read_buf,
 581                                                      data_size,
 582                                                      &readbytes, &fin))) {
 583             goto err;
 584         }
 585         if (!TEST_size_t_eq(readbytes, 0) || !TEST_true(fin))
 586             goto err;
 587     }
 588
 589     ret = 1;
 590
 591  err:
 592     ossl_quic_rstream_free(rstream);
 593     OPENSSL_free(bulk_data);
 594     OPENSSL_free(read_buf);
 595     return ret;
 596 }
 597
 598 int setup_tests(void)
 599 {
 600     ADD_TEST(test_sstream_simple);
 601     ADD_ALL_TESTS(test_sstream_bulk, 100);
 602     ADD_ALL_TESTS(test_rstream_simple, 4);
 603     ADD_ALL_TESTS(test_rstream_random, 100);
 604     return 1;
 605 }