Clippy tests

.circleci/config.yml

@@ -23,11 +23,11 @@ jobs:
 
       - run:
           name: Build
-          command: NSS_JOBS=3 cargo build -v
+          command: NSS_JOBS=3 cargo build -v --all-targets --all-features
 
       - run:
           name: Clippy
-          command: NSS_JOBS=3 cargo clippy -v
+          command: NSS_JOBS=3 cargo clippy -v --all-targets --all-features
 
       - run:
           name: Test

neqo-common/src/codec.rs

@@ -518,8 +518,8 @@ mod tests {
         let mut enc = Encoder::default();
         enc.encode_uint(2, 10u8); // 000a
         enc.encode_uint(1, 257u16); // 01
-        enc.encode_uint(3, 0xffffffu32); // ffffff
-        enc.encode_uint(8, 0xfedcba9876543210u64);
+        enc.encode_uint(3, 0xff_ffffu32); // ffffff
+        enc.encode_uint(8, 0xfedc_ba98_7654_3210u64);
         assert_eq!(enc, Encoder::from_hex("000a01fffffffedcba9876543210"));
     }
 

neqo-common/src/incrdecoder.rs

@@ -307,7 +307,7 @@ mod tests {
             "01" => 1,
             "0123" => 0x123,
             "012345" => 0x12345,
-            "ffffffffffffffff" => 0xffffffffffffffff,
+            "ffffffffffffffff" => 0xffff_ffff_ffff_ffff,
         ] {
             c.run(IncrementalDecoder::decode_uint(c.b.len() / 2));
         }

neqo-crypto/src/prio.rs

@@ -7,6 +7,7 @@
 #![allow(dead_code)]
 #![allow(non_upper_case_globals)]
 #![allow(non_snake_case)]
+#![allow(clippy::cognitive_complexity)]
 
 include!(concat!(env!("OUT_DIR"), "/nspr_io.rs"));
 

neqo-crypto/src/result.rs

@@ -85,7 +85,7 @@ mod tests {
                     "SSL received a record with an incorrect Message Authentication Code."
                 );
             }
-            _ => assert!(false),
+            _ => unreachable!(),
         }
     }
 
@@ -104,7 +104,7 @@ mod tests {
                 // Note that we don't test |desc| here because that comes from
                 // strerror(0), which is platform-dependent.
             }
-            _ => assert!(false),
+            _ => unreachable!(),
         }
     }
 
@@ -122,7 +122,7 @@ mod tests {
                 assert_eq!(code, -5998);
                 assert_eq!(desc, "The operation would have blocked");
             }
-            _ => assert!(false),
+            _ => panic!("bad error type"),
         }
     }
 

neqo-crypto/src/ssl.rs

@@ -7,6 +7,7 @@
 #![allow(dead_code)]
 #![allow(non_upper_case_globals)]
 #![allow(non_snake_case)]
+#![allow(clippy::cognitive_complexity)]
 
 use crate::constants::*;
 

neqo-crypto/src/time.rs

