]>
git.proxmox.com Git - rustc.git/blob - src/libcollectionstest/string.rs
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
;
14 use std
::string
::as_string
;
22 assert_eq
!(x
, &**as_string(x
));
27 let owned
: Option
<::std
::string
::String
> = "string".parse().ok();
28 assert_eq
!(owned
.as_ref().map(|s
| &**s
), Some("string"));
32 fn test_unsized_to_string() {
34 let _
: String
= (*s
).to_string();
39 let xs
= b
"hello".to_vec();
40 assert_eq
!(String
::from_utf8(xs
).unwrap(),
41 String
::from("hello"));
43 let xs
= "ศไทย中华Việt Nam".as_bytes().to_vec();
44 assert_eq
!(String
::from_utf8(xs
).unwrap(),
45 String
::from("ศไทย中华Việt Nam"));
47 let xs
= b
"hello\xFF".to_vec();
48 let err
= String
::from_utf8(xs
).err().unwrap();
49 assert_eq
!(err
.into_bytes(), b
"hello\xff".to_vec());
53 fn test_from_utf8_lossy() {
55 let ys
: Cow
<str> = "hello".into_cow();
56 assert_eq
!(String
::from_utf8_lossy(xs
), ys
);
58 let xs
= "ศไทย中华Việt Nam".as_bytes();
59 let ys
: Cow
<str> = "ศไทย中华Việt Nam".into_cow();
60 assert_eq
!(String
::from_utf8_lossy(xs
), ys
);
62 let xs
= b
"Hello\xC2 There\xFF Goodbye";
63 assert_eq
!(String
::from_utf8_lossy(xs
),
64 String
::from("Hello\u{FFFD} There\u{FFFD} Goodbye").into_cow());
66 let xs
= b
"Hello\xC0\x80 There\xE6\x83 Goodbye";
67 assert_eq
!(String
::from_utf8_lossy(xs
),
68 String
::from("Hello\u{FFFD}\u{FFFD} There\u{FFFD} Goodbye").into_cow());
70 let xs
= b
"\xF5foo\xF5\x80bar";
71 assert_eq
!(String
::from_utf8_lossy(xs
),
72 String
::from("\u{FFFD}foo\u{FFFD}\u{FFFD}bar").into_cow());
74 let xs
= b
"\xF1foo\xF1\x80bar\xF1\x80\x80baz";
75 assert_eq
!(String
::from_utf8_lossy(xs
),
76 String
::from("\u{FFFD}foo\u{FFFD}bar\u{FFFD}baz").into_cow());
78 let xs
= b
"\xF4foo\xF4\x80bar\xF4\xBFbaz";
79 assert_eq
!(String
::from_utf8_lossy(xs
),
80 String
::from("\u{FFFD}foo\u{FFFD}bar\u{FFFD}\u{FFFD}baz").into_cow());
82 let xs
= b
"\xF0\x80\x80\x80foo\xF0\x90\x80\x80bar";
83 assert_eq
!(String
::from_utf8_lossy(xs
), String
::from("\u{FFFD}\u{FFFD}\u{FFFD}\u{FFFD}\
84 foo\u{10000}bar").into_cow());
87 let xs
= b
"\xED\xA0\x80foo\xED\xBF\xBFbar";
88 assert_eq
!(String
::from_utf8_lossy(xs
), String
::from("\u{FFFD}\u{FFFD}\u{FFFD}foo\
89 \u{FFFD}\u{FFFD}\u{FFFD}bar").into_cow());
93 fn test_from_utf16() {
95 [(String
::from("𐍅𐌿𐌻𐍆𐌹𐌻𐌰\n"),
96 vec
![0xd800, 0xdf45, 0xd800, 0xdf3f,
97 0xd800, 0xdf3b, 0xd800, 0xdf46,
98 0xd800, 0xdf39, 0xd800, 0xdf3b,
99 0xd800, 0xdf30, 0x000a]),
101 (String
::from("𐐒𐑉𐐮𐑀𐐲𐑋 𐐏𐐲𐑍\n"),
102 vec
![0xd801, 0xdc12, 0xd801,
103 0xdc49, 0xd801, 0xdc2e, 0xd801,
104 0xdc40, 0xd801, 0xdc32, 0xd801,
105 0xdc4b, 0x0020, 0xd801, 0xdc0f,
106 0xd801, 0xdc32, 0xd801, 0xdc4d,
109 (String
::from("𐌀𐌖𐌋𐌄𐌑𐌉·𐌌𐌄𐌕𐌄𐌋𐌉𐌑\n"),
110 vec
![0xd800, 0xdf00, 0xd800, 0xdf16,
111 0xd800, 0xdf0b, 0xd800, 0xdf04,
112 0xd800, 0xdf11, 0xd800, 0xdf09,
113 0x00b7, 0xd800, 0xdf0c, 0xd800,
114 0xdf04, 0xd800, 0xdf15, 0xd800,
115 0xdf04, 0xd800, 0xdf0b, 0xd800,
116 0xdf09, 0xd800, 0xdf11, 0x000a ]),
118 (String
::from("𐒋𐒘𐒈𐒑𐒛𐒒 𐒕𐒓 𐒈𐒚𐒍 𐒏𐒜𐒒𐒖𐒆 𐒕𐒆\n"),
119 vec
![0xd801, 0xdc8b, 0xd801, 0xdc98,
120 0xd801, 0xdc88, 0xd801, 0xdc91,
121 0xd801, 0xdc9b, 0xd801, 0xdc92,
122 0x0020, 0xd801, 0xdc95, 0xd801,
123 0xdc93, 0x0020, 0xd801, 0xdc88,
124 0xd801, 0xdc9a, 0xd801, 0xdc8d,
125 0x0020, 0xd801, 0xdc8f, 0xd801,
126 0xdc9c, 0xd801, 0xdc92, 0xd801,
127 0xdc96, 0xd801, 0xdc86, 0x0020,
128 0xd801, 0xdc95, 0xd801, 0xdc86,
130 // Issue #12318, even-numbered non-BMP planes
131 (String
::from("\u{20000}"),
132 vec
![0xD840, 0xDC00])];
135 let (s
, u
) = (*p
).clone();
136 let s_as_utf16
= s
.utf16_units().collect
::<Vec
<u16>>();
137 let u_as_string
= String
::from_utf16(&u
).unwrap();
139 assert
!(::rustc_unicode
::str::is_utf16(&u
));
140 assert_eq
!(s_as_utf16
, u
);
142 assert_eq
!(u_as_string
, s
);
143 assert_eq
!(String
::from_utf16_lossy(&u
), s
);
145 assert_eq
!(String
::from_utf16(&s_as_utf16
).unwrap(), s
);
146 assert_eq
!(u_as_string
.utf16_units().collect
::<Vec
<u16>>(), u
);
151 fn test_utf16_invalid() {
152 // completely positive cases tested above.
154 assert
!(String
::from_utf16(&[0xD800]).is_err());
156 assert
!(String
::from_utf16(&[0xD800, 0xD800]).is_err());
159 assert
!(String
::from_utf16(&[0x0061, 0xDC00]).is_err());
162 assert
!(String
::from_utf16(&[0xD800, 0xd801, 0xdc8b, 0xD800]).is_err());
166 fn test_from_utf16_lossy() {
167 // completely positive cases tested above.
169 assert_eq
!(String
::from_utf16_lossy(&[0xD800]), String
::from("\u{FFFD}"));
171 assert_eq
!(String
::from_utf16_lossy(&[0xD800, 0xD800]),
172 String
::from("\u{FFFD}\u{FFFD}"));
175 assert_eq
!(String
::from_utf16_lossy(&[0x0061, 0xDC00]), String
::from("a\u{FFFD}"));
178 assert_eq
!(String
::from_utf16_lossy(&[0xD800, 0xd801, 0xdc8b, 0xD800]),
179 String
::from("\u{FFFD}𐒋\u{FFFD}"));
183 fn test_push_bytes() {
184 let mut s
= String
::from("ABC");
186 let mv
= s
.as_mut_vec();
187 mv
.push_all(&[b'D'
]);
189 assert_eq
!(s
, "ABCD");
194 let mut s
= String
::new();
196 assert_eq
!(&s
[0..], "");
198 assert_eq
!(&s
[0..], "abc");
199 s
.push_str("ประเทศไทย中华Việt Nam");
200 assert_eq
!(&s
[0..], "abcประเทศไทย中华Việt Nam");
205 let mut data
= String
::from("ประเทศไทย中");
207 data
.push('b'
); // 1 byte
208 data
.push('¢'
); // 2 byte
209 data
.push('€'
); // 3 byte
210 data
.push('𤭢'
); // 4 byte
211 assert_eq
!(data
, "ประเทศไทย中华b¢€𤭢");
216 let mut data
= String
::from("ประเทศไทย中华b¢€𤭢");
217 assert_eq
!(data
.pop().unwrap(), '𤭢'
); // 4 bytes
218 assert_eq
!(data
.pop().unwrap(), '€'
); // 3 bytes
219 assert_eq
!(data
.pop().unwrap(), '¢'
); // 2 bytes
220 assert_eq
!(data
.pop().unwrap(), 'b'
); // 1 bytes
221 assert_eq
!(data
.pop().unwrap(), '华'
);
222 assert_eq
!(data
, "ประเทศไทย中");
226 fn test_str_truncate() {
227 let mut s
= String
::from("12345");
229 assert_eq
!(s
, "12345");
231 assert_eq
!(s
, "123");
235 let mut s
= String
::from("12345");
245 fn test_str_truncate_invalid_len() {
246 let mut s
= String
::from("12345");
252 fn test_str_truncate_split_codepoint() {
253 let mut s
= String
::from("\u{FC}"); // ü
258 fn test_str_clear() {
259 let mut s
= String
::from("12345");
261 assert_eq
!(s
.len(), 0);
267 let a
= String
::from("12345");
270 assert_eq
!(b
.len(), 7);
271 assert_eq
!(b
, "1234522");
276 let mut s
= "ศไทย中华Việt Nam; foobar".to_string();;
277 assert_eq
!(s
.remove(0), 'ศ'
);
278 assert_eq
!(s
.len(), 33);
279 assert_eq
!(s
, "ไทย中华Việt Nam; foobar");
280 assert_eq
!(s
.remove(17), 'ệ'
);
281 assert_eq
!(s
, "ไทย中华Vit Nam; foobar");
284 #[test] #[should_panic]
286 "ศ".to_string().remove(1);
291 let mut s
= "foobar".to_string();
293 assert_eq
!(s
, "ệfoobar");
295 assert_eq
!(s
, "ệfooยbar");
298 #[test] #[should_panic] fn insert_bad1() { "".to_string().insert(1, 't'); }
299 #[test] #[should_panic] fn insert_bad2() { "ệ".to_string().insert(1, 't'); }
303 let s
= "foobar".to_string();
304 assert_eq
!("foobar", &s
[..]);
305 assert_eq
!("foo", &s
[..3]);
306 assert_eq
!("bar", &s
[3..]);
307 assert_eq
!("oob", &s
[1..4]);
311 fn test_simple_types() {
312 assert_eq
!(1.to_string(), "1");
313 assert_eq
!((-1).to_string(), "-1");
314 assert_eq
!(200.to_string(), "200");
315 assert_eq
!(2.to_string(), "2");
316 assert_eq
!(true.to_string(), "true");
317 assert_eq
!(false.to_string(), "false");
318 assert_eq
!(("hi".to_string()).to_string(), "hi");
323 let x
: Vec
<i32> = vec
![];
324 assert_eq
!(format
!("{:?}", x
), "[]");
325 assert_eq
!(format
!("{:?}", vec
![1]), "[1]");
326 assert_eq
!(format
!("{:?}", vec
![1, 2, 3]), "[1, 2, 3]");
327 assert
!(format
!("{:?}", vec
![vec
![], vec
![1], vec
![1, 1]]) ==
328 "[[], [1], [1, 1]]");
332 fn test_from_iterator() {
333 let s
= "ศไทย中华Việt Nam".to_string();
337 let a
: String
= s
.chars().collect();
340 let mut b
= t
.to_string();
344 let c
: String
= vec
![t
, u
].into_iter().collect();
347 let mut d
= t
.to_string();
354 let mut s
= String
::from("αβγ");
355 assert_eq
!(s
.drain(2..4).collect
::<String
>(), "β");
358 let mut t
= String
::from("abcd");
360 assert_eq
!(t
, "abcd");
362 assert_eq
!(t
, "bcd");
364 assert_eq
!(t
, "bcd");
370 fn test_extend_ref() {
371 let mut a
= "foo".to_string();
372 a
.extend(&['b'
, 'a'
, 'r'
]);
374 assert_eq
!(&a
, "foobar");
378 fn bench_with_capacity(b
: &mut Bencher
) {
380 String
::with_capacity(100)
385 fn bench_push_str(b
: &mut Bencher
) {
386 let s
= "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
388 let mut r
= String
::new();
393 const REPETITIONS
: u64 = 10_000;
396 fn bench_push_str_one_byte(b
: &mut Bencher
) {
397 b
.bytes
= REPETITIONS
;
399 let mut r
= String
::new();
400 for _
in 0..REPETITIONS
{
407 fn bench_push_char_one_byte(b
: &mut Bencher
) {
408 b
.bytes
= REPETITIONS
;
410 let mut r
= String
::new();
411 for _
in 0..REPETITIONS
{
418 fn bench_push_char_two_bytes(b
: &mut Bencher
) {
419 b
.bytes
= REPETITIONS
* 2;
421 let mut r
= String
::new();
422 for _
in 0..REPETITIONS
{
429 fn from_utf8_lossy_100_ascii(b
: &mut Bencher
) {
430 let s
= b
"Hello there, the quick brown fox jumped over the lazy dog! \
431 Lorem ipsum dolor sit amet, consectetur. ";
433 assert_eq
!(100, s
.len());
435 let _
= String
::from_utf8_lossy(s
);
440 fn from_utf8_lossy_100_multibyte(b
: &mut Bencher
) {
441 let s
= "𐌀𐌖𐌋𐌄𐌑𐌉ปรدولة الكويتทศไทย中华𐍅𐌿𐌻𐍆𐌹𐌻𐌰".as_bytes();
442 assert_eq
!(100, s
.len());
444 let _
= String
::from_utf8_lossy(s
);
449 fn from_utf8_lossy_invalid(b
: &mut Bencher
) {
450 let s
= b
"Hello\xC0\x80 There\xE6\x83 Goodbye";
452 let _
= String
::from_utf8_lossy(s
);
457 fn from_utf8_lossy_100_invalid(b
: &mut Bencher
) {
458 let s
= repeat(0xf5).take(100).collect
::<Vec
<_
>>();
460 let _
= String
::from_utf8_lossy(&s
);
465 fn bench_exact_size_shrink_to_fit(b
: &mut Bencher
) {
466 let s
= "Hello there, the quick brown fox jumped over the lazy dog! \
467 Lorem ipsum dolor sit amet, consectetur. ";
468 // ensure our operation produces an exact-size string before we benchmark it
469 let mut r
= String
::with_capacity(s
.len());
471 assert_eq
!(r
.len(), r
.capacity());
473 let mut r
= String
::with_capacity(s
.len());
481 fn bench_from_str(b
: &mut Bencher
) {
482 let s
= "Hello there, the quick brown fox jumped over the lazy dog! \
483 Lorem ipsum dolor sit amet, consectetur. ";
490 fn bench_from(b
: &mut Bencher
) {
491 let s
= "Hello there, the quick brown fox jumped over the lazy dog! \
492 Lorem ipsum dolor sit amet, consectetur. ";
499 fn bench_to_string(b
: &mut Bencher
) {
500 let s
= "Hello there, the quick brown fox jumped over the lazy dog! \
501 Lorem ipsum dolor sit amet, consectetur. ";