diff options
Diffstat (limited to 'vendor/bitflags/src/tests')
28 files changed, 0 insertions, 2032 deletions
diff --git a/vendor/bitflags/src/tests/all.rs b/vendor/bitflags/src/tests/all.rs deleted file mode 100644 index cceb93a4..00000000 --- a/vendor/bitflags/src/tests/all.rs +++ /dev/null @@ -1,23 +0,0 @@ -use super::*; - -use crate::Flags; - -#[test] -fn cases() { - case(1 | 1 << 1 | 1 << 2, TestFlags::all); - - case(0, TestZero::all); - - case(0, TestEmpty::all); - - case(!0, TestExternal::all); -} - -#[track_caller] -fn case<T: Flags>(expected: T::Bits, inherent: impl FnOnce() -> T) -where - <T as Flags>::Bits: std::fmt::Debug + PartialEq, -{ - assert_eq!(expected, inherent().bits(), "T::all()"); - assert_eq!(expected, T::all().bits(), "Flags::all()"); -} diff --git a/vendor/bitflags/src/tests/bitflags_match.rs b/vendor/bitflags/src/tests/bitflags_match.rs deleted file mode 100644 index 93190f8b..00000000 --- a/vendor/bitflags/src/tests/bitflags_match.rs +++ /dev/null @@ -1,93 +0,0 @@ -bitflags! { - #[derive(PartialEq)] - struct Flags: u8 { - const A = 1 << 0; - const B = 1 << 1; - const C = 1 << 2; - const D = 1 << 3; - } -} - -fn flag_to_string(flag: Flags) -> String { - bitflags_match!(flag, { - Flags::A => "A".to_string(), - Flags::B => { "B".to_string() } - Flags::C => "C".to_string(), - Flags::D => "D".to_string(), - Flags::A | Flags::B => "A or B".to_string(), - Flags::A & Flags::B => { "A and B | empty".to_string() }, - Flags::A ^ Flags::B => "A xor B".to_string(), - Flags::A | Flags::B | Flags::C => "A or B or C".to_string(), - Flags::A & Flags::B & Flags::C => "A and B and C".to_string(), - Flags::A ^ Flags::B ^ Flags::C => "A xor B xor C".to_string(), - Flags::A | Flags::B | Flags::C | Flags::D => "All flags".to_string(), - _ => "Unknown combination".to_string() - }) -} - -#[test] -fn test_single_flags() { - assert_eq!(flag_to_string(Flags::A), "A"); - assert_eq!(flag_to_string(Flags::B), "B"); - assert_eq!(flag_to_string(Flags::C), "C"); - assert_eq!(flag_to_string(Flags::D), "D"); -} - -#[test] -fn test_or_operations() { - assert_eq!(flag_to_string(Flags::A | Flags::B), "A or B"); - assert_eq!( - flag_to_string(Flags::A | Flags::B | Flags::C), - "A or B or C" - ); - assert_eq!( - flag_to_string(Flags::A | Flags::B | Flags::C | Flags::D), - "All flags" - ); -} - -#[test] -fn test_and_operations() { - assert_eq!(flag_to_string(Flags::A & Flags::A), "A"); - assert_eq!(flag_to_string(Flags::A & Flags::B), "A and B | empty"); - assert_eq!( - flag_to_string(Flags::A & Flags::B & Flags::C), - "A and B | empty" - ); // Since A, B, and C are mutually exclusive, the result of A & B & C is 0 ==> A & B & C = 0000 (i.e., empty). - // However, in the bitflags_match! statement (actually is if {..} else if {..} .. else {..}), - // the "A & B = 0000" condition is listed first, so 0000 will match "A & B" first, - // resulting in the output of the "A and B | empty" branch. - assert_eq!( - flag_to_string(Flags::A & Flags::B & Flags::C & Flags::D), - "A and B | empty" - ); -} - -#[test] -fn test_xor_operations() { - assert_eq!(flag_to_string(Flags::A ^ Flags::B), "A or B"); // A | B = A ^ B == 0011 - assert_eq!(flag_to_string(Flags::A ^ Flags::A), "A and B | empty"); - assert_eq!( - flag_to_string(Flags::A ^ Flags::B ^ Flags::C), - "A or B or C" - ); -} - -#[test] -fn test_complex_operations() { - assert_eq!(flag_to_string(Flags::A | (Flags::B & Flags::C)), "A"); - assert_eq!( - flag_to_string((Flags::A | Flags::B) & (Flags::B | Flags::C)), - "B" - ); - assert_eq!( - flag_to_string(Flags::A ^ (Flags::B | Flags::C)), - "A or B or C" - ); -} - -#[test] -fn test_empty_and_full_flags() { - assert_eq!(flag_to_string(Flags::empty()), "A and B | empty"); - assert_eq!(flag_to_string(Flags::all()), "All flags"); -} diff --git a/vendor/bitflags/src/tests/bits.rs b/vendor/bitflags/src/tests/bits.rs deleted file mode 100644 index 678f153e..00000000 --- a/vendor/bitflags/src/tests/bits.rs +++ /dev/null @@ -1,36 +0,0 @@ -use super::*; - -use crate::Flags; - -#[test] -fn cases() { - case(0, TestFlags::empty(), TestFlags::bits); - - case(1, TestFlags::A, TestFlags::bits); - case(1 | 1 << 1 | 1 << 2, TestFlags::ABC, TestFlags::bits); - - case(!0, TestFlags::from_bits_retain(u8::MAX), TestFlags::bits); - case(1 << 3, TestFlags::from_bits_retain(1 << 3), TestFlags::bits); - - case(1 << 3, TestZero::from_bits_retain(1 << 3), TestZero::bits); - - case(1 << 3, TestEmpty::from_bits_retain(1 << 3), TestEmpty::bits); - - case( - 1 << 4 | 1 << 6, - TestExternal::from_bits_retain(1 << 4 | 1 << 6), - TestExternal::bits, - ); -} - -#[track_caller] -fn case<T: Flags + std::fmt::Debug>( - expected: T::Bits, - value: T, - inherent: impl FnOnce(&T) -> T::Bits, -) where - T::Bits: std::fmt::Debug + PartialEq, -{ - assert_eq!(expected, inherent(&value), "{:?}.bits()", value); - assert_eq!(expected, Flags::bits(&value), "Flags::bits({:?})", value); -} diff --git a/vendor/bitflags/src/tests/clear.rs b/vendor/bitflags/src/tests/clear.rs deleted file mode 100644 index 2d42cce4..00000000 --- a/vendor/bitflags/src/tests/clear.rs +++ /dev/null @@ -1,27 +0,0 @@ -use super::*; - -use crate::Flags; - -#[test] -fn cases() { - case(TestFlags::from_bits_retain(0)); - - case(TestFlags::from_bits_retain(1 << 3)); - - case(TestFlags::ABC | TestFlags::from_bits_retain(1 << 3)); - - case(TestZero::empty()); - - case(TestZero::all()); - - case(TestFlags::from_bits_retain(1 << 3) | TestFlags::all()); -} - -#[track_caller] -fn case<T: Flags + std::fmt::Debug>(mut flags: T) -where - T: std::fmt::Debug + PartialEq + Copy, -{ - flags.clear(); - assert_eq!(flags, T::empty(), "{:?}.clear()", flags); -} diff --git a/vendor/bitflags/src/tests/complement.rs b/vendor/bitflags/src/tests/complement.rs deleted file mode 100644 index ac7a421a..00000000 --- a/vendor/bitflags/src/tests/complement.rs +++ /dev/null @@ -1,53 +0,0 @@ -use super::*; - -use crate::Flags; - -#[test] -fn cases() { - case(0, TestFlags::all(), TestFlags::complement); - case(0, TestFlags::from_bits_retain(!0), TestFlags::complement); - - case(1 | 1 << 1, TestFlags::C, TestFlags::complement); - case( - 1 | 1 << 1, - TestFlags::C | TestFlags::from_bits_retain(1 << 3), - TestFlags::complement, - ); - - case( - 1 | 1 << 1 | 1 << 2, - TestFlags::empty(), - TestFlags::complement, - ); - case( - 1 | 1 << 1 | 1 << 2, - TestFlags::from_bits_retain(1 << 3), - TestFlags::complement, - ); - - case(0, TestZero::empty(), TestZero::complement); - - case(0, TestEmpty::empty(), TestEmpty::complement); - - case(1 << 2, TestOverlapping::AB, TestOverlapping::complement); - - case(!0, TestExternal::empty(), TestExternal::complement); -} - -#[track_caller] -fn case<T: Flags + std::fmt::Debug + std::ops::Not<Output = T> + Copy>( - expected: T::Bits, - value: T, - inherent: impl FnOnce(T) -> T, -) where - T::Bits: std::fmt::Debug + PartialEq, -{ - assert_eq!(expected, inherent(value).bits(), "{:?}.complement()", value); - assert_eq!( - expected, - Flags::complement(value).bits(), - "Flags::complement({:?})", - value - ); - assert_eq!(expected, (!value).bits(), "!{:?}", value); -} diff --git a/vendor/bitflags/src/tests/contains.rs b/vendor/bitflags/src/tests/contains.rs deleted file mode 100644 index 12428ddc..00000000 --- a/vendor/bitflags/src/tests/contains.rs +++ /dev/null @@ -1,108 +0,0 @@ -use super::*; - -use crate::Flags; - -#[test] -fn cases() { - case( - TestFlags::empty(), - &[ - (TestFlags::empty(), true), - (TestFlags::A, false), - (TestFlags::B, false), - (TestFlags::C, false), - (TestFlags::from_bits_retain(1 << 3), false), - ], - TestFlags::contains, - ); - - case( - TestFlags::A, - &[ - (TestFlags::empty(), true), - (TestFlags::A, true), - (TestFlags::B, false), - (TestFlags::C, false), - (TestFlags::ABC, false), - (TestFlags::from_bits_retain(1 << 3), false), - (TestFlags::from_bits_retain(1 | (1 << 3)), false), - ], - TestFlags::contains, - ); - - case( - TestFlags::ABC, - &[ - (TestFlags::empty(), true), - (TestFlags::A, true), - (TestFlags::B, true), - (TestFlags::C, true), - (TestFlags::ABC, true), - (TestFlags::from_bits_retain(1 << 3), false), - ], - TestFlags::contains, - ); - - case( - TestFlags::from_bits_retain(1 << 3), - &[ - (TestFlags::empty(), true), - (TestFlags::A, false), - (TestFlags::B, false), - (TestFlags::C, false), - (TestFlags::from_bits_retain(1 << 3), true), - ], - TestFlags::contains, - ); - - case( - TestZero::ZERO, - &[(TestZero::ZERO, true)], - TestZero::contains, - ); - - case( - TestOverlapping::AB, - &[ - (TestOverlapping::AB, true), - (TestOverlapping::BC, false), - (TestOverlapping::from_bits_retain(1 << 1), true), - ], - TestOverlapping::contains, - ); - - case( - TestExternal::all(), - &[ - (TestExternal::A, true), - (TestExternal::B, true), - (TestExternal::C, true), - (TestExternal::from_bits_retain(1 << 5 | 1 << 7), true), - ], - TestExternal::contains, - ); -} - -#[track_caller] -fn case<T: Flags + std::fmt::Debug + Copy>( - value: T, - inputs: &[(T, bool)], - mut inherent: impl FnMut(&T, T) -> bool, -) { - for (input, expected) in inputs { - assert_eq!( - *expected, - inherent(&value, *input), - "{:?}.contains({:?})", - value, - input - ); - assert_eq!( - *expected, - Flags::contains(&value, *input), - "Flags::contains({:?}, {:?})", - value, - input - ); - } -} diff --git a/vendor/bitflags/src/tests/difference.rs b/vendor/bitflags/src/tests/difference.rs deleted file mode 100644 index 6ce9c0bf..00000000 --- a/vendor/bitflags/src/tests/difference.rs +++ /dev/null @@ -1,92 +0,0 @@ -use super::*; - -use crate::Flags; - -#[test] -fn cases() { - case( - TestFlags::A | TestFlags::B, - &[ - (TestFlags::A, 1 << 1), - (TestFlags::B, 1), - (TestFlags::from_bits_retain(1 << 3), 1 | 1 << 1), - ], - TestFlags::difference, - ); - - case( - TestFlags::from_bits_retain(1 | 1 << 3), - &[ - (TestFlags::A, 1 << 3), - (TestFlags::from_bits_retain(1 << 3), 1), - ], - TestFlags::difference, - ); - - case( - TestExternal::from_bits_retain(!0), - &[(TestExternal::A, 0b1111_1110)], - TestExternal::difference, - ); - - assert_eq!( - 0b1111_1110, - (TestExternal::from_bits_retain(!0) & !TestExternal::A).bits() - ); - - assert_eq!( - 0b1111_1110, - (TestFlags::from_bits_retain(!0).difference(TestFlags::A)).bits() - ); - - // The `!` operator unsets bits that don't correspond to known flags - assert_eq!( - 1 << 1 | 1 << 2, - (TestFlags::from_bits_retain(!0) & !TestFlags::A).bits() - ); -} - -#[track_caller] -fn case<T: Flags + std::fmt::Debug + std::ops::Sub<Output = T> + std::ops::SubAssign + Copy>( - value: T, - inputs: &[(T, T::Bits)], - mut inherent: impl FnMut(T, T) -> T, -) where - T::Bits: std::fmt::Debug + PartialEq + Copy, -{ - for (input, expected) in inputs { - assert_eq!( - *expected, - inherent(value, *input).bits(), - "{:?}.difference({:?})", - value, - input - ); - assert_eq!( - *expected, - Flags::difference(value, *input).bits(), - "Flags::difference({:?}, {:?})", - value, - input - ); - assert_eq!( - *expected, - (value - *input).bits(), - "{:?} - {:?}", - value, - input - ); - assert_eq!( - *expected, - { - let mut value = value; - value -= *input; - value - } - .bits(), - "{:?} -= {:?}", - value, - input, - ); - } -} diff --git a/vendor/bitflags/src/tests/empty.rs b/vendor/bitflags/src/tests/empty.rs deleted file mode 100644 index 57fb1c7c..00000000 --- a/vendor/bitflags/src/tests/empty.rs +++ /dev/null @@ -1,23 +0,0 @@ -use super::*; - -use crate::Flags; - -#[test] -fn cases() { - case(0, TestFlags::empty); - - case(0, TestZero::empty); - - case(0, TestEmpty::empty); - - case(0, TestExternal::empty); -} - -#[track_caller] -fn case<T: Flags>(expected: T::Bits, inherent: impl FnOnce() -> T) -where - <T as Flags>::Bits: std::fmt::Debug + PartialEq, -{ - assert_eq!(expected, inherent().bits(), "T::empty()"); - assert_eq!(expected, T::empty().bits(), "Flags::empty()"); -} diff --git a/vendor/bitflags/src/tests/eq.rs b/vendor/bitflags/src/tests/eq.rs deleted file mode 100644 index 9779af76..00000000 --- a/vendor/bitflags/src/tests/eq.rs +++ /dev/null @@ -1,10 +0,0 @@ -use super::*; - -#[test] -fn cases() { - assert_eq!(TestFlags::empty(), TestFlags::empty()); - assert_eq!(TestFlags::all(), TestFlags::all()); - - assert!(TestFlags::from_bits_retain(1) < TestFlags::from_bits_retain(2)); - assert!(TestFlags::from_bits_retain(2) > TestFlags::from_bits_retain(1)); -} diff --git a/vendor/bitflags/src/tests/extend.rs b/vendor/bitflags/src/tests/extend.rs deleted file mode 100644 index 869dc17f..00000000 --- a/vendor/bitflags/src/tests/extend.rs +++ /dev/null @@ -1,42 +0,0 @@ -use super::*; - -#[test] -fn cases() { - let mut flags = TestFlags::empty(); - - flags.extend(TestFlags::A); - - assert_eq!(TestFlags::A, flags); - - flags.extend(TestFlags::A | TestFlags::B | TestFlags::C); - - assert_eq!(TestFlags::ABC, flags); - - flags.extend(TestFlags::from_bits_retain(1 << 5)); - - assert_eq!(TestFlags::ABC | TestFlags::from_bits_retain(1 << 5), flags); -} - -mod external { - use super::*; - - #[test] - fn cases() { - let mut flags = TestExternal::empty(); - - flags.extend(TestExternal::A); - - assert_eq!(TestExternal::A, flags); - - flags.extend(TestExternal::A | TestExternal::B | TestExternal::C); - - assert_eq!(TestExternal::ABC, flags); - - flags.extend(TestExternal::from_bits_retain(1 << 5)); - - assert_eq!( - TestExternal::ABC | TestExternal::from_bits_retain(1 << 5), - flags - ); - } -} diff --git a/vendor/bitflags/src/tests/flags.rs b/vendor/bitflags/src/tests/flags.rs deleted file mode 100644 index 7a625b31..00000000 --- a/vendor/bitflags/src/tests/flags.rs +++ /dev/null @@ -1,46 +0,0 @@ -use super::*; - -use crate::Flags; - -#[test] -fn cases() { - let flags = TestFlags::FLAGS - .iter() - .map(|flag| (flag.name(), flag.value().bits())) - .collect::<Vec<_>>(); - - assert_eq!( - vec![ - ("A", 1u8), - ("B", 1 << 1), - ("C", 1 << 2), - ("ABC", 1 | 1 << 1 | 1 << 2), - ], - flags, - ); - - assert_eq!(0, TestEmpty::FLAGS.iter().count()); -} - -mod external { - use super::*; - - #[test] - fn cases() { - let flags = TestExternal::FLAGS - .iter() - .map(|flag| (flag.name(), flag.value().bits())) - .collect::<Vec<_>>(); - - assert_eq!( - vec![ - ("A", 1u8), - ("B", 1 << 1), - ("C", 1 << 2), - ("ABC", 1 | 1 << 1 | 1 << 2), - ("", !0), - ], - flags, - ); - } -} diff --git a/vendor/bitflags/src/tests/fmt.rs b/vendor/bitflags/src/tests/fmt.rs deleted file mode 100644 index ed457187..00000000 --- a/vendor/bitflags/src/tests/fmt.rs +++ /dev/null @@ -1,97 +0,0 @@ -use super::*; - -#[test] -fn cases() { - case(TestFlags::empty(), "TestFlags(0x0)", "0", "0", "0", "0"); - case(TestFlags::A, "TestFlags(A)", "1", "1", "1", "1"); - case( - TestFlags::all(), - "TestFlags(A | B | C)", - "7", - "7", - "7", - "111", - ); - case( - TestFlags::from_bits_retain(1 << 3), - "TestFlags(0x8)", - "8", - "8", - "10", - "1000", - ); - case( - TestFlags::A | TestFlags::from_bits_retain(1 << 3), - "TestFlags(A | 0x8)", - "9", - "9", - "11", - "1001", - ); - - case(TestZero::ZERO, "TestZero(0x0)", "0", "0", "0", "0"); - case( - TestZero::ZERO | TestZero::from_bits_retain(1), - "TestZero(0x1)", - "1", - "1", - "1", - "1", - ); - - case(TestZeroOne::ONE, "TestZeroOne(ONE)", "1", "1", "1", "1"); - - case( - TestOverlapping::from_bits_retain(1 << 1), - "TestOverlapping(0x2)", - "2", - "2", - "2", - "10", - ); - - case( - TestExternal::from_bits_retain(1 | 1 << 1 | 1 << 3), - "TestExternal(A | B | 0x8)", - "B", - "b", - "13", - "1011", - ); - - case( - TestExternal::all(), - "TestExternal(A | B | C | 0xf8)", - "FF", - "ff", - "377", - "11111111", - ); - - case( - TestExternalFull::all(), - "TestExternalFull(0xff)", - "FF", - "ff", - "377", - "11111111", - ); -} - -#[track_caller] -fn case< - T: std::fmt::Debug + std::fmt::UpperHex + std::fmt::LowerHex + std::fmt::Octal + std::fmt::Binary, ->( - value: T, - debug: &str, - uhex: &str, - lhex: &str, - oct: &str, - bin: &str, -) { - assert_eq!(debug, format!("{:?}", value)); - assert_eq!(uhex, format!("{:X}", value)); - assert_eq!(lhex, format!("{:x}", value)); - assert_eq!(oct, format!("{:o}", value)); - assert_eq!(bin, format!("{:b}", value)); -} diff --git a/vendor/bitflags/src/tests/from_bits.rs b/vendor/bitflags/src/tests/from_bits.rs deleted file mode 100644 index dada9aff..00000000 --- a/vendor/bitflags/src/tests/from_bits.rs +++ /dev/null @@ -1,45 +0,0 @@ -use super::*; - -use crate::Flags; - -#[test] -fn cases() { - case(Some(0), 0, TestFlags::from_bits); - case(Some(1), 1, TestFlags::from_bits); - case( - Some(1 | 1 << 1 | 1 << 2), - 1 | 1 << 1 | 1 << 2, - TestFlags::from_bits, - ); - - case(None, 1 << 3, TestFlags::from_bits); - case(None, 1 | 1 << 3, TestFlags::from_bits); - - case(Some(1 | 1 << 1), 1 | 1 << 1, TestOverlapping::from_bits); - - case(Some(1 << 1), 1 << 1, TestOverlapping::from_bits); - - case(Some(1 << 5), 1 << 5, TestExternal::from_bits); -} - -#[track_caller] -fn case<T: Flags>( - expected: Option<T::Bits>, - input: T::Bits, - inherent: impl FnOnce(T::Bits) -> Option<T>, -) where - <T as Flags>::Bits: std::fmt::Debug + PartialEq, -{ - assert_eq!( - expected, - inherent(input).map(|f| f.bits()), - "T::from_bits({:?})", - input - ); - assert_eq!( - expected, - T::from_bits(input).map(|f| f.bits()), - "Flags::from_bits({:?})", - input - ); -} diff --git a/vendor/bitflags/src/tests/from_bits_retain.rs b/vendor/bitflags/src/tests/from_bits_retain.rs deleted file mode 100644 index 1ae28a66..00000000 --- a/vendor/bitflags/src/tests/from_bits_retain.rs +++ /dev/null @@ -1,38 +0,0 @@ -use super::*; - -use crate::Flags; - -#[test] -fn cases() { - case(0, TestFlags::from_bits_retain); - case(1, TestFlags::from_bits_retain); - case(1 | 1 << 1 | 1 << 2, TestFlags::from_bits_retain); - - case(1 << 3, TestFlags::from_bits_retain); - case(1 | 1 << 3, TestFlags::from_bits_retain); - - case(1 | 1 << 1, TestOverlapping::from_bits_retain); - - case(1 << 1, TestOverlapping::from_bits_retain); - - case(1 << 5, TestExternal::from_bits_retain); -} - -#[track_caller] -fn case<T: Flags>(input: T::Bits, inherent: impl FnOnce(T::Bits) -> T) -where - <T as Flags>::Bits: std::fmt::Debug + PartialEq, -{ - assert_eq!( - input, - inherent(input).bits(), - "T::from_bits_retain({:?})", - input - ); - assert_eq!( - input, - T::from_bits_retain(input).bits(), - "Flags::from_bits_retain({:?})", - input - ); -} diff --git a/vendor/bitflags/src/tests/from_bits_truncate.rs b/vendor/bitflags/src/tests/from_bits_truncate.rs deleted file mode 100644 index e4f3e537..00000000 --- a/vendor/bitflags/src/tests/from_bits_truncate.rs +++ /dev/null @@ -1,42 +0,0 @@ -use super::*; - -use crate::Flags; - -#[test] -fn cases() { - case(0, 0, TestFlags::from_bits_truncate); - case(1, 1, TestFlags::from_bits_truncate); - case( - 1 | 1 << 1 | 1 << 2, - 1 | 1 << 1 | 1 << 2, - TestFlags::from_bits_truncate, - ); - - case(0, 1 << 3, TestFlags::from_bits_truncate); - case(1, 1 | 1 << 3, TestFlags::from_bits_truncate); - - case(1 | 1 << 1, 1 | 1 << 1, TestOverlapping::from_bits_truncate); - - case(1 << 1, 1 << 1, TestOverlapping::from_bits_truncate); - - case(1 << 5, 1 << 5, TestExternal::from_bits_truncate); -} - -#[track_caller] -fn case<T: Flags>(expected: T::Bits, input: T::Bits, inherent: impl FnOnce(T::Bits) -> T) -where - <T as Flags>::Bits: std::fmt::Debug + PartialEq, -{ - assert_eq!( - expected, - inherent(input).bits(), - "T::from_bits_truncate({:?})", - input - ); - assert_eq!( - expected, - T::from_bits_truncate(input).bits(), - "Flags::from_bits_truncate({:?})", - input - ); -} diff --git a/vendor/bitflags/src/tests/from_name.rs b/vendor/bitflags/src/tests/from_name.rs deleted file mode 100644 index 1d9a4e48..00000000 --- a/vendor/bitflags/src/tests/from_name.rs +++ /dev/null @@ -1,42 +0,0 @@ -use super::*; - -use crate::Flags; - -#[test] -fn cases() { - case(Some(1), "A", TestFlags::from_name); - case(Some(1 << 1), "B", TestFlags::from_name); - case(Some(1 | 1 << 1 | 1 << 2), "ABC", TestFlags::from_name); - - case(None, "", TestFlags::from_name); - case(None, "a", TestFlags::from_name); - case(None, "0x1", TestFlags::from_name); - case(None, "A | B", TestFlags::from_name); - - case(Some(0), "ZERO", TestZero::from_name); - - case(Some(2), "二", TestUnicode::from_name); - - case(None, "_", TestExternal::from_name); - - case(None, "", TestExternal::from_name); -} - -#[track_caller] -fn case<T: Flags>(expected: Option<T::Bits>, input: &str, inherent: impl FnOnce(&str) -> Option<T>) -where - <T as Flags>::Bits: std::fmt::Debug + PartialEq, -{ - assert_eq!( - expected, - inherent(input).map(|f| f.bits()), - "T::from_name({:?})", - input - ); - assert_eq!( - expected, - T::from_name(input).map(|f| f.bits()), - "Flags::from_name({:?})", - input - ); -} diff --git a/vendor/bitflags/src/tests/insert.rs b/vendor/bitflags/src/tests/insert.rs deleted file mode 100644 index b18cd172..00000000 --- a/vendor/bitflags/src/tests/insert.rs +++ /dev/null @@ -1,91 +0,0 @@ -use super::*; - -use crate::Flags; - -#[test] -fn cases() { - case( - TestFlags::empty(), - &[ - (TestFlags::A, 1), - (TestFlags::A | TestFlags::B, 1 | 1 << 1), - (TestFlags::empty(), 0), - (TestFlags::from_bits_retain(1 << 3), 1 << 3), - ], - TestFlags::insert, - TestFlags::set, - ); - - case( - TestFlags::A, - &[ - (TestFlags::A, 1), - (TestFlags::empty(), 1), - (TestFlags::B, 1 | 1 << 1), - ], - TestFlags::insert, - TestFlags::set, - ); -} - -#[track_caller] -fn case<T: Flags + std::fmt::Debug + Copy>( - value: T, - inputs: &[(T, T::Bits)], - mut inherent_insert: impl FnMut(&mut T, T), - mut inherent_set: impl FnMut(&mut T, T, bool), -) where - T::Bits: std::fmt::Debug + PartialEq + Copy, -{ - for (input, expected) in inputs { - assert_eq!( - *expected, - { - let mut value = value; - inherent_insert(&mut value, *input); - value - } - .bits(), - "{:?}.insert({:?})", - value, - input - ); - assert_eq!( - *expected, - { - let mut value = value; - Flags::insert(&mut value, *input); - value - } - .bits(), - "Flags::insert({:?}, {:?})", - value, - input - ); - - assert_eq!( - *expected, - { - let mut value = value; - inherent_set(&mut value, *input, true); - value - } - .bits(), - "{:?}.set({:?}, true)", - value, - input - ); - assert_eq!( - *expected, - { - let mut value = value; - Flags::set(&mut value, *input, true); - value - } - .bits(), - "Flags::set({:?}, {:?}, true)", - value, - input - ); - } -} diff --git a/vendor/bitflags/src/tests/intersection.rs b/vendor/bitflags/src/tests/intersection.rs deleted file mode 100644 index 10a8ae9f..00000000 --- a/vendor/bitflags/src/tests/intersection.rs +++ /dev/null @@ -1,79 +0,0 @@ -use super::*; - -use crate::Flags; - -#[test] -fn cases() { - case( - TestFlags::empty(), - &[(TestFlags::empty(), 0), (TestFlags::all(), 0)], - TestFlags::intersection, - ); - - case( - TestFlags::all(), - &[ - (TestFlags::all(), 1 | 1 << 1 | 1 << 2), - (TestFlags::A, 1), - (TestFlags::from_bits_retain(1 << 3), 0), - ], - TestFlags::intersection, - ); - - case( - TestFlags::from_bits_retain(1 << 3), - &[(TestFlags::from_bits_retain(1 << 3), 1 << 3)], - TestFlags::intersection, - ); - - case( - TestOverlapping::AB, - &[(TestOverlapping::BC, 1 << 1)], - TestOverlapping::intersection, - ); -} - -#[track_caller] -fn case<T: Flags + std::fmt::Debug + std::ops::BitAnd<Output = T> + std::ops::BitAndAssign + Copy>( - value: T, - inputs: &[(T, T::Bits)], - mut inherent: impl FnMut(T, T) -> T, -) where - T::Bits: std::fmt::Debug + PartialEq + Copy, -{ - for (input, expected) in inputs { - assert_eq!( - *expected, - inherent(value, *input).bits(), - "{:?}.intersection({:?})", - value, - input - ); - assert_eq!( - *expected, - Flags::intersection(value, *input).bits(), - "Flags::intersection({:?}, {:?})", - value, - input - ); - assert_eq!( - *expected, - (value & *input).bits(), - "{:?} & {:?}", - value, - input - ); - assert_eq!( - *expected, - { - let mut value = value; - value &= *input; - value - } - .bits(), - "{:?} &= {:?}", - value, - input, - ); - } -} diff --git a/vendor/bitflags/src/tests/intersects.rs b/vendor/bitflags/src/tests/intersects.rs deleted file mode 100644 index fe907981..00000000 --- a/vendor/bitflags/src/tests/intersects.rs +++ /dev/null @@ -1,91 +0,0 @@ -use super::*; - -use crate::Flags; - -#[test] -fn cases() { - case( - TestFlags::empty(), - &[ - (TestFlags::empty(), false), - (TestFlags::A, false), - (TestFlags::B, false), - (TestFlags::C, false), - (TestFlags::from_bits_retain(1 << 3), false), - ], - TestFlags::intersects, - ); - - case( - TestFlags::A, - &[ - (TestFlags::empty(), false), - (TestFlags::A, true), - (TestFlags::B, false), - (TestFlags::C, false), - (TestFlags::ABC, true), - (TestFlags::from_bits_retain(1 << 3), false), - (TestFlags::from_bits_retain(1 | (1 << 3)), true), - ], - TestFlags::intersects, - ); - - case( - TestFlags::ABC, - &[ - (TestFlags::empty(), false), - (TestFlags::A, true), - (TestFlags::B, true), - (TestFlags::C, true), - (TestFlags::ABC, true), - (TestFlags::from_bits_retain(1 << 3), false), - ], - TestFlags::intersects, - ); - - case( - TestFlags::from_bits_retain(1 << 3), - &[ - (TestFlags::empty(), false), - (TestFlags::A, false), - (TestFlags::B, false), - (TestFlags::C, false), - (TestFlags::from_bits_retain(1 << 3), true), - ], - TestFlags::intersects, - ); - - case( - TestOverlapping::AB, - &[ - (TestOverlapping::AB, true), - (TestOverlapping::BC, true), - (TestOverlapping::from_bits_retain(1 << 1), true), - ], - TestOverlapping::intersects, - ); -} - -#[track_caller] -fn case<T: Flags + std::fmt::Debug + Copy>( - value: T, - inputs: &[(T, bool)], - mut inherent: impl FnMut(&T, T) -> bool, -) { - for (input, expected) in inputs { - assert_eq!( - *expected, - inherent(&value, *input), - "{:?}.intersects({:?})", - value, - input - ); - assert_eq!( - *expected, - Flags::intersects(&value, *input), - "Flags::intersects({:?}, {:?})", - value, - input - ); - } -} diff --git a/vendor/bitflags/src/tests/is_all.rs b/vendor/bitflags/src/tests/is_all.rs deleted file mode 100644 index 382a458f..00000000 --- a/vendor/bitflags/src/tests/is_all.rs +++ /dev/null @@ -1,32 +0,0 @@ -use super::*; - -use crate::Flags; - -#[test] -fn cases() { - case(false, TestFlags::empty(), TestFlags::is_all); - case(false, TestFlags::A, TestFlags::is_all); - - case(true, TestFlags::ABC, TestFlags::is_all); - - case( - true, - TestFlags::ABC | TestFlags::from_bits_retain(1 << 3), - TestFlags::is_all, - ); - - case(true, TestZero::empty(), TestZero::is_all); - - case(true, TestEmpty::empty(), TestEmpty::is_all); -} - -#[track_caller] -fn case<T: Flags + std::fmt::Debug>(expected: bool, value: T, inherent: impl FnOnce(&T) -> bool) { - assert_eq!(expected, inherent(&value), "{:?}.is_all()", value); - assert_eq!( - expected, - Flags::is_all(&value), - "Flags::is_all({:?})", - value - ); -} diff --git a/vendor/bitflags/src/tests/is_empty.rs b/vendor/bitflags/src/tests/is_empty.rs deleted file mode 100644 index 92165f18..00000000 --- a/vendor/bitflags/src/tests/is_empty.rs +++ /dev/null @@ -1,31 +0,0 @@ -use super::*; - -use crate::Flags; - -#[test] -fn cases() { - case(true, TestFlags::empty(), TestFlags::is_empty); - - case(false, TestFlags::A, TestFlags::is_empty); - case(false, TestFlags::ABC, TestFlags::is_empty); - case( - false, - TestFlags::from_bits_retain(1 << 3), - TestFlags::is_empty, - ); - - case(true, TestZero::empty(), TestZero::is_empty); - - case(true, TestEmpty::empty(), TestEmpty::is_empty); -} - -#[track_caller] -fn case<T: Flags + std::fmt::Debug>(expected: bool, value: T, inherent: impl FnOnce(&T) -> bool) { - assert_eq!(expected, inherent(&value), "{:?}.is_empty()", value); - assert_eq!( - expected, - Flags::is_empty(&value), - "Flags::is_empty({:?})", - value - ); -} diff --git a/vendor/bitflags/src/tests/iter.rs b/vendor/bitflags/src/tests/iter.rs deleted file mode 100644 index 54b1d27d..00000000 --- a/vendor/bitflags/src/tests/iter.rs +++ /dev/null @@ -1,209 +0,0 @@ -use super::*; - -use crate::Flags; - -#[test] -#[cfg(not(miri))] // Very slow in miri -fn roundtrip() { - for a in 0u8..=255 { - for b in 0u8..=255 { - let f = TestFlags::from_bits_retain(a | b); - - assert_eq!(f, f.iter().collect::<TestFlags>()); - assert_eq!( - TestFlags::from_bits_truncate(f.bits()), - f.iter_names().map(|(_, f)| f).collect::<TestFlags>() - ); - - let f = TestExternal::from_bits_retain(a | b); - - assert_eq!(f, f.iter().collect::<TestExternal>()); - } - } -} - -mod collect { - use super::*; - - #[test] - fn cases() { - assert_eq!(0, [].into_iter().collect::<TestFlags>().bits()); - - assert_eq!(1, [TestFlags::A,].into_iter().collect::<TestFlags>().bits()); - - assert_eq!( - 1 | 1 << 1 | 1 << 2, - [TestFlags::A, TestFlags::B | TestFlags::C,] - .into_iter() - .collect::<TestFlags>() - .bits() - ); - - assert_eq!( - 1 | 1 << 3, - [ - TestFlags::from_bits_retain(1 << 3), - TestFlags::empty(), - TestFlags::A, - ] - .into_iter() - .collect::<TestFlags>() - .bits() - ); - - assert_eq!( - 1 << 5 | 1 << 7, - [ - TestExternal::empty(), - TestExternal::from_bits_retain(1 << 5), - TestExternal::from_bits_retain(1 << 7), - ] - .into_iter() - .collect::<TestExternal>() - .bits() - ); - } -} - -mod iter { - use super::*; - - #[test] - fn cases() { - case(&[], TestFlags::empty(), TestFlags::iter); - - case(&[1], TestFlags::A, TestFlags::iter); - case(&[1, 1 << 1], TestFlags::A | TestFlags::B, TestFlags::iter); - case( - &[1, 1 << 1, 1 << 3], - TestFlags::A | TestFlags::B | TestFlags::from_bits_retain(1 << 3), - TestFlags::iter, - ); - - case(&[1, 1 << 1, 1 << 2], TestFlags::ABC, TestFlags::iter); - case( - &[1, 1 << 1, 1 << 2, 1 << 3], - TestFlags::ABC | TestFlags::from_bits_retain(1 << 3), - TestFlags::iter, - ); - - case( - &[1 | 1 << 1 | 1 << 2], - TestFlagsInvert::ABC, - TestFlagsInvert::iter, - ); - - case(&[], TestZero::ZERO, TestZero::iter); - - case( - &[1, 1 << 1, 1 << 2, 0b1111_1000], - TestExternal::all(), - TestExternal::iter, - ); - } - - #[track_caller] - fn case<T: Flags + std::fmt::Debug + IntoIterator<Item = T> + Copy>( - expected: &[T::Bits], - value: T, - inherent: impl FnOnce(&T) -> crate::iter::Iter<T>, - ) where - T::Bits: std::fmt::Debug + PartialEq, - { - assert_eq!( - expected, - inherent(&value).map(|f| f.bits()).collect::<Vec<_>>(), - "{:?}.iter()", - value - ); - assert_eq!( - expected, - Flags::iter(&value).map(|f| f.bits()).collect::<Vec<_>>(), - "Flags::iter({:?})", - value - ); - assert_eq!( - expected, - value.into_iter().map(|f| f.bits()).collect::<Vec<_>>(), - "{:?}.into_iter()", - value - ); - } -} - -mod iter_names { - use super::*; - - #[test] - fn cases() { - case(&[], TestFlags::empty(), TestFlags::iter_names); - - case(&[("A", 1)], TestFlags::A, TestFlags::iter_names); - case( - &[("A", 1), ("B", 1 << 1)], - TestFlags::A | TestFlags::B, - TestFlags::iter_names, - ); - case( - &[("A", 1), ("B", 1 << 1)], - TestFlags::A | TestFlags::B | TestFlags::from_bits_retain(1 << 3), - TestFlags::iter_names, - ); - - case( - &[("A", 1), ("B", 1 << 1), ("C", 1 << 2)], - TestFlags::ABC, - TestFlags::iter_names, - ); - case( - &[("A", 1), ("B", 1 << 1), ("C", 1 << 2)], - TestFlags::ABC | TestFlags::from_bits_retain(1 << 3), - TestFlags::iter_names, - ); - - case( - &[("ABC", 1 | 1 << 1 | 1 << 2)], - TestFlagsInvert::ABC, - TestFlagsInvert::iter_names, - ); - - case(&[], TestZero::ZERO, TestZero::iter_names); - - case( - &[("A", 1)], - TestOverlappingFull::A, - TestOverlappingFull::iter_names, - ); - case( - &[("A", 1), ("D", 1 << 1)], - TestOverlappingFull::A | TestOverlappingFull::D, - TestOverlappingFull::iter_names, - ); - } - - #[track_caller] - fn case<T: Flags + std::fmt::Debug>( - expected: &[(&'static str, T::Bits)], - value: T, - inherent: impl FnOnce(&T) -> crate::iter::IterNames<T>, - ) where - T::Bits: std::fmt::Debug + PartialEq, - { - assert_eq!( - expected, - inherent(&value) - .map(|(n, f)| (n, f.bits())) - .collect::<Vec<_>>(), - "{:?}.iter_names()", - value - ); - assert_eq!( - expected, - Flags::iter_names(&value) - .map(|(n, f)| (n, f.bits())) - .collect::<Vec<_>>(), - "Flags::iter_names({:?})", - value - ); - } -} diff --git a/vendor/bitflags/src/tests/parser.rs b/vendor/bitflags/src/tests/parser.rs deleted file mode 100644 index fb27225e..00000000 --- a/vendor/bitflags/src/tests/parser.rs +++ /dev/null @@ -1,332 +0,0 @@ -use super::*; - -use crate::{parser::*, Flags}; - -#[test] -#[cfg(not(miri))] // Very slow in miri -fn roundtrip() { - let mut s = String::new(); - - for a in 0u8..=255 { - for b in 0u8..=255 { - let f = TestFlags::from_bits_retain(a | b); - - s.clear(); - to_writer(&f, &mut s).unwrap(); - - assert_eq!(f, from_str::<TestFlags>(&s).unwrap()); - } - } -} - -#[test] -#[cfg(not(miri))] // Very slow in miri -fn roundtrip_truncate() { - let mut s = String::new(); - - for a in 0u8..=255 { - for b in 0u8..=255 { - let f = TestFlags::from_bits_retain(a | b); - - s.clear(); - to_writer_truncate(&f, &mut s).unwrap(); - - assert_eq!( - TestFlags::from_bits_truncate(f.bits()), - from_str_truncate::<TestFlags>(&s).unwrap() - ); - } - } -} - -#[test] -#[cfg(not(miri))] // Very slow in miri -fn roundtrip_strict() { - let mut s = String::new(); - - for a in 0u8..=255 { - for b in 0u8..=255 { - let f = TestFlags::from_bits_retain(a | b); - - s.clear(); - to_writer_strict(&f, &mut s).unwrap(); - - let mut strict = TestFlags::empty(); - for (_, flag) in f.iter_names() { - strict |= flag; - } - let f = strict; - - if let Ok(s) = from_str_strict::<TestFlags>(&s) { - assert_eq!(f, s); - } - } - } -} - -mod from_str { - use super::*; - - #[test] - fn valid() { - assert_eq!(0, from_str::<TestFlags>("").unwrap().bits()); - - assert_eq!(1, from_str::<TestFlags>("A").unwrap().bits()); - assert_eq!(1, from_str::<TestFlags>(" A ").unwrap().bits()); - assert_eq!( - 1 | 1 << 1 | 1 << 2, - from_str::<TestFlags>("A | B | C").unwrap().bits() - ); - assert_eq!( - 1 | 1 << 1 | 1 << 2, - from_str::<TestFlags>("A\n|\tB\r\n| C ").unwrap().bits() - ); - assert_eq!( - 1 | 1 << 1 | 1 << 2, - from_str::<TestFlags>("A|B|C").unwrap().bits() - ); - - assert_eq!(1 << 3, from_str::<TestFlags>("0x8").unwrap().bits()); - assert_eq!(1 | 1 << 3, from_str::<TestFlags>("A | 0x8").unwrap().bits()); - assert_eq!( - 1 | 1 << 1 | 1 << 3, - from_str::<TestFlags>("0x1 | 0x8 | B").unwrap().bits() - ); - - assert_eq!( - 1 | 1 << 1, - from_str::<TestUnicode>("一 | 二").unwrap().bits() - ); - } - - #[test] - fn invalid() { - assert!(from_str::<TestFlags>("a") - .unwrap_err() - .to_string() - .starts_with("unrecognized named flag")); - assert!(from_str::<TestFlags>("A & B") - .unwrap_err() - .to_string() - .starts_with("unrecognized named flag")); - - assert!(from_str::<TestFlags>("0xg") - .unwrap_err() - .to_string() - .starts_with("invalid hex flag")); - assert!(from_str::<TestFlags>("0xffffffffffff") - .unwrap_err() - .to_string() - .starts_with("invalid hex flag")); - } -} - -mod to_writer { - use super::*; - - #[test] - fn cases() { - assert_eq!("", write(TestFlags::empty())); - assert_eq!("A", write(TestFlags::A)); - assert_eq!("A | B | C", write(TestFlags::all())); - assert_eq!("0x8", write(TestFlags::from_bits_retain(1 << 3))); - assert_eq!( - "A | 0x8", - write(TestFlags::A | TestFlags::from_bits_retain(1 << 3)) - ); - - assert_eq!("", write(TestZero::ZERO)); - - assert_eq!("ABC", write(TestFlagsInvert::all())); - - assert_eq!("0x1", write(TestOverlapping::from_bits_retain(1))); - - assert_eq!("A", write(TestOverlappingFull::C)); - assert_eq!( - "A | D", - write(TestOverlappingFull::C | TestOverlappingFull::D) - ); - } - - fn write<F: Flags>(value: F) -> String - where - F::Bits: crate::parser::WriteHex, - { - let mut s = String::new(); - - to_writer(&value, &mut s).unwrap(); - s - } -} - -mod from_str_truncate { - use super::*; - - #[test] - fn valid() { - assert_eq!(0, from_str_truncate::<TestFlags>("").unwrap().bits()); - - assert_eq!(1, from_str_truncate::<TestFlags>("A").unwrap().bits()); - assert_eq!(1, from_str_truncate::<TestFlags>(" A ").unwrap().bits()); - assert_eq!( - 1 | 1 << 1 | 1 << 2, - from_str_truncate::<TestFlags>("A | B | C").unwrap().bits() - ); - assert_eq!( - 1 | 1 << 1 | 1 << 2, - from_str_truncate::<TestFlags>("A\n|\tB\r\n| C ") - .unwrap() - .bits() - ); - assert_eq!( - 1 | 1 << 1 | 1 << 2, - from_str_truncate::<TestFlags>("A|B|C").unwrap().bits() - ); - - assert_eq!(0, from_str_truncate::<TestFlags>("0x8").unwrap().bits()); - assert_eq!(1, from_str_truncate::<TestFlags>("A | 0x8").unwrap().bits()); - assert_eq!( - 1 | 1 << 1, - from_str_truncate::<TestFlags>("0x1 | 0x8 | B") - .unwrap() - .bits() - ); - - assert_eq!( - 1 | 1 << 1, - from_str_truncate::<TestUnicode>("一 | 二").unwrap().bits() - ); - } -} - -mod to_writer_truncate { - use super::*; - - #[test] - fn cases() { - assert_eq!("", write(TestFlags::empty())); - assert_eq!("A", write(TestFlags::A)); - assert_eq!("A | B | C", write(TestFlags::all())); - assert_eq!("", write(TestFlags::from_bits_retain(1 << 3))); - assert_eq!( - "A", - write(TestFlags::A | TestFlags::from_bits_retain(1 << 3)) - ); - - assert_eq!("", write(TestZero::ZERO)); - - assert_eq!("ABC", write(TestFlagsInvert::all())); - - assert_eq!("0x1", write(TestOverlapping::from_bits_retain(1))); - - assert_eq!("A", write(TestOverlappingFull::C)); - assert_eq!( - "A | D", - write(TestOverlappingFull::C | TestOverlappingFull::D) - ); - } - - fn write<F: Flags>(value: F) -> String - where - F::Bits: crate::parser::WriteHex, - { - let mut s = String::new(); - - to_writer_truncate(&value, &mut s).unwrap(); - s - } -} - -mod from_str_strict { - use super::*; - - #[test] - fn valid() { - assert_eq!(0, from_str_strict::<TestFlags>("").unwrap().bits()); - - assert_eq!(1, from_str_strict::<TestFlags>("A").unwrap().bits()); - assert_eq!(1, from_str_strict::<TestFlags>(" A ").unwrap().bits()); - assert_eq!( - 1 | 1 << 1 | 1 << 2, - from_str_strict::<TestFlags>("A | B | C").unwrap().bits() - ); - assert_eq!( - 1 | 1 << 1 | 1 << 2, - from_str_strict::<TestFlags>("A\n|\tB\r\n| C ") - .unwrap() - .bits() - ); - assert_eq!( - 1 | 1 << 1 | 1 << 2, - from_str_strict::<TestFlags>("A|B|C").unwrap().bits() - ); - - assert_eq!( - 1 | 1 << 1, - from_str_strict::<TestUnicode>("一 | 二").unwrap().bits() - ); - } - - #[test] - fn invalid() { - assert!(from_str_strict::<TestFlags>("a") - .unwrap_err() - .to_string() - .starts_with("unrecognized named flag")); - assert!(from_str_strict::<TestFlags>("A & B") - .unwrap_err() - .to_string() - .starts_with("unrecognized named flag")); - - assert!(from_str_strict::<TestFlags>("0x1") - .unwrap_err() - .to_string() - .starts_with("invalid hex flag")); - assert!(from_str_strict::<TestFlags>("0xg") - .unwrap_err() - .to_string() - .starts_with("invalid hex flag")); - assert!(from_str_strict::<TestFlags>("0xffffffffffff") - .unwrap_err() - .to_string() - .starts_with("invalid hex flag")); - } -} - -mod to_writer_strict { - use super::*; - - #[test] - fn cases() { - assert_eq!("", write(TestFlags::empty())); - assert_eq!("A", write(TestFlags::A)); - assert_eq!("A | B | C", write(TestFlags::all())); - assert_eq!("", write(TestFlags::from_bits_retain(1 << 3))); - assert_eq!( - "A", - write(TestFlags::A | TestFlags::from_bits_retain(1 << 3)) - ); - - assert_eq!("", write(TestZero::ZERO)); - - assert_eq!("ABC", write(TestFlagsInvert::all())); - - assert_eq!("", write(TestOverlapping::from_bits_retain(1))); - - assert_eq!("A", write(TestOverlappingFull::C)); - assert_eq!( - "A | D", - write(TestOverlappingFull::C | TestOverlappingFull::D) - ); - } - - fn write<F: Flags>(value: F) -> String - where - F::Bits: crate::parser::WriteHex, - { - let mut s = String::new(); - - to_writer_strict(&value, &mut s).unwrap(); - s - } -} diff --git a/vendor/bitflags/src/tests/remove.rs b/vendor/bitflags/src/tests/remove.rs deleted file mode 100644 index 574b1edb..00000000 --- a/vendor/bitflags/src/tests/remove.rs +++ /dev/null @@ -1,100 +0,0 @@ -use super::*; - -use crate::Flags; - -#[test] -fn cases() { - case( - TestFlags::empty(), - &[ - (TestFlags::A, 0), - (TestFlags::empty(), 0), - (TestFlags::from_bits_retain(1 << 3), 0), - ], - TestFlags::remove, - TestFlags::set, - ); - - case( - TestFlags::A, - &[ - (TestFlags::A, 0), - (TestFlags::empty(), 1), - (TestFlags::B, 1), - ], - TestFlags::remove, - TestFlags::set, - ); - - case( - TestFlags::ABC, - &[ - (TestFlags::A, 1 << 1 | 1 << 2), - (TestFlags::A | TestFlags::C, 1 << 1), - ], - TestFlags::remove, - TestFlags::set, - ); -} - -#[track_caller] -fn case<T: Flags + std::fmt::Debug + Copy>( - value: T, - inputs: &[(T, T::Bits)], - mut inherent_remove: impl FnMut(&mut T, T), - mut inherent_set: impl FnMut(&mut T, T, bool), -) where - T::Bits: std::fmt::Debug + PartialEq + Copy, -{ - for (input, expected) in inputs { - assert_eq!( - *expected, - { - let mut value = value; - inherent_remove(&mut value, *input); - value - } - .bits(), - "{:?}.remove({:?})", - value, - input - ); - assert_eq!( - *expected, - { - let mut value = value; - Flags::remove(&mut value, *input); - value - } - .bits(), - "Flags::remove({:?}, {:?})", - value, - input - ); - - assert_eq!( - *expected, - { - let mut value = value; - inherent_set(&mut value, *input, false); - value - } - .bits(), - "{:?}.set({:?}, false)", - value, - input - ); - assert_eq!( - *expected, - { - let mut value = value; - Flags::set(&mut value, *input, false); - value - } - .bits(), - "Flags::set({:?}, {:?}, false)", - value, - input - ); - } -} diff --git a/vendor/bitflags/src/tests/symmetric_difference.rs b/vendor/bitflags/src/tests/symmetric_difference.rs deleted file mode 100644 index 75e9123a..00000000 --- a/vendor/bitflags/src/tests/symmetric_difference.rs +++ /dev/null @@ -1,110 +0,0 @@ -use super::*; - -use crate::Flags; - -#[test] -fn cases() { - case( - TestFlags::empty(), - &[ - (TestFlags::empty(), 0), - (TestFlags::all(), 1 | 1 << 1 | 1 << 2), - (TestFlags::from_bits_retain(1 << 3), 1 << 3), - ], - TestFlags::symmetric_difference, - TestFlags::toggle, - ); - - case( - TestFlags::A, - &[ - (TestFlags::empty(), 1), - (TestFlags::A, 0), - (TestFlags::all(), 1 << 1 | 1 << 2), - ], - TestFlags::symmetric_difference, - TestFlags::toggle, - ); - - case( - TestFlags::A | TestFlags::B | TestFlags::from_bits_retain(1 << 3), - &[ - (TestFlags::ABC, 1 << 2 | 1 << 3), - (TestFlags::from_bits_retain(1 << 3), 1 | 1 << 1), - ], - TestFlags::symmetric_difference, - TestFlags::toggle, - ); -} - -#[track_caller] -fn case<T: Flags + std::fmt::Debug + std::ops::BitXor<Output = T> + std::ops::BitXorAssign + Copy>( - value: T, - inputs: &[(T, T::Bits)], - mut inherent_sym_diff: impl FnMut(T, T) -> T, - mut inherent_toggle: impl FnMut(&mut T, T), -) where - T::Bits: std::fmt::Debug + PartialEq + Copy, -{ - for (input, expected) in inputs { - assert_eq!( - *expected, - inherent_sym_diff(value, *input).bits(), - "{:?}.symmetric_difference({:?})", - value, - input - ); - assert_eq!( - *expected, - Flags::symmetric_difference(value, *input).bits(), - "Flags::symmetric_difference({:?}, {:?})", - value, - input - ); - assert_eq!( - *expected, - (value ^ *input).bits(), - "{:?} ^ {:?}", - value, - input - ); - assert_eq!( - *expected, - { - let mut value = value; - value ^= *input; - value - } - .bits(), - "{:?} ^= {:?}", - value, - input, - ); - - assert_eq!( - *expected, - { - let mut value = value; - inherent_toggle(&mut value, *input); - value - } - .bits(), - "{:?}.toggle({:?})", - value, - input, - ); - - assert_eq!( - *expected, - { - let mut value = value; - Flags::toggle(&mut value, *input); - value - } - .bits(), - "{:?}.toggle({:?})", - value, - input, - ); - } -} diff --git a/vendor/bitflags/src/tests/truncate.rs b/vendor/bitflags/src/tests/truncate.rs deleted file mode 100644 index e38df48d..00000000 --- a/vendor/bitflags/src/tests/truncate.rs +++ /dev/null @@ -1,29 +0,0 @@ -use super::*; - -use crate::Flags; - -#[test] -fn cases() { - case( - TestFlags::ABC | TestFlags::from_bits_retain(1 << 3), - TestFlags::ABC, - ); - - case(TestZero::empty(), TestZero::empty()); - - case(TestZero::all(), TestZero::all()); - - case( - TestFlags::from_bits_retain(1 << 3) | TestFlags::all(), - TestFlags::all(), - ); -} - -#[track_caller] -fn case<T: Flags + std::fmt::Debug>(mut before: T, after: T) -where - T: std::fmt::Debug + PartialEq + Copy, -{ - before.truncate(); - assert_eq!(before, after, "{:?}.truncate()", before); -} diff --git a/vendor/bitflags/src/tests/union.rs b/vendor/bitflags/src/tests/union.rs deleted file mode 100644 index 61906819..00000000 --- a/vendor/bitflags/src/tests/union.rs +++ /dev/null @@ -1,71 +0,0 @@ -use super::*; - -use crate::Flags; - -#[test] -fn cases() { - case( - TestFlags::empty(), - &[ - (TestFlags::A, 1), - (TestFlags::all(), 1 | 1 << 1 | 1 << 2), - (TestFlags::empty(), 0), - (TestFlags::from_bits_retain(1 << 3), 1 << 3), - ], - TestFlags::union, - ); - - case( - TestFlags::A | TestFlags::C, - &[ - (TestFlags::A | TestFlags::B, 1 | 1 << 1 | 1 << 2), - (TestFlags::A, 1 | 1 << 2), - ], - TestFlags::union, - ); -} - -#[track_caller] -fn case<T: Flags + std::fmt::Debug + std::ops::BitOr<Output = T> + std::ops::BitOrAssign + Copy>( - value: T, - inputs: &[(T, T::Bits)], - mut inherent: impl FnMut(T, T) -> T, -) where - T::Bits: std::fmt::Debug + PartialEq + Copy, -{ - for (input, expected) in inputs { - assert_eq!( - *expected, - inherent(value, *input).bits(), - "{:?}.union({:?})", - value, - input - ); - assert_eq!( - *expected, - Flags::union(value, *input).bits(), - "Flags::union({:?}, {:?})", - value, - input - ); - assert_eq!( - *expected, - (value | *input).bits(), - "{:?} | {:?}", - value, - input - ); - assert_eq!( - *expected, - { - let mut value = value; - value |= *input; - value - } - .bits(), - "{:?} |= {:?}", - value, - input, - ); - } -} diff --git a/vendor/bitflags/src/tests/unknown.rs b/vendor/bitflags/src/tests/unknown.rs deleted file mode 100644 index 020f7e92..00000000 --- a/vendor/bitflags/src/tests/unknown.rs +++ /dev/null @@ -1,40 +0,0 @@ -use super::*; - -use crate::Flags; - -#[test] -fn cases() { - case(false, TestFlags::empty(), TestFlags::contains_unknown_bits); - case(false, TestFlags::A, TestFlags::contains_unknown_bits); - - case( - true, - TestFlags::ABC | TestFlags::from_bits_retain(1 << 3), - TestFlags::contains_unknown_bits, - ); - - case( - true, - TestFlags::empty() | TestFlags::from_bits_retain(1 << 3), - TestFlags::contains_unknown_bits, - ); - - case(false, TestFlags::all(), TestFlags::contains_unknown_bits); - - case(false, TestZero::empty(), TestZero::contains_unknown_bits); -} -#[track_caller] -fn case<T: Flags + std::fmt::Debug>(expected: bool, value: T, inherent: impl FnOnce(&T) -> bool) { - assert_eq!( - expected, - inherent(&value), - "{:?}.contains_unknown_bits()", - value - ); - assert_eq!( - expected, - Flags::contains_unknown_bits(&value), - "Flags::contains_unknown_bits({:?})", - value - ); -} |