chore: cargo fmt, clippy

src/hpack/test/fixture.rs

@@ -5,8 +5,8 @@ use hex::FromHex;
 use serde_json::Value;
 
 use std::fs::File;
-use std::io::Cursor;
 use std::io::prelude::*;
+use std::io::Cursor;
 use std::path::Path;
 use std::str;
 
@@ -30,13 +30,15 @@ fn test_story(story: Value) {
             .map(|case| {
                 let case = case.as_object().unwrap();
 
-                let size = case.get("header_table_size")
+                let size = case
+                    .get("header_table_size")
                     .map(|v| v.as_u64().unwrap() as usize);
 
                 let wire = case.get("wire").unwrap().as_str().unwrap();
                 let wire: Vec<u8> = FromHex::from_hex(wire.as_bytes()).unwrap();
 
-                let expect: Vec<_> = case.get("headers")
+                let expect: Vec<_> = case
+                    .get("headers")
                     .unwrap()
                     .as_array()
                     .unwrap()
@@ -92,7 +94,8 @@ fn test_story(story: Value) {
                 decoder.queue_size_update(size);
             }
 
-            let mut input: Vec<_> = case.expect
+            let mut input: Vec<_> = case
+                .expect
                 .iter()
                 .map(|&(ref name, ref value)| {
                     Header::new(name.clone().into(), value.clone().into())
@@ -123,9 +126,7 @@ struct Case {
 
 fn key_str(e: &Header) -> &str {
     match *e {
-        Header::Field {
-            ref name, ..
-        } => name.as_str(),
+        Header::Field { ref name, .. } => name.as_str(),
         Header::Authority(..) => ":authority",
         Header::Method(..) => ":method",
         Header::Scheme(..) => ":scheme",
@@ -136,9 +137,7 @@ fn key_str(e: &Header) -> &str {
 
 fn value_str(e: &Header) -> &str {
     match *e {
-        Header::Field {
-            ref value, ..
-        } => value.to_str().unwrap(),
+        Header::Field { ref value, .. } => value.to_str().unwrap(),
         Header::Authority(ref v) => &**v,
         Header::Method(ref m) => m.as_str(),
         Header::Scheme(ref v) => &**v,

src/hpack/test/fuzz.rs

@@ -78,17 +78,16 @@ impl FuzzHpack {
                     let low = rng.gen_range(0, high);
 
                     frame.resizes.extend(&[low, high]);
-                },
+                }
                 1..=3 => {
                     frame.resizes.push(rng.gen_range(128, MAX_CHUNK * 2));
-                },
-                _ => {},
+                }
+                _ => {}
             }
 
             let mut is_name_required = true;
 
             for _ in 0..rng.gen_range(1, (num - added) + 1) {
-
                 let x: f64 = rng.gen_range(0.0, 1.0);
                 let x = x.powi(skew);
 
@@ -100,10 +99,10 @@ impl FuzzHpack {
                         if is_name_required {
                             continue;
                         }
-                    },
+                    }
                     Header::Field { .. } => {
                         is_name_required = false;
-                    },
+                    }
                     _ => {
                         // pseudos can't be followed by a header with no name
                         is_name_required = true;
@@ -153,7 +152,7 @@ impl FuzzHpack {
                             _ => None,
                         };
                         expect.push(h);
-                    },
+                    }
                     Err(value) => {
                         expect.push(Header::Field {
                             name: prev_name.as_ref().cloned().expect("previous header name"),
@@ -161,7 +160,6 @@ impl FuzzHpack {
                         });
                     }
                 }
-
             }
 
             let mut input = frame.headers.into_iter();
@@ -193,7 +191,7 @@ impl FuzzHpack {
                             .expect("partial decode");
 
                         buf = BytesMut::with_capacity(chunks.pop().unwrap_or(MAX_CHUNK));
-                    },
+                    }
                 }
             }
 
@@ -224,7 +222,7 @@ fn gen_header(g: &mut StdRng) -> Header<Option<HeaderName>> {
             0 => {
                 let value = gen_string(g, 4, 20);
                 Header::Authority(to_shared(value))
-            },
+            }
             1 => {
                 let method = match g.next_u32() % 6 {
                     0 => Method::GET,
@@ -239,12 +237,12 @@ fn gen_header(g: &mut StdRng) -> Header<Option<HeaderName>> {
                             .collect();
 
                         Method::from_bytes(&bytes).unwrap()
-                    },
+                    }
                     _ => unreachable!(),
                 };
 
                 Header::Method(method)
-            },
+            }
             2 => {
                 let value = match g.next_u32() % 2 {
                     0 => "http",
@@ -253,7 +251,7 @@ fn gen_header(g: &mut StdRng) -> Header<Option<HeaderName>> {
                 };
 
                 Header::Scheme(to_shared(value.to_string()))
-            },
+            }
             3 => {
                 let value = match g.next_u32() % 100 {
                     0 => "/".to_string(),
@@ -262,12 +260,12 @@ fn gen_header(g: &mut StdRng) -> Header<Option<HeaderName>> {
                 };
 
                 Header::Path(to_shared(value))
-            },
+            }
             4 => {
                 let status = (g.gen::<u16>() % 500) + 100;
 
                 Header::Status(StatusCode::from_u16(status).unwrap())
-            },
+            }
             _ => unreachable!(),
         }
     } else {
@@ -282,10 +280,7 @@ fn gen_header(g: &mut StdRng) -> Header<Option<HeaderName>> {
             value.set_sensitive(true);
         }
 
-        Header::Field {
-            name,
-            value,
-        }
+        Header::Field { name, value }
     }
 }
 
@@ -368,8 +363,9 @@ fn gen_header_name(g: &mut StdRng) -> HeaderName {
             header::X_DNS_PREFETCH_CONTROL,
             header::X_FRAME_OPTIONS,
             header::X_XSS_PROTECTION,
-        ]).unwrap()
-            .clone()
+        ])
+        .unwrap()
+        .clone()
     } else {
         let value = gen_string(g, 1, 25);
         HeaderName::from_bytes(value.as_bytes()).unwrap()