fn resetting_a_stream_takes_priority()

in quic/s2n-quic-transport/src/stream/send_stream/tests.rs [2579:2653]

• 64 lines of code
• 9 McCabe index (conditional complexity)

fn resetting_a_stream_takes_priority() {
    let error_code = ApplicationErrorCode::new(123).unwrap();

    for sizes in [None, Some(&[10, 10, 10])] {
        for finish in [true, false] {
            for flush in [true, false] {
                for with_context in [true, false] {
                    let mut test_env = setup_send_only_test_env();

                    let will_wake = with_context && flush;
                    dbg!(sizes);
                    dbg!(finish);
                    dbg!(flush);
                    dbg!(with_context);

                    let mut request = ops::Request::default();

                    request.reset(error_code);
                    let mut chunks =
                        sizes.map(|sizes| gen_pattern_test_chunks(VarInt::from_u8(0), sizes));

                    if let Some(chunks) = chunks.as_deref_mut() {
                        request.send(chunks);
                    }

                    if finish {
                        request.finish();
                    }

                    if flush {
                        request.flush();
                    }

                    assert_eq!(
                        test_env.run_request(&mut request, with_context),
                        Ok(ops::Response {
                            tx: Some(ops::tx::Response {
                                status: ops::Status::Resetting,
                                will_wake,
                                ..Default::default()
                            }),
                            rx: None,
                        }),
                    );

                    execute_instructions(
                        &mut test_env,
                        &[
                            Instruction::CheckInterests(stream_interests(&["tx"])),
                            Instruction::CheckResetTx(error_code, pn(0), VarInt::from_u8(0)),
                            Instruction::CheckInterests(stream_interests(&["ack"])),
                            Instruction::AckPacket(pn(0), ExpectWakeup(Some(will_wake))),
                        ],
                    );

                    assert_matches!(
                        test_env.run_request(&mut request, with_context),
                        Ok(ops::Response {
                            tx: Some(ops::tx::Response {
                                status: ops::Status::Reset(StreamError::StreamReset { .. }),
                                ..
                            }),
                            rx: None,
                        }),
                    );

                    execute_instructions(
                        &mut test_env,
                        &[Instruction::CheckInterests(stream_interests(&["fin"]))],
                    );
                }
            }
        }
    }
}