forked/hyper
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

perf(all): replace &str.to_string() with .to_owned()

Browse Source
This commit is contained in:
Sean McArthur
2015-05-12 23:01:58 -07:00
parent 6803ef3956
commit 7e3858c962
30 changed files with 115 additions and 115 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/client/mod.rs
View File

@@ -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

4
src/client/response.rs
View File

@@ -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());
}
}

6
src/header/common/accept.rs
View File

@@ -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!(

6
src/header/common/accept_language.rs
View File

@@ -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}),
])));
}
}

2
src/header/common/accept_ranges.rs
View File

@@ -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())),
}
}
}

2
src/header/common/allow.rs
View File

@@ -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""],

20
src/header/common/authorization.rs
View File

@@ -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()));
}
}

10
src/header/common/cache_control.rs
View File

@@ -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('"')) {
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())))
(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]

2
src/header/common/connection.rs
View File

@@ -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())))
}
}
}

2
src/header/common/content_type.rs
View File

@@ -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()))]))));
}
}

12
src/header/common/cookie.rs
View File

@@ -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);

16
src/header/common/etag.rs
View File

@@ -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>);

4
src/header/common/host.rs
View File

@@ -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)
}));
}

8
src/header/common/if_match.rs
View File

@@ -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));
}
}

4
src/header/common/if_none_match.rs
View File

@@ -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)));

4
src/header/common/mod.rs
View File

@@ -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());
}

2
src/header/common/pragma.rs
View File

@@ -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);

10
src/header/common/set_cookie.rs
View File

@@ -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);

12
src/header/common/upgrade.rs
View File

@@ -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())))
}
}

2
src/header/common/user_agent.rs
View File

@@ -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())));
}
}

4
src/header/mod.rs
View File

@@ -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());
}
}

6
src/header/shared/charset.rs
View File

@@ -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())));
}

2
src/header/shared/encoding.rs
View File

@@ -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()))
}
}
}

40
src/header/shared/entity.rs
View File

@@ -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);

6
src/header/shared/language.rs
View File

@@ -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(())

2
src/header/shared/quality_item.rs
View File

@@ -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");

12
src/method.rs
View File

@@ -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");
}
}

4
src/mock.rs
View File

@@ -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)
}

10
src/server/request.rs
View File

@@ -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());
}
}

10
src/uri.rs
View File

@@ -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()));
}