test/quic_txp_test.c

   1 /*
   2  * Copyright 2022 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_txp.h"
  11 #include "internal/quic_statm.h"
  12 #include "internal/quic_demux.h"
  13 #include "internal/quic_record_rx.h"
  14 #include "testutil.h"
  15 #include "quic_record_test_util.h"
  16
  17 static const QUIC_CONN_ID scid_1 = {
  18     1, { 0x5f }
  19 };
  20
  21 static const QUIC_CONN_ID dcid_1 = {
  22     8, { 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8 }
  23 };
  24
  25 static const QUIC_CONN_ID cid_1 = {
  26     8, { 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8 }
  27 };
  28
  29 static const unsigned char reset_token_1[16] = {
  30     0x99, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11,
  31     0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x12,
  32 };
  33
  34 static const unsigned char secret_1[32] = {
  35     0x01
  36 };
  37
  38 static OSSL_TIME fake_now(void *arg)
  39 {
  40     return ossl_time_now(); /* TODO */
  41 }
  42
  43 struct helper {
  44     OSSL_QUIC_TX_PACKETISER         *txp;
  45     OSSL_QUIC_TX_PACKETISER_ARGS    args;
  46     OSSL_QTX_ARGS                   qtx_args;
  47     BIO                             *bio1, *bio2;
  48     QUIC_TXFC                       conn_txfc;
  49     QUIC_RXFC                       conn_rxfc, stream_rxfc;
  50     QUIC_RXFC                       max_streams_bidi_rxfc, max_streams_uni_rxfc;
  51     OSSL_STATM                      statm;
  52     OSSL_CC_DATA                    *cc_data;
  53     const OSSL_CC_METHOD            *cc_method;
  54     QUIC_STREAM_MAP                 qsm;
  55     char                            have_statm, have_qsm;
  56     QUIC_DEMUX                      *demux;
  57     OSSL_QRX                        *qrx;
  58     OSSL_QRX_ARGS                   qrx_args;
  59     OSSL_QRX_PKT                    *qrx_pkt;
  60     PACKET                          pkt;
  61     uint64_t                        frame_type;
  62     union {
  63         uint64_t                        max_data;
  64         OSSL_QUIC_FRAME_NEW_CONN_ID     new_conn_id;
  65         OSSL_QUIC_FRAME_ACK             ack;
  66         struct {
  67             const unsigned char *token;
  68             size_t              token_len;
  69         } new_token;
  70         OSSL_QUIC_FRAME_CRYPTO          crypto;
  71         OSSL_QUIC_FRAME_STREAM          stream;
  72         OSSL_QUIC_FRAME_STOP_SENDING    stop_sending;
  73         OSSL_QUIC_FRAME_RESET_STREAM    reset_stream;
  74         OSSL_QUIC_FRAME_CONN_CLOSE      conn_close;
  75     } frame;
  76     OSSL_QUIC_ACK_RANGE     ack_ranges[16];
  77 };
  78
  79 static void helper_cleanup(struct helper *h)
  80 {
  81     size_t i;
  82     uint32_t pn_space;
  83
  84     ossl_qrx_pkt_release(h->qrx_pkt);
  85     h->qrx_pkt = NULL;
  86
  87     for (pn_space = QUIC_PN_SPACE_INITIAL;
  88          pn_space < QUIC_PN_SPACE_NUM;
  89          ++pn_space)
  90         ossl_ackm_on_pkt_space_discarded(h->args.ackm, pn_space);
  91
  92     ossl_quic_tx_packetiser_free(h->txp);
  93     ossl_qtx_free(h->args.qtx);
  94     ossl_quic_txpim_free(h->args.txpim);
  95     ossl_quic_cfq_free(h->args.cfq);
  96     if (h->cc_data != NULL)
  97         h->cc_method->free(h->cc_data);
  98     if (h->have_statm)
  99         ossl_statm_destroy(&h->statm);
 100     if (h->have_qsm)
 101         ossl_quic_stream_map_cleanup(&h->qsm);
 102     for (i = 0; i < QUIC_PN_SPACE_NUM; ++i)
 103         ossl_quic_sstream_free(h->args.crypto[i]);
 104     ossl_ackm_free(h->args.ackm);
 105     ossl_qrx_free(h->qrx);
 106     ossl_quic_demux_free(h->demux);
 107     BIO_free(h->bio1);
 108     BIO_free(h->bio2);
 109 }
 110
 111 static int helper_init(struct helper *h)
 112 {
 113     int rc = 0;
 114     size_t i;
 115
 116     memset(h, 0, sizeof(*h));
 117
 118     /* Initialisation */
 119     if (!TEST_true(BIO_new_bio_dgram_pair(&h->bio1, 0, &h->bio2, 0)))
 120         goto err;
 121
 122     h->qtx_args.bio    = h->bio1;
 123     h->qtx_args.mdpl   = 1200;
 124
 125     if (!TEST_ptr(h->args.qtx = ossl_qtx_new(&h->qtx_args)))
 126         goto err;
 127
 128     if (!TEST_ptr(h->args.txpim = ossl_quic_txpim_new()))
 129         goto err;
 130
 131     if (!TEST_ptr(h->args.cfq = ossl_quic_cfq_new()))
 132         goto err;
 133
 134     if (!TEST_true(ossl_quic_txfc_init(&h->conn_txfc, NULL)))
 135         goto err;
 136
 137     if (!TEST_true(ossl_quic_rxfc_init(&h->conn_rxfc, NULL,
 138                                        2 * 1024 * 1024,
 139                                        10 * 1024 * 1024,
 140                                        fake_now,
 141                                        NULL)))
 142         goto err;
 143
 144     if (!TEST_true(ossl_quic_rxfc_init(&h->stream_rxfc, &h->conn_rxfc,
 145                                        1 * 1024 * 1024,
 146                                        5 * 1024 * 1024,
 147                                        fake_now,
 148                                        NULL)))
 149         goto err;
 150
 151     if (!TEST_true(ossl_quic_rxfc_init(&h->max_streams_bidi_rxfc, NULL,
 152                                        100, 100,
 153                                        fake_now,
 154                                        NULL)))
 155         goto err;
 156
 157     if (!TEST_true(ossl_quic_rxfc_init(&h->max_streams_uni_rxfc, NULL,
 158                                        100, 100,
 159                                        fake_now,
 160                                        NULL)))
 161
 162     if (!TEST_true(ossl_statm_init(&h->statm)))
 163         goto err;
 164
 165     h->have_statm = 1;
 166
 167     h->cc_method = &ossl_cc_dummy_method;
 168     if (!TEST_ptr(h->cc_data = h->cc_method->new(fake_now, NULL)))
 169         goto err;
 170
 171     if (!TEST_ptr(h->args.ackm = ossl_ackm_new(fake_now, NULL,
 172                                                &h->statm,
 173                                                h->cc_method,
 174                                                h->cc_data)))
 175         goto err;
 176
 177     if (!TEST_true(ossl_quic_stream_map_init(&h->qsm, NULL, NULL,
 178                                              &h->max_streams_bidi_rxfc,
 179                                              &h->max_streams_uni_rxfc,
 180                                              /*is_server=*/0)))
 181         goto err;
 182
 183     h->have_qsm = 1;
 184
 185     for (i = 0; i < QUIC_PN_SPACE_NUM; ++i)
 186         if (!TEST_ptr(h->args.crypto[i] = ossl_quic_sstream_new(4096)))
 187             goto err;
 188
 189     h->args.cur_scid                = scid_1;
 190     h->args.cur_dcid                = dcid_1;
 191     h->args.qsm                     = &h->qsm;
 192     h->args.conn_txfc               = &h->conn_txfc;
 193     h->args.conn_rxfc               = &h->conn_rxfc;
 194     h->args.max_streams_bidi_rxfc   = &h->max_streams_bidi_rxfc;
 195     h->args.max_streams_uni_rxfc    = &h->max_streams_uni_rxfc;
 196     h->args.cc_method               = h->cc_method;
 197     h->args.cc_data                 = h->cc_data;
 198     h->args.now                     = fake_now;
 199
 200     if (!TEST_ptr(h->txp = ossl_quic_tx_packetiser_new(&h->args)))
 201         goto err;
 202
 203     if (!TEST_ptr(h->demux = ossl_quic_demux_new(h->bio2, 8,
 204                                                  fake_now, NULL)))
 205         goto err;
 206
 207     h->qrx_args.demux                  = h->demux;
 208     h->qrx_args.short_conn_id_len      = 8;
 209     h->qrx_args.max_deferred           = 32;
 210
 211     if (!TEST_ptr(h->qrx = ossl_qrx_new(&h->qrx_args)))
 212         goto err;
 213
 214     if (!TEST_true(ossl_qrx_add_dst_conn_id(h->qrx, &dcid_1)))
 215         goto err;
 216
 217     rc = 1;
 218 err:
 219     if (!rc)
 220         helper_cleanup(h);
 221
 222     return rc;
 223 }
 224
 225 #define OPK_END                     0   /* End of Script */
 226 #define OPK_TXP_GENERATE            1   /* Call generate, expect packet output */
 227 #define OPK_TXP_GENERATE_NONE       2   /* Call generate, expect no packet output */
 228 #define OPK_RX_PKT                  3   /* Receive, expect packet */
 229 #define OPK_RX_PKT_NONE             4   /* Receive, expect no packet */
 230 #define OPK_EXPECT_DGRAM_LEN        5   /* Expect received datagram length in range */
 231 #define OPK_EXPECT_FRAME            6   /* Expect next frame is of type */
 232 #define OPK_EXPECT_INITIAL_TOKEN    7   /* Expect initial token buffer match */
 233 #define OPK_EXPECT_HDR              8   /* Expect header structure match */
 234 #define OPK_CHECK                   9   /* Call check function */
 235 #define OPK_NEXT_FRAME              10  /* Next frame */
 236 #define OPK_EXPECT_NO_FRAME         11  /* Expect no further frames */
 237 #define OPK_PROVIDE_SECRET          12  /* Provide secret to QTX and QRX */
 238 #define OPK_DISCARD_EL              13  /* Discard QTX EL */
 239 #define OPK_CRYPTO_SEND             14  /* Push data into crypto send stream */
 240 #define OPK_STREAM_NEW              15  /* Create new application stream */
 241 #define OPK_STREAM_SEND             16  /* Push data into application send stream */
 242 #define OPK_STREAM_FIN              17  /* Mark stream as finished */
 243 #define OPK_STOP_SENDING            18  /* Mark stream for STOP_SENDING */
 244 #define OPK_RESET_STREAM            19  /* Mark stream for RESET_STREAM */
 245 #define OPK_CONN_TXFC_BUMP          20  /* Bump connection TXFC CWM */
 246 #define OPK_STREAM_TXFC_BUMP        21  /* Bump stream TXFC CWM */
 247 #define OPK_HANDSHAKE_COMPLETE      22  /* Mark handshake as complete */
 248
 249 struct script_op {
 250     uint32_t opcode;
 251     uint64_t arg0, arg1;
 252     const void *buf;
 253     size_t buf_len;
 254     int (*check_func)(struct helper *h);
 255 };
 256
 257 #define OP_END      \
 258     { OPK_END }
 259 #define OP_TXP_GENERATE(archetype) \
 260     { OPK_TXP_GENERATE, (archetype) },
 261 #define OP_TXP_GENERATE_NONE(archetype) \
 262     { OPK_TXP_GENERATE_NONE, (archetype) },
 263 #define OP_RX_PKT() \
 264     { OPK_RX_PKT },
 265 #define OP_RX_PKT_NONE() \
 266     { OPK_RX_PKT_NONE },
 267 #define OP_EXPECT_DGRAM_LEN(lo, hi) \
 268     { OPK_EXPECT_DGRAM_LEN, (lo), (hi) },
 269 #define OP_EXPECT_FRAME(frame_type) \
 270     { OPK_EXPECT_FRAME, (frame_type) },
 271 #define OP_EXPECT_INITIAL_TOKEN(buf) \
 272     { OPK_EXPECT_INITIAL_TOKEN, sizeof(buf), 0, buf },
 273 #define OP_EXPECT_HDR(hdr) \
 274     { OPK_EXPECT_HDR, 0, 0, &(hdr) },
 275 #define OP_CHECK(func) \
 276     { OPK_CHECK, 0, 0, NULL, 0, (func) },
 277 #define OP_NEXT_FRAME() \
 278     { OPK_NEXT_FRAME },
 279 #define OP_EXPECT_NO_FRAME() \
 280     { OPK_EXPECT_NO_FRAME },
 281 #define OP_PROVIDE_SECRET(el, suite, secret) \
 282     { OPK_PROVIDE_SECRET, (el), (suite), (secret), sizeof(secret) },
 283 #define OP_DISCARD_EL(el) \
 284     { OPK_DISCARD_EL, (el) },
 285 #define OP_CRYPTO_SEND(pn_space, buf) \
 286     { OPK_CRYPTO_SEND, (pn_space), 0, (buf), sizeof(buf) },
 287 #define OP_STREAM_NEW(id) \
 288     { OPK_STREAM_NEW, (id) },
 289 #define OP_STREAM_SEND(id, buf) \
 290     { OPK_STREAM_SEND, (id), 0, (buf), sizeof(buf) },
 291 #define OP_STREAM_FIN(id) \
 292     { OPK_STREAM_FIN, (id) },
 293 #define OP_STOP_SENDING(id, aec) \
 294     { OPK_STOP_SENDING, (id), (aec) },
 295 #define OP_RESET_STREAM(id, aec) \
 296     { OPK_RESET_STREAM, (id), (aec) },
 297 #define OP_CONN_TXFC_BUMP(cwm) \
 298     { OPK_CONN_TXFC_BUMP, (cwm) },
 299 #define OP_STREAM_TXFC_BUMP(id, cwm) \
 300     { OPK_STREAM_TXFC_BUMP, (cwm), (id) },
 301 #define OP_HANDSHAKE_COMPLETE() \
 302     { OPK_HANDSHAKE_COMPLETE },
 303
 304 static int schedule_handshake_done(struct helper *h)
 305 {
 306     ossl_quic_tx_packetiser_schedule_handshake_done(h->txp);
 307     return 1;
 308 }
 309
 310 static int schedule_ack_eliciting_app(struct helper *h)
 311 {
 312     ossl_quic_tx_packetiser_schedule_ack_eliciting(h->txp, QUIC_PN_SPACE_APP);
 313     return 1;
 314 }
 315
 316 /* 1. 1-RTT, Single Handshake Done Frame */
 317 static const struct script_op script_1[] = {
 318     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 319     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 320     OP_CHECK(schedule_handshake_done)
 321     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
 322     OP_RX_PKT()
 323     /* Should not be long */
 324     OP_EXPECT_DGRAM_LEN(21, 32)
 325     OP_NEXT_FRAME()
 326     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE)
 327     OP_EXPECT_NO_FRAME()
 328     OP_RX_PKT_NONE()
 329     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 330     OP_END
 331 };
 332
 333 /* 2. 1-RTT, Forced ACK-Eliciting Frame */
 334 static const struct script_op script_2[] = {
 335     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 336     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 337     OP_CHECK(schedule_ack_eliciting_app)
 338     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
 339     OP_RX_PKT()
 340     /* Should not be long */
 341     OP_EXPECT_DGRAM_LEN(21, 32)
 342     /* A PING frame should have been added */
 343     OP_NEXT_FRAME()
 344     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_PING)
 345     OP_EXPECT_NO_FRAME()
 346     OP_RX_PKT_NONE()
 347     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 348     OP_END
 349 };
 350
 351 /* 3. 1-RTT, MAX_DATA */
 352 static int schedule_max_data(struct helper *h)
 353 {
 354     uint64_t cwm;
 355
 356     cwm = ossl_quic_rxfc_get_cwm(&h->stream_rxfc);
 357
 358     if (!TEST_true(ossl_quic_rxfc_on_rx_stream_frame(&h->stream_rxfc, cwm, 0))
 359         || !TEST_true(ossl_quic_rxfc_on_retire(&h->stream_rxfc, cwm,
 360                                                ossl_ticks2time(OSSL_TIME_MS))))
 361         return 0;
 362
 363     return 1;
 364 }
 365
 366 static const struct script_op script_3[] = {
 367     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 368     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 369     OP_CHECK(schedule_max_data)
 370     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
 371     OP_RX_PKT()
 372     /* Should not be long */
 373     OP_EXPECT_DGRAM_LEN(21, 40)
 374     /* A PING frame should have been added */
 375     OP_NEXT_FRAME()
 376     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_MAX_DATA)
 377     OP_EXPECT_NO_FRAME()
 378     OP_RX_PKT_NONE()
 379     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 380     OP_END
 381 };
 382
 383 /* 4. 1-RTT, CFQ (NEW_CONN_ID) */
 384 static void free_buf_mem(unsigned char *buf, size_t buf_len, void *arg)
 385 {
 386     BUF_MEM_free((BUF_MEM *)arg);
 387 }
 388
 389 static int schedule_cfq_new_conn_id(struct helper *h)
 390 {
 391     int rc = 0;
 392     QUIC_CFQ_ITEM *cfq_item;
 393     WPACKET wpkt;
 394     BUF_MEM *buf_mem = NULL;
 395     size_t l = 0;
 396     OSSL_QUIC_FRAME_NEW_CONN_ID ncid = {0};
 397
 398     ncid.seq_num         = 2345;
 399     ncid.retire_prior_to = 1234;
 400     ncid.conn_id         = cid_1;
 401     memcpy(ncid.stateless_reset_token, reset_token_1, sizeof(reset_token_1));
 402
 403     if (!TEST_ptr(buf_mem = BUF_MEM_new()))
 404         goto err;
 405
 406     if (!TEST_true(WPACKET_init(&wpkt, buf_mem)))
 407         goto err;
 408
 409     if (!TEST_true(ossl_quic_wire_encode_frame_new_conn_id(&wpkt, &ncid))) {
 410         WPACKET_cleanup(&wpkt);
 411         goto err;
 412     }
 413
 414     WPACKET_finish(&wpkt);
 415
 416     if (!TEST_true(WPACKET_get_total_written(&wpkt, &l)))
 417         goto err;
 418
 419     if (!TEST_ptr(cfq_item = ossl_quic_cfq_add_frame(h->args.cfq, 1,
 420                                                      QUIC_PN_SPACE_APP,
 421                                                      OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID,
 422                                                      (unsigned char *)buf_mem->data, l,
 423                                                      free_buf_mem,
 424                                                      buf_mem)))
 425         goto err;
 426
 427     rc = 1;
 428 err:
 429     if (!rc)
 430         BUF_MEM_free(buf_mem);
 431     return rc;
 432 }
 433
 434 static int check_cfq_new_conn_id(struct helper *h)
 435 {
 436     if (!TEST_uint64_t_eq(h->frame.new_conn_id.seq_num, 2345)
 437         || !TEST_uint64_t_eq(h->frame.new_conn_id.retire_prior_to, 1234)
 438         || !TEST_mem_eq(&h->frame.new_conn_id.conn_id, sizeof(cid_1),
 439                         &cid_1, sizeof(cid_1))
 440         || !TEST_mem_eq(&h->frame.new_conn_id.stateless_reset_token,
 441                         sizeof(reset_token_1),
 442                         reset_token_1,
 443                         sizeof(reset_token_1)))
 444         return 0;
 445
 446     return 1;
 447 }
 448
 449 static const struct script_op script_4[] = {
 450     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 451     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 452     OP_CHECK(schedule_cfq_new_conn_id)
 453     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
 454     OP_RX_PKT()
 455     OP_EXPECT_DGRAM_LEN(21, 128)
 456     OP_NEXT_FRAME()
 457     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID)
 458     OP_CHECK(check_cfq_new_conn_id)
 459     OP_EXPECT_NO_FRAME()
 460     OP_RX_PKT_NONE()
 461     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 462     OP_END
 463 };
 464
 465 /* 5. 1-RTT, CFQ (NEW_TOKEN) */
 466 static const unsigned char token_1[] = {
 467     0x10, 0x11, 0x12, 0x13, 0x14, 0x15
 468 };
 469
 470 static int schedule_cfq_new_token(struct helper *h)
 471 {
 472     int rc = 0;
 473     QUIC_CFQ_ITEM *cfq_item;
 474     WPACKET wpkt;
 475     BUF_MEM *buf_mem = NULL;
 476     size_t l = 0;
 477
 478     if (!TEST_ptr(buf_mem = BUF_MEM_new()))
 479         goto err;
 480
 481     if (!TEST_true(WPACKET_init(&wpkt, buf_mem)))
 482         goto err;
 483
 484     if (!TEST_true(ossl_quic_wire_encode_frame_new_token(&wpkt, token_1,
 485                                                          sizeof(token_1)))) {
 486         WPACKET_cleanup(&wpkt);
 487         goto err;
 488     }
 489
 490     WPACKET_finish(&wpkt);
 491
 492     if (!TEST_true(WPACKET_get_total_written(&wpkt, &l)))
 493         goto err;
 494
 495     if (!TEST_ptr(cfq_item = ossl_quic_cfq_add_frame(h->args.cfq, 1,
 496                                                      QUIC_PN_SPACE_APP,
 497                                                      OSSL_QUIC_FRAME_TYPE_NEW_TOKEN,
 498                                                      (unsigned char *)buf_mem->data, l,
 499                                                      free_buf_mem,
 500                                                      buf_mem)))
 501         goto err;
 502
 503     rc = 1;
 504 err:
 505     if (!rc)
 506         BUF_MEM_free(buf_mem);
 507     return rc;
 508 }
 509
 510 static int check_cfq_new_token(struct helper *h)
 511 {
 512     if (!TEST_mem_eq(h->frame.new_token.token,
 513                      h->frame.new_token.token_len,
 514                      token_1,
 515                      sizeof(token_1)))
 516         return 0;
 517
 518     return 1;
 519 }
 520
 521 static const struct script_op script_5[] = {
 522     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 523     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 524     OP_CHECK(schedule_cfq_new_token)
 525     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
 526     OP_RX_PKT()
 527     OP_EXPECT_DGRAM_LEN(21, 512)
 528     OP_NEXT_FRAME()
 529     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_NEW_TOKEN)
 530     OP_CHECK(check_cfq_new_token)
 531     OP_EXPECT_NO_FRAME()
 532     OP_RX_PKT_NONE()
 533     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 534     OP_END
 535 };
 536
 537 /* 6. 1-RTT, ACK */
 538 static int schedule_ack(struct helper *h)
 539 {
 540     size_t i;
 541     OSSL_ACKM_RX_PKT rx_pkt = {0};
 542
 543     /* Stimulate ACK emission by simulating a few received packets. */
 544     for (i = 0; i < 5; ++i) {
 545         rx_pkt.pkt_num          = i;
 546         rx_pkt.time             = fake_now(NULL);
 547         rx_pkt.pkt_space        = QUIC_PN_SPACE_APP;
 548         rx_pkt.is_ack_eliciting = 1;
 549
 550         if (!TEST_true(ossl_ackm_on_rx_packet(h->args.ackm, &rx_pkt)))
 551             return 0;
 552     }
 553
 554     return 1;
 555 }
 556
 557 static const struct script_op script_6[] = {
 558     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 559     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 560     OP_CHECK(schedule_ack)
 561     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
 562     OP_RX_PKT()
 563     OP_EXPECT_DGRAM_LEN(21, 512)
 564     OP_NEXT_FRAME()
 565     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_ACK_WITHOUT_ECN)
 566     OP_EXPECT_NO_FRAME()
 567     OP_RX_PKT_NONE()
 568     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 569     OP_END
 570 };
 571
 572 /* 7. 1-RTT, ACK, NEW_TOKEN */
 573 static const struct script_op script_7[] = {
 574     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 575     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 576     OP_CHECK(schedule_cfq_new_token)
 577     OP_CHECK(schedule_ack)
 578     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
 579     OP_RX_PKT()
 580     OP_EXPECT_DGRAM_LEN(21, 512)
 581     /* ACK must come before NEW_TOKEN */
 582     OP_NEXT_FRAME()
 583     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_ACK_WITHOUT_ECN)
 584     OP_NEXT_FRAME()
 585     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_NEW_TOKEN)
 586     OP_EXPECT_NO_FRAME()
 587     OP_RX_PKT_NONE()
 588     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 589     OP_END
 590 };
 591
 592 /* 8. 1-RTT, CRYPTO */
 593 static const unsigned char crypto_1[] = {
 594     0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09
 595 };
 596
 597 static const struct script_op script_8[] = {
 598     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 599     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 600     OP_CRYPTO_SEND(QUIC_PN_SPACE_APP, crypto_1)
 601     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
 602     OP_RX_PKT()
 603     OP_EXPECT_DGRAM_LEN(21, 512)
 604     OP_NEXT_FRAME()
 605     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_CRYPTO)
 606     OP_EXPECT_NO_FRAME()
 607     OP_RX_PKT_NONE()
 608     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 609     OP_END
 610 };
 611
 612 /* 9. 1-RTT, STREAM */
 613 static const unsigned char stream_9[] = {
 614     0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x7a, 0x7b
 615 };
 616
 617 static int check_stream_9(struct helper *h)
 618 {
 619     if (!TEST_mem_eq(h->frame.stream.data, (size_t)h->frame.stream.len,
 620                      stream_9, sizeof(stream_9)))
 621         return 0;
 622
 623     return 1;
 624 }
 625
 626 static const struct script_op script_9[] = {
 627     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 628     OP_HANDSHAKE_COMPLETE()
 629     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 630     OP_STREAM_NEW(42)
 631     OP_STREAM_SEND(42, stream_9)
 632     /* Still no output because of TXFC */
 633     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 634     /* Now grant a TXFC budget */
 635     OP_CONN_TXFC_BUMP(1000)
 636     OP_STREAM_TXFC_BUMP(42, 1000)
 637     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
 638     OP_RX_PKT()
 639     OP_EXPECT_DGRAM_LEN(21, 512)
 640     OP_NEXT_FRAME()
 641     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_STREAM)
 642     OP_CHECK(check_stream_9)
 643     OP_EXPECT_NO_FRAME()
 644     OP_RX_PKT_NONE()
 645     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 646     OP_END
 647 };
 648
 649 /* 10. 1-RTT, STREAM, round robin */
 650 /* The data below is randomly generated data. */
 651 static const unsigned char stream_10a[1300] = {
 652     0x40, 0x0d, 0xb6, 0x0d, 0x25, 0x5f, 0xdd, 0xb9, 0x05, 0x79, 0xa8, 0xe3,
 653     0x79, 0x32, 0xb2, 0xa7, 0x30, 0x6d, 0x29, 0xf6, 0xba, 0x50, 0xbe, 0x83,
 654     0xcb, 0x56, 0xec, 0xd6, 0xc7, 0x80, 0x84, 0xa2, 0x2f, 0xeb, 0xc4, 0x37,
 655     0x40, 0x44, 0xef, 0xd8, 0x78, 0xbb, 0x92, 0x80, 0x22, 0x33, 0xc0, 0xce,
 656     0x33, 0x5b, 0x75, 0x8c, 0xa5, 0x1a, 0x7a, 0x2a, 0xa9, 0x88, 0xaf, 0xf6,
 657     0x3a, 0xe2, 0x5e, 0x60, 0x52, 0x6d, 0xef, 0x7f, 0x2a, 0x9a, 0xaa, 0x17,
 658     0x0e, 0x12, 0x51, 0x82, 0x08, 0x2f, 0x0f, 0x5b, 0xff, 0xf5, 0x7c, 0x7c,
 659     0x89, 0x04, 0xfb, 0xa7, 0x80, 0x4e, 0xda, 0x12, 0x89, 0x01, 0x4a, 0x81,
 660     0x84, 0x78, 0x15, 0xa9, 0x12, 0x28, 0x69, 0x4a, 0x25, 0xe5, 0x8b, 0x69,
 661     0xc2, 0x9f, 0xb6, 0x59, 0x49, 0xe3, 0x53, 0x90, 0xef, 0xc9, 0xb8, 0x40,
 662     0xdd, 0x62, 0x5f, 0x99, 0x68, 0xd2, 0x0a, 0x77, 0xde, 0xf3, 0x11, 0x39,
 663     0x7f, 0x93, 0x8b, 0x81, 0x69, 0x36, 0xa7, 0x76, 0xa4, 0x10, 0x56, 0x51,
 664     0xe5, 0x45, 0x3a, 0x42, 0x49, 0x6c, 0xc6, 0xa0, 0xb4, 0x13, 0x46, 0x59,
 665     0x0e, 0x48, 0x60, 0xc9, 0xff, 0x70, 0x10, 0x8d, 0x6a, 0xf9, 0x5b, 0x94,
 666     0xc2, 0x9e, 0x49, 0x19, 0x56, 0xf2, 0xc1, 0xff, 0x08, 0x3f, 0x9e, 0x26,
 667     0x8e, 0x99, 0x71, 0xc4, 0x25, 0xb1, 0x4e, 0xcc, 0x7e, 0x5f, 0xf0, 0x4e,
 668     0x25, 0xa2, 0x2f, 0x3f, 0x68, 0xaa, 0xcf, 0xbd, 0x19, 0x19, 0x1c, 0x92,
 669     0xa0, 0xb6, 0xb8, 0x32, 0xb1, 0x0b, 0x91, 0x05, 0xa9, 0xf8, 0x1a, 0x4b,
 670     0x74, 0x09, 0xf9, 0x57, 0xd0, 0x1c, 0x38, 0x10, 0x05, 0x54, 0xd8, 0x4e,
 671     0x12, 0x67, 0xcc, 0x43, 0xa3, 0x81, 0xa9, 0x3a, 0x12, 0x57, 0xe7, 0x4b,
 672     0x0e, 0xe5, 0x51, 0xf9, 0x5f, 0xd4, 0x46, 0x73, 0xa2, 0x78, 0xb7, 0x00,
 673     0x24, 0x69, 0x35, 0x10, 0x1e, 0xb8, 0xa7, 0x4a, 0x9b, 0xbc, 0xfc, 0x04,
 674     0x6f, 0x1a, 0xb0, 0x4f, 0x12, 0xc9, 0x2b, 0x3b, 0x94, 0x85, 0x1b, 0x8e,
 675     0xba, 0xac, 0xfd, 0x10, 0x22, 0x68, 0x90, 0x17, 0x13, 0x44, 0x18, 0x2f,
 676     0x33, 0x37, 0x1a, 0x89, 0xc0, 0x2c, 0x14, 0x59, 0xb2, 0xaf, 0xc0, 0x6b,
 677     0xdc, 0x28, 0xe1, 0xe9, 0xc1, 0x0c, 0xb4, 0x80, 0x90, 0xb9, 0x1f, 0x45,
 678     0xb4, 0x63, 0x9a, 0x0e, 0xfa, 0x33, 0xf5, 0x75, 0x3a, 0x4f, 0xc3, 0x8c,
 679     0x70, 0xdb, 0xd7, 0xbf, 0xf6, 0xb8, 0x7f, 0xcc, 0xe5, 0x85, 0xb6, 0xae,
 680     0x25, 0x60, 0x18, 0x5b, 0xf1, 0x51, 0x1a, 0x85, 0xc1, 0x7f, 0xf3, 0xbe,
 681     0xb6, 0x82, 0x38, 0xe3, 0xd2, 0xff, 0x8a, 0xc4, 0xdb, 0x08, 0xe6, 0x96,
 682     0xd5, 0x3d, 0x1f, 0xc5, 0x12, 0x35, 0x45, 0x75, 0x5d, 0x17, 0x4e, 0xe1,
 683     0xb8, 0xc9, 0xf0, 0x45, 0x95, 0x0b, 0x03, 0xcb, 0x85, 0x47, 0xaf, 0xc7,
 684     0x88, 0xb6, 0xc1, 0x2c, 0xb8, 0x9b, 0xe6, 0x8b, 0x51, 0xd5, 0x2e, 0x71,
 685     0xba, 0xc9, 0xa9, 0x37, 0x5e, 0x1c, 0x2c, 0x03, 0xf0, 0xc7, 0xc1, 0xd3,
 686     0x72, 0xaa, 0x4d, 0x19, 0xd6, 0x51, 0x64, 0x12, 0xeb, 0x39, 0xeb, 0x45,
 687     0xe9, 0xb4, 0x84, 0x08, 0xb6, 0x6c, 0xc7, 0x3e, 0xf0, 0x88, 0x64, 0xc2,
 688     0x91, 0xb7, 0xa5, 0x86, 0x66, 0x83, 0xd5, 0xd3, 0x41, 0x24, 0xb2, 0x1c,
 689     0x9a, 0x18, 0x10, 0x0e, 0xa5, 0xc9, 0xef, 0xcd, 0x06, 0xce, 0xa8, 0xaf,
 690     0x22, 0x52, 0x25, 0x0b, 0x99, 0x3d, 0xe9, 0x26, 0xda, 0xa9, 0x47, 0xd1,
 691     0x4b, 0xa6, 0x4c, 0xfc, 0x80, 0xaf, 0x6a, 0x59, 0x4b, 0x35, 0xa4, 0x93,
 692     0x39, 0x5b, 0xfa, 0x91, 0x9d, 0xdf, 0x9d, 0x3c, 0xfb, 0x53, 0xca, 0x18,
 693     0x19, 0xe4, 0xda, 0x95, 0x47, 0x5a, 0x37, 0x59, 0xd7, 0xd2, 0xe4, 0x75,
 694     0x45, 0x0d, 0x03, 0x7f, 0xa0, 0xa9, 0xa0, 0x71, 0x06, 0xb1, 0x9d, 0x46,
 695     0xbd, 0xcf, 0x4a, 0x8b, 0x73, 0xc1, 0x45, 0x5c, 0x00, 0x61, 0xfd, 0xd1,
 696     0xa4, 0xa2, 0x3e, 0xaa, 0xbe, 0x72, 0xf1, 0x7a, 0x1a, 0x76, 0x88, 0x5c,
 697     0x9e, 0x74, 0x6d, 0x2a, 0x34, 0xfc, 0xf7, 0x41, 0x28, 0xe8, 0xa3, 0x43,
 698     0x4d, 0x43, 0x1d, 0x6c, 0x36, 0xb1, 0x45, 0x71, 0x5a, 0x3c, 0xd3, 0x28,
 699     0x44, 0xe4, 0x9b, 0xbf, 0x54, 0x16, 0xc3, 0x99, 0x6c, 0x42, 0xd8, 0x20,
 700     0xb6, 0x20, 0x5f, 0x6e, 0xbc, 0xba, 0x88, 0x5e, 0x2f, 0xa5, 0xd1, 0x82,
 701     0x5c, 0x92, 0xd0, 0x79, 0xfd, 0xcc, 0x61, 0x49, 0xd0, 0x73, 0x92, 0xe6,
 702     0x98, 0xe3, 0x80, 0x7a, 0xf9, 0x56, 0x63, 0x33, 0x19, 0xda, 0x54, 0x13,
 703     0xf0, 0x21, 0xa8, 0x15, 0xf6, 0xb7, 0x43, 0x7c, 0x1c, 0x1e, 0xb1, 0x89,
 704     0x8d, 0xce, 0x20, 0x54, 0x81, 0x80, 0xb5, 0x8f, 0x9b, 0xb1, 0x09, 0x92,
 705     0xdb, 0x25, 0x6f, 0x30, 0x29, 0x08, 0x1a, 0x05, 0x08, 0xf4, 0x83, 0x8b,
 706     0x1e, 0x2d, 0xfd, 0xe4, 0xb2, 0x76, 0xc8, 0x4d, 0xf3, 0xa6, 0x49, 0x5f,
 707     0x2c, 0x99, 0x78, 0xbd, 0x07, 0xef, 0xc8, 0xd9, 0xb5, 0x70, 0x3b, 0x0a,
 708     0xcb, 0xbd, 0xa0, 0xea, 0x15, 0xfb, 0xd1, 0x6e, 0x61, 0x83, 0xcb, 0x90,
 709     0xd0, 0xa3, 0x81, 0x28, 0xdc, 0xd5, 0x84, 0xae, 0x55, 0x28, 0x13, 0x9e,
 710     0xc6, 0xd8, 0xf4, 0x67, 0xd6, 0x0d, 0xd4, 0x69, 0xac, 0xf6, 0x35, 0x95,
 711     0x99, 0x44, 0x26, 0x72, 0x36, 0x55, 0xf9, 0x42, 0xa6, 0x1b, 0x00, 0x93,
 712     0x00, 0x19, 0x2f, 0x70, 0xd3, 0x16, 0x66, 0x4e, 0x80, 0xbb, 0xb6, 0x84,
 713     0xa1, 0x2c, 0x09, 0xfb, 0x41, 0xdf, 0x63, 0xde, 0x62, 0x3e, 0xd0, 0xa8,
 714     0xd8, 0x0c, 0x03, 0x06, 0xa9, 0x82, 0x17, 0x9c, 0xd2, 0xa9, 0xd5, 0x6f,
 715     0xcc, 0xc0, 0xf2, 0x5d, 0xb1, 0xba, 0xf8, 0x2e, 0x37, 0x8b, 0xe6, 0x5d,
 716     0x9f, 0x1b, 0xfb, 0x53, 0x0a, 0x96, 0xbe, 0x69, 0x31, 0x19, 0x8f, 0x44,
 717     0x1b, 0xc2, 0x42, 0x7e, 0x65, 0x12, 0x1d, 0x52, 0x1e, 0xe2, 0xc0, 0x86,
 718     0x70, 0x88, 0xe5, 0xf6, 0x87, 0x5d, 0x03, 0x4b, 0x12, 0x3c, 0x2d, 0xaf,
 719     0x09, 0xf5, 0x4f, 0x82, 0x2e, 0x2e, 0xbe, 0x07, 0xe8, 0x8d, 0x57, 0x6e,
 720     0xc0, 0xeb, 0xf9, 0x37, 0xac, 0x89, 0x01, 0xb7, 0xc6, 0x52, 0x1c, 0x86,
 721     0xe5, 0xbc, 0x1f, 0xbd, 0xde, 0xa2, 0x42, 0xb6, 0x73, 0x85, 0x6f, 0x06,
 722     0x36, 0x56, 0x40, 0x2b, 0xea, 0x16, 0x8c, 0xf4, 0x7b, 0x65, 0x6a, 0xca,
 723     0x3c, 0x56, 0x68, 0x01, 0xe3, 0x9c, 0xbb, 0xb9, 0x45, 0x54, 0xcd, 0x13,
 724     0x74, 0xad, 0x80, 0x40, 0xbc, 0xd0, 0x74, 0xb4, 0x31, 0xe4, 0xca, 0xd5,
 725     0xf8, 0x4f, 0x08, 0x5b, 0xc4, 0x15, 0x1a, 0x51, 0x3b, 0xc6, 0x40, 0xc8,
 726     0xea, 0x76, 0x30, 0x95, 0xb7, 0x76, 0xa4, 0xda, 0x20, 0xdb, 0x75, 0x1c,
 727     0xf4, 0x87, 0x24, 0x29, 0x54, 0xc6, 0x59, 0x0c, 0xf0, 0xed, 0xf5, 0x3d,
 728     0xce, 0x95, 0x23, 0x30, 0x49, 0x91, 0xa7, 0x7b, 0x22, 0xb5, 0xd7, 0x71,
 729     0xb0, 0x60, 0xe1, 0xf0, 0x84, 0x74, 0x0e, 0x2f, 0xa8, 0x79, 0x35, 0xb9,
 730     0x03, 0xb5, 0x2c, 0xdc, 0x60, 0x48, 0x12, 0xd9, 0x14, 0x5a, 0x58, 0x5d,
 731     0x95, 0xc6, 0x47, 0xfd, 0xaf, 0x09, 0xc2, 0x67, 0xa5, 0x09, 0xae, 0xff,
 732     0x4b, 0xd5, 0x6c, 0x2f, 0x1d, 0x33, 0x31, 0xcb, 0xdb, 0xcf, 0xf5, 0xf6,
 733     0xbc, 0x90, 0xb2, 0x15, 0xd4, 0x34, 0xeb, 0xde, 0x0e, 0x8f, 0x3d, 0xea,
 734     0xa4, 0x9b, 0x29, 0x8a, 0xf9, 0x4a, 0xac, 0x38, 0x1e, 0x46, 0xb2, 0x2d,
 735     0xa2, 0x61, 0xc5, 0x99, 0x5e, 0x85, 0x36, 0x85, 0xb0, 0xb1, 0x6b, 0xc4,
 736     0x06, 0x68, 0xc7, 0x9b, 0x54, 0xb9, 0xc8, 0x9d, 0xf3, 0x1a, 0xe0, 0x67,
 737     0x0e, 0x4d, 0x5c, 0x13, 0x54, 0xa4, 0x62, 0x62, 0x6f, 0xae, 0x0e, 0x86,
 738     0xa2, 0xe0, 0x31, 0xc7, 0x72, 0xa1, 0xbb, 0x87, 0x3e, 0x61, 0x96, 0xb7,
 739     0x53, 0xf9, 0x34, 0xcb, 0xfd, 0x6c, 0x67, 0x25, 0x73, 0x61, 0x75, 0x4f,
 740     0xab, 0x37, 0x08, 0xef, 0x35, 0x5a, 0x03, 0xe5, 0x08, 0x43, 0xec, 0xdc,
 741     0xb5, 0x2c, 0x1f, 0xe6, 0xeb, 0xc6, 0x06, 0x0b, 0xed, 0xad, 0x74, 0xf4,
 742     0x55, 0xef, 0xe0, 0x2e, 0x83, 0x00, 0xdb, 0x32, 0xde, 0xe9, 0xe4, 0x2f,
 743     0xf5, 0x20, 0x6d, 0x72, 0x47, 0xf4, 0x68, 0xa6, 0x7f, 0x3e, 0x6a, 0x5a,
 744     0x21, 0x76, 0x31, 0x97, 0xa0, 0xc6, 0x7d, 0x03, 0xf7, 0x27, 0x45, 0x5a,
 745     0x75, 0x03, 0xc1, 0x5c, 0x94, 0x2b, 0x37, 0x9f, 0x46, 0x8f, 0xc3, 0xa7,
 746     0x50, 0xe4, 0xe7, 0x23, 0xf7, 0x20, 0xa2, 0x8e, 0x4b, 0xfd, 0x7a, 0xa7,
 747     0x8a, 0x54, 0x7b, 0x32, 0xef, 0x0e, 0x82, 0xb9, 0xf9, 0x14, 0x62, 0x68,
 748     0x32, 0x9e, 0x55, 0xc0, 0xd8, 0xc7, 0x41, 0x9c, 0x67, 0x95, 0xbf, 0xc3,
 749     0x86, 0x74, 0x70, 0x64, 0x44, 0x23, 0x77, 0x79, 0x82, 0x23, 0x1c, 0xf4,
 750     0xa1, 0x05, 0xd3, 0x98, 0x89, 0xde, 0x7d, 0xb3, 0x5b, 0xef, 0x38, 0xd2,
 751     0x07, 0xbc, 0x5a, 0x69, 0xa3, 0xe4, 0x37, 0x9b, 0x53, 0xff, 0x04, 0x6b,
 752     0xd9, 0xd8, 0x32, 0x89, 0xf7, 0x82, 0x77, 0xcf, 0xe6, 0xff, 0xf4, 0x15,
 753     0x54, 0x91, 0x65, 0x96, 0x49, 0xd7, 0x0a, 0xa4, 0xf3, 0x55, 0x2b, 0xc1,
 754     0x48, 0xc1, 0x7e, 0x56, 0x69, 0x27, 0xf4, 0xd1, 0x47, 0x1f, 0xde, 0x86,
 755     0x15, 0x67, 0x04, 0x9d, 0x41, 0x1f, 0xe8, 0xe1, 0x23, 0xe4, 0x56, 0xb9,
 756     0xdb, 0x4e, 0xe4, 0x84, 0x6c, 0x63, 0x39, 0xad, 0x44, 0x6d, 0x4e, 0x28,
 757     0xcd, 0xf6, 0xac, 0xec, 0xc2, 0xad, 0xcd, 0xc3, 0xed, 0x03, 0x63, 0x5d,
 758     0xef, 0x1d, 0x40, 0x8d, 0x9a, 0x02, 0x67, 0x4b, 0x55, 0xb5, 0xfe, 0x75,
 759     0xb6, 0x53, 0x34, 0x1d, 0x7b, 0x26, 0x23, 0xfe, 0xb9, 0x21, 0xd3, 0xe0,
 760     0xa0, 0x1a, 0x85, 0xe5
 761 };
 762
 763 static const unsigned char stream_10b[1300] = {
 764     0x18, 0x00, 0xd7, 0xfb, 0x12, 0xda, 0xdb, 0x68, 0xeb, 0x38, 0x4d, 0xf6,
 765     0xb2, 0x45, 0x74, 0x4c, 0xcc, 0xe7, 0xa7, 0xc1, 0x26, 0x84, 0x3d, 0xdf,
 766     0x7d, 0xc5, 0xe9, 0xd4, 0x31, 0xa2, 0x51, 0x38, 0x95, 0xe2, 0x68, 0x11,
 767     0x9d, 0xd1, 0x52, 0xb5, 0xef, 0x76, 0xe0, 0x3d, 0x11, 0x50, 0xd7, 0xb2,
 768     0xc1, 0x7d, 0x12, 0xaf, 0x02, 0x52, 0x97, 0x03, 0xf3, 0x2e, 0x54, 0xdf,
 769     0xa0, 0x40, 0x76, 0x52, 0x82, 0x23, 0x3c, 0xbd, 0x20, 0x6d, 0x0a, 0x6f,
 770     0x81, 0xfc, 0x41, 0x9d, 0x2e, 0xa7, 0x2c, 0x78, 0x9c, 0xd8, 0x56, 0xb0,
 771     0x31, 0x35, 0xc8, 0x53, 0xef, 0xf9, 0x43, 0x17, 0xc0, 0x8c, 0x2c, 0x8f,
 772     0x4a, 0x68, 0xe8, 0x9f, 0xbd, 0x3f, 0xf2, 0x18, 0xb8, 0xe6, 0x55, 0xea,
 773     0x2a, 0x37, 0x3e, 0xac, 0xb0, 0x75, 0xd4, 0x75, 0x12, 0x82, 0xec, 0x21,
 774     0xb9, 0xce, 0xe5, 0xc1, 0x62, 0x49, 0xd5, 0xf1, 0xca, 0xd4, 0x32, 0x76,
 775     0x34, 0x5f, 0x3e, 0xc9, 0xb3, 0x54, 0xe4, 0xd0, 0xa9, 0x7d, 0x0c, 0x64,
 776     0x48, 0x0a, 0x74, 0x38, 0x03, 0xd0, 0x20, 0xac, 0xe3, 0x58, 0x3d, 0x4b,
 777     0xa7, 0x46, 0xac, 0x57, 0x63, 0x12, 0x17, 0xcb, 0x96, 0xed, 0xc9, 0x39,
 778     0x64, 0xde, 0xff, 0xc6, 0xb2, 0x40, 0x2c, 0xf9, 0x1d, 0xa6, 0x94, 0x2a,
 779     0x16, 0x4d, 0x7f, 0x22, 0x91, 0x8b, 0xfe, 0x83, 0x77, 0x02, 0x68, 0x62,
 780     0x27, 0x77, 0x2e, 0xe9, 0xce, 0xbc, 0x20, 0xe8, 0xfb, 0xf8, 0x4e, 0x17,
 781     0x07, 0xe1, 0xaa, 0x29, 0xb7, 0x50, 0xcf, 0xb0, 0x6a, 0xcf, 0x01, 0xec,
 782     0xbf, 0xff, 0xb5, 0x9f, 0x00, 0x64, 0x80, 0xbb, 0xa6, 0xe4, 0xa2, 0x1e,
 783     0xe4, 0xf8, 0xa3, 0x0d, 0xc7, 0x65, 0x45, 0xb7, 0x01, 0x33, 0x80, 0x37,
 784     0x11, 0x16, 0x34, 0xc1, 0x06, 0xc5, 0xd3, 0xc4, 0x70, 0x62, 0x75, 0xd8,
 785     0xa3, 0xba, 0x84, 0x9f, 0x81, 0x9f, 0xda, 0x01, 0x83, 0x42, 0x84, 0x05,
 786     0x69, 0x68, 0xb0, 0x74, 0x73, 0x0f, 0x68, 0x39, 0xd3, 0x11, 0xc5, 0x55,
 787     0x3e, 0xf2, 0xb7, 0xf4, 0xa6, 0xed, 0x0b, 0x50, 0xbe, 0x44, 0xf8, 0x67,
 788     0x48, 0x46, 0x5e, 0x71, 0x07, 0xcf, 0xca, 0x8a, 0xbc, 0xa4, 0x3c, 0xd2,
 789     0x4a, 0x80, 0x2e, 0x4f, 0xc5, 0x3b, 0x61, 0xc1, 0x7e, 0x93, 0x9e, 0xe0,
 790     0x05, 0xfb, 0x10, 0xe8, 0x53, 0xff, 0x16, 0x5e, 0x18, 0xe0, 0x9f, 0x39,
 791     0xbf, 0xaa, 0x80, 0x6d, 0xb7, 0x9f, 0x51, 0x91, 0xa0, 0xf6, 0xce, 0xad,
 792     0xed, 0x56, 0x15, 0xb9, 0x12, 0x57, 0x60, 0xa6, 0xae, 0x54, 0x6e, 0x36,
 793     0xf3, 0xe0, 0x05, 0xd8, 0x3e, 0x6d, 0x08, 0x36, 0xc9, 0x79, 0x64, 0x51,
 794     0x63, 0x92, 0xa8, 0xa1, 0xbf, 0x55, 0x26, 0x80, 0x75, 0x44, 0x33, 0x33,
 795     0xfb, 0xb7, 0xec, 0xf9, 0xc6, 0x01, 0xf9, 0xd5, 0x93, 0xfc, 0xb7, 0x43,
 796     0xa2, 0x38, 0x0d, 0x17, 0x75, 0x67, 0xec, 0xc9, 0x98, 0xd6, 0x25, 0xe6,
 797     0xb9, 0xed, 0x61, 0xa4, 0xee, 0x2c, 0xda, 0x27, 0xbd, 0xff, 0x86, 0x1e,
 798     0x45, 0x64, 0xfe, 0xcf, 0x0c, 0x9b, 0x7b, 0x75, 0x5f, 0xf1, 0xe0, 0xba,
 799     0x77, 0x8c, 0x03, 0x8f, 0xb4, 0x3a, 0xb6, 0x9c, 0xda, 0x9a, 0x83, 0xcb,
 800     0xe9, 0xcb, 0x3f, 0xf4, 0x10, 0x99, 0x5b, 0xe1, 0x19, 0x8f, 0x6b, 0x95,
 801     0x50, 0xe6, 0x78, 0xc9, 0x35, 0xb6, 0x87, 0xd8, 0x9e, 0x17, 0x30, 0x96,
 802     0x70, 0xa3, 0x04, 0x69, 0x1c, 0xa2, 0x6c, 0xd4, 0x88, 0x48, 0x44, 0x14,
 803     0x94, 0xd4, 0xc9, 0x4d, 0xe3, 0x82, 0x7e, 0x62, 0xf0, 0x0a, 0x18, 0x4d,
 804     0xd0, 0xd6, 0x63, 0xa3, 0xdf, 0xea, 0x28, 0xf4, 0x00, 0x75, 0x70, 0x78,
 805     0x08, 0x70, 0x3f, 0xff, 0x84, 0x86, 0x72, 0xea, 0x4f, 0x15, 0x8c, 0x17,
 806     0x60, 0x5f, 0xa1, 0x50, 0xa0, 0xfc, 0x6f, 0x8a, 0x46, 0xfc, 0x01, 0x8d,
 807     0x7c, 0xdc, 0x69, 0x6a, 0xd3, 0x74, 0x69, 0x76, 0x77, 0xdd, 0xe4, 0x9c,
 808     0x49, 0x1e, 0x6f, 0x7d, 0x31, 0x14, 0xd9, 0xe9, 0xe7, 0x17, 0x66, 0x82,
 809     0x1b, 0xf1, 0x0f, 0xe2, 0xba, 0xd2, 0x28, 0xd1, 0x6f, 0x48, 0xc7, 0xac,
 810     0x08, 0x4e, 0xee, 0x94, 0x66, 0x99, 0x34, 0x16, 0x5d, 0x95, 0xae, 0xe3,
 811     0x59, 0x79, 0x7f, 0x8e, 0x9f, 0xe3, 0xdb, 0xff, 0xdc, 0x4d, 0xb0, 0xbf,
 812     0xf9, 0xf3, 0x3e, 0xec, 0xcf, 0x50, 0x3d, 0x2d, 0xba, 0x94, 0x1f, 0x1a,
 813     0xab, 0xa4, 0xf4, 0x67, 0x43, 0x7e, 0xb9, 0x65, 0x20, 0x13, 0xb1, 0xd9,
 814     0x88, 0x4a, 0x24, 0x13, 0x84, 0x86, 0xae, 0x2b, 0x0c, 0x6c, 0x7e, 0xd4,
 815     0x25, 0x6e, 0xaa, 0x8d, 0x0c, 0x54, 0x99, 0xde, 0x1d, 0xac, 0x8c, 0x5c,
 816     0x73, 0x94, 0xd9, 0x75, 0xcb, 0x5a, 0x54, 0x3d, 0xeb, 0xff, 0xc1, 0x95,
 817     0x53, 0xb5, 0x39, 0xf7, 0xe5, 0xf1, 0x77, 0xd1, 0x42, 0x82, 0x4b, 0xb0,
 818     0xab, 0x19, 0x28, 0xff, 0x53, 0x28, 0x87, 0x46, 0xc6, 0x6f, 0x05, 0x06,
 819     0xa6, 0x0c, 0x97, 0x93, 0x68, 0x38, 0xe1, 0x61, 0xed, 0xf8, 0x90, 0x13,
 820     0xa3, 0x6f, 0xf2, 0x08, 0x37, 0xd7, 0x05, 0x25, 0x34, 0x43, 0x57, 0x72,
 821     0xfd, 0x6c, 0xc2, 0x19, 0x26, 0xe7, 0x50, 0x30, 0xb8, 0x6d, 0x09, 0x71,
 822     0x83, 0x75, 0xd4, 0x11, 0x25, 0x29, 0xc6, 0xee, 0xb2, 0x51, 0x1c, 0x1c,
 823     0x9e, 0x2d, 0x09, 0xb9, 0x73, 0x2b, 0xbf, 0xda, 0xc8, 0x1e, 0x2b, 0xe5,
 824     0x3f, 0x1e, 0x63, 0xe9, 0xc0, 0x6d, 0x04, 0x3a, 0x48, 0x61, 0xa8, 0xc6,
 825     0x16, 0x8d, 0x69, 0xc0, 0x67, 0x0c, 0x3b, 0xc4, 0x05, 0x36, 0xa1, 0x30,
 826     0x62, 0x92, 0x4d, 0x44, 0x31, 0x66, 0x46, 0xda, 0xef, 0x0f, 0x4e, 0xfb,
 827     0x78, 0x6a, 0xa9, 0x5b, 0xf8, 0x56, 0x26, 0x74, 0x16, 0xab, 0x17, 0x93,
 828     0x3c, 0x36, 0xbb, 0xa2, 0xbf, 0xad, 0xba, 0xb1, 0xfe, 0xc4, 0x9f, 0x75,
 829     0x47, 0x1e, 0x99, 0x7e, 0x32, 0xe8, 0xd4, 0x6c, 0xa4, 0xf8, 0xd2, 0xe4,
 830     0xb2, 0x51, 0xbb, 0xb2, 0xd7, 0xce, 0x94, 0xaf, 0x7f, 0xe6, 0x2c, 0x13,
 831     0xae, 0xd2, 0x29, 0x30, 0x7b, 0xfd, 0x25, 0x61, 0xf9, 0xe8, 0x35, 0x2d,
 832     0x1a, 0xc9, 0x81, 0xa5, 0xfe, 0xce, 0xf6, 0x17, 0xc5, 0xfb, 0x8c, 0x79,
 833     0x67, 0xa8, 0x5f, 0x5c, 0x31, 0xbc, 0xfc, 0xf3, 0x6b, 0xd3, 0x0d, 0xe0,
 834     0x62, 0xab, 0x86, 0xc3, 0x17, 0x5a, 0xba, 0x97, 0x86, 0x8f, 0x65, 0xd6,
 835     0xbd, 0x0c, 0xa1, 0xfb, 0x7f, 0x7c, 0xdc, 0xcb, 0x94, 0x30, 0x0b, 0x04,
 836     0x54, 0xc4, 0x31, 0xa1, 0xca, 0x1e, 0xc5, 0xf0, 0xb6, 0x08, 0xd7, 0x2e,
 837     0xa1, 0x90, 0x41, 0xce, 0xd9, 0xef, 0x3a, 0x58, 0x01, 0x1a, 0x73, 0x18,
 838     0xad, 0xdc, 0x20, 0x25, 0x95, 0x1a, 0xfe, 0x61, 0xf1, 0x58, 0x32, 0x8b,
 839     0x43, 0x59, 0xd6, 0x21, 0xdb, 0xa9, 0x8e, 0x54, 0xe6, 0x21, 0xcf, 0xd3,
 840     0x6b, 0x59, 0x29, 0x9b, 0x3e, 0x6c, 0x7f, 0xe2, 0x29, 0x72, 0x8c, 0xd1,
 841     0x3e, 0x9a, 0x84, 0x98, 0xb0, 0xf3, 0x20, 0x30, 0x34, 0x71, 0xa7, 0x5b,
 842     0xf0, 0x26, 0xe1, 0xf4, 0x76, 0x65, 0xc9, 0xd7, 0xe4, 0xb9, 0x25, 0x48,
 843     0xc2, 0x7e, 0xa6, 0x0b, 0x0d, 0x05, 0x68, 0xa1, 0x96, 0x61, 0x0b, 0x4c,
 844     0x2f, 0x1a, 0xe3, 0x56, 0x71, 0x89, 0x48, 0x66, 0xd8, 0xd0, 0x69, 0x37,
 845     0x7a, 0xdf, 0xdb, 0xed, 0xad, 0x82, 0xaa, 0x40, 0x25, 0x47, 0x3e, 0x75,
 846     0xa6, 0x0e, 0xf5, 0x2f, 0xa7, 0x4e, 0x97, 0xa2, 0x5f, 0x01, 0x99, 0x48,
 847     0x3a, 0x63, 0x18, 0x20, 0x61, 0x72, 0xe4, 0xcf, 0x4b, 0x3b, 0x99, 0x36,
 848     0xe1, 0xf3, 0xbf, 0xae, 0x2b, 0x6b, 0xa1, 0x94, 0xa0, 0x15, 0x94, 0xd6,
 849     0xe0, 0xba, 0x71, 0xa2, 0x85, 0xa0, 0x8c, 0x5e, 0x58, 0xe2, 0xde, 0x6b,
 850     0x08, 0x68, 0x90, 0x82, 0x71, 0x8d, 0xfd, 0x12, 0xa2, 0x49, 0x87, 0x70,
 851     0xee, 0x2a, 0x08, 0xe2, 0x26, 0xaf, 0xeb, 0x85, 0x35, 0xd2, 0x0e, 0xfd,
 852     0x2b, 0x6f, 0xc0, 0xfe, 0x41, 0xbb, 0xd7, 0x0a, 0xa3, 0x8d, 0x8b, 0xec,
 853     0x44, 0x9f, 0x46, 0x59, 0x4d, 0xac, 0x04, 0x1e, 0xde, 0x10, 0x7b, 0x17,
 854     0x0a, 0xb0, 0xcc, 0x26, 0x0c, 0xa9, 0x3c, 0x5f, 0xd8, 0xe6, 0x52, 0xd3,
 855     0xfd, 0x0b, 0x66, 0x75, 0x06, 0x84, 0x23, 0x64, 0x2b, 0x80, 0x68, 0xf9,
 856     0xcb, 0xcd, 0x04, 0x07, 0xf7, 0xe0, 0x07, 0xb4, 0xc6, 0xa0, 0x08, 0xd0,
 857     0x76, 0x16, 0x77, 0xd8, 0x48, 0xf0, 0x45, 0x4e, 0xe2, 0xf2, 0x88, 0xcd,
 858     0x0f, 0xbd, 0x7d, 0xb6, 0xbe, 0x4e, 0x9e, 0x5d, 0x6c, 0x47, 0x26, 0x34,
 859     0x94, 0xfb, 0xc5, 0x4f, 0x5c, 0xb5, 0xb5, 0xfc, 0x99, 0x34, 0x71, 0xe5,
 860     0xe1, 0x36, 0x0c, 0xd2, 0x95, 0xb8, 0x93, 0x3c, 0x5d, 0x2d, 0x71, 0x55,
 861     0x0b, 0x96, 0x4e, 0x9f, 0x07, 0x9a, 0x38, 0x9a, 0xcc, 0x24, 0xb5, 0xac,
 862     0x05, 0x8b, 0x1c, 0x61, 0xd4, 0xf2, 0xdf, 0x9e, 0x11, 0xe3, 0x7d, 0x64,
 863     0x2f, 0xe5, 0x13, 0xd4, 0x0a, 0xe9, 0x32, 0x26, 0xa8, 0x93, 0x21, 0x59,
 864     0xf3, 0x41, 0x48, 0x0a, 0xbd, 0x59, 0x8f, 0xf8, 0x72, 0xab, 0xd3, 0x65,
 865     0x8e, 0xdc, 0xaa, 0x0c, 0xc0, 0x01, 0x36, 0xb7, 0xf5, 0x84, 0x27, 0x9a,
 866     0x98, 0x89, 0x73, 0x3a, 0xeb, 0x55, 0x15, 0xc9, 0x3d, 0xe1, 0xf8, 0xea,
 867     0xf6, 0x11, 0x28, 0xe0, 0x80, 0x93, 0xcc, 0xba, 0xe1, 0xf1, 0x81, 0xbc,
 868     0xa4, 0x30, 0xbc, 0x98, 0xe8, 0x9e, 0x8d, 0x17, 0x7e, 0xb7, 0xb1, 0x27,
 869     0x6f, 0xcf, 0x9c, 0x0d, 0x1d, 0x01, 0xea, 0x45, 0xc0, 0x90, 0xda, 0x53,
 870     0xf6, 0xde, 0xdf, 0x12, 0xa1, 0x23, 0x3d, 0x92, 0x89, 0x77, 0xa7, 0x2a,
 871     0xe7, 0x45, 0x24, 0xdd, 0xf2, 0x17, 0x10, 0xca, 0x6e, 0x14, 0xb2, 0x77,
 872     0x08, 0xc4, 0x18, 0xcd
 873 };
 874
 875 static uint64_t stream_10a_off, stream_10b_off;
 876
 877 static int check_stream_10a(struct helper *h)
 878 {
 879     /*
 880      * Must have filled or almost filled the packet (using default MDPL of
 881      * 1200).
 882      */
 883     if (!TEST_uint64_t_ge(h->frame.stream.len, 1150)
 884         || !TEST_uint64_t_le(h->frame.stream.len, 1200))
 885         return 0;
 886
 887     if (!TEST_mem_eq(h->frame.stream.data, (size_t)h->frame.stream.len,
 888                      stream_10a, (size_t)h->frame.stream.len))
 889         return 0;
 890
 891     stream_10a_off = h->frame.stream.offset + h->frame.stream.len;
 892     return 1;
 893 }
 894
 895 static int check_stream_10b(struct helper *h)
 896 {
 897     if (!TEST_uint64_t_ge(h->frame.stream.len, 1150)
 898         || !TEST_uint64_t_le(h->frame.stream.len, 1200))
 899         return 0;
 900
 901     if (!TEST_mem_eq(h->frame.stream.data, (size_t)h->frame.stream.len,
 902                      stream_10b, (size_t)h->frame.stream.len))
 903         return 0;
 904
 905     stream_10b_off = h->frame.stream.offset + h->frame.stream.len;
 906     return 1;
 907 }
 908
 909 static int check_stream_10c(struct helper *h)
 910 {
 911     if (!TEST_uint64_t_ge(h->frame.stream.len, 5)
 912         || !TEST_uint64_t_le(h->frame.stream.len, 200))
 913         return 0;
 914
 915     if (!TEST_mem_eq(h->frame.stream.data, (size_t)h->frame.stream.len,
 916                      stream_10a + stream_10a_off, (size_t)h->frame.stream.len))
 917         return 0;
 918
 919     return 1;
 920 }
 921
 922 static int check_stream_10d(struct helper *h)
 923 {
 924     if (!TEST_uint64_t_ge(h->frame.stream.len, 5)
 925         || !TEST_uint64_t_le(h->frame.stream.len, 200))
 926         return 0;
 927
 928     if (!TEST_mem_eq(h->frame.stream.data, (size_t)h->frame.stream.len,
 929                      stream_10b + stream_10b_off, (size_t)h->frame.stream.len))
 930         return 0;
 931
 932     return 1;
 933 }
 934
 935 static const struct script_op script_10[] = {
 936     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 937     OP_HANDSHAKE_COMPLETE()
 938     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 939     OP_STREAM_NEW(42)
 940     OP_STREAM_NEW(43)
 941     OP_CONN_TXFC_BUMP(10000)
 942     OP_STREAM_TXFC_BUMP(42, 5000)
 943     OP_STREAM_TXFC_BUMP(43, 5000)
 944     OP_STREAM_SEND(42, stream_10a)
 945     OP_STREAM_SEND(43, stream_10b)
 946
 947     /* First packet containing data from stream 42 */
 948     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
 949     OP_RX_PKT()
 950     OP_EXPECT_DGRAM_LEN(1100, 1200)
 951     OP_NEXT_FRAME()
 952     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_STREAM)
 953     OP_CHECK(check_stream_10a)
 954     OP_EXPECT_NO_FRAME()
 955
 956     /* Second packet containing data from stream 43 */
 957     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
 958     OP_RX_PKT()
 959     OP_EXPECT_DGRAM_LEN(1100, 1200)
 960     OP_NEXT_FRAME()
 961     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_STREAM)
 962     OP_CHECK(check_stream_10b)
 963     OP_EXPECT_NO_FRAME()
 964
 965     /* Third packet containing data from stream 42 */
 966     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
 967     OP_RX_PKT()
 968     OP_EXPECT_DGRAM_LEN(200, 500)
 969     OP_NEXT_FRAME()
 970     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_STREAM_OFF_LEN)
 971     OP_CHECK(check_stream_10c)
 972     OP_NEXT_FRAME()
 973     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_STREAM_OFF)
 974     OP_CHECK(check_stream_10d)
 975     OP_EXPECT_NO_FRAME()
 976
 977     OP_RX_PKT_NONE()
 978     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 979
 980     OP_END
 981 };
 982
 983 /* 11. Initial, CRYPTO */
 984 static const struct script_op script_11[] = {
 985     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_INITIAL, QRL_SUITE_AES128GCM, secret_1)
 986     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 987     OP_CRYPTO_SEND(QUIC_PN_SPACE_INITIAL, crypto_1)
 988     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
 989     OP_RX_PKT()
 990     OP_EXPECT_DGRAM_LEN(1200, 1200)
 991     OP_NEXT_FRAME()
 992     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_CRYPTO)
 993     OP_EXPECT_NO_FRAME()
 994     OP_RX_PKT_NONE()
 995     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 996     OP_END
 997 };
 998
 999 /* 12. 1-RTT, STOP_SENDING */
