diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-17 12:18:32 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-17 12:18:32 +0000 |
commit | 4547b622d8d29df964fa2914213088b148c498fc (patch) | |
tree | 9fc6b25f3c3add6b745be9a2400a6e96140046e9 /vendor/tinystr/tests/main.rs | |
parent | Releasing progress-linux version 1.66.0+dfsg1-1~progress7.99u1. (diff) | |
download | rustc-4547b622d8d29df964fa2914213088b148c498fc.tar.xz rustc-4547b622d8d29df964fa2914213088b148c498fc.zip |
Merging upstream version 1.67.1+dfsg1.
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r-- | vendor/tinystr/tests/main.rs | 538 |
1 files changed, 0 insertions, 538 deletions
diff --git a/vendor/tinystr/tests/main.rs b/vendor/tinystr/tests/main.rs deleted file mode 100644 index a9cf7be1a..000000000 --- a/vendor/tinystr/tests/main.rs +++ /dev/null @@ -1,538 +0,0 @@ -use std::fmt::Write; -use std::mem::size_of; -use std::ops::Deref; -use tinystr::{Error, TinyStr16, TinyStr4, TinyStr8}; - -#[cfg(any(feature = "std", feature = "alloc"))] -use tinystr::TinyStrAuto; - -#[test] -fn tiny_sizes() { - assert_eq!(4, size_of::<TinyStr4>()); - assert_eq!(8, size_of::<TinyStr8>()); - assert_eq!(16, size_of::<TinyStr16>()); - assert_eq!(24, size_of::<String>()); - // Note: TinyStrAuto is size 32 even when a smaller TinyStr type is used - #[cfg(any(feature = "std", feature = "alloc"))] - assert_eq!(32, size_of::<TinyStrAuto>()); -} - -#[test] -fn tiny4_basic() { - let s: TinyStr4 = "abc".parse().unwrap(); - assert_eq!(s.deref(), "abc"); -} - -#[test] -fn tiny4_from_bytes() { - let s = TinyStr4::from_bytes("abc".as_bytes()).unwrap(); - assert_eq!(s.deref(), "abc"); - - assert_eq!( - TinyStr4::from_bytes(&[0, 159, 146, 150]), - Err(Error::NonAscii) - ); - assert_eq!(TinyStr4::from_bytes(&[]), Err(Error::InvalidSize)); - assert_eq!(TinyStr4::from_bytes(&[0]), Err(Error::InvalidNull)); -} - -#[test] -fn tiny4_size() { - assert_eq!("".parse::<TinyStr4>(), Err(Error::InvalidSize)); - assert!("1".parse::<TinyStr4>().is_ok()); - assert!("12".parse::<TinyStr4>().is_ok()); - assert!("123".parse::<TinyStr4>().is_ok()); - assert!("1234".parse::<TinyStr4>().is_ok()); - assert_eq!("12345".parse::<TinyStr4>(), Err(Error::InvalidSize)); - assert_eq!("123456789".parse::<TinyStr4>(), Err(Error::InvalidSize)); -} - -#[test] -fn tiny4_null() { - assert_eq!("a\u{0}b".parse::<TinyStr4>(), Err(Error::InvalidNull)); -} - -#[test] -fn tiny4_new_unchecked() { - let reference: TinyStr4 = "en".parse().unwrap(); - let uval: u32 = reference.into(); - let s = unsafe { TinyStr4::new_unchecked(uval) }; - assert_eq!(s, reference); - assert_eq!(s, "en"); -} - -#[test] -fn tiny4_nonascii() { - assert_eq!("\u{4000}".parse::<TinyStr4>(), Err(Error::NonAscii)); -} - -#[test] -fn tiny4_alpha() { - let s: TinyStr4 = "@aZ[".parse().unwrap(); - assert!(!s.is_ascii_alphabetic()); - assert!(!s.is_ascii_alphanumeric()); - assert_eq!(s.to_ascii_uppercase().as_str(), "@AZ["); - assert_eq!(s.to_ascii_lowercase().as_str(), "@az["); - - assert!("abYZ".parse::<TinyStr4>().unwrap().is_ascii_alphabetic()); - assert!("abYZ".parse::<TinyStr4>().unwrap().is_ascii_alphanumeric()); - assert!("a123".parse::<TinyStr4>().unwrap().is_ascii_alphanumeric()); - assert!(!"a123".parse::<TinyStr4>().unwrap().is_ascii_alphabetic()); -} - -#[test] -fn tiny4_numeric() { - let s: TinyStr4 = "@aZ[".parse().unwrap(); - assert!(!s.is_ascii_numeric()); - - assert!("0123".parse::<TinyStr4>().unwrap().is_ascii_numeric()); -} - -#[test] -fn tiny4_titlecase() { - assert_eq!( - "abcd" - .parse::<TinyStr4>() - .unwrap() - .to_ascii_titlecase() - .as_str(), - "Abcd" - ); - assert_eq!( - "ABCD" - .parse::<TinyStr4>() - .unwrap() - .to_ascii_titlecase() - .as_str(), - "Abcd" - ); - assert_eq!( - "aBCD" - .parse::<TinyStr4>() - .unwrap() - .to_ascii_titlecase() - .as_str(), - "Abcd" - ); - assert_eq!( - "A123" - .parse::<TinyStr4>() - .unwrap() - .to_ascii_titlecase() - .as_str(), - "A123" - ); - assert_eq!( - "123a" - .parse::<TinyStr4>() - .unwrap() - .to_ascii_titlecase() - .as_str(), - "123a" - ); -} - -#[test] -fn tiny4_ord() { - let mut v: Vec<TinyStr4> = vec!["zh".parse().unwrap(), "fr".parse().unwrap()]; - v.sort(); - - assert_eq!(v.get(0).unwrap().as_str(), "fr"); - assert_eq!(v.get(1).unwrap().as_str(), "zh"); -} - -#[test] -fn tiny4_eq() { - let s1: TinyStr4 = "en".parse().unwrap(); - let s2: TinyStr4 = "fr".parse().unwrap(); - let s3: TinyStr4 = "en".parse().unwrap(); - - assert_eq!(s1, s3); - assert_ne!(s1, s2); -} - -#[test] -fn tiny4_display() { - let s: TinyStr4 = "abcd".parse().unwrap(); - let mut result = String::new(); - write!(result, "{}", s).unwrap(); - assert_eq!(result, "abcd"); - assert_eq!(format!("{}", s), "abcd"); -} - -#[test] -fn tiny4_debug() { - let s: TinyStr4 = "abcd".parse().unwrap(); - assert_eq!(format!("{:#?}", s), "\"abcd\""); -} - -#[test] -fn tiny8_basic() { - let s: TinyStr8 = "abcde".parse().unwrap(); - assert_eq!(s.deref(), "abcde"); -} - -#[test] -fn tiny8_from_bytes() { - let s = TinyStr8::from_bytes("abcde".as_bytes()).unwrap(); - assert_eq!(s.deref(), "abcde"); - - assert_eq!( - TinyStr8::from_bytes(&[0, 159, 146, 150]), - Err(Error::NonAscii) - ); - assert_eq!(TinyStr8::from_bytes(&[]), Err(Error::InvalidSize)); - assert_eq!(TinyStr8::from_bytes(&[0]), Err(Error::InvalidNull)); -} - -#[test] -fn tiny8_size() { - assert_eq!("".parse::<TinyStr8>(), Err(Error::InvalidSize)); - assert!("1".parse::<TinyStr8>().is_ok()); - assert!("12".parse::<TinyStr8>().is_ok()); - assert!("123".parse::<TinyStr8>().is_ok()); - assert!("1234".parse::<TinyStr8>().is_ok()); - assert!("12345".parse::<TinyStr8>().is_ok()); - assert!("123456".parse::<TinyStr8>().is_ok()); - assert!("1234567".parse::<TinyStr8>().is_ok()); - assert!("12345678".parse::<TinyStr8>().is_ok()); - assert_eq!("123456789".parse::<TinyStr8>(), Err(Error::InvalidSize)); -} - -#[test] -fn tiny8_null() { - assert_eq!("a\u{0}b".parse::<TinyStr8>(), Err(Error::InvalidNull)); -} - -#[test] -fn tiny8_new_unchecked() { - let reference: TinyStr8 = "Windows".parse().unwrap(); - let uval: u64 = reference.into(); - let s = unsafe { TinyStr8::new_unchecked(uval) }; - assert_eq!(s, reference); - assert_eq!(s, "Windows"); -} - -#[test] -fn tiny8_nonascii() { - assert_eq!("\u{4000}".parse::<TinyStr8>(), Err(Error::NonAscii)); -} - -#[test] -fn tiny8_alpha() { - let s: TinyStr8 = "@abcXYZ[".parse().unwrap(); - assert!(!s.is_ascii_alphabetic()); - assert!(!s.is_ascii_alphanumeric()); - assert_eq!(s.to_ascii_uppercase().as_str(), "@ABCXYZ["); - assert_eq!(s.to_ascii_lowercase().as_str(), "@abcxyz["); - - assert!("abcXYZ".parse::<TinyStr8>().unwrap().is_ascii_alphabetic()); - assert!("abcXYZ" - .parse::<TinyStr8>() - .unwrap() - .is_ascii_alphanumeric()); - assert!(!"abc123".parse::<TinyStr8>().unwrap().is_ascii_alphabetic()); - assert!("abc123" - .parse::<TinyStr8>() - .unwrap() - .is_ascii_alphanumeric()); -} - -#[test] -fn tiny8_numeric() { - let s: TinyStr8 = "@abcXYZ[".parse().unwrap(); - assert!(!s.is_ascii_numeric()); - - assert!("01234567".parse::<TinyStr8>().unwrap().is_ascii_numeric()); -} - -#[test] -fn tiny8_titlecase() { - assert_eq!( - "abcdabcd" - .parse::<TinyStr8>() - .unwrap() - .to_ascii_titlecase() - .as_str(), - "Abcdabcd" - ); - assert_eq!( - "ABCDABCD" - .parse::<TinyStr8>() - .unwrap() - .to_ascii_titlecase() - .as_str(), - "Abcdabcd" - ); - assert_eq!( - "aBCDaBCD" - .parse::<TinyStr8>() - .unwrap() - .to_ascii_titlecase() - .as_str(), - "Abcdabcd" - ); - assert_eq!( - "A123a123" - .parse::<TinyStr8>() - .unwrap() - .to_ascii_titlecase() - .as_str(), - "A123a123" - ); - assert_eq!( - "123a123A" - .parse::<TinyStr8>() - .unwrap() - .to_ascii_titlecase() - .as_str(), - "123a123a" - ); -} - -#[test] -fn tiny8_ord() { - let mut v: Vec<TinyStr8> = vec!["nedis".parse().unwrap(), "macos".parse().unwrap()]; - v.sort(); - - assert_eq!(v.get(0).unwrap().as_str(), "macos"); - assert_eq!(v.get(1).unwrap().as_str(), "nedis"); -} - -#[test] -fn tiny8_eq() { - let s1: TinyStr8 = "windows".parse().unwrap(); - let s2: TinyStr8 = "mac".parse().unwrap(); - let s3: TinyStr8 = "windows".parse().unwrap(); - - assert_eq!(s1, s3); - assert_ne!(s1, s2); -} - -#[test] -fn tiny8_display() { - let s: TinyStr8 = "abcdef".parse().unwrap(); - let mut result = String::new(); - write!(result, "{}", s).unwrap(); - assert_eq!(result, "abcdef"); - assert_eq!(format!("{}", s), "abcdef"); -} - -#[test] -fn tiny8_debug() { - let s: TinyStr8 = "abcdef".parse().unwrap(); - assert_eq!(format!("{:#?}", s), "\"abcdef\""); -} - -#[test] -fn tiny16_from_bytes() { - let s = TinyStr16::from_bytes("abcdefghijk".as_bytes()).unwrap(); - assert_eq!(s.deref(), "abcdefghijk"); - - assert_eq!( - TinyStr16::from_bytes(&[0, 159, 146, 150]), - Err(Error::NonAscii) - ); - assert_eq!(TinyStr16::from_bytes(&[]), Err(Error::InvalidSize)); - assert_eq!(TinyStr16::from_bytes(&[0]), Err(Error::InvalidNull)); -} - -#[test] -fn tiny16_size() { - assert_eq!("".parse::<TinyStr16>(), Err(Error::InvalidSize)); - assert!("1".parse::<TinyStr16>().is_ok()); - assert!("12".parse::<TinyStr16>().is_ok()); - assert!("123".parse::<TinyStr16>().is_ok()); - assert!("1234".parse::<TinyStr16>().is_ok()); - assert!("12345".parse::<TinyStr16>().is_ok()); - assert!("123456".parse::<TinyStr16>().is_ok()); - assert!("1234567".parse::<TinyStr16>().is_ok()); - assert!("12345678".parse::<TinyStr16>().is_ok()); - assert!("123456781".parse::<TinyStr16>().is_ok()); - assert!("1234567812".parse::<TinyStr16>().is_ok()); - assert!("12345678123".parse::<TinyStr16>().is_ok()); - assert!("123456781234".parse::<TinyStr16>().is_ok()); - assert!("1234567812345".parse::<TinyStr16>().is_ok()); - assert!("12345678123456".parse::<TinyStr16>().is_ok()); - assert!("123456781234567".parse::<TinyStr16>().is_ok()); - assert!("1234567812345678".parse::<TinyStr16>().is_ok()); - assert_eq!( - "12345678123456789".parse::<TinyStr16>(), - Err(Error::InvalidSize) - ); -} - -#[test] -fn tiny16_null() { - assert_eq!("a\u{0}b".parse::<TinyStr16>(), Err(Error::InvalidNull)); -} - -#[test] -fn tiny16_new_unchecked() { - let reference: TinyStr16 = "WindowsCE/ME/NT".parse().unwrap(); - let uval: u128 = reference.into(); - let s = unsafe { TinyStr16::new_unchecked(uval) }; - assert_eq!(s, reference); - assert_eq!(s, "WindowsCE/ME/NT"); -} - -#[test] -fn tiny16_nonascii() { - assert_eq!("\u{4000}".parse::<TinyStr16>(), Err(Error::NonAscii)); -} - -#[test] -fn tiny16_alpha() { - let s: TinyStr16 = "@abcdefgTUVWXYZ[".parse().unwrap(); - assert!(!s.is_ascii_alphabetic()); - assert!(!s.is_ascii_alphanumeric()); - assert_eq!(s.to_ascii_uppercase().as_str(), "@ABCDEFGTUVWXYZ["); - assert_eq!(s.to_ascii_lowercase().as_str(), "@abcdefgtuvwxyz["); - - assert!("abcdefgTUVWXYZ" - .parse::<TinyStr16>() - .unwrap() - .is_ascii_alphabetic()); - assert!("abcdefgTUVWXYZ" - .parse::<TinyStr16>() - .unwrap() - .is_ascii_alphanumeric()); - assert!(!"abcdefg0123456" - .parse::<TinyStr16>() - .unwrap() - .is_ascii_alphabetic()); - assert!("abcdefgTUVWXYZ" - .parse::<TinyStr16>() - .unwrap() - .is_ascii_alphanumeric()); -} - -#[test] -fn tiny16_numeric() { - let s: TinyStr16 = "@abcdefgTUVWXYZ[".parse().unwrap(); - assert!(!s.is_ascii_numeric()); - - assert!("0123456789" - .parse::<TinyStr16>() - .unwrap() - .is_ascii_numeric()); -} - -#[test] -fn tiny16_titlecase() { - assert_eq!( - "abcdabcdabcdabcd" - .parse::<TinyStr16>() - .unwrap() - .to_ascii_titlecase() - .as_str(), - "Abcdabcdabcdabcd" - ); - assert_eq!( - "ABCDABCDABCDABCD" - .parse::<TinyStr16>() - .unwrap() - .to_ascii_titlecase() - .as_str(), - "Abcdabcdabcdabcd" - ); - assert_eq!( - "aBCDaBCDaBCDaBCD" - .parse::<TinyStr16>() - .unwrap() - .to_ascii_titlecase() - .as_str(), - "Abcdabcdabcdabcd" - ); - assert_eq!( - "A123a123A123a123" - .parse::<TinyStr16>() - .unwrap() - .to_ascii_titlecase() - .as_str(), - "A123a123a123a123" - ); - assert_eq!( - "123a123A123a123A" - .parse::<TinyStr16>() - .unwrap() - .to_ascii_titlecase() - .as_str(), - "123a123a123a123a" - ); -} - -#[test] -fn tiny16_ord() { - let mut v: Vec<TinyStr16> = vec!["nedis_xxxx".parse().unwrap(), "macos_xxxx".parse().unwrap()]; - v.sort(); - - assert_eq!(v.get(0).unwrap().as_str(), "macos_xxxx"); - assert_eq!(v.get(1).unwrap().as_str(), "nedis_xxxx"); -} - -#[test] -fn tiny16_eq() { - let s1: TinyStr16 = "windows98SE".parse().unwrap(); - let s2: TinyStr16 = "mac".parse().unwrap(); - let s3: TinyStr16 = "windows98SE".parse().unwrap(); - - assert_eq!(s1, s3); - assert_ne!(s1, s2); -} - -#[test] -fn tiny16_display() { - let s: TinyStr16 = "abcdefghijkl".parse().unwrap(); - let mut result = String::new(); - write!(result, "{}", s).unwrap(); - assert_eq!(result, "abcdefghijkl"); - assert_eq!(format!("{}", s), "abcdefghijkl"); -} - -#[test] -fn tiny16_debug() { - let s: TinyStr16 = "abcdefghijkl".parse().unwrap(); - assert_eq!(format!("{:#?}", s), "\"abcdefghijkl\""); -} - -#[cfg(any(feature = "std", feature = "alloc"))] -#[test] -fn tinyauto_basic() { - let s1: TinyStrAuto = "abc".parse().unwrap(); - assert_eq!(s1, "abc"); - - let s2: TinyStrAuto = "veryveryveryveryverylong".parse().unwrap(); - assert_eq!(s2, "veryveryveryveryverylong"); -} - -#[cfg(any(feature = "std", feature = "alloc"))] -#[test] -fn tinyauto_nonascii() { - assert_eq!("\u{4000}".parse::<TinyStrAuto>(), Err(Error::NonAscii)); - assert_eq!( - "veryveryveryveryverylong\u{4000}".parse::<TinyStrAuto>(), - Err(Error::NonAscii) - ); -} - -#[cfg(feature = "macros")] -const TS: TinyStr8 = tinystr::macros::tinystr8!("test"); - -#[cfg(feature = "macros")] -#[test] -fn tinystr_macros() { - use tinystr::macros::*; - - let x: TinyStr8 = "test".parse().unwrap(); - assert_eq!(TS, x); - - let x: TinyStr4 = "foo".parse().unwrap(); - assert_eq!(tinystr4!("foo"), x); - - let x: TinyStr8 = "barbaz".parse().unwrap(); - assert_eq!(tinystr8!("barbaz"), x); - - let x: TinyStr16 = "metamorphosis".parse().unwrap(); - assert_eq!(tinystr16!("metamorphosis"), x); -} |