Merge pull request #528 from hyperium/clippy

Cleanup found by clippy lints
2015-05-13 22:25:47 -07:00
parent 5e91ba19e4 7d508d684f
commit 7179651d81
31 changed files with 120 additions and 120 deletions
--- a/src/client/mod.rs
+++ b/src/client/mod.rs
@@ -430,7 +430,7 @@ mod tests {
        client.set_redirect_policy(RedirectPolicy::FollowAll);

        let res = client.get("http://127.0.0.1").send().unwrap();
-        assert_eq!(res.headers.get(), Some(&Server("mock3".to_string())));
+        assert_eq!(res.headers.get(), Some(&Server("mock3".to_owned())));
    }

    #[test]
@@ -438,7 +438,7 @@ mod tests {
        let mut client = Client::with_connector(MockRedirectPolicy);
        client.set_redirect_policy(RedirectPolicy::FollowNone);
        let res = client.get("http://127.0.0.1").send().unwrap();
-        assert_eq!(res.headers.get(), Some(&Server("mock1".to_string())));
+        assert_eq!(res.headers.get(), Some(&Server("mock1".to_owned())));
    }

    #[test]
@@ -449,7 +449,7 @@ mod tests {
        let mut client = Client::with_connector(MockRedirectPolicy);
        client.set_redirect_policy(RedirectPolicy::FollowIf(follow_if));
        let res = client.get("http://127.0.0.1").send().unwrap();
-        assert_eq!(res.headers.get(), Some(&Server("mock2".to_string())));
+        assert_eq!(res.headers.get(), Some(&Server("mock2".to_owned())));
    }

    /// Tests that the `Client::set_ssl_verifier` method does not drop the
--- a/src/client/response.rs
+++ b/src/client/response.rs
@@ -172,7 +172,7 @@ mod tests {
            None => panic!("Transfer-Encoding: chunked expected!"),
        };
        // The body is correct?
-        assert_eq!(read_to_string(res).unwrap(), "qwert".to_string());
+        assert_eq!(read_to_string(res).unwrap(), "qwert".to_owned());
    }

    /// Tests that when a chunk size is not a valid radix-16 number, an error
@@ -229,6 +229,6 @@ mod tests {

        let res = Response::new(Box::new(stream)).unwrap();

-        assert_eq!(read_to_string(res).unwrap(), "1".to_string());
+        assert_eq!(read_to_string(res).unwrap(), "1".to_owned());
    }
 }
--- a/src/header/common/accept.rs
+++ b/src/header/common/accept.rs
@@ -40,7 +40,7 @@ header! {
        //    vec![b"audio/*; q=0.2, audio/basic"],
        //    Some(HeaderField(vec![
        //        QualityItem::new(Mime(TopLevel::Audio, SubLevel::Star, vec![]), Quality(200)),
-        //        qitem(Mime(TopLevel::Audio, SubLevel::Ext("basic".to_string()), vec![])),
+        //        qitem(Mime(TopLevel::Audio, SubLevel::Ext("basic".to_owned()), vec![])),
        //        ])));
        test_header!(
            test2,
@@ -49,9 +49,9 @@ header! {
                QualityItem::new(Mime(TopLevel::Text, SubLevel::Plain, vec![]), Quality(500)),
                qitem(Mime(TopLevel::Text, SubLevel::Html, vec![])),
                QualityItem::new(
-                    Mime(TopLevel::Text, SubLevel::Ext("x-dvi".to_string()), vec![]),
+                    Mime(TopLevel::Text, SubLevel::Ext("x-dvi".to_owned()), vec![]),
                    Quality(800)),
-                qitem(Mime(TopLevel::Text, SubLevel::Ext("x-c".to_string()), vec![])),
+                qitem(Mime(TopLevel::Text, SubLevel::Ext("x-c".to_owned()), vec![])),
                ])));
        // Custom tests
        test_header!(
--- a/src/header/common/accept_language.rs
+++ b/src/header/common/accept_language.rs
@@ -26,9 +26,9 @@ header! {
        test_header!(
            test2, vec![b"en-us, en; q=0.5, fr"],
            Some(AcceptLanguage(vec![
-                qitem(Language {primary: "en".to_string(), sub: Some("us".to_string())}),
-                QualityItem::new(Language{primary: "en".to_string(), sub: None}, Quality(500)),
-                qitem(Language {primary: "fr".to_string(), sub: None}),
+                qitem(Language {primary: "en".to_owned(), sub: Some("us".to_owned())}),
+                QualityItem::new(Language{primary: "en".to_owned(), sub: None}, Quality(500)),
+                qitem(Language {primary: "fr".to_owned(), sub: None}),
        ])));
    }
 }
