split out tests

Author: BoxyUwU

compiler/rustc_data_structures/src/tagged_ptr/covariant.rs

@@ -321,56 +321,4 @@ where
 const _: () = ();
 
 #[cfg(test)]
-mod tests {
-    use std::ptr;
-
-    use super::*;
-    use crate::hashes::Hash128;
-    use crate::stable_hasher::{HashStable, StableHasher};
-    use crate::tagged_ptr::tests::Tag2;
-
-    #[test]
-    fn smoke() {
-        let value = 12u32;
-        let reference = &value;
-        let tag = Tag2::B01;
-
-        let ptr = tag_ptr(reference, tag);
-
-        assert_eq!(ptr.tag(), tag);
-        assert_eq!(*ptr, 12);
-        assert!(ptr::eq(ptr.pointer(), reference));
-
-        let copy = ptr;
-
-        let mut ptr = ptr;
-        ptr.set_tag(Tag2::B00);
-        assert_eq!(ptr.tag(), Tag2::B00);
-
-        assert_eq!(copy.tag(), tag);
-        assert_eq!(*copy, 12);
-        assert!(ptr::eq(copy.pointer(), reference));
-    }
-
-    #[test]
-    fn stable_hash_hashes_as_tuple() {
-        let hash_packed = {
-            let mut hasher = StableHasher::new();
-            tag_ptr(&12, Tag2::B11).hash_stable(&mut (), &mut hasher);
-            hasher.finish::<Hash128>()
-        };
-
-        let hash_tupled = {
-            let mut hasher = StableHasher::new();
-            (&12, Tag2::B11).hash_stable(&mut (), &mut hasher);
-            hasher.finish::<Hash128>()
-        };
-
-        assert_eq!(hash_packed, hash_tupled);
-    }
-
-    /// Helper to create tagged pointers without specifying `COMPARE_PACKED` if it does not matter.
-    fn tag_ptr<P: Pointer, T: Tag>(ptr: P, tag: T) -> TaggedPtr<P, P::Target, T, true> {
-        TaggedPtr::new(ptr, tag)
-    }
-}
+mod tests;

compiler/rustc_data_structures/src/tagged_ptr/covariant/tests.rs

@@ -0,0 +1,51 @@
+use std::ptr;
+
+use super::*;
+use crate::hashes::Hash128;
+use crate::stable_hasher::{HashStable, StableHasher};
+use crate::tagged_ptr::tests::Tag2;
+
+#[test]
+fn smoke() {
+    let value = 12u32;
+    let reference = &value;
+    let tag = Tag2::B01;
+
+    let ptr = tag_ptr(reference, tag);
+
+    assert_eq!(ptr.tag(), tag);
+    assert_eq!(*ptr, 12);
+    assert!(ptr::eq(ptr.pointer(), reference));
+
+    let copy = ptr;
+
+    let mut ptr = ptr;
+    ptr.set_tag(Tag2::B00);
+    assert_eq!(ptr.tag(), Tag2::B00);
+
+    assert_eq!(copy.tag(), tag);
+    assert_eq!(*copy, 12);
+    assert!(ptr::eq(copy.pointer(), reference));
+}
+
+#[test]
+fn stable_hash_hashes_as_tuple() {
+    let hash_packed = {
+        let mut hasher = StableHasher::new();
+        tag_ptr(&12, Tag2::B11).hash_stable(&mut (), &mut hasher);
+        hasher.finish::<Hash128>()
+    };
+
+    let hash_tupled = {
+        let mut hasher = StableHasher::new();
+        (&12, Tag2::B11).hash_stable(&mut (), &mut hasher);
+        hasher.finish::<Hash128>()
+    };
+
+    assert_eq!(hash_packed, hash_tupled);
+}
+
+/// Helper to create tagged pointers without specifying `COMPARE_PACKED` if it does not matter.
+fn tag_ptr<P: Pointer, T: Tag>(ptr: P, tag: T) -> TaggedPtr<P, P::Target, T, true> {
+    TaggedPtr::new(ptr, tag)
+}

compiler/rustc_data_structures/src/tagged_ptr/impl_tag.rs

@@ -141,39 +141,4 @@ macro_rules! impl_tag {
 }
 
 #[cfg(test)]
-mod tests {
-    #[test]
-    fn bits_constant() {
-        use crate::tagged_ptr::Tag;
-
-        #[derive(Copy, Clone)]
-        struct Unit;
-        impl_tag! { impl Tag for Unit; Unit, }
-        assert_eq!(Unit::BITS, 0);
-
-        #[derive(Copy, Clone)]
-        enum Enum3 {
-            A,
-            B,
-            C,
-        }
-        impl_tag! { impl Tag for Enum3; Enum3::A, Enum3::B, Enum3::C, }
-        assert_eq!(Enum3::BITS, 2);
-
-        #[derive(Copy, Clone)]
-        struct Eight(bool, bool, bool);
-        impl_tag! {
-            impl Tag for Eight;
-            Eight { 0: true,  1: true,  2: true  },
-            Eight { 0: true,  1: true,  2: false },
-            Eight { 0: true,  1: false, 2: true  },
-            Eight { 0: true,  1: false, 2: false },
-            Eight { 0: false, 1: true,  2: true  },
-            Eight { 0: false, 1: true,  2: false },
-            Eight { 0: false, 1: false, 2: true  },
-            Eight { 0: false, 1: false, 2: false },
-        }
-
-        assert_eq!(Eight::BITS, 3);
-    }
-}
+mod tests;

compiler/rustc_data_structures/src/tagged_ptr/impl_tag/tests.rs

@@ -0,0 +1,34 @@
+#[test]
+fn bits_constant() {
+    use crate::tagged_ptr::Tag;
+
+    #[derive(Copy, Clone)]
+    struct Unit;
+    impl_tag! { impl Tag for Unit; Unit, }
+    assert_eq!(Unit::BITS, 0);
+
+    #[derive(Copy, Clone)]
+    enum Enum3 {
+        A,
+        B,
+        C,
+    }
+    impl_tag! { impl Tag for Enum3; Enum3::A, Enum3::B, Enum3::C, }
+    assert_eq!(Enum3::BITS, 2);
+
+    #[derive(Copy, Clone)]
+    struct Eight(bool, bool, bool);
+    impl_tag! {
+        impl Tag for Eight;
+        Eight { 0: true,  1: true,  2: true  },
+        Eight { 0: true,  1: true,  2: false },
+        Eight { 0: true,  1: false, 2: true  },
+        Eight { 0: true,  1: false, 2: false },
+        Eight { 0: false, 1: true,  2: true  },
+        Eight { 0: false, 1: true,  2: false },
+        Eight { 0: false, 1: false, 2: true  },
+        Eight { 0: false, 1: false, 2: false },
+    }
+
+    assert_eq!(Eight::BITS, 3);
+}