rust: run rustfmt

6 files changed, 172 insertions, 109 deletions

diff --git a/src/rust/protover/errors.rs b/src/rust/protover/errors.rs
index 56473d12e6..71fbc53e17 100644
--- a/src/rust/protover/errors.rs
+++ b/src/rust/protover/errors.rs
@@ -24,20 +24,30 @@ pub enum ProtoverError {
 impl Display for ProtoverError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            ProtoverError::Overlap
-                => write!(f, "Two or more (low, high) protover ranges would overlap once expanded."),
-            ProtoverError::LowGreaterThanHigh
-                => write!(f, "The low in a (low, high) protover range was greater than high."),
-            ProtoverError::Unparseable
-                => write!(f, "The protover string was unparseable."),
-            ProtoverError::ExceedsMax
-                => write!(f, "The high in a (low, high) protover range exceeds u32::MAX."),
-            ProtoverError::ExceedsExpansionLimit
-                => write!(f, "The protover string would exceed the maximum expansion limit."),
-            ProtoverError::UnknownProtocol
-                => write!(f, "A protocol in the protover string we attempted to parse is unknown."),
-            ProtoverError::ExceedsNameLimit
-                => write!(f, "An unrecognised protocol name was too long."),
+            ProtoverError::Overlap => write!(
+                f,
+                "Two or more (low, high) protover ranges would overlap once expanded."
+            ),
+            ProtoverError::LowGreaterThanHigh => write!(
+                f,
+                "The low in a (low, high) protover range was greater than high."
+            ),
+            ProtoverError::Unparseable => write!(f, "The protover string was unparseable."),
+            ProtoverError::ExceedsMax => write!(
+                f,
+                "The high in a (low, high) protover range exceeds u32::MAX."
+            ),
+            ProtoverError::ExceedsExpansionLimit => write!(
+                f,
+                "The protover string would exceed the maximum expansion limit."
+            ),
+            ProtoverError::UnknownProtocol => write!(
+                f,
+                "A protocol in the protover string we attempted to parse is unknown."
+            ),
+            ProtoverError::ExceedsNameLimit => {
+                write!(f, "An unrecognised protocol name was too long.")
+            }
         }
     }
 }
