1 files changed, 130 insertions, 0 deletions
diff --git a/third_party/rust/packed_simd/src/testing/utils.rs b/third_party/rust/packed_simd/src/testing/utils.rs
new file mode 100644
index 0000000000..7d8f395739
--- /dev/null
+++ b/third_party/rust/packed_simd/src/testing/utils.rs
@@ -0,0 +1,130 @@
+//! Testing utilities
+
+#![allow(dead_code)]
+// FIXME: Or don't. But it's true this is a problematic comparison.
+#![allow(clippy::neg_cmp_op_on_partial_ord)]
+
+use crate::{cmp::PartialOrd, fmt::Debug, LexicographicallyOrdered};
+
+/// Tests PartialOrd for `a` and `b` where `a < b` is true.
+pub fn test_lt<T>(a: LexicographicallyOrdered<T>, b: LexicographicallyOrdered<T>)
+where
+    LexicographicallyOrdered<T>: Debug + PartialOrd,
+{
+    assert!(a < b, "{:?}, {:?}", a, b);
+    assert!(b > a, "{:?}, {:?}", a, b);
+
+    assert!(!(a == b), "{:?}, {:?}", a, b);
+    assert_ne!(a, b, "{:?}, {:?}", a, b);
+
+    assert!(a <= b, "{:?}, {:?}", a, b);
+    assert!(b >= a, "{:?}, {:?}", a, b);
+
+    // The elegance of the mathematical expression of irreflexivity is more
+    // than clippy can handle.
+    #[allow(clippy::eq_op)]
+    {
+        // Irreflexivity
+        assert!(!(a < a), "{:?}, {:?}", a, b);
+        assert!(!(b < b), "{:?}, {:?}", a, b);
+        assert!(!(a > a), "{:?}, {:?}", a, b);
+        assert!(!(b > b), "{:?}, {:?}", a, b);
+
+        assert!(a <= a, "{:?}, {:?}", a, b);
+        assert!(b <= b, "{:?}, {:?}", a, b);
+    }
+}
+
+/// Tests PartialOrd for `a` and `b` where `a <= b` is true.
+pub fn test_le<T>(a: LexicographicallyOrdered<T>, b: LexicographicallyOrdered<T>)
+where
+    LexicographicallyOrdered<T>: Debug + PartialOrd,
+{
+    assert!(a <= b, "{:?}, {:?}", a, b);
+    assert!(b >= a, "{:?}, {:?}", a, b);
+
+    assert!(a <= b, "{:?}, {:?}", a, b);
+    assert!(b >= a, "{:?}, {:?}", a, b);
+
+    if a == b {
+        assert!(!(a < b), "{:?}, {:?}", a, b);
+        assert!(!(b > a), "{:?}, {:?}", a, b);
+
+        assert!(!(a != b), "{:?}, {:?}", a, b);
+    } else {
+        assert_ne!(a, b, "{:?}, {:?}", a, b);
+        test_lt(a, b);
+    }
+}
+
+/// Test PartialOrd::partial_cmp for `a` and `b` returning `Ordering`
+pub fn test_cmp<T>(
+    a: LexicographicallyOrdered<T>,
+    b: LexicographicallyOrdered<T>,
+    o: Option<crate::cmp::Ordering>,
+) where
+    LexicographicallyOrdered<T>: PartialOrd + Debug,
+    T: Debug + crate::sealed::Simd + Copy + Clone,
+    <T as crate::sealed::Simd>::Element: Default + Copy + Clone + PartialOrd,
+{
+    assert!(T::LANES <= 64, "array length in these two arrays needs updating");
+    let mut arr_a: [T::Element; 64] = [Default::default(); 64];
+    let mut arr_b: [T::Element; 64] = [Default::default(); 64];
+
+    unsafe { crate::ptr::write_unaligned(arr_a.as_mut_ptr() as *mut LexicographicallyOrdered<T>, a) }
+    unsafe { crate::ptr::write_unaligned(arr_b.as_mut_ptr() as *mut LexicographicallyOrdered<T>, b) }
+    let expected = arr_a[0..T::LANES].partial_cmp(&arr_b[0..T::LANES]);
+    let result = a.partial_cmp(&b);
+    assert_eq!(expected, result, "{:?}, {:?}", a, b);
+    assert_eq!(o, result, "{:?}, {:?}", a, b);
+    match o {
+        Some(crate::cmp::Ordering::Less) => {
+            test_lt(a, b);
+            test_le(a, b);
+        }
+        Some(crate::cmp::Ordering::Greater) => {
+            test_lt(b, a);
+            test_le(b, a);
+        }
+        Some(crate::cmp::Ordering::Equal) => {
+            assert!(a == b, "{:?}, {:?}", a, b);
+            assert!(!(a != b), "{:?}, {:?}", a, b);
+            assert!(!(a < b), "{:?}, {:?}", a, b);
+            assert!(!(b < a), "{:?}, {:?}", a, b);
+            assert!(!(a > b), "{:?}, {:?}", a, b);
+            assert!(!(b > a), "{:?}, {:?}", a, b);
+
+            test_le(a, b);
+            test_le(b, a);
+        }
+        None => {
+            assert!(!(a == b), "{:?}, {:?}", a, b);
+            assert!(!(a != b), "{:?}, {:?}", a, b);
+            assert!(!(a < b), "{:?}, {:?}", a, b);
+            assert!(!(a > b), "{:?}, {:?}", a, b);
+            assert!(!(b < a), "{:?}, {:?}", a, b);
+            assert!(!(b > a), "{:?}, {:?}", a, b);
+            assert!(!(a <= b), "{:?}, {:?}", a, b);
+            assert!(!(b <= a), "{:?}, {:?}", a, b);
+            assert!(!(a >= b), "{:?}, {:?}", a, b);
+            assert!(!(b >= a), "{:?}, {:?}", a, b);
+        }
+    }
+}
+
+// Returns a tuple containing two distinct pointer values of the same type as
+// the element type of the Simd vector `$id`.
+#[allow(unused)]
+macro_rules! ptr_vals {
+    ($id:ty) => {
+        // expands to an expression
+        #[allow(unused_unsafe)]
+        unsafe {
+            // all bits cleared
+            let clear: <$id as sealed::Simd>::Element = crate::mem::zeroed();
+            // all bits set
+            let set: <$id as sealed::Simd>::Element = crate::mem::transmute(-1_isize);
+            (clear, set)
+        }
+    };
+}