@@ -181,7 +181,7 @@ mod test {
     #[test]
     fn convert_stable() {
         let now = Time::from(Instant::now());
-        let pr: PRTime = now.clone().try_into().expect("should convert successfully");
+        let pr: PRTime = now.try_into().expect("should convert successfully");
         println!("now {:?}", now);
         println!("pr {:?}", pr);
         println!("Time::try_from(pr) {:?}", Time::try_from(pr));

neqo-crypto/tests/agent.rs

@@ -27,40 +27,58 @@ fn basic() {
     println!("server {:p}", &server);
 
     let bytes = client.handshake(now(), &[]).expect("send CH");
-    assert!(bytes.len() > 0);
+    assert!(!bytes.is_empty());
     assert_eq!(*client.state(), HandshakeState::InProgress);
 
     let bytes = server
         .handshake(now(), &bytes[..])
         .expect("read CH, send SH");
-    assert!(bytes.len() > 0);
+    assert!(!bytes.is_empty());
     assert_eq!(*server.state(), HandshakeState::InProgress);
 
     let bytes = client.handshake(now(), &bytes[..]).expect("send CF");
-    assert_eq!(bytes.len(), 0);
+    assert!(bytes.is_empty());
     assert_eq!(*client.state(), HandshakeState::AuthenticationPending);
 
     client.authenticated();
     assert_eq!(*client.state(), HandshakeState::Authenticated);
 
     // Calling handshake() again indicates that we're happy with the cert.
     let bytes = client.handshake(now(), &[]).expect("send CF");
-    assert!(bytes.len() > 0);
+    assert!(!bytes.is_empty());
     assert!(client.state().connected());
 
     let client_info = client.info().expect("got info");
     assert_eq!(TLS_VERSION_1_3, client_info.version());
     assert_eq!(TLS_AES_128_GCM_SHA256, client_info.cipher_suite());
 
     let bytes = server.handshake(now(), &bytes[..]).expect("finish");
-    assert_eq!(bytes.len(), 0);
+    assert!(bytes.is_empty());
     assert!(server.state().connected());
 
     let server_info = server.info().expect("got info");
     assert_eq!(TLS_VERSION_1_3, server_info.version());
     assert_eq!(TLS_AES_128_GCM_SHA256, server_info.cipher_suite());
 }
 
+fn check_client_preinfo(client_preinfo: SecretAgentPreInfo) {
+    assert_eq!(client_preinfo.version(), None);
+    assert_eq!(client_preinfo.cipher_suite(), None);
+    assert_eq!(client_preinfo.early_data(), false);
+    assert_eq!(client_preinfo.early_data_cipher(), None);
+    assert_eq!(client_preinfo.max_early_data(), 0);
+    assert_eq!(client_preinfo.alpn(), None);
+}
+
+fn check_server_preinfo(server_preinfo: SecretAgentPreInfo) {
+    assert_eq!(server_preinfo.version(), Some(TLS_VERSION_1_3));
+    assert_eq!(server_preinfo.cipher_suite(), Some(TLS_AES_128_GCM_SHA256));
+    assert_eq!(server_preinfo.early_data(), false);
+    assert_eq!(server_preinfo.early_data_cipher(), None);
+    assert_eq!(server_preinfo.max_early_data(), 0);
+    assert_eq!(server_preinfo.alpn(), None);
+}
+
 #[test]
 fn raw() {
     fixture_init();
@@ -70,44 +88,32 @@ fn raw() {
     println!("server {:?}", server);
 
     let client_records = client.handshake_raw(now(), None).expect("send CH");
-    assert!(client_records.len() > 0);
+    assert!(!client_records.is_empty());
     assert_eq!(*client.state(), HandshakeState::InProgress);
 
-    let client_preinfo = client.preinfo().expect("get preinfo");
-    assert_eq!(client_preinfo.version(), None);
-    assert_eq!(client_preinfo.cipher_suite(), None);
-    assert_eq!(client_preinfo.early_data(), false);
-    assert_eq!(client_preinfo.early_data_cipher(), None);
-    assert_eq!(client_preinfo.max_early_data(), 0);
-    assert_eq!(client_preinfo.alpn(), None);
+    check_client_preinfo(client.preinfo().expect("get preinfo"));
 
     let server_records =
         forward_records(now(), &mut server, client_records).expect("read CH, send SH");
-    assert!(server_records.len() > 0);
+    assert!(!server_records.is_empty());
     assert_eq!(*server.state(), HandshakeState::InProgress);
 
-    let server_preinfo = server.preinfo().expect("get preinfo");
-    assert_eq!(server_preinfo.version(), Some(TLS_VERSION_1_3));
-    assert_eq!(server_preinfo.cipher_suite(), Some(TLS_AES_128_GCM_SHA256));
-    assert_eq!(server_preinfo.early_data(), false);
-    assert_eq!(server_preinfo.early_data_cipher(), None);
-    assert_eq!(server_preinfo.max_early_data(), 0);
-    assert_eq!(server_preinfo.alpn(), None);
+    check_server_preinfo(server.preinfo().expect("get preinfo"));
 
     let client_records = forward_records(now(), &mut client, server_records).expect("send CF");
-    assert_eq!(client_records.len(), 0);
+    assert!(client_records.is_empty());
     assert_eq!(*client.state(), HandshakeState::AuthenticationPending);
 
     client.authenticated();
     assert_eq!(*client.state(), HandshakeState::Authenticated);
 
     // Calling handshake() again indicates that we're happy with the cert.
     let client_records = client.handshake_raw(now(), None).expect("send CF");
-    assert!(client_records.len() > 0);
+    assert!(!client_records.is_empty());
     assert!(client.state().connected());
 
     let server_records = forward_records(now(), &mut server, client_records).expect("finish");
-    assert_eq!(server_records.len(), 0);
+    assert!(server_records.is_empty());
     assert!(server.state().connected());
 
     // The client should have one certificate for the server.
@@ -277,8 +283,8 @@ fn zero_rtt() {
     server
         .enable_0rtt(
             anti_replay.as_ref().unwrap(),
-            0xffffffff,
-            PermissiveZeroRttChecker::new(),
+            0xffff_ffff,
+            PermissiveZeroRttChecker::make(),
         )
         .expect("should enable 0-RTT");
 
@@ -302,8 +308,8 @@ fn zero_rtt_no_eoed() {
     server
         .enable_0rtt(
             anti_replay.as_ref().unwrap(),
-            0xffffffff,
-            PermissiveZeroRttChecker::new(),
+            0xffff_ffff,
+            PermissiveZeroRttChecker::make(),
         )
         .expect("should enable 0-RTT");
     server.disable_end_of_early_data();
@@ -336,7 +342,7 @@ fn reject_zero_rtt() {
     server
         .enable_0rtt(
             anti_replay.as_ref().unwrap(),
-            0xffffffff,
+            0xffff_ffff,
             Box::new(RejectZeroRtt {}),
         )
         .expect("should enable 0-RTT");

neqo-crypto/tests/handshake.rs

@@ -83,7 +83,7 @@ pub struct PermissiveZeroRttChecker {
     resuming: bool,
 }
 impl PermissiveZeroRttChecker {
-    pub fn new() -> Box<dyn ZeroRttChecker> {
+    pub fn make() -> Box<dyn ZeroRttChecker> {
         Box::new(PermissiveZeroRttChecker { resuming: true })
     }
 }
@@ -110,7 +110,7 @@ fn zero_rtt_setup(
         server
             .enable_0rtt(
                 &anti_replay,
-                0xffffffff,
+                0xffff_ffff,
                 Box::new(PermissiveZeroRttChecker { resuming: false }),
             )
             .expect("should enable 0-RTT on server");