1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 use std::borrow::{IntoCow, Cow};
12 use std::iter::repeat;
18 let owned: Option<::std::string::String> = "string".parse().ok();
19 assert_eq!(owned.as_ref().map(|s| &**s), Some("string"));
23 fn test_unsized_to_string() {
25 let _: String = (*s).to_string();
30 let xs = b"hello".to_vec();
31 assert_eq!(String::from_utf8(xs).unwrap(),
32 String::from("hello"));
34 let xs = "ศไทย中华Việt Nam".as_bytes().to_vec();
35 assert_eq!(String::from_utf8(xs).unwrap(),
36 String::from("ศไทย中华Việt Nam"));
38 let xs = b"hello\xFF".to_vec();
39 let err = String::from_utf8(xs).err().unwrap();
40 assert_eq!(err.into_bytes(), b"hello\xff".to_vec());
44 fn test_from_utf8_lossy() {
46 let ys: Cow<str> = "hello".into_cow();
47 assert_eq!(String::from_utf8_lossy(xs), ys);
49 let xs = "ศไทย中华Việt Nam".as_bytes();
50 let ys: Cow<str> = "ศไทย中华Việt Nam".into_cow();
51 assert_eq!(String::from_utf8_lossy(xs), ys);
53 let xs = b"Hello\xC2 There\xFF Goodbye";
54 assert_eq!(String::from_utf8_lossy(xs),
55 String::from("Hello\u{FFFD} There\u{FFFD} Goodbye").into_cow());
57 let xs = b"Hello\xC0\x80 There\xE6\x83 Goodbye";
58 assert_eq!(String::from_utf8_lossy(xs),
59 String::from("Hello\u{FFFD}\u{FFFD} There\u{FFFD} Goodbye").into_cow());
61 let xs = b"\xF5foo\xF5\x80bar";
62 assert_eq!(String::from_utf8_lossy(xs),
63 String::from("\u{FFFD}foo\u{FFFD}\u{FFFD}bar").into_cow());
65 let xs = b"\xF1foo\xF1\x80bar\xF1\x80\x80baz";
66 assert_eq!(String::from_utf8_lossy(xs),
67 String::from("\u{FFFD}foo\u{FFFD}bar\u{FFFD}baz").into_cow());
69 let xs = b"\xF4foo\xF4\x80bar\xF4\xBFbaz";
70 assert_eq!(String::from_utf8_lossy(xs),
71 String::from("\u{FFFD}foo\u{FFFD}bar\u{FFFD}\u{FFFD}baz").into_cow());
73 let xs = b"\xF0\x80\x80\x80foo\xF0\x90\x80\x80bar";
74 assert_eq!(String::from_utf8_lossy(xs), String::from("\u{FFFD}\u{FFFD}\u{FFFD}\u{FFFD}\
75 foo\u{10000}bar").into_cow());
78 let xs = b"\xED\xA0\x80foo\xED\xBF\xBFbar";
79 assert_eq!(String::from_utf8_lossy(xs), String::from("\u{FFFD}\u{FFFD}\u{FFFD}foo\
80 \u{FFFD}\u{FFFD}\u{FFFD}bar").into_cow());
84 fn test_from_utf16() {
86 [(String::from("𐍅𐌿𐌻𐍆𐌹𐌻𐌰\n"),
87 vec![0xd800, 0xdf45, 0xd800, 0xdf3f,
88 0xd800, 0xdf3b, 0xd800, 0xdf46,
89 0xd800, 0xdf39, 0xd800, 0xdf3b,
90 0xd800, 0xdf30, 0x000a]),
92 (String::from("𐐒𐑉𐐮𐑀𐐲𐑋 𐐏𐐲𐑍\n"),
93 vec![0xd801, 0xdc12, 0xd801,
94 0xdc49, 0xd801, 0xdc2e, 0xd801,
95 0xdc40, 0xd801, 0xdc32, 0xd801,
96 0xdc4b, 0x0020, 0xd801, 0xdc0f,
97 0xd801, 0xdc32, 0xd801, 0xdc4d,
100 (String::from("𐌀𐌖𐌋𐌄𐌑𐌉·𐌌𐌄𐌕𐌄𐌋𐌉𐌑\n"),
101 vec![0xd800, 0xdf00, 0xd800, 0xdf16,
102 0xd800, 0xdf0b, 0xd800, 0xdf04,
103 0xd800, 0xdf11, 0xd800, 0xdf09,
104 0x00b7, 0xd800, 0xdf0c, 0xd800,
105 0xdf04, 0xd800, 0xdf15, 0xd800,
106 0xdf04, 0xd800, 0xdf0b, 0xd800,
107 0xdf09, 0xd800, 0xdf11, 0x000a ]),
109 (String::from("𐒋𐒘𐒈𐒑𐒛𐒒 𐒕𐒓 𐒈𐒚𐒍 𐒏𐒜𐒒𐒖𐒆 𐒕𐒆\n"),
110 vec![0xd801, 0xdc8b, 0xd801, 0xdc98,
111 0xd801, 0xdc88, 0xd801, 0xdc91,
112 0xd801, 0xdc9b, 0xd801, 0xdc92,
113 0x0020, 0xd801, 0xdc95, 0xd801,
114 0xdc93, 0x0020, 0xd801, 0xdc88,
115 0xd801, 0xdc9a, 0xd801, 0xdc8d,
116 0x0020, 0xd801, 0xdc8f, 0xd801,
117 0xdc9c, 0xd801, 0xdc92, 0xd801,
118 0xdc96, 0xd801, 0xdc86, 0x0020,
119 0xd801, 0xdc95, 0xd801, 0xdc86,
121 // Issue #12318, even-numbered non-BMP planes
122 (String::from("\u{20000}"),
123 vec![0xD840, 0xDC00])];
126 let (s, u) = (*p).clone();
127 let s_as_utf16 = s.utf16_units().collect::<Vec<u16>>();
128 let u_as_string = String::from_utf16(&u).unwrap();
130 assert!(::rustc_unicode::str::is_utf16(&u));
131 assert_eq!(s_as_utf16, u);
133 assert_eq!(u_as_string, s);
134 assert_eq!(String::from_utf16_lossy(&u), s);
136 assert_eq!(String::from_utf16(&s_as_utf16).unwrap(), s);
137 assert_eq!(u_as_string.utf16_units().collect::<Vec<u16>>(), u);
142 fn test_utf16_invalid() {
143 // completely positive cases tested above.
145 assert!(String::from_utf16(&[0xD800]).is_err());
147 assert!(String::from_utf16(&[0xD800, 0xD800]).is_err());
150 assert!(String::from_utf16(&[0x0061, 0xDC00]).is_err());
153 assert!(String::from_utf16(&[0xD800, 0xd801, 0xdc8b, 0xD800]).is_err());
157 fn test_from_utf16_lossy() {
158 // completely positive cases tested above.
160 assert_eq!(String::from_utf16_lossy(&[0xD800]), String::from("\u{FFFD}"));
162 assert_eq!(String::from_utf16_lossy(&[0xD800, 0xD800]),
163 String::from("\u{FFFD}\u{FFFD}"));
166 assert_eq!(String::from_utf16_lossy(&[0x0061, 0xDC00]), String::from("a\u{FFFD}"));
169 assert_eq!(String::from_utf16_lossy(&[0xD800, 0xd801, 0xdc8b, 0xD800]),
170 String::from("\u{FFFD}𐒋\u{FFFD}"));
174 fn test_push_bytes() {
175 let mut s = String::from("ABC");
177 let mv = s.as_mut_vec();
178 mv.push_all(&[b'D']);
180 assert_eq!(s, "ABCD");
185 let mut s = String::new();
187 assert_eq!(&s[0..], "");
189 assert_eq!(&s[0..], "abc");
190 s.push_str("ประเทศไทย中华Việt Nam");
191 assert_eq!(&s[0..], "abcประเทศไทย中华Việt Nam");
196 let mut data = String::from("ประเทศไทย中");
198 data.push('b'); // 1 byte
199 data.push('¢'); // 2 byte
200 data.push('€'); // 3 byte
201 data.push('𤭢'); // 4 byte
202 assert_eq!(data, "ประเทศไทย中华b¢€𤭢");
207 let mut data = String::from("ประเทศไทย中华b¢€𤭢");
208 assert_eq!(data.pop().unwrap(), '𤭢'); // 4 bytes
209 assert_eq!(data.pop().unwrap(), '€'); // 3 bytes
210 assert_eq!(data.pop().unwrap(), '¢'); // 2 bytes
211 assert_eq!(data.pop().unwrap(), 'b'); // 1 bytes
212 assert_eq!(data.pop().unwrap(), '华');
213 assert_eq!(data, "ประเทศไทย中");
217 fn test_str_truncate() {
218 let mut s = String::from("12345");
220 assert_eq!(s, "12345");
222 assert_eq!(s, "123");
226 let mut s = String::from("12345");
236 fn test_str_truncate_invalid_len() {
237 let mut s = String::from("12345");
243 fn test_str_truncate_split_codepoint() {
244 let mut s = String::from("\u{FC}"); // ü
249 fn test_str_clear() {
250 let mut s = String::from("12345");
252 assert_eq!(s.len(), 0);
258 let a = String::from("12345");
261 assert_eq!(b.len(), 7);
262 assert_eq!(b, "1234522");
267 let mut s = "ศไทย中华Việt Nam; foobar".to_string();
268 assert_eq!(s.remove(0), 'ศ');
269 assert_eq!(s.len(), 33);
270 assert_eq!(s, "ไทย中华Việt Nam; foobar");
271 assert_eq!(s.remove(17), 'ệ');
272 assert_eq!(s, "ไทย中华Vit Nam; foobar");
275 #[test] #[should_panic]
277 "ศ".to_string().remove(1);
282 let mut s = "foobar".to_string();
284 assert_eq!(s, "ệfoobar");
286 assert_eq!(s, "ệfooยbar");
289 #[test] #[should_panic] fn insert_bad1() { "".to_string().insert(1, 't'); }
290 #[test] #[should_panic] fn insert_bad2() { "ệ".to_string().insert(1, 't'); }
294 let s = "foobar".to_string();
295 assert_eq!("foobar", &s[..]);
296 assert_eq!("foo", &s[..3]);
297 assert_eq!("bar", &s[3..]);
298 assert_eq!("oob", &s[1..4]);
302 fn test_simple_types() {
303 assert_eq!(1.to_string(), "1");
304 assert_eq!((-1).to_string(), "-1");
305 assert_eq!(200.to_string(), "200");
306 assert_eq!(2.to_string(), "2");
307 assert_eq!(true.to_string(), "true");
308 assert_eq!(false.to_string(), "false");
309 assert_eq!(("hi".to_string()).to_string(), "hi");
314 let x: Vec<i32> = vec![];
315 assert_eq!(format!("{:?}", x), "[]");
316 assert_eq!(format!("{:?}", vec![1]), "[1]");
317 assert_eq!(format!("{:?}", vec![1, 2, 3]), "[1, 2, 3]");
318 assert!(format!("{:?}", vec![vec![], vec![1], vec![1, 1]]) ==
319 "[[], [1], [1, 1]]");
323 fn test_from_iterator() {
324 let s = "ศไทย中华Việt Nam".to_string();
328 let a: String = s.chars().collect();
331 let mut b = t.to_string();
335 let c: String = vec![t, u].into_iter().collect();
338 let mut d = t.to_string();
345 let mut s = String::from("αβγ");
346 assert_eq!(s.drain(2..4).collect::<String>(), "β");
349 let mut t = String::from("abcd");
351 assert_eq!(t, "abcd");
353 assert_eq!(t, "bcd");
355 assert_eq!(t, "bcd");
361 fn test_extend_ref() {
362 let mut a = "foo".to_string();
363 a.extend(&['b', 'a', 'r']);
365 assert_eq!(&a, "foobar");
369 fn test_into_boxed_str() {
370 let xs = String::from("hello my name is bob");
371 let ys = xs.into_boxed_str();
372 assert_eq!(&*ys, "hello my name is bob");
376 fn bench_with_capacity(b: &mut Bencher) {
378 String::with_capacity(100)
383 fn bench_push_str(b: &mut Bencher) {
384 let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
386 let mut r = String::new();
391 const REPETITIONS: u64 = 10_000;
394 fn bench_push_str_one_byte(b: &mut Bencher) {
395 b.bytes = REPETITIONS;
397 let mut r = String::new();
398 for _ in 0..REPETITIONS {
405 fn bench_push_char_one_byte(b: &mut Bencher) {
406 b.bytes = REPETITIONS;
408 let mut r = String::new();
409 for _ in 0..REPETITIONS {
416 fn bench_push_char_two_bytes(b: &mut Bencher) {
417 b.bytes = REPETITIONS * 2;
419 let mut r = String::new();
420 for _ in 0..REPETITIONS {
427 fn from_utf8_lossy_100_ascii(b: &mut Bencher) {
428 let s = b"Hello there, the quick brown fox jumped over the lazy dog! \
429 Lorem ipsum dolor sit amet, consectetur. ";
431 assert_eq!(100, s.len());
433 let _ = String::from_utf8_lossy(s);
438 fn from_utf8_lossy_100_multibyte(b: &mut Bencher) {
439 let s = "𐌀𐌖𐌋𐌄𐌑𐌉ปรدولة الكويتทศไทย中华𐍅𐌿𐌻𐍆𐌹𐌻𐌰".as_bytes();
440 assert_eq!(100, s.len());
442 let _ = String::from_utf8_lossy(s);
447 fn from_utf8_lossy_invalid(b: &mut Bencher) {
448 let s = b"Hello\xC0\x80 There\xE6\x83 Goodbye";
450 let _ = String::from_utf8_lossy(s);
455 fn from_utf8_lossy_100_invalid(b: &mut Bencher) {
456 let s = repeat(0xf5).take(100).collect::<Vec<_>>();
458 let _ = String::from_utf8_lossy(&s);
463 fn bench_exact_size_shrink_to_fit(b: &mut Bencher) {
464 let s = "Hello there, the quick brown fox jumped over the lazy dog! \
465 Lorem ipsum dolor sit amet, consectetur. ";
466 // ensure our operation produces an exact-size string before we benchmark it
467 let mut r = String::with_capacity(s.len());
469 assert_eq!(r.len(), r.capacity());
471 let mut r = String::with_capacity(s.len());
479 fn bench_from_str(b: &mut Bencher) {
480 let s = "Hello there, the quick brown fox jumped over the lazy dog! \
481 Lorem ipsum dolor sit amet, consectetur. ";
488 fn bench_from(b: &mut Bencher) {
489 let s = "Hello there, the quick brown fox jumped over the lazy dog! \
490 Lorem ipsum dolor sit amet, consectetur. ";
497 fn bench_to_string(b: &mut Bencher) {
498 let s = "Hello there, the quick brown fox jumped over the lazy dog! \
499 Lorem ipsum dolor sit amet, consectetur. ";