1000 static int check_stream_12(struct helper *h)
1001 {
1002     if (!TEST_uint64_t_eq(h->frame.stop_sending.stream_id, 42)
1003         || !TEST_uint64_t_eq(h->frame.stop_sending.app_error_code, 4568))
1004         return 0;
1005
1006     return 1;
1007 }
1008
1009 static const struct script_op script_12[] = {
1010     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
1011     OP_HANDSHAKE_COMPLETE()
1012     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1013     OP_STREAM_NEW(42)
1014     OP_STOP_SENDING(42, 4568)
1015     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
1016     OP_RX_PKT()
1017     OP_EXPECT_DGRAM_LEN(21, 128)
1018     OP_NEXT_FRAME()
1019     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_STOP_SENDING)
1020     OP_CHECK(check_stream_12)
1021     OP_EXPECT_NO_FRAME()
1022     OP_RX_PKT_NONE()
1023     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1024     OP_END
1025 };
1026
1027 /* 13. 1-RTT, RESET_STREAM */
1028 static const unsigned char stream_13[] = {
1029     0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x7a, 0x7b
1030 };
1031
1032 static ossl_unused int check_stream_13(struct helper *h)
1033 {
1034     if (!TEST_uint64_t_eq(h->frame.reset_stream.stream_id, 42)
1035         || !TEST_uint64_t_eq(h->frame.reset_stream.app_error_code, 4568)
1036         || !TEST_uint64_t_eq(h->frame.reset_stream.final_size, 8))
1037         return 0;
1038
1039     return 1;
1040 }
1041
1042 static const struct script_op script_13[] = {
1043     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
1044     OP_HANDSHAKE_COMPLETE()
1045     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1046     OP_STREAM_NEW(42)
1047     OP_CONN_TXFC_BUMP(8)
1048     OP_STREAM_TXFC_BUMP(42, 8)
1049     OP_STREAM_SEND(42, stream_13)
1050     OP_RESET_STREAM(42, 4568)
1051     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
1052     OP_RX_PKT()
1053     OP_EXPECT_DGRAM_LEN(21, 128)
1054     OP_NEXT_FRAME()
1055     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_RESET_STREAM)
1056     OP_CHECK(check_stream_13)
1057     OP_NEXT_FRAME()
1058     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_STREAM)
1059     OP_EXPECT_NO_FRAME()
1060     OP_RX_PKT_NONE()
1061     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1062     OP_END
1063 };
1064
1065 /* 14. 1-RTT, CONNECTION_CLOSE */
1066 static int gen_conn_close(struct helper *h)
1067 {
1068     OSSL_QUIC_FRAME_CONN_CLOSE f = {0};
1069
1070     f.error_code     = 2345;
1071     f.frame_type     = OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE;
1072     f.reason         = "Reason string";
1073     f.reason_len     = strlen(f.reason);
1074
1075     if (!TEST_true(ossl_quic_tx_packetiser_schedule_conn_close(h->txp, &f)))
1076         return 0;
1077
1078     return 1;
1079 }
1080
1081 static int check_14(struct helper *h)
1082 {
1083     if (!TEST_int_eq(h->frame.conn_close.is_app, 0)
1084         || !TEST_uint64_t_eq(h->frame.conn_close.frame_type,
1085                              OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE)
1086         || !TEST_uint64_t_eq(h->frame.conn_close.error_code, 2345)
1087         || !TEST_mem_eq(h->frame.conn_close.reason, h->frame.conn_close.reason_len,
1088                         "Reason string", 13))
1089         return 0;
1090
1091     return 1;
1092 }
1093
1094 static const struct script_op script_14[] = {
1095     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
1096     OP_HANDSHAKE_COMPLETE()
1097     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1098     OP_CHECK(gen_conn_close)
1099     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
1100     OP_RX_PKT()
1101     OP_EXPECT_DGRAM_LEN(21, 512)
1102     OP_NEXT_FRAME()
1103     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_TRANSPORT)
1104     OP_CHECK(check_14)
1105     OP_EXPECT_NO_FRAME()
1106     OP_RX_PKT_NONE()
1107     OP_END
1108 };
1109
1110 /* 15. INITIAL, Anti-Deadlock Probe Simulation */
1111 static int gen_probe_initial(struct helper *h)
1112 {
1113     OSSL_ACKM_PROBE_INFO *probe = ossl_ackm_get0_probe_request(h->args.ackm);
1114
1115     /*
1116      * Pretend the ACKM asked for an anti-deadlock Initial probe.
1117      * We test output of this in the ACKM unit tests.
1118      */
1119     ++probe->anti_deadlock_initial;
1120     return 1;
1121 }
1122
1123 static const struct script_op script_15[] = {
1124     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_INITIAL, QRL_SUITE_AES128GCM, secret_1)
1125     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1126     OP_CHECK(gen_probe_initial)
1127     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
1128     OP_RX_PKT()
1129     OP_EXPECT_DGRAM_LEN(1200, 1200)
1130     OP_NEXT_FRAME()
1131     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_PING)
1132     OP_EXPECT_NO_FRAME()
1133     OP_RX_PKT_NONE()
1134     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1135     OP_END
1136 };
1137
1138 /* 16. HANDSHAKE, Anti-Deadlock Probe Simulation */
1139 static int gen_probe_handshake(struct helper *h)
1140 {
1141     OSSL_ACKM_PROBE_INFO *probe = ossl_ackm_get0_probe_request(h->args.ackm);
1142
1143     /*
1144      * Pretend the ACKM asked for an anti-deadlock Handshake probe.
1145      * We test output of this in the ACKM unit tests.
1146      */
1147     ++probe->anti_deadlock_handshake;
1148     return 1;
1149 }
1150
1151 static const struct script_op script_16[] = {
1152     OP_DISCARD_EL(QUIC_ENC_LEVEL_INITIAL)
1153     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_HANDSHAKE, QRL_SUITE_AES128GCM, secret_1)
1154     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1155     OP_CHECK(gen_probe_handshake)
1156     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
1157     OP_RX_PKT()
1158     OP_EXPECT_DGRAM_LEN(21, 512)
1159     OP_NEXT_FRAME()
1160     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_PING)
1161     OP_EXPECT_NO_FRAME()
1162     OP_RX_PKT_NONE()
1163     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1164     OP_END
1165 };
1166
1167 /* 17. 1-RTT, Probe Simulation */
1168 static int gen_probe_1rtt(struct helper *h)
1169 {
1170     OSSL_ACKM_PROBE_INFO *probe = ossl_ackm_get0_probe_request(h->args.ackm);
1171
1172     /*
1173      * Pretend the ACKM asked for a 1-RTT PTO probe.
1174      * We test output of this in the ACKM unit tests.
1175      */
1176     ++probe->pto[QUIC_PN_SPACE_APP];
1177     return 1;
1178 }
1179
1180 static const struct script_op script_17[] = {
1181     OP_DISCARD_EL(QUIC_ENC_LEVEL_INITIAL)
1182     OP_DISCARD_EL(QUIC_ENC_LEVEL_HANDSHAKE)
1183     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
1184     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1185     OP_CHECK(gen_probe_1rtt)
1186     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
1187     OP_RX_PKT()
1188     OP_EXPECT_DGRAM_LEN(21, 512)
1189     OP_NEXT_FRAME()
1190     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_PING)
1191     OP_EXPECT_NO_FRAME()
1192     OP_RX_PKT_NONE()
1193     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1194     OP_END
1195 };
1196
1197 static const struct script_op *const scripts[] = {
1198     script_1,
1199     script_2,
1200     script_3,
1201     script_4,
1202     script_5,
1203     script_6,
1204     script_7,
1205     script_8,
1206     script_9,
1207     script_10,
1208     script_11,
1209     script_12,
1210     script_13,
1211     script_14,
1212     script_15,
1213     script_16,
1214     script_17
1215 };
1216
1217 static void skip_padding(struct helper *h)
1218 {
1219     uint64_t frame_type;
1220
1221     if (!ossl_quic_wire_peek_frame_header(&h->pkt, &frame_type))
1222         return; /* EOF */
1223
1224     if (frame_type == OSSL_QUIC_FRAME_TYPE_PADDING)
1225         ossl_quic_wire_decode_padding(&h->pkt);
1226 }
1227
1228 static int run_script(const struct script_op *script)
1229 {
1230     int testresult = 0, have_helper = 0, sent_ack_eliciting = 0;
1231     struct helper h;
1232     const struct script_op *op;
1233
1234     if (!helper_init(&h))
1235         goto err;
1236
1237     have_helper = 1;
1238     for (op = script; op->opcode != OPK_END; ++op) {
1239         switch (op->opcode) {
1240         case OPK_TXP_GENERATE:
1241             if (!TEST_int_eq(ossl_quic_tx_packetiser_generate(h.txp, (int)op->arg0,
1242                                                               &sent_ack_eliciting),
1243                              TX_PACKETISER_RES_SENT_PKT))
1244                 goto err;
1245
1246             ossl_qtx_finish_dgram(h.args.qtx);
1247             ossl_qtx_flush_net(h.args.qtx);
1248             break;
1249         case OPK_TXP_GENERATE_NONE:
1250             if (!TEST_int_eq(ossl_quic_tx_packetiser_generate(h.txp, (int)op->arg0,
1251                                                               &sent_ack_eliciting),
1252                              TX_PACKETISER_RES_NO_PKT))
1253                 goto err;
1254
1255             break;
1256         case OPK_RX_PKT:
1257             ossl_quic_demux_pump(h.demux);
1258             ossl_qrx_pkt_release(h.qrx_pkt);
1259             h.qrx_pkt = NULL;
1260             if (!TEST_true(ossl_qrx_read_pkt(h.qrx, &h.qrx_pkt)))
1261                 goto err;
1262             if (!TEST_true(PACKET_buf_init(&h.pkt,
1263                                            h.qrx_pkt->hdr->data,
1264                                            h.qrx_pkt->hdr->len)))
1265                 goto err;
1266             h.frame_type = UINT64_MAX;
1267             break;
1268         case OPK_RX_PKT_NONE:
1269             ossl_quic_demux_pump(h.demux);
1270             if (!TEST_false(ossl_qrx_read_pkt(h.qrx, &h.qrx_pkt)))
1271                 goto err;
1272             h.frame_type = UINT64_MAX;
1273             break;
1274         case OPK_EXPECT_DGRAM_LEN:
1275             if (!TEST_size_t_ge(h.qrx_pkt->datagram_len, (size_t)op->arg0)
1276                 || !TEST_size_t_le(h.qrx_pkt->datagram_len, (size_t)op->arg1))
1277                 goto err;
1278             break;
1279         case OPK_EXPECT_FRAME:
1280             if (!TEST_uint64_t_eq(h.frame_type, op->arg0))
1281                 goto err;
1282             break;
1283         case OPK_EXPECT_INITIAL_TOKEN:
1284             if (!TEST_mem_eq(h.qrx_pkt->hdr->token, h.qrx_pkt->hdr->token_len,
1285                              op->buf, (size_t)op->arg0))
1286                 goto err;
1287             break;
1288         case OPK_EXPECT_HDR:
1289             if (!TEST_true(cmp_pkt_hdr(h.qrx_pkt->hdr, op->buf,
1290                                        NULL, 0, 0)))
1291                 goto err;
1292             break;
1293         case OPK_CHECK:
1294             if (!TEST_true(op->check_func(&h)))
1295                 goto err;
1296             break;
1297         case OPK_NEXT_FRAME:
1298             skip_padding(&h);
1299             if (!ossl_quic_wire_peek_frame_header(&h.pkt, &h.frame_type)) {
1300                 h.frame_type = UINT64_MAX;
1301                 break;
1302             }
1303
1304             switch (h.frame_type) {
1305             case OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE:
1306                 if (!TEST_true(ossl_quic_wire_decode_frame_handshake_done(&h.pkt)))
1307                     goto err;
1308                 break;
1309             case OSSL_QUIC_FRAME_TYPE_PING:
1310                 if (!TEST_true(ossl_quic_wire_decode_frame_ping(&h.pkt)))
1311                     goto err;
1312                 break;
1313             case OSSL_QUIC_FRAME_TYPE_MAX_DATA:
1314                 if (!TEST_true(ossl_quic_wire_decode_frame_max_data(&h.pkt,
1315                                                                     &h.frame.max_data)))
1316                     goto err;
1317                 break;
1318             case OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID:
1319                 if (!TEST_true(ossl_quic_wire_decode_frame_new_conn_id(&h.pkt,
1320                                                                        &h.frame.new_conn_id)))
1321                     goto err;
1322                 break;
1323             case OSSL_QUIC_FRAME_TYPE_NEW_TOKEN:
1324                 if (!TEST_true(ossl_quic_wire_decode_frame_new_token(&h.pkt,
1325                                                                      &h.frame.new_token.token,
1326                                                                      &h.frame.new_token.token_len)))
1327                     goto err;
1328                 break;
1329             case OSSL_QUIC_FRAME_TYPE_ACK_WITH_ECN:
1330             case OSSL_QUIC_FRAME_TYPE_ACK_WITHOUT_ECN:
1331                 h.frame.ack.ack_ranges      = h.ack_ranges;
1332                 h.frame.ack.num_ack_ranges  = OSSL_NELEM(h.ack_ranges);
1333                 if (!TEST_true(ossl_quic_wire_decode_frame_ack(&h.pkt,
1334                                                                h.args.ack_delay_exponent,
1335                                                                &h.frame.ack,
1336                                                                NULL)))
1337                     goto err;
1338                 break;
1339             case OSSL_QUIC_FRAME_TYPE_CRYPTO:
1340                 if (!TEST_true(ossl_quic_wire_decode_frame_crypto(&h.pkt, &h.frame.crypto)))
1341                     goto err;
1342                 break;
1343
1344             case OSSL_QUIC_FRAME_TYPE_STREAM:
1345             case OSSL_QUIC_FRAME_TYPE_STREAM_FIN:
1346             case OSSL_QUIC_FRAME_TYPE_STREAM_LEN:
1347             case OSSL_QUIC_FRAME_TYPE_STREAM_LEN_FIN:
1348             case OSSL_QUIC_FRAME_TYPE_STREAM_OFF:
1349             case OSSL_QUIC_FRAME_TYPE_STREAM_OFF_FIN:
1350             case OSSL_QUIC_FRAME_TYPE_STREAM_OFF_LEN:
1351             case OSSL_QUIC_FRAME_TYPE_STREAM_OFF_LEN_FIN:
1352                 if (!TEST_true(ossl_quic_wire_decode_frame_stream(&h.pkt, &h.frame.stream)))
1353                     goto err;
1354                 break;
1355
1356             case OSSL_QUIC_FRAME_TYPE_STOP_SENDING:
1357                 if (!TEST_true(ossl_quic_wire_decode_frame_stop_sending(&h.pkt,
1358                                                                         &h.frame.stop_sending)))
1359                     goto err;
1360                 break;
1361
1362             case OSSL_QUIC_FRAME_TYPE_RESET_STREAM:
1363                 if (!TEST_true(ossl_quic_wire_decode_frame_reset_stream(&h.pkt,
1364                                                                         &h.frame.reset_stream)))
1365                     goto err;
1366                 break;
1367
1368             case OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_TRANSPORT:
1369             case OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_APP:
1370                 if (!TEST_true(ossl_quic_wire_decode_frame_conn_close(&h.pkt,
1371                                                                       &h.frame.conn_close)))
1372                     goto err;
1373                 break;
1374
1375             default:
1376                 TEST_error("unknown frame type");
1377                 goto err;
1378             }
1379             break;
1380         case OPK_EXPECT_NO_FRAME:
1381             skip_padding(&h);
1382             if (!TEST_size_t_eq(PACKET_remaining(&h.pkt), 0))
1383                 goto err;
1384             break;
1385         case OPK_PROVIDE_SECRET:
1386             if (!TEST_true(ossl_qtx_provide_secret(h.args.qtx,
1387                                                    (uint32_t)op->arg0,
1388                                                    (uint32_t)op->arg1,
1389                                                    NULL, op->buf, op->buf_len)))
1390                 goto err;
1391             if (!TEST_true(ossl_qrx_provide_secret(h.qrx,
1392                                                    (uint32_t)op->arg0,
1393                                                    (uint32_t)op->arg1,
1394                                                    NULL, op->buf, op->buf_len)))
1395                 goto err;
1396             break;
1397         case OPK_DISCARD_EL:
1398             if (!TEST_true(ossl_quic_tx_packetiser_discard_enc_level(h.txp,
1399                                                                      (uint32_t)op->arg0)))
1400                 goto err;
1401             /*
1402              * We do not discard on the QRX here, the object is to test the
1403              * TXP so if the TXP does erroneously send at a discarded EL we
1404              * want to know about it.
1405              */
1406             break;
1407         case OPK_CRYPTO_SEND:
1408             {
1409                 size_t consumed = 0;
1410
1411                 if (!TEST_true(ossl_quic_sstream_append(h.args.crypto[op->arg0],
1412                                                         op->buf, op->buf_len,
1413                                                         &consumed)))
1414                     goto err;
1415
1416                 if (!TEST_size_t_eq(consumed, op->buf_len))
1417                     goto err;
1418             }
1419             break;
1420         case OPK_STREAM_NEW:
1421             {
1422                 QUIC_STREAM *s;
1423
1424                 if (!TEST_ptr(s = ossl_quic_stream_map_alloc(h.args.qsm, op->arg0,
1425                                                              QUIC_STREAM_DIR_BIDI)))
1426                     goto err;
1427
1428                 if (!TEST_ptr(s->sstream = ossl_quic_sstream_new(512 * 1024))
1429                     || !TEST_true(ossl_quic_txfc_init(&s->txfc, &h.conn_txfc))
1430                     || !TEST_true(ossl_quic_rxfc_init(&s->rxfc, &h.conn_rxfc,
1431                                                       1 * 1024 * 1024,
1432                                                       16 * 1024 * 1024,
1433                                                       fake_now, NULL))) {
1434                     ossl_quic_sstream_free(s->sstream);
1435                     ossl_quic_stream_map_release(h.args.qsm, s);
1436                     goto err;
1437                 }
1438             }
1439             break;
1440         case OPK_STREAM_SEND:
1441             {
1442                 QUIC_STREAM *s;
1443                 size_t consumed = 0;
1444
1445                 if (!TEST_ptr(s = ossl_quic_stream_map_get_by_id(h.args.qsm,
1446                                                                  op->arg0)))
1447                     goto err;
1448
1449                 if (!TEST_true(ossl_quic_sstream_append(s->sstream, op->buf,
1450                                                         op->buf_len, &consumed)))
1451                     goto err;
1452
1453                 if (!TEST_size_t_eq(consumed, op->buf_len))
1454                     goto err;
1455
1456                 ossl_quic_stream_map_update_state(h.args.qsm, s);
1457             }
1458             break;
1459         case OPK_STREAM_FIN:
1460             {
1461                 QUIC_STREAM *s;
1462
1463                 if (!TEST_ptr(s = ossl_quic_stream_map_get_by_id(h.args.qsm,
1464                                                                  op->arg0)))
1465                     goto err;
1466
1467                 ossl_quic_sstream_fin(s->sstream);
1468             }
1469             break;
1470         case OPK_STOP_SENDING:
1471             {
1472                 QUIC_STREAM *s;
1473
1474                 if (!TEST_ptr(s = ossl_quic_stream_map_get_by_id(h.args.qsm,
1475                                                                  op->arg0)))
1476                     goto err;
1477
1478                 if (!TEST_true(ossl_quic_stream_map_stop_sending_recv_part(h.args.qsm,
1479                                                                            s, op->arg1)))
1480                     goto err;
1481
1482                 ossl_quic_stream_map_update_state(h.args.qsm, s);
1483
1484                 if (!TEST_true(s->active))
1485                     goto err;
1486             }
1487             break;
1488         case OPK_RESET_STREAM:
1489             {
1490                 QUIC_STREAM *s;
1491
1492                 if (!TEST_ptr(s = ossl_quic_stream_map_get_by_id(h.args.qsm,
1493                                                                  op->arg0)))
1494                     goto err;
1495
1496                 if (!TEST_true(ossl_quic_stream_map_reset_stream_send_part(h.args.qsm,
1497                                                                            s, op->arg1)))
1498                     goto err;
1499
1500                 ossl_quic_stream_map_update_state(h.args.qsm, s);
1501
1502                 if (!TEST_true(s->active))
1503                     goto err;
1504             }
1505             break;
1506         case OPK_CONN_TXFC_BUMP:
1507             if (!TEST_true(ossl_quic_txfc_bump_cwm(h.args.conn_txfc, op->arg0)))
1508                 goto err;
1509
1510             break;
1511         case OPK_STREAM_TXFC_BUMP:
1512             {
1513                 QUIC_STREAM *s;
1514
1515                 if (!TEST_ptr(s = ossl_quic_stream_map_get_by_id(h.args.qsm,
1516                                                                  op->arg1)))
1517                     goto err;
1518
1519                 if (!TEST_true(ossl_quic_txfc_bump_cwm(&s->txfc, op->arg0)))
1520                     goto err;
1521
1522                 ossl_quic_stream_map_update_state(h.args.qsm, s);
1523             }
1524             break;
1525         case OPK_HANDSHAKE_COMPLETE:
1526             ossl_quic_tx_packetiser_notify_handshake_complete(h.txp);
1527             break;
1528         default:
1529             TEST_error("bad opcode");
1530             goto err;
1531         }
1532     }
1533
1534     testresult = 1;
1535 err:
1536     if (have_helper)
1537         helper_cleanup(&h);
1538     return testresult;
1539 }
1540
1541 static int test_script(int idx)
1542 {
1543     return run_script(scripts[idx]);
1544 }
1545
1546 int setup_tests(void)
1547 {
1548     ADD_ALL_TESTS(test_script, OSSL_NELEM(scripts));
1549     return 1;
1550 }