chore: Add some more tests to drive up coverage (#3284)

I think this is the last batch of the easy ones.

Author: larseggert

neqo-common/src/codec.rs

@@ -1331,4 +1331,9 @@ mod tests {
         let v: Vec<u8> = cloned.into();
         assert_eq!(v, vec![0x03, 0x04, 0x05, 0x06]);
     }
+
+    #[test]
+    fn encoder_debug() {
+        assert_eq!(format!("{:?}", Encoder::from_hex("010203")), "[3]: 010203");
+    }
 }

neqo-qpack/src/lib.rs

@@ -110,3 +110,47 @@ impl Error {
         })
     }
 }
+
+#[cfg(test)]
+#[cfg_attr(coverage_nightly, coverage(off))]
+mod tests {
+    use super::Error;
+
+    #[test]
+    fn error_codes() {
+        assert_eq!(Error::Decompression.code(), 0x200);
+        assert_eq!(Error::EncoderStream.code(), 0x201);
+        assert_eq!(Error::DecoderStream.code(), 0x202);
+        assert_eq!(Error::ClosedCriticalStream.code(), 0x104);
+        for err in [
+            Error::Internal,
+            Error::NeedMoreData,
+            Error::HeaderLookup,
+            Error::HuffmanDecompression,
+            Error::BadUtf8,
+            Error::ChangeCapacity,
+            Error::DynamicTableFull,
+            Error::IncrementAck,
+            Error::IntegerOverflow,
+            Error::WrongStreamCount,
+            Error::Decoding,
+            Error::EncoderStreamBlocked,
+            Error::Transport(neqo_transport::Error::NoMoreData),
+            Error::Qlog,
+        ] {
+            assert_eq!(err.code(), 3);
+        }
+    }
+
+    #[test]
+    fn map_error() {
+        assert_eq!(
+            Error::map_error::<()>(Err(Error::ClosedCriticalStream), Error::Internal),
+            Err(Error::ClosedCriticalStream)
+        );
+        assert_eq!(
+            Error::map_error::<()>(Err(Error::Internal), Error::Decompression),
+            Err(Error::Decompression)
+        );
+    }
+}

neqo-transport/src/frame.rs

@@ -1118,4 +1118,164 @@ mod tests {
         e.pad_to(u16::MAX as usize + 1, 0);
         assert_eq!(Frame::decode(&mut e.as_decoder()), Err(Error::TooMuchData));
     }
+
+    #[test]
+    fn dump() {
+        let s = |id| StreamId::from(id);
+        assert_eq!(Frame::Padding(5).dump(), "Padding { len: 5 }");
+        assert_eq!(
+            Frame::Crypto {
+                offset: 1,
+                data: &[2, 3]
+            }
+            .dump(),
+            "Crypto { offset: 1, len: 2 }"
+        );
+        assert_eq!(
+            Frame::Stream {
+                stream_id: s(4),
+                offset: 10,
+                data: &[1],
+                fin: true,
+                fill: false
+            }
+            .dump(),
+            "Stream { stream_id: 4, offset: 10, len: 1, fin: true }"
+        );
+        assert_eq!(
+            Frame::Stream {
+                stream_id: s(4),
+                offset: 0,
+                data: &[1, 2],
+                fin: false,
+                fill: true
+            }
+            .dump(),
+            "Stream { stream_id: 4, offset: 0, len: >>2, fin: false }"
+        );
+        assert_eq!(
+            Frame::Datagram {
+                data: &[1, 2, 3],
+                fill: false
+            }
+            .dump(),
+            "Datagram { len: 3 }"
+        );
+        // Remaining frames use Debug format
+        assert_eq!(Frame::Ping.dump(), "Ping");
+        assert_eq!(
+            Frame::Ack {
+                largest_acknowledged: 1,
+                ack_delay: 2,
+                first_ack_range: 0,
+                ack_ranges: vec![],
+                ecn_count: None
+            }
+            .dump(),
+            "Ack { largest_acknowledged: 1, ack_delay: 2, first_ack_range: 0, ack_ranges: [], ecn_count: None }"
+        );
+        assert_eq!(
+            Frame::ResetStream {
+                stream_id: s(1),
+                application_error_code: 2,
+                final_size: 3
+            }
+            .dump(),
+            "ResetStream { stream_id: StreamId(1), application_error_code: 2, final_size: 3 }"
+        );
+        assert_eq!(
+            Frame::StopSending {
+                stream_id: s(1),
+                application_error_code: 2
+            }
+            .dump(),
+            "StopSending { stream_id: StreamId(1), application_error_code: 2 }"
+        );
+        assert_eq!(
+            Frame::NewToken { token: &[1] }.dump(),
+            "NewToken { token: [1] }"
+        );
+        assert_eq!(
+            Frame::MaxData { maximum_data: 100 }.dump(),
+            "MaxData { maximum_data: 100 }"
+        );
+        assert_eq!(
+            Frame::MaxStreamData {
+                stream_id: s(1),
+                maximum_stream_data: 100
+            }
+            .dump(),
+            "MaxStreamData { stream_id: StreamId(1), maximum_stream_data: 100 }"
+        );
+        assert_eq!(
+            Frame::MaxStreams {
+                stream_type: StreamType::BiDi,
+                maximum_streams: 10
+            }
+            .dump(),
+            "MaxStreams { stream_type: BiDi, maximum_streams: 10 }"
+        );
+        assert_eq!(
+            Frame::DataBlocked { data_limit: 50 }.dump(),
+            "DataBlocked { data_limit: 50 }"
+        );
+        assert_eq!(
+            Frame::StreamDataBlocked {
+                stream_id: s(1),
+                stream_data_limit: 50
+            }
+            .dump(),
+            "StreamDataBlocked { stream_id: StreamId(1), stream_data_limit: 50 }"
+        );
+        assert_eq!(
+            Frame::StreamsBlocked {
+                stream_type: StreamType::UniDi,
+                stream_limit: 5
+            }
+            .dump(),
+            "StreamsBlocked { stream_type: UniDi, stream_limit: 5 }"
+        );
+        assert_eq!(
+            Frame::NewConnectionId {
+                sequence_number: 1,
+                retire_prior: 0,
+                connection_id: &[1, 2],
+                stateless_reset_token: Srt::new([0; 16])
+            }
+            .dump(),
+            "NewConnectionId { sequence_number: 1, retire_prior: 0, connection_id: [1, 2], stateless_reset_token: Token([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) }"
+        );
+        assert_eq!(
+            Frame::RetireConnectionId { sequence_number: 1 }.dump(),
+            "RetireConnectionId { sequence_number: 1 }"
+        );
+        assert_eq!(
+            Frame::PathChallenge { data: [1; 8] }.dump(),
+            "PathChallenge { data: [1, 1, 1, 1, 1, 1, 1, 1] }"
+        );
+        assert_eq!(
+            Frame::PathResponse { data: [2; 8] }.dump(),
+            "PathResponse { data: [2, 2, 2, 2, 2, 2, 2, 2] }"
+        );
+        assert_eq!(
+            Frame::ConnectionClose {
+                error_code: CloseError::Transport(0),
+                frame_type: 0,
+                reason_phrase: String::new()
+            }
+            .dump(),
+            "ConnectionClose { error_code: Transport(0), frame_type: 0, reason_phrase: \"\" }"
+        );
+        assert_eq!(Frame::HandshakeDone.dump(), "HandshakeDone");
+        assert_eq!(
+            Frame::AckFrequency {
+                seqno: 1,
+                tolerance: 2,
+                delay: 3,
+                ignore_order: false
+            }
+            .dump(),
+            "AckFrequency { seqno: 1, tolerance: 2, delay: 3, ignore_order: false }"
+        );
+    }
 }