--- a/src/header/common/accept_ranges.rs
+++ b/src/header/common/accept_ranges.rs
@@ -58,7 +58,7 @@ impl FromStr for RangeUnit {
            "bytes" => Ok(RangeUnit::Bytes),
            "none" => Ok(RangeUnit::None),
            // FIXME: Check if s is really a Token
-            _ => Ok(RangeUnit::Unregistered(s.to_string())),
+            _ => Ok(RangeUnit::Unregistered(s.to_owned())),
        }
    }
 }
--- a/src/header/common/access_control_allow_origin.rs
+++ b/src/header/common/access_control_allow_origin.rs
@@ -41,7 +41,7 @@ impl Header for AccessControlAllowOrigin {
                b"*" => Some(AccessControlAllowOrigin::Any),
                b"null" => Some(AccessControlAllowOrigin::Null),
                r => if let Ok(s) = str::from_utf8(r) {
-                    Url::parse(s).ok().map(|url| AccessControlAllowOrigin::Value(url))
+                    Url::parse(s).ok().map(AccessControlAllowOrigin::Value)
                } else { None }
            }
        } else { None }
--- a/src/header/common/allow.rs
+++ b/src/header/common/allow.rs
@@ -39,7 +39,7 @@ header! {
                Method::Trace,
                Method::Connect,
                Method::Patch,
-                Method::Extension("fOObAr".to_string())])));
+                Method::Extension("fOObAr".to_owned())])));
        test_header!(
            test3,
            vec![b""],
--- a/src/header/common/authorization.rs
+++ b/src/header/common/authorization.rs
@@ -128,11 +128,11 @@ impl FromStr for Basic {
                Ok(text) => {
                    let mut parts = &mut text.split(':');
                    let user = match parts.next() {
-                        Some(part) => part.to_string(),
+                        Some(part) => part.to_owned(),
                        None => return Err(())
                    };
                    let password = match parts.next() {
-                        Some(part) => Some(part.to_string()),
+                        Some(part) => Some(part.to_owned()),
                        None => None
                    };
                    Ok(Basic {
@@ -161,8 +161,8 @@ mod tests {
    #[test]
    fn test_raw_auth() {
        let mut headers = Headers::new();
-        headers.set(Authorization("foo bar baz".to_string()));
-        assert_eq!(headers.to_string(), "Authorization: foo bar baz\r\n".to_string());
+        headers.set(Authorization("foo bar baz".to_owned()));
+        assert_eq!(headers.to_string(), "Authorization: foo bar baz\r\n".to_owned());
    }

    #[test]
@@ -176,17 +176,17 @@ mod tests {
    fn test_basic_auth() {
        let mut headers = Headers::new();
        headers.set(Authorization(
-            Basic { username: "Aladdin".to_string(), password: Some("open sesame".to_string()) }));
+            Basic { username: "Aladdin".to_owned(), password: Some("open sesame".to_owned()) }));
        assert_eq!(
            headers.to_string(),
-            "Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==\r\n".to_string());
+            "Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==\r\n".to_owned());
    }

    #[test]
    fn test_basic_auth_no_password() {
        let mut headers = Headers::new();
-        headers.set(Authorization(Basic { username: "Aladdin".to_string(), password: None }));
-        assert_eq!(headers.to_string(), "Authorization: Basic QWxhZGRpbjo=\r\n".to_string());
+        headers.set(Authorization(Basic { username: "Aladdin".to_owned(), password: None }));
+        assert_eq!(headers.to_string(), "Authorization: Basic QWxhZGRpbjo=\r\n".to_owned());
    }

    #[test]
@@ -194,7 +194,7 @@ mod tests {
        let auth: Authorization<Basic> = Header::parse_header(
            &[b"Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==".to_vec()]).unwrap();
        assert_eq!(auth.0.username, "Aladdin");
-        assert_eq!(auth.0.password, Some("open sesame".to_string()));
+        assert_eq!(auth.0.password, Some("open sesame".to_owned()));
    }

    #[test]
@@ -202,7 +202,7 @@ mod tests {
        let auth: Authorization<Basic> = Header::parse_header(
            &[b"Basic QWxhZGRpbjo=".to_vec()]).unwrap();
        assert_eq!(auth.0.username, "Aladdin");
-        assert_eq!(auth.0.password, Some("".to_string()));
+        assert_eq!(auth.0.password, Some("".to_owned()));
    }

 }
--- a/src/header/common/cache_control.rs
+++ b/src/header/common/cache_control.rs
@@ -126,15 +126,15 @@ impl FromStr for CacheDirective {
            "proxy-revalidate" => Ok(ProxyRevalidate),
            "" => Err(None),
            _ => match s.find('=') {
-                Some(idx) if idx+1 < s.len() => match (&s[..idx], &s[idx+1..].trim_matches('"')) {
-                    ("max-age" , secs) => secs.parse().map(MaxAge).map_err(|x| Some(x)),
-                    ("max-stale", secs) => secs.parse().map(MaxStale).map_err(|x| Some(x)),
-                    ("min-fresh", secs) => secs.parse().map(MinFresh).map_err(|x| Some(x)),
-                    ("s-maxage", secs) => secs.parse().map(SMaxAge).map_err(|x| Some(x)),
-                    (left, right) => Ok(Extension(left.to_string(), Some(right.to_string())))
+                Some(idx) if idx+1 < s.len() => match (&s[..idx], (&s[idx+1..]).trim_matches('"')) {
+                    ("max-age" , secs) => secs.parse().map(MaxAge).map_err(Some),
+                    ("max-stale", secs) => secs.parse().map(MaxStale).map_err(Some),
+                    ("min-fresh", secs) => secs.parse().map(MinFresh).map_err(Some),
+                    ("s-maxage", secs) => secs.parse().map(SMaxAge).map_err(Some),
+                    (left, right) => Ok(Extension(left.to_owned(), Some(right.to_owned())))
                },
                Some(_) => Err(None),
-                None => Ok(Extension(s.to_string(), None))
+                None => Ok(Extension(s.to_owned(), None))
            }
        }
    }
@@ -169,8 +169,8 @@ mod tests {
    fn test_parse_extension() {
        let cache = Header::parse_header(&[b"foo, bar=baz".to_vec()]);
        assert_eq!(cache, Some(CacheControl(vec![
-            CacheDirective::Extension("foo".to_string(), None),
-            CacheDirective::Extension("bar".to_string(), Some("baz".to_string()))])))
+            CacheDirective::Extension("foo".to_owned(), None),
+            CacheDirective::Extension("bar".to_owned(), Some("baz".to_owned()))])))
    }

    #[test]
