vendor/stringprep-0.1.2/tests/nameprep_tests.rs - toolchain/rustc - Git at Google

 // Integration tests from https://tools.ietf.org/html/draft-josefsson-idn-test-vectors-00
 extern crate stringprep;

 use stringprep::{Error, nameprep};

 fn assert_prohibited_character<T>(result: Result<T, Error>) {
     assert!(result.is_err());
 }

 fn assert_prohibited_bidirectional_text<T>(result: Result<T, Error>) {
     assert!(result.is_err());
 }

 // Additional examples from http://josefsson.org/idn.php
 #[test]
 fn test_nameprep() {
     assert_eq!("安室奈美恵-with-super-monkeys", nameprep("安室奈美恵-with-SUPER-MONKEYS").unwrap());
     assert_eq!("미술", nameprep("미술").unwrap());                                                       // Korean
     assert_eq!("ليهمابتكلموشعربي؟", nameprep("ليهمابتكلموشعربي؟").unwrap());                             // Egyptian
     assert_eq!("他们为什么不说中文", nameprep("他们为什么不说中文").unwrap());                           // Chinese
     assert_eq!("למההםפשוטלאמדבריםעברית", nameprep("למההםפשוטלאמדבריםעברית").unwrap());                   // Hebrew
     assert_eq!("почемужеонинеговорятпорусски", nameprep("почемужеонинеговорятпорусски").unwrap());       // Russian
     assert_eq!("tạisaohọkhôngthểchỉnóitiếngviệt", nameprep("TạisaohọkhôngthểchỉnóitiếngViệt").unwrap()); // Vietnamese
     assert_eq!("ひとつ屋根の下2", nameprep("ひとつ屋根の下2").unwrap());                                 // Japanese
     assert_eq!("pročprostěnemluvíčesky", nameprep("Pročprostěnemluvíčesky").unwrap());                   // Czech
     assert_eq!("यहलोगहिन्दीक्योंनहींबोलसकतेहैं", nameprep("यहलोगहिन्दीक्योंनहींबोलसकतेहैं").unwrap());             // Hindi
     assert_eq!("ພາສາລາວ", nameprep("ພາສາລາວ").unwrap());                                                 // Lao
     assert_eq!("bonġusaħħa", nameprep("bonġusaħħa").unwrap());                                           // Maltese
     assert_eq!("ελληνικά", nameprep("ελληνικά").unwrap());                                               // Greek
 }

 // 4.1 Map to nothing
 #[test]
 fn should_map_to_nothing() {
     let input = "foo\u{00ad}\u{034f}\u{1806}\u{180b}bar\u{200b}\u{2060}baz\u{fe00}\u{fe08}\u{fe0f}\u{feff}";
     assert_eq!("foobarbaz", nameprep(input).unwrap());
 }

 // 4.2 Case folding ASCII U+0043 U+0041 U+0046 U+0045
 #[test]
 fn should_case_fold_ascii() {
     assert_eq!("cafe", nameprep("CAFE").unwrap());
 }

 // 4.3 Case folding 8bit U+00DF (german sharp s)
 #[test]
 fn should_case_fold_8bit() {
     assert_eq!("ss", nameprep("\u{00df}").unwrap());
 }

 // 4.4 Case folding U+0130 (turkish capital I with dot)
 #[test]
 fn should_case_fold_16bit() {
     assert_eq!("\u{0069}\u{0307}", nameprep("\u{0130}").unwrap());
 }

 // 4.5 Case folding multibyte U+0143 U+037A
 #[test]
 fn should_case_fold_multibyte() {
     let input = "\u{0143}\u{037a}";
     let output = "\u{0144} \u{03b9}";
     assert_eq!(output, nameprep(input).unwrap());
 }

 // 4.6 Case folding U+2121 U+33C6 U+1D7BB
 #[test]
 fn should_case_fold() {
     let input = "\u{2121}\u{33c6}\u{1d7bb}";
     let output = "telc\u{2215}\u{006b}\u{0067}\u{03c3}";
     assert_eq!(output, nameprep(input).unwrap());
 }

 // 4.7 Normalization of U+006a U+030c U+00A0 U+00AA
 #[test]
 fn should_normalize() {
     let input = "j\u{030c}\u{00a0}\u{00aa}";
     let output = "\u{01f0} a";
     assert_eq!(output, nameprep(input).unwrap());
 }

 // 4.8 Case folding U+1FB7 and normalization
 #[test]
 fn should_case_fold_and_normalize() {
     let input = "\u{1fb7}";
     let output = "\u{1fb6}\u{03b9}";
     assert_eq!(output, nameprep(input).unwrap());
 }

 // 4.9  Self-reverting case folding U+01F0 and normalization
 // 4.10 Self-reverting case folding U+0390 and normalization
 // 4.11 Self-reverting case folding U+03B0 and normalization
 // 4.12 Self-reverting case folding U+1E96 and normalization
 // 4.13 Self-reverting case folding U+1F56 and normalization
 #[test]
 fn should_revert_case_fold_and_normalization() {
     let inputs = ["\u{01f0}", "\u{0390}", "\u{03b0}", "\u{1e96}", "\u{1f56}"];
     for input in inputs.iter() {
         assert_eq!(input.clone(), nameprep(input).unwrap());
     }
 }

 // 4.14 ASCII space character U+0020
 #[test]
 fn should_permit_ascii_space() {
     assert_eq!(" ", nameprep(" ").unwrap());
 }

 // 4.15 Non-ASCII 8bit space character U+00A0
 #[test]
 fn should_map_8bit_space() {
     assert_eq!(" ", nameprep("\u{00a0}").unwrap());
 }

 // 4.16 Non-ASCII multibyte space character U+1680
 #[test]
 fn should_prohibit_multibyte_space() {
     assert_prohibited_character(nameprep("\u{1680}"));
 }

 // 4.17 Non-ASCII multibyte space character U+2000
 #[test]
 fn should_map_multibyte_space1() {
     assert_eq!(" ", nameprep("\u{2000}").unwrap());
 }

 // 4.18 Zero Width Space U+200b
 #[test]
 fn should_drop_zero_width_space() {
     assert_eq!("", nameprep("\u{200b}").unwrap());
 }

 // 4.19 Non-ASCII multibyte space character U+3000
 #[test]
 fn should_map_multibyte_space2() {
     assert_eq!(" ", nameprep("\u{3000}").unwrap());
 }

 // 4.20 ASCII control characters U+0010 U+007F
 #[test]
 fn should_permit_ascii_control() {
     assert_eq!("\u{0010}\u{007f}", nameprep("\u{0010}\u{007f}").unwrap());
 }

 // 4.21 Non-ASCII 8bit control character U+0085
 #[test]
 fn should_prohibit_8bit_control() {
     assert_prohibited_character(nameprep("\u{0085}"));
 }

 // 4.22 Non-ASCII multibyte control character U+180E
 #[test]
 fn should_prohibit_multibyte_control() {
     assert_prohibited_character(nameprep("\u{180e}"));
 }

 // 4.23 Zero Width No-Break Space U+FEFF
 #[test]
 fn should_drop_zero_width_no_break_space() {
     assert_eq!("", nameprep("\u{feff}").unwrap());
 }

 // 4.24 Non-ASCII control character U+1D175
 #[test]
 fn should_prohibit_non_ascii_control() {
     assert_prohibited_character(nameprep("\u{1d175}"));
 }

 // 4.25 Plane 0 private use character U+F123
 #[test]
 fn should_prohibit_plane0_private_use() {
     assert_prohibited_character(nameprep("\u{f123}"));
 }

 // 4.26 Plane 15 private use character U+F1234
 #[test]
 fn should_prohibit_plane15_private_use() {
     assert_prohibited_character(nameprep("\u{f1234}"));
 }

 // 4.27 Plane 16 private use character U+10F234
 #[test]
 fn should_prohibit_plane16_private_use() {
     assert_prohibited_character(nameprep("\u{10f234}"));
 }

 // 4.28 Non-character code point U+8FFFE
 #[test]
 fn should_prohibit_non_character1() {
     assert_prohibited_character(nameprep("\u{8fffe}"));
 }

 // 4.29 Non-character code point U+10FFFF
 #[test]
 fn should_prohibit_non_character2() {
     assert_prohibited_character(nameprep("\u{10ffff}"));
 }

 // 4.31 Non-plain text character U+FFFD
 #[test]
 fn should_prohibit_non_plain_text() {
     assert_prohibited_character(nameprep("\u{fffd}"));
 }

 // 4.32 Ideographic description character U+2FF5
 #[test]
 fn should_prohibit_ideographic_description() {
     assert_prohibited_character(nameprep("\u{2ff5}"));
 }

 // 4.33 Display property character U+0341
 #[test]
 fn should_normalize_display_property() {
     assert_eq!("\u{0301}", nameprep("\u{0341}").unwrap());
 }

 // 4.34 Left-to-right mark U+200E
 #[test]
 fn should_prohibit_left_to_right_mark() {
     assert_prohibited_character(nameprep("\u{200e}"));
 }

 // 4.35 Deprecated U+202A
 #[test]
 fn should_prohibit_deprecated() {
     assert_prohibited_character(nameprep("\u{202a}"));
 }

 // 4.36 Language tagging character U+E0001
 #[test]
 fn should_prohibit_language_tagging1() {
     assert_prohibited_character(nameprep("\u{e0001}"));
 }

 // 4.37 Language tagging character U+E0042
 #[test]
 fn should_prohibit_language_tagging2() {
     assert_prohibited_character(nameprep("\u{e0042}"));
 }

 // 4.38 Bidi: RandALCat character U+05BE and LCat characters
 #[test]
 fn should_prohibit_randalcat_with_lcat1() {
     assert_prohibited_bidirectional_text(nameprep("foo\u{05be}bar"));
 }

 // 4.39 Bidi: RandALCat character U+FD50 and LCat characters
 #[test]
 fn should_prohibit_randalcat_with_lcat2() {
     assert_prohibited_bidirectional_text(nameprep("foo\u{fd50}bar"));
 }

 // 4.40 Bidi: RandALCat character U+FB38 and LCat characters
 #[test]
 fn should_permit_randalcat1() {
     assert_eq!("foo \u{064e}bar", nameprep("foo\u{fe76}bar").unwrap());
 }

 // 4.41 Bidi: RandALCat without trailing RandALCat U+0627 U+0031
 #[test]
 fn should_prohibit_mixed_randalcat() {
     assert_prohibited_bidirectional_text(nameprep("\u{0672}\u{0031}"));
 }

 // 4.42 Bidi: RandALCat character U+0627 U+0031 U+0628
 #[test]
 fn should_permit_randalcat2() {
     assert_eq!("\u{0627}\u{0031}\u{0628}", nameprep("\u{0627}\u{0031}\u{0628}").unwrap());
 }

 // 4.43 Unassigned code point U+E0002
 #[test]
 fn should_prohibit_unassigned_code_point() {
     assert_prohibited_character(nameprep("\u{e0002}"));
 }

 // 4.44 Larger test (shrinking)
 #[test]
 fn should_shrink() {
     let input = "X\u{00ad}\u{00df}\u{0130}\u{2121}j\u{030c}\u{00a0}\u{00aa}\u{03b0}\u{2000}";
     let output = "xssi\u{0307}tel\u{01f0} a\u{03b0}\u{0020}";
     assert_eq!(output, nameprep(input).unwrap());
 }

 // 4.45 Larger test (expanding)
 #[test]
 fn should_expand() {
     let input = "X\u{00df}\u{3316}\u{0130}\u{2121}\u{249f}\u{3300}";
     let output = "xss\u{30ad}\u{30ed}\u{30e1}\u{30fc}\u{30c8}\u{30eb}\u{0069}\u{0307}\u{0074}\u{0065}\u{006c}\u{0028}\u{0064}\u{0029}\u{30a2}\u{30d1}\u{30fc}\u{30c8}";
     assert_eq!(output, nameprep(input).unwrap());
 }
	// Integration tests from https://tools.ietf.org/html/draft-josefsson-idn-test-vectors-00
	extern crate stringprep;

	use stringprep::{Error, nameprep};

	fn assert_prohibited_character<T>(result: Result<T, Error>) {
	assert!(result.is_err());
	}

	fn assert_prohibited_bidirectional_text<T>(result: Result<T, Error>) {
	assert!(result.is_err());
	}

	// Additional examples from http://josefsson.org/idn.php
	#[test]
	fn test_nameprep() {
	assert_eq!("安室奈美恵-with-super-monkeys", nameprep("安室奈美恵-with-SUPER-MONKEYS").unwrap());
	assert_eq!("미술", nameprep("미술").unwrap()); // Korean
	assert_eq!("ليهمابتكلموشعربي؟", nameprep("ليهمابتكلموشعربي؟").unwrap()); // Egyptian
	assert_eq!("他们为什么不说中文", nameprep("他们为什么不说中文").unwrap()); // Chinese
	assert_eq!("למההםפשוטלאמדבריםעברית", nameprep("למההםפשוטלאמדבריםעברית").unwrap()); // Hebrew
	assert_eq!("почемужеонинеговорятпорусски", nameprep("почемужеонинеговорятпорусски").unwrap()); // Russian
	assert_eq!("tạisaohọkhôngthểchỉnóitiếngviệt", nameprep("TạisaohọkhôngthểchỉnóitiếngViệt").unwrap()); // Vietnamese
	assert_eq!("ひとつ屋根の下2", nameprep("ひとつ屋根の下2").unwrap()); // Japanese
	assert_eq!("pročprostěnemluvíčesky", nameprep("Pročprostěnemluvíčesky").unwrap()); // Czech
	assert_eq!("यहलोगहिन्दीक्योंनहींबोलसकतेहैं", nameprep("यहलोगहिन्दीक्योंनहींबोलसकतेहैं").unwrap()); // Hindi
	assert_eq!("ພາສາລາວ", nameprep("ພາສາລາວ").unwrap()); // Lao
	assert_eq!("bonġusaħħa", nameprep("bonġusaħħa").unwrap()); // Maltese
	assert_eq!("ελληνικά", nameprep("ελληνικά").unwrap()); // Greek
	}

	// 4.1 Map to nothing
	#[test]
	fn should_map_to_nothing() {
	let input = "foo\u{00ad}\u{034f}\u{1806}\u{180b}bar\u{200b}\u{2060}baz\u{fe00}\u{fe08}\u{fe0f}\u{feff}";
	assert_eq!("foobarbaz", nameprep(input).unwrap());
	}

	// 4.2 Case folding ASCII U+0043 U+0041 U+0046 U+0045
	#[test]
	fn should_case_fold_ascii() {
	assert_eq!("cafe", nameprep("CAFE").unwrap());
	}

	// 4.3 Case folding 8bit U+00DF (german sharp s)
	#[test]
	fn should_case_fold_8bit() {
	assert_eq!("ss", nameprep("\u{00df}").unwrap());
	}

	// 4.4 Case folding U+0130 (turkish capital I with dot)
	#[test]
	fn should_case_fold_16bit() {
	assert_eq!("\u{0069}\u{0307}", nameprep("\u{0130}").unwrap());
	}

	// 4.5 Case folding multibyte U+0143 U+037A
	#[test]
	fn should_case_fold_multibyte() {
	let input = "\u{0143}\u{037a}";
	let output = "\u{0144} \u{03b9}";
	assert_eq!(output, nameprep(input).unwrap());
	}

	// 4.6 Case folding U+2121 U+33C6 U+1D7BB
	#[test]
	fn should_case_fold() {
	let input = "\u{2121}\u{33c6}\u{1d7bb}";
	let output = "telc\u{2215}\u{006b}\u{0067}\u{03c3}";
	assert_eq!(output, nameprep(input).unwrap());
	}

	// 4.7 Normalization of U+006a U+030c U+00A0 U+00AA
	#[test]
	fn should_normalize() {
	let input = "j\u{030c}\u{00a0}\u{00aa}";
	let output = "\u{01f0} a";
	assert_eq!(output, nameprep(input).unwrap());
	}

	// 4.8 Case folding U+1FB7 and normalization
	#[test]
	fn should_case_fold_and_normalize() {
	let input = "\u{1fb7}";
	let output = "\u{1fb6}\u{03b9}";
	assert_eq!(output, nameprep(input).unwrap());
	}

	// 4.9 Self-reverting case folding U+01F0 and normalization
	// 4.10 Self-reverting case folding U+0390 and normalization
	// 4.11 Self-reverting case folding U+03B0 and normalization
	// 4.12 Self-reverting case folding U+1E96 and normalization
	// 4.13 Self-reverting case folding U+1F56 and normalization
	#[test]
	fn should_revert_case_fold_and_normalization() {
	let inputs = ["\u{01f0}", "\u{0390}", "\u{03b0}", "\u{1e96}", "\u{1f56}"];
	for input in inputs.iter() {
	assert_eq!(input.clone(), nameprep(input).unwrap());
	}
	}

	// 4.14 ASCII space character U+0020
	#[test]
	fn should_permit_ascii_space() {
	assert_eq!(" ", nameprep(" ").unwrap());
	}

	// 4.15 Non-ASCII 8bit space character U+00A0
	#[test]
	fn should_map_8bit_space() {
	assert_eq!(" ", nameprep("\u{00a0}").unwrap());
	}

	// 4.16 Non-ASCII multibyte space character U+1680
	#[test]
	fn should_prohibit_multibyte_space() {
	assert_prohibited_character(nameprep("\u{1680}"));
	}

	// 4.17 Non-ASCII multibyte space character U+2000
	#[test]
	fn should_map_multibyte_space1() {
	assert_eq!(" ", nameprep("\u{2000}").unwrap());
	}

	// 4.18 Zero Width Space U+200b
	#[test]
	fn should_drop_zero_width_space() {
	assert_eq!("", nameprep("\u{200b}").unwrap());
	}

	// 4.19 Non-ASCII multibyte space character U+3000
	#[test]
	fn should_map_multibyte_space2() {
	assert_eq!(" ", nameprep("\u{3000}").unwrap());
	}

	// 4.20 ASCII control characters U+0010 U+007F
	#[test]
	fn should_permit_ascii_control() {
	assert_eq!("\u{0010}\u{007f}", nameprep("\u{0010}\u{007f}").unwrap());
	}

	// 4.21 Non-ASCII 8bit control character U+0085
	#[test]
	fn should_prohibit_8bit_control() {
	assert_prohibited_character(nameprep("\u{0085}"));
	}

	// 4.22 Non-ASCII multibyte control character U+180E
	#[test]
	fn should_prohibit_multibyte_control() {
	assert_prohibited_character(nameprep("\u{180e}"));
	}

	// 4.23 Zero Width No-Break Space U+FEFF
	#[test]
	fn should_drop_zero_width_no_break_space() {
	assert_eq!("", nameprep("\u{feff}").unwrap());
	}

	// 4.24 Non-ASCII control character U+1D175
	#[test]
	fn should_prohibit_non_ascii_control() {
	assert_prohibited_character(nameprep("\u{1d175}"));
	}

	// 4.25 Plane 0 private use character U+F123
	#[test]
	fn should_prohibit_plane0_private_use() {
	assert_prohibited_character(nameprep("\u{f123}"));
	}

	// 4.26 Plane 15 private use character U+F1234
	#[test]
	fn should_prohibit_plane15_private_use() {
	assert_prohibited_character(nameprep("\u{f1234}"));
	}

	// 4.27 Plane 16 private use character U+10F234
	#[test]
	fn should_prohibit_plane16_private_use() {
	assert_prohibited_character(nameprep("\u{10f234}"));
	}

	// 4.28 Non-character code point U+8FFFE
	#[test]
	fn should_prohibit_non_character1() {
	assert_prohibited_character(nameprep("\u{8fffe}"));
	}

	// 4.29 Non-character code point U+10FFFF
	#[test]
	fn should_prohibit_non_character2() {
	assert_prohibited_character(nameprep("\u{10ffff}"));
	}

	// 4.31 Non-plain text character U+FFFD
	#[test]
	fn should_prohibit_non_plain_text() {
	assert_prohibited_character(nameprep("\u{fffd}"));
	}

	// 4.32 Ideographic description character U+2FF5
	#[test]
	fn should_prohibit_ideographic_description() {
	assert_prohibited_character(nameprep("\u{2ff5}"));
	}

	// 4.33 Display property character U+0341
	#[test]
	fn should_normalize_display_property() {
	assert_eq!("\u{0301}", nameprep("\u{0341}").unwrap());
	}

	// 4.34 Left-to-right mark U+200E
	#[test]
	fn should_prohibit_left_to_right_mark() {
	assert_prohibited_character(nameprep("\u{200e}"));
	}

	// 4.35 Deprecated U+202A
	#[test]
	fn should_prohibit_deprecated() {
	assert_prohibited_character(nameprep("\u{202a}"));
	}

	// 4.36 Language tagging character U+E0001
	#[test]
	fn should_prohibit_language_tagging1() {
	assert_prohibited_character(nameprep("\u{e0001}"));
	}

	// 4.37 Language tagging character U+E0042
	#[test]
	fn should_prohibit_language_tagging2() {
	assert_prohibited_character(nameprep("\u{e0042}"));
	}

	// 4.38 Bidi: RandALCat character U+05BE and LCat characters
	#[test]
	fn should_prohibit_randalcat_with_lcat1() {
	assert_prohibited_bidirectional_text(nameprep("foo\u{05be}bar"));
	}

	// 4.39 Bidi: RandALCat character U+FD50 and LCat characters
	#[test]
	fn should_prohibit_randalcat_with_lcat2() {
	assert_prohibited_bidirectional_text(nameprep("foo\u{fd50}bar"));
	}

	// 4.40 Bidi: RandALCat character U+FB38 and LCat characters
	#[test]
	fn should_permit_randalcat1() {
	assert_eq!("foo \u{064e}bar", nameprep("foo\u{fe76}bar").unwrap());
	}

	// 4.41 Bidi: RandALCat without trailing RandALCat U+0627 U+0031
	#[test]
	fn should_prohibit_mixed_randalcat() {
	assert_prohibited_bidirectional_text(nameprep("\u{0672}\u{0031}"));
	}

	// 4.42 Bidi: RandALCat character U+0627 U+0031 U+0628
	#[test]
	fn should_permit_randalcat2() {
	assert_eq!("\u{0627}\u{0031}\u{0628}", nameprep("\u{0627}\u{0031}\u{0628}").unwrap());
	}

	// 4.43 Unassigned code point U+E0002
	#[test]
	fn should_prohibit_unassigned_code_point() {
	assert_prohibited_character(nameprep("\u{e0002}"));
	}

	// 4.44 Larger test (shrinking)
	#[test]
	fn should_shrink() {
	let input = "X\u{00ad}\u{00df}\u{0130}\u{2121}j\u{030c}\u{00a0}\u{00aa}\u{03b0}\u{2000}";
	let output = "xssi\u{0307}tel\u{01f0} a\u{03b0}\u{0020}";
	assert_eq!(output, nameprep(input).unwrap());
	}

	// 4.45 Larger test (expanding)
	#[test]
	fn should_expand() {
	let input = "X\u{00df}\u{3316}\u{0130}\u{2121}\u{249f}\u{3300}";
	let output = "xss\u{30ad}\u{30ed}\u{30e1}\u{30fc}\u{30c8}\u{30eb}\u{0069}\u{0307}\u{0074}\u{0065}\u{006c}\u{0028}\u{0064}\u{0029}\u{30a2}\u{30d1}\u{30fc}\u{30c8}";
	assert_eq!(output, nameprep(input).unwrap());
	}