src/libcollectionstest/str.rs

   1 // Copyright 2012-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.
   4 //
   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.
  10
  11 use std::cmp::Ordering::{Equal, Greater, Less};
  12 use std::iter::AdditiveIterator;
  13 use std::str::{Utf8Error, from_utf8};
  14
  15 #[test]
  16 fn test_le() {
  17     assert!("" <= "");
  18     assert!("" <= "foo");
  19     assert!("foo" <= "foo");
  20     assert!("foo" != "bar");
  21 }
  22
  23 #[test]
  24 fn test_len() {
  25     assert_eq!("".len(), 0);
  26     assert_eq!("hello world".len(), 11);
  27     assert_eq!("\x63".len(), 1);
  28     assert_eq!("\u{a2}".len(), 2);
  29     assert_eq!("\u{3c0}".len(), 2);
  30     assert_eq!("\u{2620}".len(), 3);
  31     assert_eq!("\u{1d11e}".len(), 4);
  32
  33     assert_eq!("".chars().count(), 0);
  34     assert_eq!("hello world".chars().count(), 11);
  35     assert_eq!("\x63".chars().count(), 1);
  36     assert_eq!("\u{a2}".chars().count(), 1);
  37     assert_eq!("\u{3c0}".chars().count(), 1);
  38     assert_eq!("\u{2620}".chars().count(), 1);
  39     assert_eq!("\u{1d11e}".chars().count(), 1);
  40     assert_eq!("ประเทศไทย中华Việt Nam".chars().count(), 19);
  41
  42     assert_eq!("ｈｅｌｌｏ".width(false), 10);
  43     assert_eq!("ｈｅｌｌｏ".width(true), 10);
  44     assert_eq!("\0\0\0\0\0".width(false), 0);
  45     assert_eq!("\0\0\0\0\0".width(true), 0);
  46     assert_eq!("".width(false), 0);
  47     assert_eq!("".width(true), 0);
  48     assert_eq!("\u{2081}\u{2082}\u{2083}\u{2084}".width(false), 4);
  49     assert_eq!("\u{2081}\u{2082}\u{2083}\u{2084}".width(true), 8);
  50 }
  51
  52 #[test]
  53 fn test_find() {
  54     assert_eq!("hello".find('l'), Some(2));
  55     assert_eq!("hello".find(|c:char| c == 'o'), Some(4));
  56     assert!("hello".find('x').is_none());
  57     assert!("hello".find(|c:char| c == 'x').is_none());
  58     assert_eq!("ประเทศไทย中华Việt Nam".find('华'), Some(30));
  59     assert_eq!("ประเทศไทย中华Việt Nam".find(|c: char| c == '华'), Some(30));
  60 }
  61
  62 #[test]
  63 fn test_rfind() {
  64     assert_eq!("hello".rfind('l'), Some(3));
  65     assert_eq!("hello".rfind(|c:char| c == 'o'), Some(4));
  66     assert!("hello".rfind('x').is_none());
  67     assert!("hello".rfind(|c:char| c == 'x').is_none());
  68     assert_eq!("ประเทศไทย中华Việt Nam".rfind('华'), Some(30));
  69     assert_eq!("ประเทศไทย中华Việt Nam".rfind(|c: char| c == '华'), Some(30));
  70 }
  71
  72 #[test]
  73 fn test_collect() {
  74     let empty = String::from_str("");
  75     let s: String = empty.chars().collect();
  76     assert_eq!(empty, s);
  77     let data = String::from_str("ประเทศไทย中");
  78     let s: String = data.chars().collect();
  79     assert_eq!(data, s);
  80 }
  81
  82 #[test]
  83 fn test_into_bytes() {
  84     let data = String::from_str("asdf");
  85     let buf = data.into_bytes();
  86     assert_eq!(b"asdf", buf);
  87 }
  88
  89 #[test]
  90 fn test_find_str() {
  91     // byte positions
  92     assert_eq!("".find_str(""), Some(0));
  93     assert!("banana".find_str("apple pie").is_none());
  94
  95     let data = "abcabc";
  96     assert_eq!(data[0..6].find_str("ab"), Some(0));
  97     assert_eq!(data[2..6].find_str("ab"), Some(3 - 2));
  98     assert!(data[2..4].find_str("ab").is_none());
  99
 100     let string = "ประเทศไทย中华Việt Nam";
 101     let mut data = String::from_str(string);
 102     data.push_str(string);
 103     assert!(data.find_str("ไท华").is_none());
 104     assert_eq!(data[0..43].find_str(""), Some(0));
 105     assert_eq!(data[6..43].find_str(""), Some(6 - 6));
 106
 107     assert_eq!(data[0..43].find_str("ประ"), Some( 0));
 108     assert_eq!(data[0..43].find_str("ทศไ"), Some(12));
 109     assert_eq!(data[0..43].find_str("ย中"), Some(24));
 110     assert_eq!(data[0..43].find_str("iệt"), Some(34));
 111     assert_eq!(data[0..43].find_str("Nam"), Some(40));
 112
 113     assert_eq!(data[43..86].find_str("ประ"), Some(43 - 43));
 114     assert_eq!(data[43..86].find_str("ทศไ"), Some(55 - 43));
 115     assert_eq!(data[43..86].find_str("ย中"), Some(67 - 43));
 116     assert_eq!(data[43..86].find_str("iệt"), Some(77 - 43));
 117     assert_eq!(data[43..86].find_str("Nam"), Some(83 - 43));
 118 }
 119
 120 #[test]
 121 fn test_slice_chars() {
 122     fn t(a: &str, b: &str, start: usize) {
 123         assert_eq!(a.slice_chars(start, start + b.chars().count()), b);
 124     }
 125     t("", "", 0);
 126     t("hello", "llo", 2);
 127     t("hello", "el", 1);
 128     t("αβλ", "β", 1);
 129     t("αβλ", "", 3);
 130     assert_eq!("ะเทศไท", "ประเทศไทย中华Việt Nam".slice_chars(2, 8));
 131 }
 132
 133 fn s(x: &str) -> String { x.to_string() }
 134
 135 macro_rules! test_concat {
 136     ($expected: expr, $string: expr) => {
 137         {
 138             let s: String = $string.concat();
 139             assert_eq!($expected, s);
 140         }
 141     }
 142 }
 143
 144 #[test]
 145 fn test_concat_for_different_types() {
 146     test_concat!("ab", vec![s("a"), s("b")]);
 147     test_concat!("ab", vec!["a", "b"]);
 148     test_concat!("ab", vec!["a", "b"]);
 149     test_concat!("ab", vec![s("a"), s("b")]);
 150 }
 151
 152 #[test]
 153 fn test_concat_for_different_lengths() {
 154     let empty: &[&str] = &[];
 155     test_concat!("", empty);
 156     test_concat!("a", ["a"]);
 157     test_concat!("ab", ["a", "b"]);
 158     test_concat!("abc", ["", "a", "bc"]);
 159 }
 160
 161 macro_rules! test_connect {
 162     ($expected: expr, $string: expr, $delim: expr) => {
 163         {
 164             let s = $string.connect($delim);
 165             assert_eq!($expected, s);
 166         }
 167     }
 168 }
 169
 170 #[test]
 171 fn test_connect_for_different_types() {
 172     test_connect!("a-b", ["a", "b"], "-");
 173     let hyphen = "-".to_string();
 174     test_connect!("a-b", [s("a"), s("b")], &*hyphen);
 175     test_connect!("a-b", vec!["a", "b"], &*hyphen);
 176     test_connect!("a-b", &*vec!["a", "b"], "-");
 177     test_connect!("a-b", vec![s("a"), s("b")], "-");
 178 }
 179
 180 #[test]
 181 fn test_connect_for_different_lengths() {
 182     let empty: &[&str] = &[];
 183     test_connect!("", empty, "-");
 184     test_connect!("a", ["a"], "-");
 185     test_connect!("a-b", ["a", "b"], "-");
 186     test_connect!("-a-bc", ["", "a", "bc"], "-");
 187 }
 188
 189 #[test]
 190 fn test_unsafe_slice() {
 191     assert_eq!("ab", unsafe {"abc".slice_unchecked(0, 2)});
 192     assert_eq!("bc", unsafe {"abc".slice_unchecked(1, 3)});
 193     assert_eq!("", unsafe {"abc".slice_unchecked(1, 1)});
 194     fn a_million_letter_a() -> String {
 195         let mut i = 0;
 196         let mut rs = String::new();
 197         while i < 100000 {
 198             rs.push_str("aaaaaaaaaa");
 199             i += 1;
 200         }
 201         rs
 202     }
 203     fn half_a_million_letter_a() -> String {
 204         let mut i = 0;
 205         let mut rs = String::new();
 206         while i < 100000 {
 207             rs.push_str("aaaaa");
 208             i += 1;
 209         }
 210         rs
 211     }
 212     let letters = a_million_letter_a();
 213     assert!(half_a_million_letter_a() ==
 214         unsafe {String::from_str(letters.slice_unchecked(
 215                                  0,
 216                                  500000))});
 217 }
 218
 219 #[test]
 220 fn test_starts_with() {
 221     assert!(("".starts_with("")));
 222     assert!(("abc".starts_with("")));
 223     assert!(("abc".starts_with("a")));
 224     assert!((!"a".starts_with("abc")));
 225     assert!((!"".starts_with("abc")));
 226     assert!((!"ödd".starts_with("-")));
 227     assert!(("ödd".starts_with("öd")));
 228 }
 229
 230 #[test]
 231 fn test_ends_with() {
 232     assert!(("".ends_with("")));
 233     assert!(("abc".ends_with("")));
 234     assert!(("abc".ends_with("c")));
 235     assert!((!"a".ends_with("abc")));
 236     assert!((!"".ends_with("abc")));
 237     assert!((!"ddö".ends_with("-")));
 238     assert!(("ddö".ends_with("dö")));
 239 }
 240
 241 #[test]
 242 fn test_is_empty() {
 243     assert!("".is_empty());
 244     assert!(!"a".is_empty());
 245 }
 246
 247 #[test]
 248 fn test_replace() {
 249     let a = "a";
 250     assert_eq!("".replace(a, "b"), String::from_str(""));
 251     assert_eq!("a".replace(a, "b"), String::from_str("b"));
 252     assert_eq!("ab".replace(a, "b"), String::from_str("bb"));
 253     let test = "test";
 254     assert!(" test test ".replace(test, "toast") ==
 255         String::from_str(" toast toast "));
 256     assert_eq!(" test test ".replace(test, ""), String::from_str("   "));
 257 }
 258
 259 #[test]
 260 fn test_replace_2a() {
 261     let data = "ประเทศไทย中华";
 262     let repl = "دولة الكويت";
 263
 264     let a = "ประเ";
 265     let a2 = "دولة الكويتทศไทย中华";
 266     assert_eq!(data.replace(a, repl), a2);
 267 }
 268
 269 #[test]
 270 fn test_replace_2b() {
 271     let data = "ประเทศไทย中华";
 272     let repl = "دولة الكويت";
 273
 274     let b = "ะเ";
 275     let b2 = "ปรدولة الكويتทศไทย中华";
 276     assert_eq!(data.replace(b, repl), b2);
 277 }
 278
 279 #[test]
 280 fn test_replace_2c() {
 281     let data = "ประเทศไทย中华";
 282     let repl = "دولة الكويت";
 283
 284     let c = "中华";
 285     let c2 = "ประเทศไทยدولة الكويت";
 286     assert_eq!(data.replace(c, repl), c2);
 287 }
 288
 289 #[test]
 290 fn test_replace_2d() {
 291     let data = "ประเทศไทย中华";
 292     let repl = "دولة الكويت";
 293
 294     let d = "ไท华";
 295     assert_eq!(data.replace(d, repl), data);
 296 }
 297
 298 #[test]
 299 fn test_slice() {
 300     assert_eq!("ab", "abc".slice(0, 2));
 301     assert_eq!("bc", "abc".slice(1, 3));
 302     assert_eq!("", "abc".slice(1, 1));
 303     assert_eq!("\u{65e5}", "\u{65e5}\u{672c}".slice(0, 3));
 304
 305     let data = "ประเทศไทย中华";
 306     assert_eq!("ป", data.slice(0, 3));
 307     assert_eq!("ร", data.slice(3, 6));
 308     assert_eq!("", data.slice(3, 3));
 309     assert_eq!("华", data.slice(30, 33));
 310
 311     fn a_million_letter_x() -> String {
 312         let mut i = 0;
 313         let mut rs = String::new();
 314         while i < 100000 {
 315             rs.push_str("华华华华华华华华华华");
 316             i += 1;
 317         }
 318         rs
 319     }
 320     fn half_a_million_letter_x() -> String {
 321         let mut i = 0;
 322         let mut rs = String::new();
 323         while i < 100000 {
 324             rs.push_str("华华华华华");
 325             i += 1;
 326         }
 327         rs
 328     }
 329     let letters = a_million_letter_x();
 330     assert!(half_a_million_letter_x() ==
 331         String::from_str(letters.slice(0, 3 * 500000)));
 332 }
 333
 334 #[test]
 335 fn test_slice_2() {
 336     let ss = "中华Việt Nam";
 337
 338     assert_eq!("华", ss.slice(3, 6));
 339     assert_eq!("Việt Nam", ss.slice(6, 16));
 340
 341     assert_eq!("ab", "abc".slice(0, 2));
 342     assert_eq!("bc", "abc".slice(1, 3));
 343     assert_eq!("", "abc".slice(1, 1));
 344
 345     assert_eq!("中", ss.slice(0, 3));
 346     assert_eq!("华V", ss.slice(3, 7));
 347     assert_eq!("", ss.slice(3, 3));
 348     /*0: 中
 349       3: 华
 350       6: V
 351       7: i
 352       8: ệ
 353      11: t
 354      12:
 355      13: N
 356      14: a
 357      15: m */
 358 }
 359
 360 #[test]
 361 #[should_panic]
 362 fn test_slice_fail() {
 363     "中华Việt Nam".slice(0, 2);
 364 }
 365
 366 #[test]
 367 fn test_slice_from() {
 368     assert_eq!("abcd".slice_from(0), "abcd");
 369     assert_eq!("abcd".slice_from(2), "cd");
 370     assert_eq!("abcd".slice_from(4), "");
 371 }
 372 #[test]
 373 fn test_slice_to() {
 374     assert_eq!("abcd".slice_to(0), "");
 375     assert_eq!("abcd".slice_to(2), "ab");
 376     assert_eq!("abcd".slice_to(4), "abcd");
 377 }
 378
 379 #[test]
 380 fn test_trim_left_matches() {
 381     let v: &[char] = &[];
 382     assert_eq!(" *** foo *** ".trim_left_matches(v), " *** foo *** ");
 383     let chars: &[char] = &['*', ' '];
 384     assert_eq!(" *** foo *** ".trim_left_matches(chars), "foo *** ");
 385     assert_eq!(" ***  *** ".trim_left_matches(chars), "");
 386     assert_eq!("foo *** ".trim_left_matches(chars), "foo *** ");
 387
 388     assert_eq!("11foo1bar11".trim_left_matches('1'), "foo1bar11");
 389     let chars: &[char] = &['1', '2'];
 390     assert_eq!("12foo1bar12".trim_left_matches(chars), "foo1bar12");
 391     assert_eq!("123foo1bar123".trim_left_matches(|c: char| c.is_numeric()), "foo1bar123");
 392 }
 393
 394 #[test]
 395 fn test_trim_right_matches() {
 396     let v: &[char] = &[];
 397     assert_eq!(" *** foo *** ".trim_right_matches(v), " *** foo *** ");
 398     let chars: &[char] = &['*', ' '];
 399     assert_eq!(" *** foo *** ".trim_right_matches(chars), " *** foo");
 400     assert_eq!(" ***  *** ".trim_right_matches(chars), "");
 401     assert_eq!(" *** foo".trim_right_matches(chars), " *** foo");
 402
 403     assert_eq!("11foo1bar11".trim_right_matches('1'), "11foo1bar");
 404     let chars: &[char] = &['1', '2'];
 405     assert_eq!("12foo1bar12".trim_right_matches(chars), "12foo1bar");
 406     assert_eq!("123foo1bar123".trim_right_matches(|c: char| c.is_numeric()), "123foo1bar");
 407 }
 408
 409 #[test]
 410 fn test_trim_matches() {
 411     let v: &[char] = &[];
 412     assert_eq!(" *** foo *** ".trim_matches(v), " *** foo *** ");
 413     let chars: &[char] = &['*', ' '];
 414     assert_eq!(" *** foo *** ".trim_matches(chars), "foo");
 415     assert_eq!(" ***  *** ".trim_matches(chars), "");
 416     assert_eq!("foo".trim_matches(chars), "foo");
 417
 418     assert_eq!("11foo1bar11".trim_matches('1'), "foo1bar");
 419     let chars: &[char] = &['1', '2'];
 420     assert_eq!("12foo1bar12".trim_matches(chars), "foo1bar");
 421     assert_eq!("123foo1bar123".trim_matches(|c: char| c.is_numeric()), "foo1bar");
 422 }
 423
 424 #[test]
 425 fn test_trim_left() {
 426     assert_eq!("".trim_left(), "");
 427     assert_eq!("a".trim_left(), "a");
 428     assert_eq!("    ".trim_left(), "");
 429     assert_eq!("     blah".trim_left(), "blah");
 430     assert_eq!("   \u{3000}  wut".trim_left(), "wut");
 431     assert_eq!("hey ".trim_left(), "hey ");
 432 }
 433
 434 #[test]
 435 fn test_trim_right() {
 436     assert_eq!("".trim_right(), "");
 437     assert_eq!("a".trim_right(), "a");
 438     assert_eq!("    ".trim_right(), "");
 439     assert_eq!("blah     ".trim_right(), "blah");
 440     assert_eq!("wut   \u{3000}  ".trim_right(), "wut");
 441     assert_eq!(" hey".trim_right(), " hey");
 442 }
 443
 444 #[test]
 445 fn test_trim() {
 446     assert_eq!("".trim(), "");
 447     assert_eq!("a".trim(), "a");
 448     assert_eq!("    ".trim(), "");
 449     assert_eq!("    blah     ".trim(), "blah");
 450     assert_eq!("\nwut   \u{3000}  ".trim(), "wut");
 451     assert_eq!(" hey dude ".trim(), "hey dude");
 452 }
 453
 454 #[test]
 455 fn test_is_whitespace() {
 456     assert!("".chars().all(|c| c.is_whitespace()));
 457     assert!(" ".chars().all(|c| c.is_whitespace()));
 458     assert!("\u{2009}".chars().all(|c| c.is_whitespace())); // Thin space
 459     assert!("  \n\t   ".chars().all(|c| c.is_whitespace()));
 460     assert!(!"   _   ".chars().all(|c| c.is_whitespace()));
 461 }
 462
 463 #[test]
 464 fn test_slice_shift_char() {
 465     let data = "ประเทศไทย中";
 466     assert_eq!(data.slice_shift_char(), Some(('ป', "ระเทศไทย中")));
 467 }
 468
 469 #[test]
 470 fn test_slice_shift_char_2() {
 471     let empty = "";
 472     assert_eq!(empty.slice_shift_char(), None);
 473 }
 474
 475 #[test]
 476 fn test_is_utf8() {
 477     // deny overlong encodings
 478     assert!(from_utf8(&[0xc0, 0x80]).is_err());
 479     assert!(from_utf8(&[0xc0, 0xae]).is_err());
 480     assert!(from_utf8(&[0xe0, 0x80, 0x80]).is_err());
 481     assert!(from_utf8(&[0xe0, 0x80, 0xaf]).is_err());
 482     assert!(from_utf8(&[0xe0, 0x81, 0x81]).is_err());
 483     assert!(from_utf8(&[0xf0, 0x82, 0x82, 0xac]).is_err());
 484     assert!(from_utf8(&[0xf4, 0x90, 0x80, 0x80]).is_err());
 485
 486     // deny surrogates
 487     assert!(from_utf8(&[0xED, 0xA0, 0x80]).is_err());
 488     assert!(from_utf8(&[0xED, 0xBF, 0xBF]).is_err());
 489
 490     assert!(from_utf8(&[0xC2, 0x80]).is_ok());
 491     assert!(from_utf8(&[0xDF, 0xBF]).is_ok());
 492     assert!(from_utf8(&[0xE0, 0xA0, 0x80]).is_ok());
 493     assert!(from_utf8(&[0xED, 0x9F, 0xBF]).is_ok());
 494     assert!(from_utf8(&[0xEE, 0x80, 0x80]).is_ok());
 495     assert!(from_utf8(&[0xEF, 0xBF, 0xBF]).is_ok());
 496     assert!(from_utf8(&[0xF0, 0x90, 0x80, 0x80]).is_ok());
 497     assert!(from_utf8(&[0xF4, 0x8F, 0xBF, 0xBF]).is_ok());
 498 }
 499
 500 #[test]
 501 fn test_is_utf16() {
 502     use unicode::str::is_utf16;
 503
 504     macro_rules! pos {
 505         ($($e:expr),*) => { { $(assert!(is_utf16($e));)* } }
 506     }
 507
 508     // non-surrogates
 509     pos!(&[0x0000],
 510          &[0x0001, 0x0002],
 511          &[0xD7FF],
 512          &[0xE000]);
 513
 514     // surrogate pairs (randomly generated with Python 3's
 515     // .encode('utf-16be'))
 516     pos!(&[0xdb54, 0xdf16, 0xd880, 0xdee0, 0xdb6a, 0xdd45],
 517          &[0xd91f, 0xdeb1, 0xdb31, 0xdd84, 0xd8e2, 0xde14],
 518          &[0xdb9f, 0xdc26, 0xdb6f, 0xde58, 0xd850, 0xdfae]);
 519
 520     // mixtures (also random)
 521     pos!(&[0xd921, 0xdcc2, 0x002d, 0x004d, 0xdb32, 0xdf65],
 522          &[0xdb45, 0xdd2d, 0x006a, 0xdacd, 0xddfe, 0x0006],
 523          &[0x0067, 0xd8ff, 0xddb7, 0x000f, 0xd900, 0xdc80]);
 524
 525     // negative tests
 526     macro_rules! neg {
 527         ($($e:expr),*) => { { $(assert!(!is_utf16($e));)* } }
 528     }
 529
 530     neg!(
 531         // surrogate + regular unit
 532         &[0xdb45, 0x0000],
 533         // surrogate + lead surrogate
 534         &[0xd900, 0xd900],
 535         // unterminated surrogate
 536         &[0xd8ff],
 537         // trail surrogate without a lead
 538         &[0xddb7]);
 539
 540     // random byte sequences that Python 3's .decode('utf-16be')
 541     // failed on
 542     neg!(&[0x5b3d, 0x0141, 0xde9e, 0x8fdc, 0xc6e7],
 543          &[0xdf5a, 0x82a5, 0x62b9, 0xb447, 0x92f3],
 544          &[0xda4e, 0x42bc, 0x4462, 0xee98, 0xc2ca],
 545          &[0xbe00, 0xb04a, 0x6ecb, 0xdd89, 0xe278],
 546          &[0x0465, 0xab56, 0xdbb6, 0xa893, 0x665e],
 547          &[0x6b7f, 0x0a19, 0x40f4, 0xa657, 0xdcc5],
 548          &[0x9b50, 0xda5e, 0x24ec, 0x03ad, 0x6dee],
 549          &[0x8d17, 0xcaa7, 0xf4ae, 0xdf6e, 0xbed7],
 550          &[0xdaee, 0x2584, 0x7d30, 0xa626, 0x121a],
 551          &[0xd956, 0x4b43, 0x7570, 0xccd6, 0x4f4a],
 552          &[0x9dcf, 0x1b49, 0x4ba5, 0xfce9, 0xdffe],
 553          &[0x6572, 0xce53, 0xb05a, 0xf6af, 0xdacf],
 554          &[0x1b90, 0x728c, 0x9906, 0xdb68, 0xf46e],
 555          &[0x1606, 0xbeca, 0xbe76, 0x860f, 0xdfa5],
 556          &[0x8b4f, 0xde7a, 0xd220, 0x9fac, 0x2b6f],
 557          &[0xb8fe, 0xebbe, 0xda32, 0x1a5f, 0x8b8b],
 558          &[0x934b, 0x8956, 0xc434, 0x1881, 0xddf7],
 559          &[0x5a95, 0x13fc, 0xf116, 0xd89b, 0x93f9],
 560          &[0xd640, 0x71f1, 0xdd7d, 0x77eb, 0x1cd8],
 561          &[0x348b, 0xaef0, 0xdb2c, 0xebf1, 0x1282],
 562          &[0x50d7, 0xd824, 0x5010, 0xb369, 0x22ea]);
 563 }
 564
 565 #[test]
 566 fn test_as_bytes() {
 567     // no null
 568     let v = [
 569         224, 184, 168, 224, 185, 132, 224, 184, 151, 224, 184, 162, 228,
 570         184, 173, 229, 141, 142, 86, 105, 225, 187, 135, 116, 32, 78, 97,
 571         109
 572     ];
 573     let b: &[u8] = &[];
 574     assert_eq!("".as_bytes(), b);
 575     assert_eq!("abc".as_bytes(), b"abc");
 576     assert_eq!("ศไทย中华Việt Nam".as_bytes(), v);
 577 }
 578
 579 #[test]
 580 #[should_panic]
 581 fn test_as_bytes_fail() {
 582     // Don't double free. (I'm not sure if this exercises the
 583     // original problem code path anymore.)
 584     let s = String::from_str("");
 585     let _bytes = s.as_bytes();
 586     panic!();
 587 }
 588
 589 #[test]
 590 fn test_as_ptr() {
 591     let buf = "hello".as_ptr();
 592     unsafe {
 593         assert_eq!(*buf.offset(0), b'h');
 594         assert_eq!(*buf.offset(1), b'e');
 595         assert_eq!(*buf.offset(2), b'l');
 596         assert_eq!(*buf.offset(3), b'l');
 597         assert_eq!(*buf.offset(4), b'o');
 598     }
 599 }
 600
 601 #[test]
 602 fn test_subslice_offset() {
 603     let a = "kernelsprite";
 604     let b = &a[7..a.len()];
 605     let c = &a[0..a.len() - 6];
 606     assert_eq!(a.subslice_offset(b), 7);
 607     assert_eq!(a.subslice_offset(c), 0);
 608
 609     let string = "a\nb\nc";
 610     let lines: Vec<&str> = string.lines().collect();
 611     assert_eq!(string.subslice_offset(lines[0]), 0);
 612     assert_eq!(string.subslice_offset(lines[1]), 2);
 613     assert_eq!(string.subslice_offset(lines[2]), 4);
 614 }
 615
 616 #[test]
 617 #[should_panic]
 618 fn test_subslice_offset_2() {
 619     let a = "alchemiter";
 620     let b = "cruxtruder";
 621     a.subslice_offset(b);
 622 }
 623
 624 #[test]
 625 fn vec_str_conversions() {
 626     let s1: String = String::from_str("All mimsy were the borogoves");
 627
 628     let v: Vec<u8> = s1.as_bytes().to_vec();
 629     let s2: String = String::from_str(from_utf8(&v).unwrap());
 630     let mut i = 0;
 631     let n1 = s1.len();
 632     let n2 = v.len();
 633     assert_eq!(n1, n2);
 634     while i < n1 {
 635         let a: u8 = s1.as_bytes()[i];
 636         let b: u8 = s2.as_bytes()[i];
 637         debug!("{}", a);
 638         debug!("{}", b);
 639         assert_eq!(a, b);
 640         i += 1;
 641     }
 642 }
 643
 644 #[test]
 645 fn test_contains() {
 646     assert!("abcde".contains("bcd"));
 647     assert!("abcde".contains("abcd"));
 648     assert!("abcde".contains("bcde"));
 649     assert!("abcde".contains(""));
 650     assert!("".contains(""));
 651     assert!(!"abcde".contains("def"));
 652     assert!(!"".contains("a"));
 653
 654     let data = "ประเทศไทย中华Việt Nam";
 655     assert!(data.contains("ประเ"));
 656     assert!(data.contains("ะเ"));
 657     assert!(data.contains("中华"));
 658     assert!(!data.contains("ไท华"));
 659 }
 660
 661 #[test]
 662 fn test_contains_char() {
 663     assert!("abc".contains_char('b'));
 664     assert!("a".contains_char('a'));
 665     assert!(!"abc".contains_char('d'));
 666     assert!(!"".contains_char('a'));
 667 }
 668
 669 #[test]
 670 fn test_char_at() {
 671     let s = "ศไทย中华Việt Nam";
 672     let v = vec!['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
 673     let mut pos = 0;
 674     for ch in &v {
 675         assert!(s.char_at(pos) == *ch);
 676         pos += ch.to_string().len();
 677     }
 678 }
 679
 680 #[test]
 681 fn test_char_at_reverse() {
 682     let s = "ศไทย中华Việt Nam";
 683     let v = vec!['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
 684     let mut pos = s.len();
 685     for ch in v.iter().rev() {
 686         assert!(s.char_at_reverse(pos) == *ch);
 687         pos -= ch.to_string().len();
 688     }
 689 }
 690
 691 #[test]
 692 fn test_escape_unicode() {
 693     assert_eq!("abc".escape_unicode(),
 694                String::from_str("\\u{61}\\u{62}\\u{63}"));
 695     assert_eq!("a c".escape_unicode(),
 696                String::from_str("\\u{61}\\u{20}\\u{63}"));
 697     assert_eq!("\r\n\t".escape_unicode(),
 698                String::from_str("\\u{d}\\u{a}\\u{9}"));
 699     assert_eq!("'\"\\".escape_unicode(),
 700                String::from_str("\\u{27}\\u{22}\\u{5c}"));
 701     assert_eq!("\x00\x01\u{fe}\u{ff}".escape_unicode(),
 702                String::from_str("\\u{0}\\u{1}\\u{fe}\\u{ff}"));
 703     assert_eq!("\u{100}\u{ffff}".escape_unicode(),
 704                String::from_str("\\u{100}\\u{ffff}"));
 705     assert_eq!("\u{10000}\u{10ffff}".escape_unicode(),
 706                String::from_str("\\u{10000}\\u{10ffff}"));
 707     assert_eq!("ab\u{fb00}".escape_unicode(),
 708                String::from_str("\\u{61}\\u{62}\\u{fb00}"));
 709     assert_eq!("\u{1d4ea}\r".escape_unicode(),
 710                String::from_str("\\u{1d4ea}\\u{d}"));
 711 }
 712
 713 #[test]
 714 fn test_escape_default() {
 715     assert_eq!("abc".escape_default(), String::from_str("abc"));
 716     assert_eq!("a c".escape_default(), String::from_str("a c"));
 717     assert_eq!("\r\n\t".escape_default(), String::from_str("\\r\\n\\t"));
 718     assert_eq!("'\"\\".escape_default(), String::from_str("\\'\\\"\\\\"));
 719     assert_eq!("\u{100}\u{ffff}".escape_default(),
 720                String::from_str("\\u{100}\\u{ffff}"));
 721     assert_eq!("\u{10000}\u{10ffff}".escape_default(),
 722                String::from_str("\\u{10000}\\u{10ffff}"));
 723     assert_eq!("ab\u{fb00}".escape_default(),
 724                String::from_str("ab\\u{fb00}"));
 725     assert_eq!("\u{1d4ea}\r".escape_default(),
 726                String::from_str("\\u{1d4ea}\\r"));
 727 }
 728
 729 #[test]
 730 fn test_total_ord() {
 731     "1234".cmp("123") == Greater;
 732     "123".cmp("1234") == Less;
 733     "1234".cmp("1234") == Equal;
 734     "12345555".cmp("123456") == Less;
 735     "22".cmp("1234") == Greater;
 736 }
 737
 738 #[test]
 739 fn test_char_range_at() {
 740     let data = "b¢€𤭢𤭢€¢b";
 741     assert_eq!('b', data.char_range_at(0).ch);
 742     assert_eq!('¢', data.char_range_at(1).ch);
 743     assert_eq!('€', data.char_range_at(3).ch);
 744     assert_eq!('𤭢', data.char_range_at(6).ch);
 745     assert_eq!('𤭢', data.char_range_at(10).ch);
 746     assert_eq!('€', data.char_range_at(14).ch);
 747     assert_eq!('¢', data.char_range_at(17).ch);
 748     assert_eq!('b', data.char_range_at(19).ch);
 749 }
 750
 751 #[test]
 752 fn test_char_range_at_reverse_underflow() {
 753     assert_eq!("abc".char_range_at_reverse(0).next, 0);
 754 }
 755
 756 #[test]
 757 fn test_iterator() {
 758     let s = "ศไทย中华Việt Nam";
 759     let v = ['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
 760
 761     let mut pos = 0;
 762     let it = s.chars();
 763
 764     for c in it {
 765         assert_eq!(c, v[pos]);
 766         pos += 1;
 767     }
 768     assert_eq!(pos, v.len());
 769 }
 770
 771 #[test]
 772 fn test_rev_iterator() {
 773     let s = "ศไทย中华Việt Nam";
 774     let v = ['m', 'a', 'N', ' ', 't', 'ệ','i','V','华','中','ย','ท','ไ','ศ'];
 775
 776     let mut pos = 0;
 777     let it = s.chars().rev();
 778
 779     for c in it {
 780         assert_eq!(c, v[pos]);
 781         pos += 1;
 782     }
 783     assert_eq!(pos, v.len());
 784 }
 785
 786 #[test]
 787 fn test_chars_decoding() {
 788     let mut bytes = [0; 4];
 789     for c in (0..0x110000).filter_map(::std::char::from_u32) {
 790         let len = c.encode_utf8(&mut bytes).unwrap_or(0);
 791         let s = ::std::str::from_utf8(&bytes[..len]).unwrap();
 792         if Some(c) != s.chars().next() {
 793             panic!("character {:x}={} does not decode correctly", c as u32, c);
 794         }
 795     }
 796 }
 797
 798 #[test]
 799 fn test_chars_rev_decoding() {
 800     let mut bytes = [0; 4];
 801     for c in (0..0x110000).filter_map(::std::char::from_u32) {
 802         let len = c.encode_utf8(&mut bytes).unwrap_or(0);
 803         let s = ::std::str::from_utf8(&bytes[..len]).unwrap();
 804         if Some(c) != s.chars().rev().next() {
 805             panic!("character {:x}={} does not decode correctly", c as u32, c);
 806         }
 807     }
 808 }
 809
 810 #[test]
 811 fn test_iterator_clone() {
 812     let s = "ศไทย中华Việt Nam";
 813     let mut it = s.chars();
 814     it.next();
 815     assert!(it.clone().zip(it).all(|(x,y)| x == y));
 816 }
 817
 818 #[test]
 819 fn test_bytesator() {
 820     let s = "ศไทย中华Việt Nam";
 821     let v = [
 822         224, 184, 168, 224, 185, 132, 224, 184, 151, 224, 184, 162, 228,
 823         184, 173, 229, 141, 142, 86, 105, 225, 187, 135, 116, 32, 78, 97,
 824         109
 825     ];
 826     let mut pos = 0;
 827
 828     for b in s.bytes() {
 829         assert_eq!(b, v[pos]);
 830         pos += 1;
 831     }
 832 }
 833
 834 #[test]
 835 fn test_bytes_revator() {
 836     let s = "ศไทย中华Việt Nam";
 837     let v = [
 838         224, 184, 168, 224, 185, 132, 224, 184, 151, 224, 184, 162, 228,
 839         184, 173, 229, 141, 142, 86, 105, 225, 187, 135, 116, 32, 78, 97,
 840         109
 841     ];
 842     let mut pos = v.len();
 843
 844     for b in s.bytes().rev() {
 845         pos -= 1;
 846         assert_eq!(b, v[pos]);
 847     }
 848 }
 849
 850 #[test]
 851 fn test_char_indicesator() {
 852     let s = "ศไทย中华Việt Nam";
 853     let p = [0, 3, 6, 9, 12, 15, 18, 19, 20, 23, 24, 25, 26, 27];
 854     let v = ['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
 855
 856     let mut pos = 0;
 857     let it = s.char_indices();
 858
 859     for c in it {
 860         assert_eq!(c, (p[pos], v[pos]));
 861         pos += 1;
 862     }
 863     assert_eq!(pos, v.len());
 864     assert_eq!(pos, p.len());
 865 }
 866
 867 #[test]
 868 fn test_char_indices_revator() {
 869     let s = "ศไทย中华Việt Nam";
 870     let p = [27, 26, 25, 24, 23, 20, 19, 18, 15, 12, 9, 6, 3, 0];
 871     let v = ['m', 'a', 'N', ' ', 't', 'ệ','i','V','华','中','ย','ท','ไ','ศ'];
 872
 873     let mut pos = 0;
 874     let it = s.char_indices().rev();
 875
 876     for c in it {
 877         assert_eq!(c, (p[pos], v[pos]));
 878         pos += 1;
 879     }
 880     assert_eq!(pos, v.len());
 881     assert_eq!(pos, p.len());
 882 }
 883
 884 #[test]
 885 fn test_splitn_char_iterator() {
 886     let data = "\nMäry häd ä little lämb\nLittle lämb\n";
 887
 888     let split: Vec<&str> = data.splitn(3, ' ').collect();
 889     assert_eq!(split, ["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]);
 890
 891     let split: Vec<&str> = data.splitn(3, |c: char| c == ' ').collect();
 892     assert_eq!(split, ["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]);
 893
 894     // Unicode
 895     let split: Vec<&str> = data.splitn(3, 'ä').collect();
 896     assert_eq!(split, ["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]);
 897
 898     let split: Vec<&str> = data.splitn(3, |c: char| c == 'ä').collect();
 899     assert_eq!(split, ["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]);
 900 }
 901
 902 #[test]
 903 fn test_split_char_iterator_no_trailing() {
 904     let data = "\nMäry häd ä little lämb\nLittle lämb\n";
 905
 906     let split: Vec<&str> = data.split('\n').collect();
 907     assert_eq!(split, ["", "Märy häd ä little lämb", "Little lämb", ""]);
 908
 909     let split: Vec<&str> = data.split_terminator('\n').collect();
 910     assert_eq!(split, ["", "Märy häd ä little lämb", "Little lämb"]);
 911 }
 912
 913 #[test]
 914 fn test_rsplit() {
 915     let data = "\nMäry häd ä little lämb\nLittle lämb\n";
 916
 917     let split: Vec<&str> = data.rsplit(' ').collect();
 918     assert_eq!(split, ["lämb\n", "lämb\nLittle", "little", "ä", "häd", "\nMäry"]);
 919
 920     let split: Vec<&str> = data.rsplit("lämb").collect();
 921     assert_eq!(split, ["\n", "\nLittle ", "\nMäry häd ä little "]);
 922
 923     let split: Vec<&str> = data.rsplit(|c: char| c == 'ä').collect();
 924     assert_eq!(split, ["mb\n", "mb\nLittle l", " little l", "d ", "ry h", "\nM"]);
 925 }
 926
 927 #[test]
 928 fn test_rsplitn() {
 929     let data = "\nMäry häd ä little lämb\nLittle lämb\n";
 930
 931     let split: Vec<&str> = data.rsplitn(1, ' ').collect();
 932     assert_eq!(split, ["lämb\n", "\nMäry häd ä little lämb\nLittle"]);
 933
 934     let split: Vec<&str> = data.rsplitn(1, "lämb").collect();
 935     assert_eq!(split, ["\n", "\nMäry häd ä little lämb\nLittle "]);
 936
 937     let split: Vec<&str> = data.rsplitn(1, |c: char| c == 'ä').collect();
 938     assert_eq!(split, ["mb\n", "\nMäry häd ä little lämb\nLittle l"]);
 939 }
 940
 941 #[test]
 942 fn test_words() {
 943     let data = "\n \tMäry   häd\tä  little lämb\nLittle lämb\n";
 944     let words: Vec<&str> = data.words().collect();
 945     assert_eq!(words, ["Märy", "häd", "ä", "little", "lämb", "Little", "lämb"])
 946 }
 947
 948 #[test]
 949 fn test_nfd_chars() {
 950     macro_rules! t {
 951         ($input: expr, $expected: expr) => {
 952             assert_eq!($input.nfd_chars().collect::<String>(), $expected);
 953         }
 954     }
 955     t!("abc", "abc");
 956     t!("\u{1e0b}\u{1c4}", "d\u{307}\u{1c4}");
 957     t!("\u{2026}", "\u{2026}");
 958     t!("\u{2126}", "\u{3a9}");
 959     t!("\u{1e0b}\u{323}", "d\u{323}\u{307}");
 960     t!("\u{1e0d}\u{307}", "d\u{323}\u{307}");
 961     t!("a\u{301}", "a\u{301}");
 962     t!("\u{301}a", "\u{301}a");
 963     t!("\u{d4db}", "\u{1111}\u{1171}\u{11b6}");
 964     t!("\u{ac1c}", "\u{1100}\u{1162}");
 965 }
 966
 967 #[test]
 968 fn test_nfkd_chars() {
 969     macro_rules! t {
 970         ($input: expr, $expected: expr) => {
 971             assert_eq!($input.nfkd_chars().collect::<String>(), $expected);
 972         }
 973     }
 974     t!("abc", "abc");
 975     t!("\u{1e0b}\u{1c4}", "d\u{307}DZ\u{30c}");
 976     t!("\u{2026}", "...");
 977     t!("\u{2126}", "\u{3a9}");
 978     t!("\u{1e0b}\u{323}", "d\u{323}\u{307}");
 979     t!("\u{1e0d}\u{307}", "d\u{323}\u{307}");
 980     t!("a\u{301}", "a\u{301}");
 981     t!("\u{301}a", "\u{301}a");
 982     t!("\u{d4db}", "\u{1111}\u{1171}\u{11b6}");
 983     t!("\u{ac1c}", "\u{1100}\u{1162}");
 984 }
 985
 986 #[test]
 987 fn test_nfc_chars() {
 988     macro_rules! t {
 989         ($input: expr, $expected: expr) => {
 990             assert_eq!($input.nfc_chars().collect::<String>(), $expected);
 991         }
 992     }
 993     t!("abc", "abc");
 994     t!("\u{1e0b}\u{1c4}", "\u{1e0b}\u{1c4}");
 995     t!("\u{2026}", "\u{2026}");
 996     t!("\u{2126}", "\u{3a9}");
 997     t!("\u{1e0b}\u{323}", "\u{1e0d}\u{307}");
 998     t!("\u{1e0d}\u{307}", "\u{1e0d}\u{307}");
 999     t!("a\u{301}", "\u{e1}");
1000     t!("\u{301}a", "\u{301}a");
1001     t!("\u{d4db}", "\u{d4db}");
1002     t!("\u{ac1c}", "\u{ac1c}");
1003     t!("a\u{300}\u{305}\u{315}\u{5ae}b", "\u{e0}\u{5ae}\u{305}\u{315}b");
1004 }
1005
1006 #[test]
1007 fn test_nfkc_chars() {
1008     macro_rules! t {
1009         ($input: expr, $expected: expr) => {
1010             assert_eq!($input.nfkc_chars().collect::<String>(), $expected);
1011         }
1012     }
1013     t!("abc", "abc");
1014     t!("\u{1e0b}\u{1c4}", "\u{1e0b}D\u{17d}");
1015     t!("\u{2026}", "...");
1016     t!("\u{2126}", "\u{3a9}");
1017     t!("\u{1e0b}\u{323}", "\u{1e0d}\u{307}");
1018     t!("\u{1e0d}\u{307}", "\u{1e0d}\u{307}");
1019     t!("a\u{301}", "\u{e1}");
1020     t!("\u{301}a", "\u{301}a");
1021     t!("\u{d4db}", "\u{d4db}");
1022     t!("\u{ac1c}", "\u{ac1c}");
1023     t!("a\u{300}\u{305}\u{315}\u{5ae}b", "\u{e0}\u{5ae}\u{305}\u{315}b");
1024 }
1025
1026 #[test]
1027 fn test_lines() {
1028     let data = "\nMäry häd ä little lämb\n\nLittle lämb\n";
1029     let lines: Vec<&str> = data.lines().collect();
1030     assert_eq!(lines, ["", "Märy häd ä little lämb", "", "Little lämb"]);
1031
1032     let data = "\nMäry häd ä little lämb\n\nLittle lämb"; // no trailing \n
1033     let lines: Vec<&str> = data.lines().collect();
1034     assert_eq!(lines, ["", "Märy häd ä little lämb", "", "Little lämb"]);
1035 }
1036
1037 #[test]
1038 fn test_graphemes() {
1039     use std::iter::order;
1040
1041     // official Unicode test data
1042     // from http://www.unicode.org/Public/UCD/latest/ucd/auxiliary/GraphemeBreakTest.txt
1043     let test_same: [(_, &[_]); 325] = [
1044         ("\u{20}\u{20}", &["\u{20}", "\u{20}"]),
1045         ("\u{20}\u{308}\u{20}", &["\u{20}\u{308}", "\u{20}"]),
1046         ("\u{20}\u{D}", &["\u{20}", "\u{D}"]),
1047         ("\u{20}\u{308}\u{D}", &["\u{20}\u{308}", "\u{D}"]),
1048         ("\u{20}\u{A}", &["\u{20}", "\u{A}"]),
1049         ("\u{20}\u{308}\u{A}", &["\u{20}\u{308}", "\u{A}"]),
1050         ("\u{20}\u{1}", &["\u{20}", "\u{1}"]),
1051         ("\u{20}\u{308}\u{1}", &["\u{20}\u{308}", "\u{1}"]),
1052         ("\u{20}\u{300}", &["\u{20}\u{300}"]),
1053         ("\u{20}\u{308}\u{300}", &["\u{20}\u{308}\u{300}"]),
1054         ("\u{20}\u{1100}", &["\u{20}", "\u{1100}"]),
1055         ("\u{20}\u{308}\u{1100}", &["\u{20}\u{308}", "\u{1100}"]),
1056         ("\u{20}\u{1160}", &["\u{20}", "\u{1160}"]),
1057         ("\u{20}\u{308}\u{1160}", &["\u{20}\u{308}", "\u{1160}"]),
1058         ("\u{20}\u{11A8}", &["\u{20}", "\u{11A8}"]),
1059         ("\u{20}\u{308}\u{11A8}", &["\u{20}\u{308}", "\u{11A8}"]),
1060         ("\u{20}\u{AC00}", &["\u{20}", "\u{AC00}"]),
1061         ("\u{20}\u{308}\u{AC00}", &["\u{20}\u{308}", "\u{AC00}"]),
1062         ("\u{20}\u{AC01}", &["\u{20}", "\u{AC01}"]),
1063         ("\u{20}\u{308}\u{AC01}", &["\u{20}\u{308}", "\u{AC01}"]),
1064         ("\u{20}\u{1F1E6}", &["\u{20}", "\u{1F1E6}"]),
1065         ("\u{20}\u{308}\u{1F1E6}", &["\u{20}\u{308}", "\u{1F1E6}"]),
1066         ("\u{20}\u{378}", &["\u{20}", "\u{378}"]),
1067         ("\u{20}\u{308}\u{378}", &["\u{20}\u{308}", "\u{378}"]),
1068         ("\u{D}\u{20}", &["\u{D}", "\u{20}"]),
1069         ("\u{D}\u{308}\u{20}", &["\u{D}", "\u{308}", "\u{20}"]),
1070         ("\u{D}\u{D}", &["\u{D}", "\u{D}"]),
1071         ("\u{D}\u{308}\u{D}", &["\u{D}", "\u{308}", "\u{D}"]),
1072         ("\u{D}\u{A}", &["\u{D}\u{A}"]),
1073         ("\u{D}\u{308}\u{A}", &["\u{D}", "\u{308}", "\u{A}"]),
1074         ("\u{D}\u{1}", &["\u{D}", "\u{1}"]),
1075         ("\u{D}\u{308}\u{1}", &["\u{D}", "\u{308}", "\u{1}"]),
1076         ("\u{D}\u{300}", &["\u{D}", "\u{300}"]),
1077         ("\u{D}\u{308}\u{300}", &["\u{D}", "\u{308}\u{300}"]),
1078         ("\u{D}\u{903}", &["\u{D}", "\u{903}"]),
1079         ("\u{D}\u{1100}", &["\u{D}", "\u{1100}"]),
1080         ("\u{D}\u{308}\u{1100}", &["\u{D}", "\u{308}", "\u{1100}"]),
1081         ("\u{D}\u{1160}", &["\u{D}", "\u{1160}"]),
1082         ("\u{D}\u{308}\u{1160}", &["\u{D}", "\u{308}", "\u{1160}"]),
1083         ("\u{D}\u{11A8}", &["\u{D}", "\u{11A8}"]),
1084         ("\u{D}\u{308}\u{11A8}", &["\u{D}", "\u{308}", "\u{11A8}"]),
1085         ("\u{D}\u{AC00}", &["\u{D}", "\u{AC00}"]),
1086         ("\u{D}\u{308}\u{AC00}", &["\u{D}", "\u{308}", "\u{AC00}"]),
1087         ("\u{D}\u{AC01}", &["\u{D}", "\u{AC01}"]),
1088         ("\u{D}\u{308}\u{AC01}", &["\u{D}", "\u{308}", "\u{AC01}"]),
1089         ("\u{D}\u{1F1E6}", &["\u{D}", "\u{1F1E6}"]),
1090         ("\u{D}\u{308}\u{1F1E6}", &["\u{D}", "\u{308}", "\u{1F1E6}"]),
1091         ("\u{D}\u{378}", &["\u{D}", "\u{378}"]),
1092         ("\u{D}\u{308}\u{378}", &["\u{D}", "\u{308}", "\u{378}"]),
1093         ("\u{A}\u{20}", &["\u{A}", "\u{20}"]),
1094         ("\u{A}\u{308}\u{20}", &["\u{A}", "\u{308}", "\u{20}"]),
1095         ("\u{A}\u{D}", &["\u{A}", "\u{D}"]),
1096         ("\u{A}\u{308}\u{D}", &["\u{A}", "\u{308}", "\u{D}"]),
1097         ("\u{A}\u{A}", &["\u{A}", "\u{A}"]),
1098         ("\u{A}\u{308}\u{A}", &["\u{A}", "\u{308}", "\u{A}"]),
1099         ("\u{A}\u{1}", &["\u{A}", "\u{1}"]),
1100         ("\u{A}\u{308}\u{1}", &["\u{A}", "\u{308}", "\u{1}"]),
1101         ("\u{A}\u{300}", &["\u{A}", "\u{300}"]),
1102         ("\u{A}\u{308}\u{300}", &["\u{A}", "\u{308}\u{300}"]),
1103         ("\u{A}\u{903}", &["\u{A}", "\u{903}"]),
1104         ("\u{A}\u{1100}", &["\u{A}", "\u{1100}"]),
1105         ("\u{A}\u{308}\u{1100}", &["\u{A}", "\u{308}", "\u{1100}"]),
1106         ("\u{A}\u{1160}", &["\u{A}", "\u{1160}"]),
1107         ("\u{A}\u{308}\u{1160}", &["\u{A}", "\u{308}", "\u{1160}"]),
1108         ("\u{A}\u{11A8}", &["\u{A}", "\u{11A8}"]),
1109         ("\u{A}\u{308}\u{11A8}", &["\u{A}", "\u{308}", "\u{11A8}"]),
1110         ("\u{A}\u{AC00}", &["\u{A}", "\u{AC00}"]),
1111         ("\u{A}\u{308}\u{AC00}", &["\u{A}", "\u{308}", "\u{AC00}"]),
1112         ("\u{A}\u{AC01}", &["\u{A}", "\u{AC01}"]),
1113         ("\u{A}\u{308}\u{AC01}", &["\u{A}", "\u{308}", "\u{AC01}"]),
1114         ("\u{A}\u{1F1E6}", &["\u{A}", "\u{1F1E6}"]),
1115         ("\u{A}\u{308}\u{1F1E6}", &["\u{A}", "\u{308}", "\u{1F1E6}"]),
1116         ("\u{A}\u{378}", &["\u{A}", "\u{378}"]),
1117         ("\u{A}\u{308}\u{378}", &["\u{A}", "\u{308}", "\u{378}"]),
1118         ("\u{1}\u{20}", &["\u{1}", "\u{20}"]),
1119         ("\u{1}\u{308}\u{20}", &["\u{1}", "\u{308}", "\u{20}"]),
1120         ("\u{1}\u{D}", &["\u{1}", "\u{D}"]),
1121         ("\u{1}\u{308}\u{D}", &["\u{1}", "\u{308}", "\u{D}"]),
1122         ("\u{1}\u{A}", &["\u{1}", "\u{A}"]),
1123         ("\u{1}\u{308}\u{A}", &["\u{1}", "\u{308}", "\u{A}"]),
1124         ("\u{1}\u{1}", &["\u{1}", "\u{1}"]),
1125         ("\u{1}\u{308}\u{1}", &["\u{1}", "\u{308}", "\u{1}"]),
1126         ("\u{1}\u{300}", &["\u{1}", "\u{300}"]),
1127         ("\u{1}\u{308}\u{300}", &["\u{1}", "\u{308}\u{300}"]),
1128         ("\u{1}\u{903}", &["\u{1}", "\u{903}"]),
1129         ("\u{1}\u{1100}", &["\u{1}", "\u{1100}"]),
1130         ("\u{1}\u{308}\u{1100}", &["\u{1}", "\u{308}", "\u{1100}"]),
1131         ("\u{1}\u{1160}", &["\u{1}", "\u{1160}"]),
1132         ("\u{1}\u{308}\u{1160}", &["\u{1}", "\u{308}", "\u{1160}"]),
1133         ("\u{1}\u{11A8}", &["\u{1}", "\u{11A8}"]),
1134         ("\u{1}\u{308}\u{11A8}", &["\u{1}", "\u{308}", "\u{11A8}"]),
1135         ("\u{1}\u{AC00}", &["\u{1}", "\u{AC00}"]),
1136         ("\u{1}\u{308}\u{AC00}", &["\u{1}", "\u{308}", "\u{AC00}"]),
1137         ("\u{1}\u{AC01}", &["\u{1}", "\u{AC01}"]),
1138         ("\u{1}\u{308}\u{AC01}", &["\u{1}", "\u{308}", "\u{AC01}"]),
1139         ("\u{1}\u{1F1E6}", &["\u{1}", "\u{1F1E6}"]),
1140         ("\u{1}\u{308}\u{1F1E6}", &["\u{1}", "\u{308}", "\u{1F1E6}"]),
1141         ("\u{1}\u{378}", &["\u{1}", "\u{378}"]),
1142         ("\u{1}\u{308}\u{378}", &["\u{1}", "\u{308}", "\u{378}"]),
1143         ("\u{300}\u{20}", &["\u{300}", "\u{20}"]),
1144         ("\u{300}\u{308}\u{20}", &["\u{300}\u{308}", "\u{20}"]),
1145         ("\u{300}\u{D}", &["\u{300}", "\u{D}"]),
1146         ("\u{300}\u{308}\u{D}", &["\u{300}\u{308}", "\u{D}"]),
1147         ("\u{300}\u{A}", &["\u{300}", "\u{A}"]),
1148         ("\u{300}\u{308}\u{A}", &["\u{300}\u{308}", "\u{A}"]),
1149         ("\u{300}\u{1}", &["\u{300}", "\u{1}"]),
1150         ("\u{300}\u{308}\u{1}", &["\u{300}\u{308}", "\u{1}"]),
1151         ("\u{300}\u{300}", &["\u{300}\u{300}"]),
1152         ("\u{300}\u{308}\u{300}", &["\u{300}\u{308}\u{300}"]),
1153         ("\u{300}\u{1100}", &["\u{300}", "\u{1100}"]),
1154         ("\u{300}\u{308}\u{1100}", &["\u{300}\u{308}", "\u{1100}"]),
1155         ("\u{300}\u{1160}", &["\u{300}", "\u{1160}"]),
1156         ("\u{300}\u{308}\u{1160}", &["\u{300}\u{308}", "\u{1160}"]),
1157         ("\u{300}\u{11A8}", &["\u{300}", "\u{11A8}"]),
1158         ("\u{300}\u{308}\u{11A8}", &["\u{300}\u{308}", "\u{11A8}"]),
1159         ("\u{300}\u{AC00}", &["\u{300}", "\u{AC00}"]),
1160         ("\u{300}\u{308}\u{AC00}", &["\u{300}\u{308}", "\u{AC00}"]),
1161         ("\u{300}\u{AC01}", &["\u{300}", "\u{AC01}"]),
1162         ("\u{300}\u{308}\u{AC01}", &["\u{300}\u{308}", "\u{AC01}"]),
1163         ("\u{300}\u{1F1E6}", &["\u{300}", "\u{1F1E6}"]),
1164         ("\u{300}\u{308}\u{1F1E6}", &["\u{300}\u{308}", "\u{1F1E6}"]),
1165         ("\u{300}\u{378}", &["\u{300}", "\u{378}"]),
1166         ("\u{300}\u{308}\u{378}", &["\u{300}\u{308}", "\u{378}"]),
1167         ("\u{903}\u{20}", &["\u{903}", "\u{20}"]),
1168         ("\u{903}\u{308}\u{20}", &["\u{903}\u{308}", "\u{20}"]),
1169         ("\u{903}\u{D}", &["\u{903}", "\u{D}"]),
1170         ("\u{903}\u{308}\u{D}", &["\u{903}\u{308}", "\u{D}"]),
1171         ("\u{903}\u{A}", &["\u{903}", "\u{A}"]),
1172         ("\u{903}\u{308}\u{A}", &["\u{903}\u{308}", "\u{A}"]),
1173         ("\u{903}\u{1}", &["\u{903}", "\u{1}"]),
1174         ("\u{903}\u{308}\u{1}", &["\u{903}\u{308}", "\u{1}"]),
1175         ("\u{903}\u{300}", &["\u{903}\u{300}"]),
1176         ("\u{903}\u{308}\u{300}", &["\u{903}\u{308}\u{300}"]),
1177         ("\u{903}\u{1100}", &["\u{903}", "\u{1100}"]),
1178         ("\u{903}\u{308}\u{1100}", &["\u{903}\u{308}", "\u{1100}"]),
1179         ("\u{903}\u{1160}", &["\u{903}", "\u{1160}"]),
1180         ("\u{903}\u{308}\u{1160}", &["\u{903}\u{308}", "\u{1160}"]),
1181         ("\u{903}\u{11A8}", &["\u{903}", "\u{11A8}"]),
1182         ("\u{903}\u{308}\u{11A8}", &["\u{903}\u{308}", "\u{11A8}"]),
1183         ("\u{903}\u{AC00}", &["\u{903}", "\u{AC00}"]),
1184         ("\u{903}\u{308}\u{AC00}", &["\u{903}\u{308}", "\u{AC00}"]),
1185         ("\u{903}\u{AC01}", &["\u{903}", "\u{AC01}"]),
1186         ("\u{903}\u{308}\u{AC01}", &["\u{903}\u{308}", "\u{AC01}"]),
1187         ("\u{903}\u{1F1E6}", &["\u{903}", "\u{1F1E6}"]),
1188         ("\u{903}\u{308}\u{1F1E6}", &["\u{903}\u{308}", "\u{1F1E6}"]),
1189         ("\u{903}\u{378}", &["\u{903}", "\u{378}"]),
1190         ("\u{903}\u{308}\u{378}", &["\u{903}\u{308}", "\u{378}"]),
1191         ("\u{1100}\u{20}", &["\u{1100}", "\u{20}"]),
1192         ("\u{1100}\u{308}\u{20}", &["\u{1100}\u{308}", "\u{20}"]),
1193         ("\u{1100}\u{D}", &["\u{1100}", "\u{D}"]),
1194         ("\u{1100}\u{308}\u{D}", &["\u{1100}\u{308}", "\u{D}"]),
1195         ("\u{1100}\u{A}", &["\u{1100}", "\u{A}"]),
1196         ("\u{1100}\u{308}\u{A}", &["\u{1100}\u{308}", "\u{A}"]),
1197         ("\u{1100}\u{1}", &["\u{1100}", "\u{1}"]),
1198         ("\u{1100}\u{308}\u{1}", &["\u{1100}\u{308}", "\u{1}"]),
1199         ("\u{1100}\u{300}", &["\u{1100}\u{300}"]),
1200         ("\u{1100}\u{308}\u{300}", &["\u{1100}\u{308}\u{300}"]),
1201         ("\u{1100}\u{1100}", &["\u{1100}\u{1100}"]),
1202         ("\u{1100}\u{308}\u{1100}", &["\u{1100}\u{308}", "\u{1100}"]),
1203         ("\u{1100}\u{1160}", &["\u{1100}\u{1160}"]),
1204         ("\u{1100}\u{308}\u{1160}", &["\u{1100}\u{308}", "\u{1160}"]),
1205         ("\u{1100}\u{11A8}", &["\u{1100}", "\u{11A8}"]),
1206         ("\u{1100}\u{308}\u{11A8}", &["\u{1100}\u{308}", "\u{11A8}"]),
1207         ("\u{1100}\u{AC00}", &["\u{1100}\u{AC00}"]),
1208         ("\u{1100}\u{308}\u{AC00}", &["\u{1100}\u{308}", "\u{AC00}"]),
1209         ("\u{1100}\u{AC01}", &["\u{1100}\u{AC01}"]),
1210         ("\u{1100}\u{308}\u{AC01}", &["\u{1100}\u{308}", "\u{AC01}"]),
1211         ("\u{1100}\u{1F1E6}", &["\u{1100}", "\u{1F1E6}"]),
1212         ("\u{1100}\u{308}\u{1F1E6}", &["\u{1100}\u{308}", "\u{1F1E6}"]),
1213         ("\u{1100}\u{378}", &["\u{1100}", "\u{378}"]),
1214         ("\u{1100}\u{308}\u{378}", &["\u{1100}\u{308}", "\u{378}"]),
1215         ("\u{1160}\u{20}", &["\u{1160}", "\u{20}"]),
1216         ("\u{1160}\u{308}\u{20}", &["\u{1160}\u{308}", "\u{20}"]),
1217         ("\u{1160}\u{D}", &["\u{1160}", "\u{D}"]),
1218         ("\u{1160}\u{308}\u{D}", &["\u{1160}\u{308}", "\u{D}"]),
1219         ("\u{1160}\u{A}", &["\u{1160}", "\u{A}"]),
1220         ("\u{1160}\u{308}\u{A}", &["\u{1160}\u{308}", "\u{A}"]),
1221         ("\u{1160}\u{1}", &["\u{1160}", "\u{1}"]),
1222         ("\u{1160}\u{308}\u{1}", &["\u{1160}\u{308}", "\u{1}"]),
1223         ("\u{1160}\u{300}", &["\u{1160}\u{300}"]),
1224         ("\u{1160}\u{308}\u{300}", &["\u{1160}\u{308}\u{300}"]),
1225         ("\u{1160}\u{1100}", &["\u{1160}", "\u{1100}"]),
1226         ("\u{1160}\u{308}\u{1100}", &["\u{1160}\u{308}", "\u{1100}"]),
1227         ("\u{1160}\u{1160}", &["\u{1160}\u{1160}"]),
1228         ("\u{1160}\u{308}\u{1160}", &["\u{1160}\u{308}", "\u{1160}"]),
1229         ("\u{1160}\u{11A8}", &["\u{1160}\u{11A8}"]),
1230         ("\u{1160}\u{308}\u{11A8}", &["\u{1160}\u{308}", "\u{11A8}"]),
1231         ("\u{1160}\u{AC00}", &["\u{1160}", "\u{AC00}"]),
1232         ("\u{1160}\u{308}\u{AC00}", &["\u{1160}\u{308}", "\u{AC00}"]),
1233         ("\u{1160}\u{AC01}", &["\u{1160}", "\u{AC01}"]),
1234         ("\u{1160}\u{308}\u{AC01}", &["\u{1160}\u{308}", "\u{AC01}"]),
1235         ("\u{1160}\u{1F1E6}", &["\u{1160}", "\u{1F1E6}"]),
1236         ("\u{1160}\u{308}\u{1F1E6}", &["\u{1160}\u{308}", "\u{1F1E6}"]),
1237         ("\u{1160}\u{378}", &["\u{1160}", "\u{378}"]),
1238         ("\u{1160}\u{308}\u{378}", &["\u{1160}\u{308}", "\u{378}"]),
1239         ("\u{11A8}\u{20}", &["\u{11A8}", "\u{20}"]),
1240         ("\u{11A8}\u{308}\u{20}", &["\u{11A8}\u{308}", "\u{20}"]),
1241         ("\u{11A8}\u{D}", &["\u{11A8}", "\u{D}"]),
1242         ("\u{11A8}\u{308}\u{D}", &["\u{11A8}\u{308}", "\u{D}"]),
1243         ("\u{11A8}\u{A}", &["\u{11A8}", "\u{A}"]),
1244         ("\u{11A8}\u{308}\u{A}", &["\u{11A8}\u{308}", "\u{A}"]),
1245         ("\u{11A8}\u{1}", &["\u{11A8}", "\u{1}"]),
1246         ("\u{11A8}\u{308}\u{1}", &["\u{11A8}\u{308}", "\u{1}"]),
1247         ("\u{11A8}\u{300}", &["\u{11A8}\u{300}"]),
1248         ("\u{11A8}\u{308}\u{300}", &["\u{11A8}\u{308}\u{300}"]),
1249         ("\u{11A8}\u{1100}", &["\u{11A8}", "\u{1100}"]),
1250         ("\u{11A8}\u{308}\u{1100}", &["\u{11A8}\u{308}", "\u{1100}"]),
1251         ("\u{11A8}\u{1160}", &["\u{11A8}", "\u{1160}"]),
1252         ("\u{11A8}\u{308}\u{1160}", &["\u{11A8}\u{308}", "\u{1160}"]),
1253         ("\u{11A8}\u{11A8}", &["\u{11A8}\u{11A8}"]),
1254         ("\u{11A8}\u{308}\u{11A8}", &["\u{11A8}\u{308}", "\u{11A8}"]),
1255         ("\u{11A8}\u{AC00}", &["\u{11A8}", "\u{AC00}"]),
1256         ("\u{11A8}\u{308}\u{AC00}", &["\u{11A8}\u{308}", "\u{AC00}"]),
1257         ("\u{11A8}\u{AC01}", &["\u{11A8}", "\u{AC01}"]),
1258         ("\u{11A8}\u{308}\u{AC01}", &["\u{11A8}\u{308}", "\u{AC01}"]),
1259         ("\u{11A8}\u{1F1E6}", &["\u{11A8}", "\u{1F1E6}"]),
1260         ("\u{11A8}\u{308}\u{1F1E6}", &["\u{11A8}\u{308}", "\u{1F1E6}"]),
1261         ("\u{11A8}\u{378}", &["\u{11A8}", "\u{378}"]),
1262         ("\u{11A8}\u{308}\u{378}", &["\u{11A8}\u{308}", "\u{378}"]),
1263         ("\u{AC00}\u{20}", &["\u{AC00}", "\u{20}"]),
1264         ("\u{AC00}\u{308}\u{20}", &["\u{AC00}\u{308}", "\u{20}"]),
1265         ("\u{AC00}\u{D}", &["\u{AC00}", "\u{D}"]),
1266         ("\u{AC00}\u{308}\u{D}", &["\u{AC00}\u{308}", "\u{D}"]),
1267         ("\u{AC00}\u{A}", &["\u{AC00}", "\u{A}"]),
1268         ("\u{AC00}\u{308}\u{A}", &["\u{AC00}\u{308}", "\u{A}"]),
1269         ("\u{AC00}\u{1}", &["\u{AC00}", "\u{1}"]),
1270         ("\u{AC00}\u{308}\u{1}", &["\u{AC00}\u{308}", "\u{1}"]),
1271         ("\u{AC00}\u{300}", &["\u{AC00}\u{300}"]),
1272         ("\u{AC00}\u{308}\u{300}", &["\u{AC00}\u{308}\u{300}"]),
1273         ("\u{AC00}\u{1100}", &["\u{AC00}", "\u{1100}"]),
1274         ("\u{AC00}\u{308}\u{1100}", &["\u{AC00}\u{308}", "\u{1100}"]),
1275         ("\u{AC00}\u{1160}", &["\u{AC00}\u{1160}"]),
1276         ("\u{AC00}\u{308}\u{1160}", &["\u{AC00}\u{308}", "\u{1160}"]),
1277         ("\u{AC00}\u{11A8}", &["\u{AC00}\u{11A8}"]),
1278         ("\u{AC00}\u{308}\u{11A8}", &["\u{AC00}\u{308}", "\u{11A8}"]),
1279         ("\u{AC00}\u{AC00}", &["\u{AC00}", "\u{AC00}"]),
1280         ("\u{AC00}\u{308}\u{AC00}", &["\u{AC00}\u{308}", "\u{AC00}"]),
1281         ("\u{AC00}\u{AC01}", &["\u{AC00}", "\u{AC01}"]),
1282         ("\u{AC00}\u{308}\u{AC01}", &["\u{AC00}\u{308}", "\u{AC01}"]),
1283         ("\u{AC00}\u{1F1E6}", &["\u{AC00}", "\u{1F1E6}"]),
1284         ("\u{AC00}\u{308}\u{1F1E6}", &["\u{AC00}\u{308}", "\u{1F1E6}"]),
1285         ("\u{AC00}\u{378}", &["\u{AC00}", "\u{378}"]),
1286         ("\u{AC00}\u{308}\u{378}", &["\u{AC00}\u{308}", "\u{378}"]),
1287         ("\u{AC01}\u{20}", &["\u{AC01}", "\u{20}"]),
1288         ("\u{AC01}\u{308}\u{20}", &["\u{AC01}\u{308}", "\u{20}"]),
1289         ("\u{AC01}\u{D}", &["\u{AC01}", "\u{D}"]),
1290         ("\u{AC01}\u{308}\u{D}", &["\u{AC01}\u{308}", "\u{D}"]),
1291         ("\u{AC01}\u{A}", &["\u{AC01}", "\u{A}"]),
1292         ("\u{AC01}\u{308}\u{A}", &["\u{AC01}\u{308}", "\u{A}"]),
1293         ("\u{AC01}\u{1}", &["\u{AC01}", "\u{1}"]),
1294         ("\u{AC01}\u{308}\u{1}", &["\u{AC01}\u{308}", "\u{1}"]),
1295         ("\u{AC01}\u{300}", &["\u{AC01}\u{300}"]),
1296         ("\u{AC01}\u{308}\u{300}", &["\u{AC01}\u{308}\u{300}"]),
1297         ("\u{AC01}\u{1100}", &["\u{AC01}", "\u{1100}"]),
1298         ("\u{AC01}\u{308}\u{1100}", &["\u{AC01}\u{308}", "\u{1100}"]),
1299         ("\u{AC01}\u{1160}", &["\u{AC01}", "\u{1160}"]),
1300         ("\u{AC01}\u{308}\u{1160}", &["\u{AC01}\u{308}", "\u{1160}"]),
1301         ("\u{AC01}\u{11A8}", &["\u{AC01}\u{11A8}"]),
1302         ("\u{AC01}\u{308}\u{11A8}", &["\u{AC01}\u{308}", "\u{11A8}"]),
1303         ("\u{AC01}\u{AC00}", &["\u{AC01}", "\u{AC00}"]),
1304         ("\u{AC01}\u{308}\u{AC00}", &["\u{AC01}\u{308}", "\u{AC00}"]),
1305         ("\u{AC01}\u{AC01}", &["\u{AC01}", "\u{AC01}"]),
1306         ("\u{AC01}\u{308}\u{AC01}", &["\u{AC01}\u{308}", "\u{AC01}"]),
1307         ("\u{AC01}\u{1F1E6}", &["\u{AC01}", "\u{1F1E6}"]),
1308         ("\u{AC01}\u{308}\u{1F1E6}", &["\u{AC01}\u{308}", "\u{1F1E6}"]),
1309         ("\u{AC01}\u{378}", &["\u{AC01}", "\u{378}"]),
1310         ("\u{AC01}\u{308}\u{378}", &["\u{AC01}\u{308}", "\u{378}"]),
1311         ("\u{1F1E6}\u{20}", &["\u{1F1E6}", "\u{20}"]),
1312         ("\u{1F1E6}\u{308}\u{20}", &["\u{1F1E6}\u{308}", "\u{20}"]),
1313         ("\u{1F1E6}\u{D}", &["\u{1F1E6}", "\u{D}"]),
1314         ("\u{1F1E6}\u{308}\u{D}", &["\u{1F1E6}\u{308}", "\u{D}"]),
1315         ("\u{1F1E6}\u{A}", &["\u{1F1E6}", "\u{A}"]),
1316         ("\u{1F1E6}\u{308}\u{A}", &["\u{1F1E6}\u{308}", "\u{A}"]),
1317         ("\u{1F1E6}\u{1}", &["\u{1F1E6}", "\u{1}"]),
1318         ("\u{1F1E6}\u{308}\u{1}", &["\u{1F1E6}\u{308}", "\u{1}"]),
1319         ("\u{1F1E6}\u{300}", &["\u{1F1E6}\u{300}"]),
1320         ("\u{1F1E6}\u{308}\u{300}", &["\u{1F1E6}\u{308}\u{300}"]),
1321         ("\u{1F1E6}\u{1100}", &["\u{1F1E6}", "\u{1100}"]),
1322         ("\u{1F1E6}\u{308}\u{1100}", &["\u{1F1E6}\u{308}", "\u{1100}"]),
1323         ("\u{1F1E6}\u{1160}", &["\u{1F1E6}", "\u{1160}"]),
1324         ("\u{1F1E6}\u{308}\u{1160}", &["\u{1F1E6}\u{308}", "\u{1160}"]),
1325         ("\u{1F1E6}\u{11A8}", &["\u{1F1E6}", "\u{11A8}"]),
1326         ("\u{1F1E6}\u{308}\u{11A8}", &["\u{1F1E6}\u{308}", "\u{11A8}"]),
1327         ("\u{1F1E6}\u{AC00}", &["\u{1F1E6}", "\u{AC00}"]),
1328         ("\u{1F1E6}\u{308}\u{AC00}", &["\u{1F1E6}\u{308}", "\u{AC00}"]),
1329         ("\u{1F1E6}\u{AC01}", &["\u{1F1E6}", "\u{AC01}"]),
1330         ("\u{1F1E6}\u{308}\u{AC01}", &["\u{1F1E6}\u{308}", "\u{AC01}"]),
1331         ("\u{1F1E6}\u{1F1E6}", &["\u{1F1E6}\u{1F1E6}"]),
1332         ("\u{1F1E6}\u{308}\u{1F1E6}", &["\u{1F1E6}\u{308}", "\u{1F1E6}"]),
1333         ("\u{1F1E6}\u{378}", &["\u{1F1E6}", "\u{378}"]),
1334         ("\u{1F1E6}\u{308}\u{378}", &["\u{1F1E6}\u{308}", "\u{378}"]),
1335         ("\u{378}\u{20}", &["\u{378}", "\u{20}"]),
1336         ("\u{378}\u{308}\u{20}", &["\u{378}\u{308}", "\u{20}"]),
1337         ("\u{378}\u{D}", &["\u{378}", "\u{D}"]),
1338         ("\u{378}\u{308}\u{D}", &["\u{378}\u{308}", "\u{D}"]),
1339         ("\u{378}\u{A}", &["\u{378}", "\u{A}"]),
1340         ("\u{378}\u{308}\u{A}", &["\u{378}\u{308}", "\u{A}"]),
1341         ("\u{378}\u{1}", &["\u{378}", "\u{1}"]),
1342         ("\u{378}\u{308}\u{1}", &["\u{378}\u{308}", "\u{1}"]),
1343         ("\u{378}\u{300}", &["\u{378}\u{300}"]),
1344         ("\u{378}\u{308}\u{300}", &["\u{378}\u{308}\u{300}"]),
1345         ("\u{378}\u{1100}", &["\u{378}", "\u{1100}"]),
1346         ("\u{378}\u{308}\u{1100}", &["\u{378}\u{308}", "\u{1100}"]),
1347         ("\u{378}\u{1160}", &["\u{378}", "\u{1160}"]),
1348         ("\u{378}\u{308}\u{1160}", &["\u{378}\u{308}", "\u{1160}"]),
1349         ("\u{378}\u{11A8}", &["\u{378}", "\u{11A8}"]),
1350         ("\u{378}\u{308}\u{11A8}", &["\u{378}\u{308}", "\u{11A8}"]),
1351         ("\u{378}\u{AC00}", &["\u{378}", "\u{AC00}"]),
1352         ("\u{378}\u{308}\u{AC00}", &["\u{378}\u{308}", "\u{AC00}"]),
1353         ("\u{378}\u{AC01}", &["\u{378}", "\u{AC01}"]),
1354         ("\u{378}\u{308}\u{AC01}", &["\u{378}\u{308}", "\u{AC01}"]),
1355         ("\u{378}\u{1F1E6}", &["\u{378}", "\u{1F1E6}"]),
1356         ("\u{378}\u{308}\u{1F1E6}", &["\u{378}\u{308}", "\u{1F1E6}"]),
1357         ("\u{378}\u{378}", &["\u{378}", "\u{378}"]),
1358         ("\u{378}\u{308}\u{378}", &["\u{378}\u{308}", "\u{378}"]),
1359         ("\u{61}\u{1F1E6}\u{62}", &["\u{61}", "\u{1F1E6}", "\u{62}"]),
1360         ("\u{1F1F7}\u{1F1FA}", &["\u{1F1F7}\u{1F1FA}"]),
1361         ("\u{1F1F7}\u{1F1FA}\u{1F1F8}", &["\u{1F1F7}\u{1F1FA}\u{1F1F8}"]),
1362         ("\u{1F1F7}\u{1F1FA}\u{1F1F8}\u{1F1EA}",
1363         &["\u{1F1F7}\u{1F1FA}\u{1F1F8}\u{1F1EA}"]),
1364         ("\u{1F1F7}\u{1F1FA}\u{200B}\u{1F1F8}\u{1F1EA}",
1365          &["\u{1F1F7}\u{1F1FA}", "\u{200B}", "\u{1F1F8}\u{1F1EA}"]),
1366         ("\u{1F1E6}\u{1F1E7}\u{1F1E8}", &["\u{1F1E6}\u{1F1E7}\u{1F1E8}"]),
1367         ("\u{1F1E6}\u{200D}\u{1F1E7}\u{1F1E8}", &["\u{1F1E6}\u{200D}",
1368          "\u{1F1E7}\u{1F1E8}"]),
1369         ("\u{1F1E6}\u{1F1E7}\u{200D}\u{1F1E8}",
1370          &["\u{1F1E6}\u{1F1E7}\u{200D}", "\u{1F1E8}"]),
1371         ("\u{20}\u{200D}\u{646}", &["\u{20}\u{200D}", "\u{646}"]),
1372         ("\u{646}\u{200D}\u{20}", &["\u{646}\u{200D}", "\u{20}"]),
1373     ];
1374
1375     let test_diff: [(_, &[_], &[_]); 23] = [
1376         ("\u{20}\u{903}", &["\u{20}\u{903}"], &["\u{20}", "\u{903}"]), ("\u{20}\u{308}\u{903}",
1377         &["\u{20}\u{308}\u{903}"], &["\u{20}\u{308}", "\u{903}"]), ("\u{D}\u{308}\u{903}",
1378         &["\u{D}", "\u{308}\u{903}"], &["\u{D}", "\u{308}", "\u{903}"]), ("\u{A}\u{308}\u{903}",
1379         &["\u{A}", "\u{308}\u{903}"], &["\u{A}", "\u{308}", "\u{903}"]), ("\u{1}\u{308}\u{903}",
1380         &["\u{1}", "\u{308}\u{903}"], &["\u{1}", "\u{308}", "\u{903}"]), ("\u{300}\u{903}",
1381         &["\u{300}\u{903}"], &["\u{300}", "\u{903}"]), ("\u{300}\u{308}\u{903}",
1382         &["\u{300}\u{308}\u{903}"], &["\u{300}\u{308}", "\u{903}"]), ("\u{903}\u{903}",
1383         &["\u{903}\u{903}"], &["\u{903}", "\u{903}"]), ("\u{903}\u{308}\u{903}",
1384         &["\u{903}\u{308}\u{903}"], &["\u{903}\u{308}", "\u{903}"]), ("\u{1100}\u{903}",
1385         &["\u{1100}\u{903}"], &["\u{1100}", "\u{903}"]), ("\u{1100}\u{308}\u{903}",
1386         &["\u{1100}\u{308}\u{903}"], &["\u{1100}\u{308}", "\u{903}"]), ("\u{1160}\u{903}",
1387         &["\u{1160}\u{903}"], &["\u{1160}", "\u{903}"]), ("\u{1160}\u{308}\u{903}",
1388         &["\u{1160}\u{308}\u{903}"], &["\u{1160}\u{308}", "\u{903}"]), ("\u{11A8}\u{903}",
1389         &["\u{11A8}\u{903}"], &["\u{11A8}", "\u{903}"]), ("\u{11A8}\u{308}\u{903}",
1390         &["\u{11A8}\u{308}\u{903}"], &["\u{11A8}\u{308}", "\u{903}"]), ("\u{AC00}\u{903}",
1391         &["\u{AC00}\u{903}"], &["\u{AC00}", "\u{903}"]), ("\u{AC00}\u{308}\u{903}",
1392         &["\u{AC00}\u{308}\u{903}"], &["\u{AC00}\u{308}", "\u{903}"]), ("\u{AC01}\u{903}",
1393         &["\u{AC01}\u{903}"], &["\u{AC01}", "\u{903}"]), ("\u{AC01}\u{308}\u{903}",
1394         &["\u{AC01}\u{308}\u{903}"], &["\u{AC01}\u{308}", "\u{903}"]), ("\u{1F1E6}\u{903}",
1395         &["\u{1F1E6}\u{903}"], &["\u{1F1E6}", "\u{903}"]), ("\u{1F1E6}\u{308}\u{903}",
1396         &["\u{1F1E6}\u{308}\u{903}"], &["\u{1F1E6}\u{308}", "\u{903}"]), ("\u{378}\u{903}",
1397         &["\u{378}\u{903}"], &["\u{378}", "\u{903}"]), ("\u{378}\u{308}\u{903}",
1398         &["\u{378}\u{308}\u{903}"], &["\u{378}\u{308}", "\u{903}"]),
1399     ];
1400
1401     for &(s, g) in &test_same[..] {
1402         // test forward iterator
1403         assert!(order::equals(s.graphemes(true), g.iter().cloned()));
1404         assert!(order::equals(s.graphemes(false), g.iter().cloned()));
1405
1406         // test reverse iterator
1407         assert!(order::equals(s.graphemes(true).rev(), g.iter().rev().cloned()));
1408         assert!(order::equals(s.graphemes(false).rev(), g.iter().rev().cloned()));
1409     }
1410
1411     for &(s, gt, gf) in &test_diff {
1412         // test forward iterator
1413         assert!(order::equals(s.graphemes(true), gt.iter().cloned()));
1414         assert!(order::equals(s.graphemes(false), gf.iter().cloned()));
1415
1416         // test reverse iterator
1417         assert!(order::equals(s.graphemes(true).rev(), gt.iter().rev().cloned()));
1418         assert!(order::equals(s.graphemes(false).rev(), gf.iter().rev().cloned()));
1419     }
1420
1421     // test the indices iterators
1422     let s = "a̐éö̲\r\n";
1423     let gr_inds = s.grapheme_indices(true).collect::<Vec<(usize, &str)>>();
1424     let b: &[_] = &[(0, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")];
1425     assert_eq!(gr_inds, b);
1426     let gr_inds = s.grapheme_indices(true).rev().collect::<Vec<(usize, &str)>>();
1427     let b: &[_] = &[(11, "\r\n"), (6, "ö̲"), (3, "é"), (0, "a̐")];
1428     assert_eq!(gr_inds, b);
1429     let mut gr_inds_iter = s.grapheme_indices(true);
1430     {
1431         let gr_inds = gr_inds_iter.by_ref();
1432         let e1 = gr_inds.size_hint();
1433         assert_eq!(e1, (1, Some(13)));
1434         let c = gr_inds.count();
1435         assert_eq!(c, 4);
1436     }
1437     let e2 = gr_inds_iter.size_hint();
1438     assert_eq!(e2, (0, Some(0)));
1439
1440     // make sure the reverse iterator does the right thing with "\n" at beginning of string
1441     let s = "\n\r\n\r";
1442     let gr = s.graphemes(true).rev().collect::<Vec<&str>>();
1443     let b: &[_] = &["\r", "\r\n", "\n"];
1444     assert_eq!(gr, b);
1445 }
1446
1447 #[test]
1448 fn test_split_strator() {
1449     fn t(s: &str, sep: &str, u: &[&str]) {
1450         let v: Vec<&str> = s.split_str(sep).collect();
1451         assert_eq!(v, u);
1452     }
1453     t("--1233345--", "12345", &["--1233345--"]);
1454     t("abc::hello::there", "::", &["abc", "hello", "there"]);
1455     t("::hello::there", "::", &["", "hello", "there"]);
1456     t("hello::there::", "::", &["hello", "there", ""]);
1457     t("::hello::there::", "::", &["", "hello", "there", ""]);
1458     t("ประเทศไทย中华Việt Nam", "中华", &["ประเทศไทย", "Việt Nam"]);
1459     t("zzXXXzzYYYzz", "zz", &["", "XXX", "YYY", ""]);
1460     t("zzXXXzYYYz", "XXX", &["zz", "zYYYz"]);
1461     t(".XXX.YYY.", ".", &["", "XXX", "YYY", ""]);
1462     t("", ".", &[""]);
1463     t("zz", "zz", &["",""]);
1464     t("ok", "z", &["ok"]);
1465     t("zzz", "zz", &["","z"]);
1466     t("zzzzz", "zz", &["","","z"]);
1467 }
1468
1469 #[test]
1470 fn test_str_default() {
1471     use std::default::Default;
1472
1473     fn t<S: Default + Str>() {
1474         let s: S = Default::default();
1475         assert_eq!(s.as_slice(), "");
1476     }
1477
1478     t::<&str>();
1479     t::<String>();
1480 }
1481
1482 #[test]
1483 fn test_str_container() {
1484     fn sum_len(v: &[&str]) -> usize {
1485         v.iter().map(|x| x.len()).sum()
1486     }
1487
1488     let s = String::from_str("01234");
1489     assert_eq!(5, sum_len(&["012", "", "34"]));
1490     assert_eq!(5, sum_len(&[&String::from_str("01"),
1491                             &String::from_str("2"),
1492                             &String::from_str("34"),
1493                             &String::from_str("")]));
1494     assert_eq!(5, sum_len(&[&s]));
1495 }
1496
1497 #[test]
1498 fn test_str_from_utf8() {
1499     let xs = b"hello";
1500     assert_eq!(from_utf8(xs), Ok("hello"));
1501
1502     let xs = "ศไทย中华Việt Nam".as_bytes();
1503     assert_eq!(from_utf8(xs), Ok("ศไทย中华Việt Nam"));
1504
1505     let xs = b"hello\xFF";
1506     assert_eq!(from_utf8(xs), Err(Utf8Error::TooShort));
1507 }
1508
1509 mod bench {
1510     use test::{Bencher, black_box};
1511
1512     #[bench]
1513     fn char_iterator(b: &mut Bencher) {
1514         let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
1515
1516         b.iter(|| s.chars().count());
1517     }
1518
1519     #[bench]
1520     fn char_iterator_for(b: &mut Bencher) {
1521         let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
1522
1523         b.iter(|| {
1524             for ch in s.chars() { black_box(ch); }
1525         });
1526     }
1527
1528     #[bench]
1529     fn char_iterator_ascii(b: &mut Bencher) {
1530         let s = "Mary had a little lamb, Little lamb
1531         Mary had a little lamb, Little lamb
1532         Mary had a little lamb, Little lamb
1533         Mary had a little lamb, Little lamb
1534         Mary had a little lamb, Little lamb
1535         Mary had a little lamb, Little lamb";
1536
1537         b.iter(|| s.chars().count());
1538     }
1539
1540     #[bench]
1541     fn char_iterator_rev(b: &mut Bencher) {
1542         let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
1543
1544         b.iter(|| s.chars().rev().count());
1545     }
1546
1547     #[bench]
1548     fn char_iterator_rev_for(b: &mut Bencher) {
1549         let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
1550
1551         b.iter(|| {
1552             for ch in s.chars().rev() { black_box(ch); }
1553         });
1554     }
1555
1556     #[bench]
1557     fn char_indicesator(b: &mut Bencher) {
1558         let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
1559         let len = s.chars().count();
1560
1561         b.iter(|| assert_eq!(s.char_indices().count(), len));
1562     }
1563
1564     #[bench]
1565     fn char_indicesator_rev(b: &mut Bencher) {
1566         let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
1567         let len = s.chars().count();
1568
1569         b.iter(|| assert_eq!(s.char_indices().rev().count(), len));
1570     }
1571
1572     #[bench]
1573     fn split_unicode_ascii(b: &mut Bencher) {
1574         let s = "ประเทศไทย中华Việt Namประเทศไทย中华Việt Nam";
1575
1576         b.iter(|| assert_eq!(s.split('V').count(), 3));
1577     }
1578
1579     #[bench]
1580     fn split_ascii(b: &mut Bencher) {
1581         let s = "Mary had a little lamb, Little lamb, little-lamb.";
1582         let len = s.split(' ').count();
1583
1584         b.iter(|| assert_eq!(s.split(' ').count(), len));
1585     }
1586
1587     #[bench]
1588     fn split_extern_fn(b: &mut Bencher) {
1589         let s = "Mary had a little lamb, Little lamb, little-lamb.";
1590         let len = s.split(' ').count();
1591         fn pred(c: char) -> bool { c == ' ' }
1592
1593         b.iter(|| assert_eq!(s.split(pred).count(), len));
1594     }
1595
1596     #[bench]
1597     fn split_closure(b: &mut Bencher) {
1598         let s = "Mary had a little lamb, Little lamb, little-lamb.";
1599         let len = s.split(' ').count();
1600
1601         b.iter(|| assert_eq!(s.split(|c: char| c == ' ').count(), len));
1602     }
1603
1604     #[bench]
1605     fn split_slice(b: &mut Bencher) {
1606         let s = "Mary had a little lamb, Little lamb, little-lamb.";
1607         let len = s.split(' ').count();
1608
1609         let c: &[char] = &[' '];
1610         b.iter(|| assert_eq!(s.split(c).count(), len));
1611     }
1612
1613     #[bench]
1614     fn bench_connect(b: &mut Bencher) {
1615         let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
1616         let sep = "→";
1617         let v = vec![s, s, s, s, s, s, s, s, s, s];
1618         b.iter(|| {
1619             assert_eq!(v.connect(sep).len(), s.len() * 10 + sep.len() * 9);
1620         })
1621     }
1622
1623     #[bench]
1624     fn bench_contains_short_short(b: &mut Bencher) {
1625         let haystack = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
1626         let needle = "sit";
1627
1628         b.iter(|| {
1629             assert!(haystack.contains(needle));
1630         })
1631     }
1632
1633     #[bench]
1634     fn bench_contains_short_long(b: &mut Bencher) {
1635         let haystack = "\
1636 Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse quis lorem sit amet dolor \
1637 ultricies condimentum. Praesent iaculis purus elit, ac malesuada quam malesuada in. Duis sed orci \
1638 eros. Suspendisse sit amet magna mollis, mollis nunc luctus, imperdiet mi. Integer fringilla non \
1639 sem ut lacinia. Fusce varius tortor a risus porttitor hendrerit. Morbi mauris dui, ultricies nec \
1640 tempus vel, gravida nec quam.
1641
1642 In est dui, tincidunt sed tempus interdum, adipiscing laoreet ante. Etiam tempor, tellus quis \
1643 sagittis interdum, nulla purus mattis sem, quis auctor erat odio ac tellus. In nec nunc sit amet \
1644 diam volutpat molestie at sed ipsum. Vestibulum laoreet consequat vulputate. Integer accumsan \
1645 lorem ac dignissim placerat. Suspendisse convallis faucibus lorem. Aliquam erat volutpat. In vel \
1646 eleifend felis. Sed suscipit nulla lorem, sed mollis est sollicitudin et. Nam fermentum egestas \
1647 interdum. Curabitur ut nisi justo.
1648
1649 Sed sollicitudin ipsum tellus, ut condimentum leo eleifend nec. Cras ut velit ante. Phasellus nec \
1650 mollis odio. Mauris molestie erat in arcu mattis, at aliquet dolor vehicula. Quisque malesuada \
1651 lectus sit amet nisi pretium, a condimentum ipsum porta. Morbi at dapibus diam. Praesent egestas \
1652 est sed risus elementum, eu rutrum metus ultrices. Etiam fermentum consectetur magna, id rutrum \
1653 felis accumsan a. Aliquam ut pellentesque libero. Sed mi nulla, lobortis eu tortor id, suscipit \
1654 ultricies neque. Morbi iaculis sit amet risus at iaculis. Praesent eget ligula quis turpis \
1655 feugiat suscipit vel non arcu. Interdum et malesuada fames ac ante ipsum primis in faucibus. \
1656 Aliquam sit amet placerat lorem.
1657
1658 Cras a lacus vel ante posuere elementum. Nunc est leo, bibendum ut facilisis vel, bibendum at \
1659 mauris. Nullam adipiscing diam vel odio ornare, luctus adipiscing mi luctus. Nulla facilisi. \
1660 Mauris adipiscing bibendum neque, quis adipiscing lectus tempus et. Sed feugiat erat et nisl \
1661 lobortis pharetra. Donec vitae erat enim. Nullam sit amet felis et quam lacinia tincidunt. Aliquam \
1662 suscipit dapibus urna. Sed volutpat urna in magna pulvinar volutpat. Phasellus nec tellus ac diam \
1663 cursus accumsan.
1664
1665 Nam lectus enim, dapibus non nisi tempor, consectetur convallis massa. Maecenas eleifend dictum \
1666 feugiat. Etiam quis mauris vel risus luctus mattis a a nunc. Nullam orci quam, imperdiet id \
1667 vehicula in, porttitor ut nibh. Duis sagittis adipiscing nisl vitae congue. Donec mollis risus eu \
1668 leo suscipit, varius porttitor nulla porta. Pellentesque ut sem nec nisi euismod vehicula. Nulla \
1669 malesuada sollicitudin quam eu fermentum.";
1670         let needle = "english";
1671
1672         b.iter(|| {
1673             assert!(!haystack.contains(needle));
1674         })
1675     }
1676
1677     #[bench]
1678     fn bench_contains_bad_naive(b: &mut Bencher) {
1679         let haystack = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
1680         let needle = "aaaaaaaab";
1681
1682         b.iter(|| {
1683             assert!(!haystack.contains(needle));
1684         })
1685     }
1686
1687     #[bench]
1688     fn bench_contains_equal(b: &mut Bencher) {
1689         let haystack = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
1690         let needle = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
1691
1692         b.iter(|| {
1693             assert!(haystack.contains(needle));
1694         })
1695     }
1696 }