diff --git a/src/rust/protover/ffi.rs b/src/rust/protover/ffi.rs
index 91bd83addf..0c28d032c6 100644
--- a/src/rust/protover/ffi.rs
+++ b/src/rust/protover/ffi.rs
@@ -62,8 +62,7 @@ pub extern "C" fn protover_all_supported(
         };
 
     if let Some(unsupported) = relay_proto_entry.all_supported() {
-        let c_unsupported: CString = match CString::new(unsupported.to_string())
-        {
+        let c_unsupported: CString = match CString::new(unsupported.to_string()) {
             Ok(n) => n,
             Err(_) => return 1,
         };
@@ -113,9 +112,7 @@ pub extern "C" fn protocol_list_supports_protocol(
 }
 
 #[no_mangle]
-pub extern "C" fn protover_contains_long_protocol_names_(
-    c_protocol_list: *const c_char,
-) -> c_int {
+pub extern "C" fn protover_contains_long_protocol_names_(c_protocol_list: *const c_char) -> c_int {
     if c_protocol_list.is_null() {
         return 1;
     }
@@ -216,8 +213,7 @@ pub extern "C" fn protover_compute_vote(
         };
         proto_entries.push(entry);
     }
-    let vote: UnvalidatedProtoEntry =
-        ProtoverVote::compute(&proto_entries, &hold);
+    let vote: UnvalidatedProtoEntry = ProtoverVote::compute(&proto_entries, &hold);
 
     allocate_and_copy_string(&vote.to_string())
 }
@@ -225,10 +221,7 @@ pub extern "C" fn protover_compute_vote(
 /// Provide an interface for C to translate arguments and return types for
 /// protover::is_supported_here
 #[no_mangle]
-pub extern "C" fn protover_is_supported_here(
-    c_protocol: uint32_t,
-    version: uint32_t,
-) -> c_int {
+pub extern "C" fn protover_is_supported_here(c_protocol: uint32_t, version: uint32_t) -> c_int {
     let protocol = match translate_to_rust(c_protocol) {
         Ok(n) => n,
         Err(_) => return 0,
@@ -242,9 +235,7 @@ pub extern "C" fn protover_is_supported_here(
 /// Provide an interface for C to translate arguments and return types for
 /// protover::compute_for_old_tor
 #[no_mangle]
-pub extern "C" fn protover_compute_for_old_tor(
-    version: *const c_char,
-) -> *const c_char {
+pub extern "C" fn protover_compute_for_old_tor(version: *const c_char) -> *const c_char {
     let supported: &'static CStr;
     let empty: &'static CStr;
 
diff --git a/src/rust/protover/lib.rs b/src/rust/protover/lib.rs
index 4ea20665c8..9625cb58ad 100644
--- a/src/rust/protover/lib.rs
+++ b/src/rust/protover/lib.rs
@@ -25,16 +25,16 @@
 // XXX: add missing docs
 //#![deny(missing_docs)]
 
+extern crate external;
 extern crate libc;
 extern crate smartlist;
-extern crate external;
 extern crate tor_allocate;
 #[macro_use]
 extern crate tor_util;
 
 pub mod errors;
+pub mod ffi;
 pub mod protoset;
 mod protover;
-pub mod ffi;
 
 pub use protover::*;
diff --git a/src/rust/protover/protoset.rs b/src/rust/protover/protoset.rs
index 4afc50edf8..5cea03983a 100644
--- a/src/rust/protover/protoset.rs
+++ b/src/rust/protover/protoset.rs
@@ -53,7 +53,7 @@ impl Default for ProtoSet {
     fn default() -> Self {
         let pairs: Vec<(Version, Version)> = Vec::new();
 
-        ProtoSet{ pairs }
+        ProtoSet { pairs }
     }
 }
 
@@ -73,7 +73,7 @@ impl<'a> ProtoSet {
         pairs.sort_unstable();
         pairs.dedup();
 
-        ProtoSet{ pairs }.is_ok()
+        ProtoSet { pairs }.is_ok()
     }
 }
 
@@ -263,7 +263,8 @@ impl ProtoSet {
     /// ```
     // XXX we could probably do something more efficient here. —isis
     pub fn retain<F>(&mut self, f: F)
-        where F: FnMut(&Version) -> bool
+    where
+        F: FnMut(&Version) -> bool,
     {
         let mut expanded: Vec<Version> = self.clone().expand();
         expanded.retain(f);
@@ -299,7 +300,7 @@ impl FromStr for ProtoSet {
     /// * there are greater than 2^16 version numbers to expand.
     ///
     /// # Examples
-    /// 
+    ///
     /// ```
     /// use std::str::FromStr;
     ///
@@ -350,10 +351,10 @@ impl FromStr for ProtoSet {
             } else if p.contains('-') {
                 let mut pair = p.split('-');
 
-                let low  = pair.next().ok_or(ProtoverError::Unparseable)?;
+                let low = pair.next().ok_or(ProtoverError::Unparseable)?;
                 let high = pair.next().ok_or(ProtoverError::Unparseable)?;
 
-                let lo: Version =  low.parse().or(Err(ProtoverError::Unparseable))?;
+                let lo: Version = low.parse().or(Err(ProtoverError::Unparseable))?;
                 let hi: Version = high.parse().or(Err(ProtoverError::Unparseable))?;
 
                 if lo == u32::MAX || hi == u32::MAX {
@@ -457,11 +458,11 @@ impl From<Vec<Version>> for ProtoSet {
             if has_range {
                 let first: Version = match v.first() {
                     Some(x) => *x,
-                    None    => continue,
+                    None => continue,
                 };
-                let last:  Version = match v.get(index) {
+                let last: Version = match v.get(index) {
                     Some(x) => *x,
-                    None    => continue,
+                    None => continue,
                 };
                 debug_assert!(last == end, format!("last = {}, end = {}", last, end));
 
@@ -474,7 +475,7 @@ impl From<Vec<Version>> for ProtoSet {
             } else {
                 let last: Version = match v.get(index) {
                     Some(x) => *x,
-                    None    => continue,
+                    None => continue,
                 };
                 version_pairs.push((last, last));
                 v.remove(index);
@@ -498,22 +499,22 @@ mod test {
     }
 
     macro_rules! assert_contains_each {
-        ($protoset:expr, $versions:expr) => (
+        ($protoset:expr, $versions:expr) => {
             for version in $versions {
                 assert!($protoset.contains(version));
             }
-        )
+        };
     }
 
     macro_rules! test_protoset_contains_versions {
-        ($list:expr, $str:expr) => (
+        ($list:expr, $str:expr) => {
             let versions: &[Version] = $list;
             let protoset: Result<ProtoSet, ProtoverError> = ProtoSet::from_str($str);
 
             assert!(protoset.is_ok());
             let p = protoset.unwrap();
             assert_contains_each!(p, versions);
-        )
+        };
     }
 
     #[test]
@@ -555,26 +556,41 @@ mod test {
 
     #[test]
     fn test_versions_from_slice_overlap() {
-        assert_eq!(Err(ProtoverError::Overlap), ProtoSet::from_slice(&[(1, 3), (2, 4)]));
+        assert_eq!(
+            Err(ProtoverError::Overlap),
+            ProtoSet::from_slice(&[(1, 3), (2, 4)])
+        );
     }
 
     #[test]
     fn test_versions_from_str_max() {
-        assert_eq!(Err(ProtoverError::ExceedsMax), ProtoSet::from_str("4294967295"));
+        assert_eq!(
+            Err(ProtoverError::ExceedsMax),
+            ProtoSet::from_str("4294967295")
+        );
     }
 
     #[test]
     fn test_versions_from_slice_max() {
-        assert_eq!(Err(ProtoverError::ExceedsMax), ProtoSet::from_slice(&[(4294967295, 4294967295)]));
+        assert_eq!(
+            Err(ProtoverError::ExceedsMax),
+            ProtoSet::from_slice(&[(4294967295, 4294967295)])
+        );
     }
 
     #[test]
     fn test_protoset_contains() {
         let protoset: ProtoSet = ProtoSet::from_slice(&[(0, 5), (7, 9), (13, 14)]).unwrap();
 
-        for x in 0..6   { assert!(protoset.contains(&x), format!("should contain {}", x)); }
-        for x in 7..10  { assert!(protoset.contains(&x), format!("should contain {}", x)); }
-        for x in 13..15 { assert!(protoset.contains(&x), format!("should contain {}", x)); }
+        for x in 0..6 {
+            assert!(protoset.contains(&x), format!("should contain {}", x));
+        }
+        for x in 7..10 {
+            assert!(protoset.contains(&x), format!("should contain {}", x));
+        }
+        for x in 13..15 {
+            assert!(protoset.contains(&x), format!("should contain {}", x));
+        }
 
         for x in [6, 10, 11, 12, 15, 42, 43, 44, 45, 1234584].iter() {
             assert!(!protoset.contains(&x), format!("should not contain {}", x));
@@ -585,7 +601,9 @@ mod test {
     fn test_protoset_contains_0_3() {
         let protoset: ProtoSet = ProtoSet::from_slice(&[(0, 3)]).unwrap();
 
-        for x in 0..4 { assert!(protoset.contains(&x), format!("should contain {}", x)); }
+        for x in 0..4 {
+            assert!(protoset.contains(&x), format!("should contain {}", x));
+        }
     }
 
     macro_rules! assert_protoset_from_vec_contains_all {
@@ -611,7 +629,7 @@ mod test {
 
     #[test]
     fn test_protoset_from_vec_unordered() {
-        let v: Vec<Version> = vec!(2, 3, 8, 4, 3, 9, 7, 2);
+        let v: Vec<Version> = vec![2, 3, 8, 4, 3, 9, 7, 2];
         let ps: ProtoSet = v.into();
 
         assert_eq!(ps.to_string(), "2-4,7-9");
diff --git a/src/rust/protover/protover.rs b/src/rust/protover/protover.rs
index 299e433722..933defa705 100644
--- a/src/rust/protover/protover.rs
+++ b/src/rust/protover/protover.rs
@@ -1,8 +1,8 @@
 // Copyright (c) 2016-2018, The Tor Project, Inc. */
 // See LICENSE for licensing information */
 
-use std::collections::HashMap;
 use std::collections::hash_map;
+use std::collections::HashMap;
 use std::ffi::CStr;
 use std::fmt;
 use std::str;
@@ -12,8 +12,8 @@ use std::string::String;
 use external::c_tor_version_as_new_as;
 
 use errors::ProtoverError;
-use protoset::Version;
 use protoset::ProtoSet;
+use protoset::Version;
 
 /// The first version of Tor that included "proto" entries in its descriptors.
 /// Authorities should use this to decide whether to guess proto lines.
@@ -26,7 +26,7 @@ const FIRST_TOR_VERSION_TO_ADVERTISE_PROTOCOLS: &'static str = "0.2.9.3-alpha";
 /// before concluding that someone is trying to DoS us
 ///
 /// C_RUST_COUPLED: protover.c `MAX_PROTOCOLS_TO_EXPAND`
-const MAX_PROTOCOLS_TO_EXPAND: usize = (1<<16);
+const MAX_PROTOCOLS_TO_EXPAND: usize = (1 << 16);
 
 /// The maximum size an `UnknownProtocol`'s name may be.
 pub(crate) const MAX_PROTOCOL_NAME_LENGTH: usize = 100;
@@ -132,16 +132,18 @@ impl From<Protocol> for UnknownProtocol {
 ///
 //  C_RUST_COUPLED: protover.c `protover_get_supported_protocols`
 pub(crate) fn get_supported_protocols_cstr() -> &'static CStr {
-    cstr!("Cons=1-2 \
-           Desc=1-2 \
-           DirCache=1-2 \
-           HSDir=1-2 \
-           HSIntro=3-4 \
-           HSRend=1-2 \
-           Link=1-5 \
-           LinkAuth=1,3 \
-           Microdesc=1-2 \
-           Relay=1-2")
+    cstr!(
+        "Cons=1-2 \
+         Desc=1-2 \
+         DirCache=1-2 \
+         HSDir=1-2 \
+         HSIntro=3-4 \
+         HSRend=1-2 \
+         Link=1-5 \
+         LinkAuth=1,3 \
+         Microdesc=1-2 \
+         Relay=1-2"
+    )
 }
 
 /// A map of protocol names to the versions of them which are supported.
@@ -150,7 +152,7 @@ pub struct ProtoEntry(HashMap<Protocol, ProtoSet>);
 
 impl Default for ProtoEntry {
     fn default() -> ProtoEntry {
-        ProtoEntry( HashMap::new() )
+        ProtoEntry(HashMap::new())
     }
 }
 
@@ -240,7 +242,7 @@ impl FromStr for ProtoEntry {
 /// Generate an implementation of `ToString` for either a `ProtoEntry` or an
 /// `UnvalidatedProtoEntry`.
 macro_rules! impl_to_string_for_proto_entry {
-    ($t:ty) => (
+    ($t:ty) => {
         impl ToString for $t {
             fn to_string(&self) -> String {
                 let mut parts: Vec<String> = Vec::new();
@@ -252,7 +254,7 @@ macro_rules! impl_to_string_for_proto_entry {
                 parts.join(" ")
             }
         }
-    )
+    };
 }
 
 impl_to_string_for_proto_entry!(ProtoEntry);
@@ -266,7 +268,7 @@ pub struct UnvalidatedProtoEntry(HashMap<UnknownProtocol, ProtoSet>);
 
 impl Default for UnvalidatedProtoEntry {
     fn default() -> UnvalidatedProtoEntry {
-        UnvalidatedProtoEntry( HashMap::new() )
+        UnvalidatedProtoEntry(HashMap::new())
     }
 }
 
@@ -324,7 +326,7 @@ impl UnvalidatedProtoEntry {
     pub fn all_supported(&self) -> Option<UnvalidatedProtoEntry> {
         let mut unsupported: UnvalidatedProtoEntry = UnvalidatedProtoEntry::default();
         let supported: ProtoEntry = match ProtoEntry::supported() {
-            Ok(x)  => x,
+            Ok(x) => x,
             Err(_) => return None,
         };
 
@@ -454,9 +456,9 @@ impl UnvalidatedProtoEntry {
     /// * If a protocol name is an empty string, e.g. `"Cons=1,3 =3-5"`.
     /// * If a protocol name cannot be parsed as utf-8.
     /// * If the version numbers are an empty string, e.g. `"Cons="`.
-    fn parse_protocol_and_version_str<'a>(protocol_string: &'a str)
-        -> Result<Vec<(&'a str, &'a str)>, ProtoverError>
-    {
+    fn parse_protocol_and_version_str<'a>(
+        protocol_string: &'a str,
+    ) -> Result<Vec<(&'a str, &'a str)>, ProtoverError> {
         let mut protovers: Vec<(&str, &str)> = Vec::new();
 
         for subproto in protocol_string.split(' ') {
@@ -523,9 +525,9 @@ impl FromStr for UnvalidatedProtoEntry {
 impl UnvalidatedProtoEntry {
     /// Create an `UnknownProtocol`, ignoring whether or not it
     /// exceeds MAX_PROTOCOL_NAME_LENGTH.
-    pub(crate) fn from_str_any_len(protocol_string: &str)
-        -> Result<UnvalidatedProtoEntry, ProtoverError>
-    {
+    pub(crate) fn from_str_any_len(
+        protocol_string: &str,
+    ) -> Result<UnvalidatedProtoEntry, ProtoverError> {
         let mut parsed: UnvalidatedProtoEntry = UnvalidatedProtoEntry::default();
         let parts: Vec<(&str, &str)> =
             UnvalidatedProtoEntry::parse_protocol_and_version_str(protocol_string)?;
@@ -560,11 +562,11 @@ impl From<ProtoEntry> for UnvalidatedProtoEntry {
 /// The "protocols" are *not* guaranteed to be known/supported `Protocol`s, in
 /// order to allow new subprotocols to be introduced even if Directory
 /// Authorities don't yet know of them.
-pub struct ProtoverVote( HashMap<UnknownProtocol, HashMap<Version, usize>> );
+pub struct ProtoverVote(HashMap<UnknownProtocol, HashMap<Version, usize>>);
 
 impl Default for ProtoverVote {
     fn default() -> ProtoverVote {
-        ProtoverVote( HashMap::new() )
+        ProtoverVote(HashMap::new())
     }
 }
 
@@ -578,9 +580,10 @@ impl IntoIterator for ProtoverVote {
 }
 
 impl ProtoverVote {
-    pub fn entry(&mut self, key: UnknownProtocol)
-        -> hash_map::Entry<UnknownProtocol, HashMap<Version, usize>>
-    {
+    pub fn entry(
+        &mut self,
+        key: UnknownProtocol,
+    ) -> hash_map::Entry<UnknownProtocol, HashMap<Version, usize>> {
         self.0.entry(key)
     }
 
@@ -602,7 +605,10 @@ impl ProtoverVote {
     /// assert_eq!("Link=3", vote.to_string());
     /// ```
     // C_RUST_COUPLED: protover.c protover_compute_vote
-    pub fn compute(proto_entries: &[UnvalidatedProtoEntry], threshold: &usize) -> UnvalidatedProtoEntry {
+    pub fn compute(
+        proto_entries: &[UnvalidatedProtoEntry],
+        threshold: &usize,
+    ) -> UnvalidatedProtoEntry {
         let mut all_count: ProtoverVote = ProtoverVote::default();
         let mut final_output: UnvalidatedProtoEntry = UnvalidatedProtoEntry::default();
 
@@ -628,8 +634,7 @@ impl ProtoverVote {
                     all_count.entry(protocol.clone()).or_insert(HashMap::new());
 
                 for version in versions.clone().expand() {
-                    let counter: &mut usize =
-                        supported_vers.entry(version).or_insert(0);
+                    let counter: &mut usize = supported_vers.entry(version).or_insert(0);
                     *counter += 1;
                 }
             }
@@ -708,16 +713,22 @@ pub(crate) fn compute_for_old_tor_cstr(version: &str) -> &'static CStr {
         return empty;
     }
     if c_tor_version_as_new_as(version, "0.2.9.1-alpha") {
-        return cstr!("Cons=1-2 Desc=1-2 DirCache=1 HSDir=1 HSIntro=3 HSRend=1-2 \
-                      Link=1-4 LinkAuth=1 Microdesc=1-2 Relay=1-2");
+        return cstr!(
+            "Cons=1-2 Desc=1-2 DirCache=1 HSDir=1 HSIntro=3 HSRend=1-2 \
+             Link=1-4 LinkAuth=1 Microdesc=1-2 Relay=1-2"
+        );
     }
     if c_tor_version_as_new_as(version, "0.2.7.5") {
-        return cstr!("Cons=1-2 Desc=1-2 DirCache=1 HSDir=1 HSIntro=3 HSRend=1 \
-                      Link=1-4 LinkAuth=1 Microdesc=1-2 Relay=1-2");
+        return cstr!(
+            "Cons=1-2 Desc=1-2 DirCache=1 HSDir=1 HSIntro=3 HSRend=1 \
+             Link=1-4 LinkAuth=1 Microdesc=1-2 Relay=1-2"
+        );
     }
     if c_tor_version_as_new_as(version, "0.2.4.19") {
-        return cstr!("Cons=1 Desc=1 DirCache=1 HSDir=1 HSIntro=3 HSRend=1 \
-                      Link=1-4 LinkAuth=1 Microdesc=1 Relay=1-2");
+        return cstr!(
+            "Cons=1 Desc=1 DirCache=1 HSDir=1 HSIntro=3 HSRend=1 \
+             Link=1-4 LinkAuth=1 Microdesc=1 Relay=1-2"
+        );
     }
     empty
 }
@@ -752,7 +763,9 @@ pub(crate) fn compute_for_old_tor_cstr(version: &str) -> &'static CStr {
 pub fn compute_for_old_tor(version: &str) -> Result<&'static str, ProtoverError> {
     // .to_str() fails with a Utf8Error if it couldn't validate the
     // utf-8, so convert that here into an Unparseable ProtoverError.
-    compute_for_old_tor_cstr(version).to_str().or(Err(ProtoverError::Unparseable))
+    compute_for_old_tor_cstr(version)
+        .to_str()
+        .or(Err(ProtoverError::Unparseable))
 }
 
 #[cfg(test)]
@@ -763,19 +776,19 @@ mod test {
     use super::*;
 
     macro_rules! assert_protoentry_is_parseable {
-        ($e:expr) => (
+        ($e:expr) => {
             let protoentry: Result<ProtoEntry, ProtoverError> = $e.parse();
 
             assert!(protoentry.is_ok(), format!("{:?}", protoentry.err()));
-        )
+        };
     }
 
     macro_rules! assert_protoentry_is_unparseable {
-        ($e:expr) => (
+        ($e:expr) => {
             let protoentry: Result<ProtoEntry, ProtoverError> = $e.parse();
 
             assert!(protoentry.is_err());
-        )
+        };
     }
 
     #[test]
@@ -861,24 +874,45 @@ mod test {
     #[test]
     fn test_contract_protocol_list() {
         let mut versions = "";
-        assert_eq!(String::from(versions), ProtoSet::from_str(&versions).unwrap().to_string());
+        assert_eq!(
+            String::from(versions),
+            ProtoSet::from_str(&versions).unwrap().to_string()
+        );
 
         versions = "1";
-        assert_eq!(String::from(versions), ProtoSet::from_str(&versions).unwrap().to_string());
+        assert_eq!(
+            String::from(versions),
+            ProtoSet::from_str(&versions).unwrap().to_string()
+        );
 
         versions = "1-2";
-        assert_eq!(String::from(versions), ProtoSet::from_str(&versions).unwrap().to_string());
+        assert_eq!(
+            String::from(versions),
+            ProtoSet::from_str(&versions).unwrap().to_string()
+        );
 
         versions = "1,3";
-        assert_eq!(String::from(versions), ProtoSet::from_str(&versions).unwrap().to_string());
+        assert_eq!(
+            String::from(versions),
+            ProtoSet::from_str(&versions).unwrap().to_string()
+        );
 
         versions = "1-4";
-        assert_eq!(String::from(versions), ProtoSet::from_str(&versions).unwrap().to_string());
+        assert_eq!(
+            String::from(versions),
+            ProtoSet::from_str(&versions).unwrap().to_string()
+        );
 
         versions = "1,3,5-7";
-        assert_eq!(String::from(versions), ProtoSet::from_str(&versions).unwrap().to_string());
+        assert_eq!(
+            String::from(versions),
+            ProtoSet::from_str(&versions).unwrap().to_string()
+        );
 
         versions = "1-3,500";
-        assert_eq!(String::from(versions), ProtoSet::from_str(&versions).unwrap().to_string());
+        assert_eq!(
+            String::from(versions),
+            ProtoSet::from_str(&versions).unwrap().to_string()
+        );
     }
 }
diff --git a/src/rust/protover/tests/protover.rs b/src/rust/protover/tests/protover.rs
index ac78d34b7a..a091e692d6 100644
--- a/src/rust/protover/tests/protover.rs
+++ b/src/rust/protover/tests/protover.rs
@@ -3,10 +3,10 @@
 
 extern crate protover;
 
+use protover::errors::ProtoverError;
 use protover::ProtoEntry;
 use protover::ProtoverVote;
 use protover::UnvalidatedProtoEntry;
-use protover::errors::ProtoverError;
 
 #[test]
 fn parse_protocol_with_single_proto_and_single_version() {
@@ -179,14 +179,16 @@ fn protover_compute_vote_returns_two_protocols_for_two_matching() {
 
 #[test]
 fn protover_compute_vote_returns_one_protocol_when_one_out_of_two_matches() {
-    let protocols: &[UnvalidatedProtoEntry] = &["Cons=1 Link=2".parse().unwrap(), "Cons=1".parse().unwrap()];
+    let protocols: &[UnvalidatedProtoEntry] =
+        &["Cons=1 Link=2".parse().unwrap(), "Cons=1".parse().unwrap()];
     let listed = ProtoverVote::compute(protocols, &2);
     assert_eq!("Cons=1", listed.to_string());
 }
 
 #[test]
 fn protover_compute_vote_returns_protocols_that_it_doesnt_currently_support() {
-    let protocols: &[UnvalidatedProtoEntry] = &["Foo=1 Cons=2".parse().unwrap(), "Bar=1".parse().unwrap()];
+    let protocols: &[UnvalidatedProtoEntry] =
+        &["Foo=1 Cons=2".parse().unwrap(), "Bar=1".parse().unwrap()];
     let listed = ProtoverVote::compute(protocols, &1);
     assert_eq!("Bar=1 Cons=2 Foo=1", listed.to_string());
 }
@@ -222,10 +224,12 @@ fn protover_compute_vote_returns_matching_for_longer_mix_with_threshold_two() {
 
 #[test]
 fn protover_compute_vote_handles_duplicated_versions() {
-    let protocols: &[UnvalidatedProtoEntry] = &["Cons=1".parse().unwrap(), "Cons=1".parse().unwrap()];
+    let protocols: &[UnvalidatedProtoEntry] =
+        &["Cons=1".parse().unwrap(), "Cons=1".parse().unwrap()];
     assert_eq!("Cons=1", ProtoverVote::compute(protocols, &2).to_string());
 
-    let protocols: &[UnvalidatedProtoEntry] = &["Cons=1-2".parse().unwrap(), "Cons=1-2".parse().unwrap()];
+    let protocols: &[UnvalidatedProtoEntry] =
+        &["Cons=1-2".parse().unwrap(), "Cons=1-2".parse().unwrap()];
     assert_eq!("Cons=1-2", ProtoverVote::compute(protocols, &2).to_string());
 }
 
@@ -246,12 +250,18 @@ fn parse_protocol_with_single_protocol_and_two_nonsequential_versions() {
 
 #[test]
 fn protover_is_supported_here_returns_true_for_supported_protocol() {
-    assert_eq!(true, protover::is_supported_here(&protover::Protocol::Cons, &1));
+    assert_eq!(
+        true,
+        protover::is_supported_here(&protover::Protocol::Cons, &1)
+    );
 }
 
 #[test]
 fn protover_is_supported_here_returns_false_for_unsupported_protocol() {
-    assert_eq!(false, protover::is_supported_here(&protover::Protocol::Cons, &5));
+    assert_eq!(
+        false,
+        protover::is_supported_here(&protover::Protocol::Cons, &5)
+    );
 }
 
 #[test]