--- a/src/header/common/connection.rs
+++ b/src/header/common/connection.rs
@@ -28,7 +28,7 @@ impl FromStr for ConnectionOption {
        match s {
            "keep-alive" => Ok(KeepAlive),
            "close" => Ok(Close),
-            s => Ok(ConnectionHeader(UniCase(s.to_string())))
+            s => Ok(ConnectionHeader(UniCase(s.to_owned())))
        }
    }
 }
--- a/src/header/common/content_type.rs
+++ b/src/header/common/content_type.rs
@@ -30,7 +30,7 @@ header! {
            Some(HeaderField(Mime(
                TopLevel::Text,
                SubLevel::Html,
-                vec![(Attr::Charset, Value::Ext("iso-8859-4".to_string()))]))));
+                vec![(Attr::Charset, Value::Ext("iso-8859-4".to_owned()))]))));
    }
 }

--- a/src/header/common/cookie.rs
+++ b/src/header/common/cookie.rs
@@ -86,8 +86,8 @@ impl Cookie {
 #[test]
 fn test_parse() {
    let h = Header::parse_header(&[b"foo=bar; baz=quux".to_vec()][..]);
-    let c1 = CookiePair::new("foo".to_string(), "bar".to_string());
-    let c2 = CookiePair::new("baz".to_string(), "quux".to_string());
+    let c1 = CookiePair::new("foo".to_owned(), "bar".to_owned());
+    let c2 = CookiePair::new("baz".to_owned(), "quux".to_owned());
    assert_eq!(h, Some(Cookie(vec![c1, c2])));
 }

@@ -95,12 +95,12 @@ fn test_parse() {
 fn test_fmt() {
    use header::Headers;

-    let mut cookie_pair = CookiePair::new("foo".to_string(), "bar".to_string());
+    let mut cookie_pair = CookiePair::new("foo".to_owned(), "bar".to_owned());
    cookie_pair.httponly = true;
-    cookie_pair.path = Some("/p".to_string());
+    cookie_pair.path = Some("/p".to_owned());
    let cookie_header = Cookie(vec![
        cookie_pair,
-        CookiePair::new("baz".to_string(),"quux".to_string())]);
+        CookiePair::new("baz".to_owned(),"quux".to_owned())]);
    let mut headers = Headers::new();
    headers.set(cookie_header);

@@ -109,7 +109,7 @@ fn test_fmt() {

 #[test]
 fn cookie_jar() {
-    let cookie_pair = CookiePair::new("foo".to_string(), "bar".to_string());
+    let cookie_pair = CookiePair::new("foo".to_owned(), "bar".to_owned());
    let cookie_header = Cookie(vec![cookie_pair]);
    let jar = cookie_header.to_cookie_jar(&[]);
    let new_cookie_header = Cookie::from_cookie_jar(&jar);
--- a/src/header/common/etag.rs
+++ b/src/header/common/etag.rs
@@ -28,29 +28,29 @@ header! {
        // From the RFC
        test_header!(test1,
            vec![b"\"xyzzy\""],
-            Some(ETag(EntityTag::new(false, "xyzzy".to_string()))));
+            Some(ETag(EntityTag::new(false, "xyzzy".to_owned()))));
        test_header!(test2,
            vec![b"W/\"xyzzy\""],
-            Some(ETag(EntityTag::new(true, "xyzzy".to_string()))));
+            Some(ETag(EntityTag::new(true, "xyzzy".to_owned()))));
        test_header!(test3,
            vec![b"\"\""],
-            Some(ETag(EntityTag::new(false, "".to_string()))));
+            Some(ETag(EntityTag::new(false, "".to_owned()))));
        // Own tests
        test_header!(test4,
            vec![b"\"foobar\""],
-            Some(ETag(EntityTag::new(false, "foobar".to_string()))));
+            Some(ETag(EntityTag::new(false, "foobar".to_owned()))));
        test_header!(test5,
            vec![b"\"\""],
-            Some(ETag(EntityTag::new(false, "".to_string()))));
+            Some(ETag(EntityTag::new(false, "".to_owned()))));
        test_header!(test6,
            vec![b"W/\"weak-etag\""],
-            Some(ETag(EntityTag::new(true, "weak-etag".to_string()))));
+            Some(ETag(EntityTag::new(true, "weak-etag".to_owned()))));
        test_header!(test7,
            vec![b"W/\"\x65\x62\""],
-            Some(ETag(EntityTag::new(true, "\u{0065}\u{0062}".to_string()))));
+            Some(ETag(EntityTag::new(true, "\u{0065}\u{0062}".to_owned()))));
        test_header!(test8,
            vec![b"W/\"\""],
-            Some(ETag(EntityTag::new(true, "".to_string()))));
+            Some(ETag(EntityTag::new(true, "".to_owned()))));
        test_header!(test9,
            vec![b"no-dquotes"],
            None::<ETag>);
