summaryrefslogtreecommitdiffstats
path: root/vendor/tinystr/tests
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/tinystr/tests')
-rw-r--r--vendor/tinystr/tests/main.rs538
-rw-r--r--vendor/tinystr/tests/serde.rs39
2 files changed, 39 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);
-}
diff --git a/vendor/tinystr/tests/serde.rs b/vendor/tinystr/tests/serde.rs
new file mode 100644
index 000000000..282914e6f
--- /dev/null
+++ b/vendor/tinystr/tests/serde.rs
@@ -0,0 +1,39 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+use tinystr::*;
+
+// Tests largely adapted from `tinystr` crate
+// https://github.com/zbraniecki/tinystr/blob/4e4eab55dd6bded7f29a18b41452c506c461716c/tests/serde.rs
+
+macro_rules! test_roundtrip {
+ ($f:ident, $n:literal, $val:expr) => {
+ #[test]
+ fn $f() {
+ let tiny: TinyAsciiStr<$n> = $val.parse().unwrap();
+ let json_string = serde_json::to_string(&tiny).unwrap();
+ let expected_json = concat!("\"", $val, "\"");
+ assert_eq!(json_string, expected_json);
+ let recover: TinyAsciiStr<$n> = serde_json::from_str(&json_string).unwrap();
+ assert_eq!(&*tiny, &*recover);
+
+ let bin = bincode::serialize(&tiny).unwrap();
+ assert_eq!(bin, &tiny.all_bytes()[..]);
+ let debin: TinyAsciiStr<$n> = bincode::deserialize(&bin).unwrap();
+ assert_eq!(&*tiny, &*debin);
+
+ let post = postcard::to_stdvec(&tiny).unwrap();
+ assert_eq!(post, &tiny.all_bytes()[..]);
+ let unpost: TinyAsciiStr<$n> = postcard::from_bytes(&post).unwrap();
+ assert_eq!(&*tiny, &*unpost);
+ }
+ };
+}
+
+test_roundtrip!(test_roundtrip4_1, 4, "en");
+test_roundtrip!(test_roundtrip4_2, 4, "Latn");
+test_roundtrip!(test_roundtrip8, 8, "calendar");
+test_roundtrip!(test_roundtrip16, 16, "verylongstring");
+test_roundtrip!(test_roundtrip10, 11, "shortstring");
+test_roundtrip!(test_roundtrip30, 24, "veryveryverylongstring");
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-15 04:30:38 +0000