fn ping_test()

in quic/s2n-quic-transport/src/sync/flag.rs [201:365]

• 132 lines of code
• 1 McCabe index (conditional complexity)

    fn ping_test() {
        let mut frame_buffer = OutgoingFrameBuffer::new();
        let mut context = MockWriteContext::new(
            time::now(),
            &mut frame_buffer,
            transmission::Constraint::None,
            transmission::Mode::Normal,
            endpoint::Type::Server,
        );

        let mut pinger = Ping::default();

        assert!(pinger.is_idle());
        assert!(
            !pinger.has_transmission_interest(),
            "status should not express interest in default state"
        );

        pinger.on_transmit(&mut context).unwrap();

        assert!(
            context.frame_buffer.is_empty(),
            "status should not transmit in default state"
        );

        pinger.send();
        assert!(!pinger.is_idle());

        assert_eq!(
            pinger.get_transmission_interest(),
            transmission::Interest::NewData,
            "status should express interest in deliver after calling send"
        );

        pinger.send();
        assert_eq!(
            pinger.get_transmission_interest(),
            transmission::Interest::NewData,
            "status should accept duplicate calls to send"
        );

        context.transmission_constraint = transmission::Constraint::CongestionLimited;
        pinger.on_transmit(&mut context).unwrap();
        assert!(!pinger.is_idle());

        assert_eq!(
            pinger.delivery,
            DeliveryState::RequiresTransmission,
            "status should not transmit when congestion limited"
        );
        assert!(
            context.frame_buffer.is_empty(),
            "status should not transmit in congestion limited state"
        );

        context.transmission_constraint = transmission::Constraint::None;

        pinger.on_transmit(&mut context).unwrap();
        assert!(!pinger.is_idle());

        let stable_packet_number = context
            .frame_buffer
            .pop_front()
            .expect("status should write PING frames")
            .packet_nr;
        context.frame_buffer.clear();

        assert_eq!(
            pinger.delivery,
            DeliveryState::InFlight {
                stable: stable_packet_number,
                latest: stable_packet_number
            }
        );

        context.transmission_constraint = transmission::Constraint::RetransmissionOnly;

        pinger.on_transmit(&mut context).unwrap();
        assert!(!pinger.is_idle());

        assert!(
            context.frame_buffer.is_empty(),
            "status should not passively write frames when transmission constrained"
        );

        context.transmission_constraint = transmission::Constraint::None;

        pinger.on_transmit(&mut context).unwrap();
        assert!(!pinger.is_idle());

        let latest_packet_number = context
            .frame_buffer
            .pop_front()
            .expect("status should passively write PING frames")
            .packet_nr;
        context.frame_buffer.clear();

        assert_eq!(
            pinger.delivery,
            DeliveryState::InFlight {
                stable: stable_packet_number,
                latest: latest_packet_number,
            }
        );

        pinger.on_packet_loss(&stable_packet_number);

        assert_eq!(
            pinger.delivery,
            DeliveryState::InFlight {
                stable: latest_packet_number,
                latest: latest_packet_number,
            },
            "status should transition to latest on stable packet loss"
        );

        pinger.on_packet_loss(&latest_packet_number);

        assert_eq!(
            pinger.get_transmission_interest(),
            transmission::Interest::LostData,
            "transmission should be active on latest packet loss"
        );
        assert_eq!(
            pinger.delivery,
            DeliveryState::RequiresRetransmission,
            "status should force retransmission on loss"
        );

        context.transmission_constraint = transmission::Constraint::CongestionLimited;
        pinger.on_transmit(&mut context).unwrap();
        assert!(!pinger.is_idle());

        assert_eq!(
            pinger.delivery,
            DeliveryState::RequiresRetransmission,
            "status should not transmit when congestion limited"
        );

        context.transmission_constraint = transmission::Constraint::RetransmissionOnly;

        pinger.on_transmit(&mut context).unwrap();

        let latest_packet_number = context
            .frame_buffer
            .pop_front()
            .expect("status should passively write PING frames")
            .packet_nr;
        context.frame_buffer.clear();

        pinger.on_packet_ack(&latest_packet_number);

        assert_eq!(pinger.delivery, DeliveryState::Delivered);

        assert!(
            !pinger.has_transmission_interest(),
            "status should not express interest after complete",
        );

        pinger.on_transmit(&mut context).unwrap();
        assert!(
            context.frame_buffer.is_empty(),
            "status should not transmit after complete"
        );
    }