--- a/src/header/common/host.rs
+++ b/src/header/common/host.rs
@@ -83,14 +83,14 @@ mod tests {
    fn test_host() {
        let host = Header::parse_header([b"foo.com".to_vec()].as_ref());
        assert_eq!(host, Some(Host {
-            hostname: "foo.com".to_string(),
+            hostname: "foo.com".to_owned(),
            port: None
        }));


        let host = Header::parse_header([b"foo.com:8080".to_vec()].as_ref());
        assert_eq!(host, Some(Host {
-            hostname: "foo.com".to_string(),
+            hostname: "foo.com".to_owned(),
            port: Some(8080)
        }));
    }
--- a/src/header/common/if_match.rs
+++ b/src/header/common/if_match.rs
@@ -31,14 +31,14 @@ header! {
            test1,
            vec![b"\"xyzzy\""],
            Some(HeaderField::Items(
-                vec![EntityTag::new(false, "xyzzy".to_string())])));
+                vec![EntityTag::new(false, "xyzzy".to_owned())])));
        test_header!(
            test2,
            vec![b"\"xyzzy\", \"r2d2xxxx\", \"c3piozzzz\""],
            Some(HeaderField::Items(
-                vec![EntityTag::new(false, "xyzzy".to_string()),
-                     EntityTag::new(false, "r2d2xxxx".to_string()),
-                     EntityTag::new(false, "c3piozzzz".to_string())])));
+                vec![EntityTag::new(false, "xyzzy".to_owned()),
+                     EntityTag::new(false, "r2d2xxxx".to_owned()),
+                     EntityTag::new(false, "c3piozzzz".to_owned())])));
        test_header!(test3, vec![b"*"], Some(IfMatch::Any));
    }
 }