neqo-transport/src/lib.rs

@@ -269,3 +269,58 @@ impl CloseReason {
 }
 
 pub type Res<T> = Result<T, Error>;
+
+#[cfg(test)]
+#[cfg_attr(coverage_nightly, coverage(off))]
+mod tests {
+    use super::{CloseReason, Error};
+
+    #[test]
+    fn error_codes() {
+        for (err, code) in [
+            (Error::None, 0),
+            (Error::IdleTimeout, 0),
+            (Error::Peer(0), 0),
+            (Error::PeerApplication(0), 0),
+            (Error::ConnectionRefused, 2),
+            (Error::FlowControl, 3),
+            (Error::StreamLimit, 4),
+            (Error::StreamState, 5),
+            (Error::FinalSize, 6),
+            (Error::FrameEncoding, 7),
+            (Error::TransportParameter, 8),
+            (Error::ProtocolViolation, 10),
+            (Error::InvalidToken, 11),
+            (Error::KeysExhausted, 15),
+            (Error::Application, 12),
+            (Error::NoAvailablePath, 16),
+            (Error::CryptoBufferExceeded, 13),
+            (Error::CryptoAlert(0x2a), 0x12a),
+            (Error::EchRetry(vec![]), 0x179),
+            (Error::VersionNegotiation, 0x53f8),
+            (Error::Internal, 1),
+        ] {
+            assert_eq!(err.code(), code);
+        }
+    }
+
+    #[test]
+    fn close_reason_is_error() {
+        assert!(!CloseReason::Transport(Error::None).is_error());
+        assert!(!CloseReason::Application(0).is_error());
+        assert!(CloseReason::Transport(Error::Internal).is_error());
+        assert!(CloseReason::Application(1).is_error());
+    }
+
+    #[test]
+    fn error_from_impls() {
+        assert_eq!(
+            Error::from(neqo_crypto::Error::EchRetry(vec![1, 2])),
+            Error::EchRetry(vec![1, 2])
+        );
+        assert!(matches!(
+            Error::from(u64::try_from(-1_i32).unwrap_err()),
+            Error::IntegerOverflow
+        ));
+    }
+}

neqo-transport/src/tparams.rs

@@ -1286,4 +1286,9 @@ mod tests {
         assert!(!current.ok_for_0rtt(&remembered));
         assert!(!remembered.ok_for_0rtt(&current));
     }
+
+    #[test]
+    fn transport_parameter_id_display() {
+        assert_eq!(format!("{IdleTimeout}"), "IdleTimeout((0x01))");
+    }
 }