Adding upstream version 1.64.0+dfsg1.upstream/1.64.0+dfsg1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 538 insertions, 0 deletions

diff --git a/vendor/tinystr/tests/main.rs b/vendor/tinystr/tests/main.rs
new file mode 100644
index 000000000..a9cf7be1a
--- /dev/null
+++ b/vendor/tinystr/tests/main.rs
@@ -0,0 +1,538 @@
+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);
+}