--- a/src/header/common/if_none_match.rs
+++ b/src/header/common/if_none_match.rs
@@ -52,8 +52,8 @@ mod tests {

        if_none_match = Header::parse_header([b"\"foobar\", W/\"weak-etag\"".to_vec()].as_ref());
        let mut entities: Vec<EntityTag> = Vec::new();
-        let foobar_etag = EntityTag::new(false, "foobar".to_string());
-        let weak_etag = EntityTag::new(true, "weak-etag".to_string());
+        let foobar_etag = EntityTag::new(false, "foobar".to_owned());
+        let weak_etag = EntityTag::new(true, "weak-etag".to_owned());
        entities.push(foobar_etag);
        entities.push(weak_etag);
        assert_eq!(if_none_match, Some(IfNoneMatch::Items(entities)));
--- a/src/header/common/mod.rs
+++ b/src/header/common/mod.rs
@@ -128,12 +128,12 @@ macro_rules! test_header {
            let result_cmp: Vec<String> = result
                .to_ascii_lowercase()
                .split(' ')
-                .map(|x| x.to_string())
+                .map(|x| x.to_owned())
                .collect();
            let expected_cmp: Vec<String> = expected
                .to_ascii_lowercase()
                .split(' ')
-                .map(|x| x.to_string())
+                .map(|x| x.to_owned())
                .collect();
            assert_eq!(result_cmp.concat(), expected_cmp.concat());
        }
--- a/src/header/common/pragma.rs
+++ b/src/header/common/pragma.rs
@@ -55,7 +55,7 @@ fn test_parse_header() {
    let b = Pragma::NoCache;
    assert_eq!(a, b);
    let c: Pragma = Header::parse_header([b"FoObar".to_vec()].as_ref()).unwrap();
-    let d = Pragma::Ext("FoObar".to_string());
+    let d = Pragma::Ext("FoObar".to_owned());
    assert_eq!(c, d);
    let e: Option<Pragma> = Header::parse_header([b"".to_vec()].as_ref());
    assert_eq!(e, None);
--- a/src/header/common/set_cookie.rs
+++ b/src/header/common/set_cookie.rs
@@ -117,7 +117,7 @@ impl SetCookie {
 #[test]
 fn test_parse() {
    let h = Header::parse_header(&[b"foo=bar; HttpOnly".to_vec()][..]);
-    let mut c1 = Cookie::new("foo".to_string(), "bar".to_string());
+    let mut c1 = Cookie::new("foo".to_owned(), "bar".to_owned());
    c1.httponly = true;

    assert_eq!(h, Some(SetCookie(vec![c1])));
@@ -127,10 +127,10 @@ fn test_parse() {
 fn test_fmt() {
    use header::Headers;

-    let mut cookie = Cookie::new("foo".to_string(), "bar".to_string());
+    let mut cookie = Cookie::new("foo".to_owned(), "bar".to_owned());
    cookie.httponly = true;
-    cookie.path = Some("/p".to_string());
-    let cookies = SetCookie(vec![cookie, Cookie::new("baz".to_string(), "quux".to_string())]);
+    cookie.path = Some("/p".to_owned());
+    let cookies = SetCookie(vec![cookie, Cookie::new("baz".to_owned(), "quux".to_owned())]);
    let mut headers = Headers::new();
    headers.set(cookies);

@@ -142,7 +142,7 @@ fn test_fmt() {
 #[test]
 fn cookie_jar() {
    let jar = CookieJar::new(b"secret");
-    let cookie = Cookie::new("foo".to_string(), "bar".to_string());
+    let cookie = Cookie::new("foo".to_owned(), "bar".to_owned());
    jar.encrypted().add(cookie);

    let cookies = SetCookie::from_cookie_jar(&jar);
--- a/src/header/common/upgrade.rs
+++ b/src/header/common/upgrade.rs
@@ -34,10 +34,10 @@ header! {
            test1,
            vec![b"HTTP/2.0, SHTTP/1.3, IRC/6.9, RTA/x11"],
            Some(Upgrade(vec![
-                Protocol::new(ProtocolName::Http, Some("2.0".to_string())),
-                Protocol::new(ProtocolName::Unregistered("SHTTP".to_string()), Some("1.3".to_string())),
-                Protocol::new(ProtocolName::Unregistered("IRC".to_string()), Some("6.9".to_string())),
-                Protocol::new(ProtocolName::Unregistered("RTA".to_string()), Some("x11".to_string())),
+                Protocol::new(ProtocolName::Http, Some("2.0".to_owned())),
+                Protocol::new(ProtocolName::Unregistered("SHTTP".to_owned()), Some("1.3".to_owned())),
+                Protocol::new(ProtocolName::Unregistered("IRC".to_owned()), Some("6.9".to_owned())),
+                Protocol::new(ProtocolName::Unregistered("RTA".to_owned()), Some("x11".to_owned())),
                ])));
        // Own tests
        test_header!(
@@ -79,7 +79,7 @@ impl FromStr for ProtocolName {
                if UniCase(s) == UniCase("websocket") {
                    ProtocolName::WebSocket
                } else {
-                    ProtocolName::Unregistered(s.to_string())
+                    ProtocolName::Unregistered(s.to_owned())
                }
            }
        })
@@ -118,7 +118,7 @@ impl FromStr for Protocol {
    type Err =();
    fn from_str(s: &str) -> Result<Protocol, ()> {
        let mut parts = s.splitn(2, '/');
-        Ok(Protocol::new(try!(parts.next().unwrap().parse()), parts.next().map(|x| x.to_string())))
+        Ok(Protocol::new(try!(parts.next().unwrap().parse()), parts.next().map(|x| x.to_owned())))
    }
 }

--- a/src/header/common/user_agent.rs
+++ b/src/header/common/user_agent.rs
@@ -29,6 +29,6 @@ header! {
        // Testcase from RFC
        test_header!(test1, vec![b"CERN-LineMode/2.15 libwww/2.17b3"]);
        // Own testcase
-        test_header!(test2, vec![b"Bunnies"], Some(UserAgent("Bunnies".to_string())));
+        test_header!(test2, vec![b"Bunnies"], Some(UserAgent("Bunnies".to_owned())));
    }
 }
--- a/src/header/mod.rs
+++ b/src/header/mod.rs
@@ -503,7 +503,7 @@ mod tests {
    fn test_headers_show() {
        let mut headers = Headers::new();
        headers.set(ContentLength(15));
-        headers.set(Host { hostname: "foo.bar".to_string(), port: None });
+        headers.set(Host { hostname: "foo.bar".to_owned(), port: None });

        let s = headers.to_string();
        // hashmap's iterators have arbitrary order, so we must sort first
@@ -567,7 +567,7 @@ mod tests {
            assert!(header.is::<ContentLength>());
            assert_eq!(header.name(), <ContentLength as Header>::header_name());
            assert_eq!(header.value(), Some(&ContentLength(11)));
-            assert_eq!(header.value_string(), "11".to_string());
+            assert_eq!(header.value_string(), "11".to_owned());
        }
    }

--- a/src/header/shared/charset.rs
+++ b/src/header/shared/charset.rs
@@ -130,7 +130,7 @@ impl FromStr for Charset {
            "GB2312" => Gb2312,
            "5" => Big5,
            "KOI8-R" => Koi8_R,
-            s => Ext(s.to_string())
+            s => Ext(s.to_owned())
        })
    }
 }
@@ -141,11 +141,11 @@ fn test_parse() {
    assert_eq!(Us_Ascii,"US-Ascii".parse().unwrap());
    assert_eq!(Us_Ascii,"US-ASCII".parse().unwrap());
    assert_eq!(Shift_Jis,"Shift-JIS".parse().unwrap());
-    assert_eq!(Ext("ABCD".to_string()),"abcd".parse().unwrap());
+    assert_eq!(Ext("ABCD".to_owned()),"abcd".parse().unwrap());
 }

 #[test]
 fn test_display() {
    assert_eq!("US-ASCII", format!("{}", Us_Ascii));
-    assert_eq!("ABCD", format!("{}", Ext("ABCD".to_string())));
+    assert_eq!("ABCD", format!("{}", Ext("ABCD".to_owned())));
 }
--- a/src/header/shared/encoding.rs
+++ b/src/header/shared/encoding.rs
@@ -45,7 +45,7 @@ impl str::FromStr for Encoding {
            "gzip" => Ok(Gzip),
            "compress" => Ok(Compress),
            "identity" => Ok(Identity),
-            _ => Ok(EncodingExt(s.to_string()))
+            _ => Ok(EncodingExt(s.to_owned()))
        }
    }
 }
--- a/src/header/shared/entity.rs
+++ b/src/header/shared/entity.rs
@@ -119,9 +119,9 @@ impl FromStr for EntityTag {
        if slice.starts_with('"') && check_slice_validity(&slice[1..length-1]) {
            // No need to check if the last char is a DQUOTE,
            // we already did that above.
-            return Ok(EntityTag { weak: false, tag: slice[1..length-1].to_string() });
+            return Ok(EntityTag { weak: false, tag: slice[1..length-1].to_owned() });
        } else if slice.starts_with("W/\"") && check_slice_validity(&slice[3..length-1]) {
-            return Ok(EntityTag { weak: true, tag: slice[3..length-1].to_string() });
+            return Ok(EntityTag { weak: true, tag: slice[3..length-1].to_owned() });
        }
        Err(())
    }
@@ -134,11 +134,11 @@ mod tests {
    #[test]
    fn test_etag_parse_success() {
        // Expected success
-        assert_eq!("\"foobar\"".parse::<EntityTag>().unwrap(), EntityTag::new(false, "foobar".to_string()));
-        assert_eq!("\"\"".parse::<EntityTag>().unwrap(), EntityTag::new(false, "".to_string()));
-        assert_eq!("W/\"weaktag\"".parse::<EntityTag>().unwrap(), EntityTag::new(true, "weaktag".to_string()));
-        assert_eq!("W/\"\x65\x62\"".parse::<EntityTag>().unwrap(), EntityTag::new(true, "\x65\x62".to_string()));
-        assert_eq!("W/\"\"".parse::<EntityTag>().unwrap(), EntityTag::new(true, "".to_string()));
+        assert_eq!("\"foobar\"".parse::<EntityTag>().unwrap(), EntityTag::new(false, "foobar".to_owned()));
+        assert_eq!("\"\"".parse::<EntityTag>().unwrap(), EntityTag::new(false, "".to_owned()));
+        assert_eq!("W/\"weaktag\"".parse::<EntityTag>().unwrap(), EntityTag::new(true, "weaktag".to_owned()));
+        assert_eq!("W/\"\x65\x62\"".parse::<EntityTag>().unwrap(), EntityTag::new(true, "\x65\x62".to_owned()));
+        assert_eq!("W/\"\"".parse::<EntityTag>().unwrap(), EntityTag::new(true, "".to_owned()));
    }

    #[test]
@@ -154,11 +154,11 @@ mod tests {

    #[test]
    fn test_etag_fmt() {
-        assert_eq!(format!("{}", EntityTag::new(false, "foobar".to_string())), "\"foobar\"");
-        assert_eq!(format!("{}", EntityTag::new(false, "".to_string())), "\"\"");
-        assert_eq!(format!("{}", EntityTag::new(true, "weak-etag".to_string())), "W/\"weak-etag\"");
-        assert_eq!(format!("{}", EntityTag::new(true, "\u{0065}".to_string())), "W/\"\x65\"");
-        assert_eq!(format!("{}", EntityTag::new(true, "".to_string())), "W/\"\"");
+        assert_eq!(format!("{}", EntityTag::new(false, "foobar".to_owned())), "\"foobar\"");
+        assert_eq!(format!("{}", EntityTag::new(false, "".to_owned())), "\"\"");
+        assert_eq!(format!("{}", EntityTag::new(true, "weak-etag".to_owned())), "W/\"weak-etag\"");
+        assert_eq!(format!("{}", EntityTag::new(true, "\u{0065}".to_owned())), "W/\"\x65\"");
+        assert_eq!(format!("{}", EntityTag::new(true, "".to_owned())), "W/\"\"");
    }

    #[test]
@@ -169,29 +169,29 @@ mod tests {
        // | `W/"1"` | `W/"2"` | no match          | no match        |
        // | `W/"1"` | `"1"`   | no match          | match           |
        // | `"1"`   | `"1"`   | match             | match           |
-        let mut etag1 = EntityTag::new(true, "1".to_string());
-        let mut etag2 = EntityTag::new(true, "1".to_string());
+        let mut etag1 = EntityTag::new(true, "1".to_owned());
+        let mut etag2 = EntityTag::new(true, "1".to_owned());
        assert_eq!(etag1.strong_eq(&etag2), false);
        assert_eq!(etag1.weak_eq(&etag2), true);
        assert_eq!(etag1.strong_ne(&etag2), true);
        assert_eq!(etag1.weak_ne(&etag2), false);

-        etag1 = EntityTag::new(true, "1".to_string());
-        etag2 = EntityTag::new(true, "2".to_string());
+        etag1 = EntityTag::new(true, "1".to_owned());
+        etag2 = EntityTag::new(true, "2".to_owned());
        assert_eq!(etag1.strong_eq(&etag2), false);
        assert_eq!(etag1.weak_eq(&etag2), false);
        assert_eq!(etag1.strong_ne(&etag2), true);
        assert_eq!(etag1.weak_ne(&etag2), true);

-        etag1 = EntityTag::new(true, "1".to_string());
-        etag2 = EntityTag::new(false, "1".to_string());
+        etag1 = EntityTag::new(true, "1".to_owned());
+        etag2 = EntityTag::new(false, "1".to_owned());
        assert_eq!(etag1.strong_eq(&etag2), false);
        assert_eq!(etag1.weak_eq(&etag2), true);
        assert_eq!(etag1.strong_ne(&etag2), true);
        assert_eq!(etag1.weak_ne(&etag2), false);

-        etag1 = EntityTag::new(false, "1".to_string());
-        etag2 = EntityTag::new(false, "1".to_string());
+        etag1 = EntityTag::new(false, "1".to_owned());
+        etag2 = EntityTag::new(false, "1".to_owned());
        assert_eq!(etag1.strong_eq(&etag2), true);
        assert_eq!(etag1.weak_eq(&etag2), true);
        assert_eq!(etag1.strong_ne(&etag2), false);
--- a/src/header/shared/language.rs
+++ b/src/header/shared/language.rs
@@ -22,11 +22,11 @@ impl FromStr for Language {
        let s = i.next();
        match (p, s) {
            (Some(p), Some(s)) => Ok(Language {
-                primary: p.to_string(),
-                sub: Some(s.to_string())
+                primary: p.to_owned(),
+                sub: Some(s.to_owned())
                }),
            (Some(p), _) => Ok(Language {
-                primary: p.to_string(),
+                primary: p.to_owned(),
                sub: None
                }),
            _ => Err(())
--- a/src/header/shared/quality_item.rs
+++ b/src/header/shared/quality_item.rs
@@ -147,7 +147,7 @@ mod tests {
    fn test_quality_item_show3() {
        // Custom value
        let x = QualityItem{
-            item: EncodingExt("identity".to_string()),
+            item: EncodingExt("identity".to_owned()),
            quality: Quality(500),
        };
        assert_eq!(format!("{}", x), "identity; q=0.5");
--- a/src/method.rs
+++ b/src/method.rs
@@ -102,7 +102,7 @@ impl FromStr for Method {
                "TRACE" => Trace,
                "CONNECT" => Connect,
                "PATCH" => Patch,
-                _ => Extension(s.to_string())
+                _ => Extension(s.to_owned())
            })
        }
    }
@@ -149,7 +149,7 @@ mod tests {
    #[test]
    fn test_from_str() {
        assert_eq!(Get, FromStr::from_str("GET").unwrap());
-        assert_eq!(Extension("MOVE".to_string()),
+        assert_eq!(Extension("MOVE".to_owned()),
                   FromStr::from_str("MOVE").unwrap());
        let x: Result<Method, _> = FromStr::from_str("");
        if let Err(Error::Method) = x {
@@ -160,9 +160,9 @@ mod tests {

    #[test]
    fn test_fmt() {
-        assert_eq!("GET".to_string(), format!("{}", Get));
-        assert_eq!("MOVE".to_string(),
-                   format!("{}", Extension("MOVE".to_string())));
+        assert_eq!("GET".to_owned(), format!("{}", Get));
+        assert_eq!("MOVE".to_owned(),
+                   format!("{}", Extension("MOVE".to_owned())));
    }

    #[test]
@@ -177,6 +177,6 @@ mod tests {
        assert_eq!(Get.as_ref(), "GET");
        assert_eq!(Post.as_ref(), "POST");
        assert_eq!(Put.as_ref(), "PUT");
-        assert_eq!(Extension("MOVE".to_string()).as_ref(), "MOVE");
+        assert_eq!(Extension("MOVE".to_owned()).as_ref(), "MOVE");
    }
 }
--- a/src/mock.rs
+++ b/src/mock.rs
@@ -133,9 +133,9 @@ macro_rules! mock_connector (
                let key = format!("{}://{}", scheme, host);
                // ignore port for now
                match map.get(&*key) {
-                    Some(res) => Ok($crate::mock::MockStream {
+                    Some(&res) => Ok($crate::mock::MockStream {
                        write: vec![],
-                        read: Cursor::new(res.to_string().into_bytes()),
+                        read: Cursor::new(res.to_owned().into_bytes()),
                    }),
                    None => panic!("{:?} doesn't know url {}", stringify!($name), key)
                }
--- a/src/server/request.rs
+++ b/src/server/request.rs
@@ -114,7 +114,7 @@ mod tests {
        let mut stream = BufReader::new(mock);

        let req = Request::new(&mut stream, sock("127.0.0.1:80")).unwrap();
-        assert_eq!(read_to_string(req).unwrap(), "".to_string());
+        assert_eq!(read_to_string(req).unwrap(), "".to_owned());
    }

    #[test]
@@ -131,7 +131,7 @@ mod tests {
        let mut stream = BufReader::new(mock);

        let req = Request::new(&mut stream, sock("127.0.0.1:80")).unwrap();
-        assert_eq!(read_to_string(req).unwrap(), "".to_string());
+        assert_eq!(read_to_string(req).unwrap(), "".to_owned());
    }

    #[test]
@@ -148,7 +148,7 @@ mod tests {
        let mut stream = BufReader::new(mock);

        let req = Request::new(&mut stream, sock("127.0.0.1:80")).unwrap();
-        assert_eq!(read_to_string(req).unwrap(), "".to_string());
+        assert_eq!(read_to_string(req).unwrap(), "".to_owned());
    }

    #[test]
@@ -189,7 +189,7 @@ mod tests {
            None => panic!("Transfer-Encoding: chunked expected!"),
        };
        // The content is correctly read?
-        assert_eq!(read_to_string(req).unwrap(), "qwert".to_string());
+        assert_eq!(read_to_string(req).unwrap(), "qwert".to_owned());
    }

    /// Tests that when a chunk size is not a valid radix-16 number, an error
@@ -261,7 +261,7 @@ mod tests {

        let req = Request::new(&mut stream, sock("127.0.0.1:80")).unwrap();

-        assert_eq!(read_to_string(req).unwrap(), "1".to_string());
+        assert_eq!(read_to_string(req).unwrap(), "1".to_owned());
    }

 }
--- a/src/uri.rs
+++ b/src/uri.rs
@@ -59,15 +59,15 @@ impl FromStr for RequestUri {
        } else if bytes == b"*" {
            Ok(RequestUri::Star)
        } else if bytes.starts_with(b"/") {
-            Ok(RequestUri::AbsolutePath(s.to_string()))
+            Ok(RequestUri::AbsolutePath(s.to_owned()))
        } else if bytes.contains(&b'/') {
            Ok(RequestUri::AbsoluteUri(try!(Url::parse(s))))
        } else {
-            let mut temp = "http://".to_string();
+            let mut temp = "http://".to_owned();
            temp.push_str(s);
            try!(Url::parse(&temp[..]));
            todo!("compare vs u.authority()");
-            Ok(RequestUri::Authority(s.to_string()))
+            Ok(RequestUri::Authority(s.to_owned()))
        }
    }
 }
@@ -80,8 +80,8 @@ fn test_uri_fromstr() {

    read("*", RequestUri::Star);
    read("http://hyper.rs/", RequestUri::AbsoluteUri(Url::parse("http://hyper.rs/").unwrap()));
-    read("hyper.rs", RequestUri::Authority("hyper.rs".to_string()));
-    read("/", RequestUri::AbsolutePath("/".to_string()));
+    read("hyper.rs", RequestUri::Authority("hyper.rs".to_owned()));
+    read("/", RequestUri::AbsolutePath("/".to_owned()));
 }