Docs and Tests

Author: peter-lyons-kehl

README.md

@@ -37,13 +37,13 @@ That does work out of the box when the client passes a reference/slice defined a
 `addresses_unique_between_statics()`](https://github.com/peter-lyons-kehl/ndd/blob/26d743d9b7bbaf41155e00174f8827efca5d5f32/src/lib.rs#L72).
 
 However, there is a problem (caused by de-duplication in `release`, and for some types even in `dev
-or `miri`). It affects ("ordinary") `const` values/expressions that equal in value to any `static`
+or `miri). It affects ("ordinary") `const` values/expressions that equal in value to any `static`
 (whether it's a `static` variable, or a static literal), which may be your designated `static`.
 Rust/LLVM re-uses address of one such matching `static` for references to any equal value(s) defined
 as `const`. See a test [`src/lib.rs` ->
 `addresses_not_unique_between_const_and_static()`](https://github.com/peter-lyons-kehl/ndd/blob/26d743d9b7bbaf41155e00174f8827efca5d5f32/src/lib.rs#L95).
-Such `const`, `static` or literal could be in 3rd party, and even in private (not exported), code
-(see [`cross_crate_demo_bug`](cross_crate_demo_bug))!
+Such `const`, `static` or literal could be in 3rd party code, even private. (See
+[`cross_crate_demo_bug/`](https://github.com/peter-lyons-kehl/ndd/tree/main/cross_crate_demo_bug))!
 
 Things get worse: `dev` builds don't have this consistent:
 

src/lib.rs

@@ -216,27 +216,27 @@ impl<OWN: Any + Send + Sync, TO: Any + Send + Sync + ?Sized> Drop
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use core::ptr;
-
-    const fn expect_sync_ref<T: Sync>() {}
-    const _: () = expect_sync_ref::<NonDeDuplicated<u8>>();
+mod tests_shared {
+    pub const STR_CONST_FROM_BYTE_ARRAY_HI: &str = {
+        match str::from_utf8(&[b'H', b'i']) {
+            Ok(s) => s,
+            Err(_) => unreachable!(),
+        }
+    };
 
-    #[test]
-    #[cfg(any(debug_assertions, miri))]
-    #[should_panic(
-        expected = "Do not use for local variables, const, or on heap. Use for static variables only."
-    )]
-    fn drop_panics_in_debug_and_miri() {
-        let _: NonDeDuplicated<()> = NonDeDuplicated::new(());
-    }
+    pub const STR_CONST_FROM_BYTE_STRING_HELLO: &str = {
+        match str::from_utf8(b"Hello") {
+            Ok(s) => s,
+            Err(_) => unreachable!(),
+        }
+    };
+}
 
-    #[cfg(not(any(debug_assertions, miri)))]
-    #[test]
-    fn drop_silent_in_release() {
-        let _: NonDeDuplicated<()> = NonDeDuplicated::new(());
-    }
+/// These tests don't actually test `ndd`, but they test the behavior **without** `ndd`.
+#[cfg(test)]
+mod tests_behavior_without_ndd {
+    use crate::tests_shared::{STR_CONST_FROM_BYTE_ARRAY_HI, STR_CONST_FROM_BYTE_STRING_HELLO};
+    use core::ptr;
 
     const U8_CONST: u8 = b'A';
     static U8_STATIC_1: u8 = b'A';
@@ -262,22 +262,6 @@ mod tests {
         assert!(!ptr::eq(&U8_STATIC_1, &U8_CONST));
     }
 
-    static U8_NDD: NonDeDuplicated<u8> = NonDeDuplicated::new(U8_CONST);
-    static U8_NDD_REF: &u8 = U8_NDD.get();
-    #[test]
-    fn u8_global_const_and_ndd() {
-        assert!(!ptr::eq(U8_NDD_REF, &U8_CONST));
-        assert!(!ptr::eq(U8_NDD_REF, &U8_STATIC_1));
-        assert!(!ptr::eq(U8_NDD_REF, &U8_STATIC_2));
-    }
-
-    const STR_CONST_FROM_BYTE_ARRAY_HI: &str = {
-        match str::from_utf8(&[b'H', b'i']) {
-            Ok(s) => s,
-            Err(_) => unreachable!(),
-        }
-    };
-
     #[cfg(not(miri))]
     #[test]
     #[should_panic(expected = "assertion failed: !ptr::eq(STR_CONST_FROM_BYTE_ARRAY_HI, \"Hi\")")]
@@ -290,27 +274,12 @@ mod tests {
         assert!(!ptr::eq(STR_CONST_FROM_BYTE_ARRAY_HI, "Hi"));
     }
 
-    const STR_CONST_FROM_BYTE_STRING_HELLO: &str = {
-        match str::from_utf8(b"Hello") {
-            Ok(s) => s,
-            Err(_) => unreachable!(),
-        }
-    };
-
     /// This is the same for all three: release, debug AND miri!
     #[test]
     fn str_global_byte_by_byte_const_and_local_static() {
         assert!(ptr::eq(STR_CONST_FROM_BYTE_STRING_HELLO, "Hello"));
     }
 
-    static STR_NDD_HI: NonDeDuplicatedStr<5> = NonDeDuplicatedStr::new("Hello");
-    #[test]
-    fn str_ndd_hi() {
-        assert!(!ptr::eq(STR_NDD_HI.get(), "Hi"));
-        assert!(!ptr::eq(STR_NDD_HI.get(), STR_CONST_FROM_BYTE_ARRAY_HI));
-        assert!(!ptr::eq(STR_NDD_HI.get(), STR_CONST_FROM_BYTE_STRING_HELLO));
-    }
-
     static STR_STATIC: &str = "Ciao";
 
     #[cfg(not(miri))]
@@ -330,14 +299,6 @@ mod tests {
         assert!(!ptr::eq(local_const_based_slice, STR_STATIC));
     }
 
-    static STR_NDD_CIAO: NonDeDuplicatedStr<4> = NonDeDuplicatedStr::new("Ciao");
-    #[test]
-    fn str_local_const_based_and_str_ndd() {
-        const LOCAL_CONST_ARR: [u8; 4] = [b'C', b'i', b'a', b'o'];
-        let local_const_based_slice: &str = str::from_utf8(&LOCAL_CONST_ARR).unwrap();
-        assert!(!ptr::eq(local_const_based_slice, STR_NDD_CIAO.get()));
-    }
-
     mod cross_module_static {
         pub static STATIC_OPT_U8_A: Option<u8> = Some(b'A');
     }
@@ -366,3 +327,57 @@ mod tests {
         }
     }
 }
+
+#[cfg(test)]
+mod tests_behavior_with_ndd {
+    use super::*;
+    use crate::tests_shared::{STR_CONST_FROM_BYTE_ARRAY_HI, STR_CONST_FROM_BYTE_STRING_HELLO};
+    use core::ptr;
+
+    const U8_CONST: u8 = b'A';
+    static U8_STATIC_1: u8 = b'A';
+    static U8_STATIC_2: u8 = b'A';
+
+    const fn expect_sync_ref<T: Sync>() {}
+    const _: () = expect_sync_ref::<NonDeDuplicated<u8>>();
+
+    static U8_NDD: NonDeDuplicated<u8> = NonDeDuplicated::new(U8_CONST);
+    static U8_NDD_REF: &u8 = U8_NDD.get();
+    #[test]
+    fn u8_global_const_and_ndd() {
+        assert!(!ptr::eq(U8_NDD_REF, &U8_CONST));
+        assert!(!ptr::eq(U8_NDD_REF, &U8_STATIC_1));
+        assert!(!ptr::eq(U8_NDD_REF, &U8_STATIC_2));
+    }
+
+    static STR_NDD_HI: NonDeDuplicatedStr<5> = NonDeDuplicatedStr::new("Hello");
+    #[test]
+    fn str_ndd_hi() {
+        assert!(!ptr::eq(STR_NDD_HI.get(), "Hi"));
+        assert!(!ptr::eq(STR_NDD_HI.get(), STR_CONST_FROM_BYTE_ARRAY_HI));
+        assert!(!ptr::eq(STR_NDD_HI.get(), STR_CONST_FROM_BYTE_STRING_HELLO));
+    }
+
+    static STR_NDD_CIAO: NonDeDuplicatedStr<4> = NonDeDuplicatedStr::new("Ciao");
+    #[test]
+    fn str_local_const_based_and_str_ndd() {
+        const LOCAL_CONST_ARR: [u8; 4] = [b'C', b'i', b'a', b'o'];
+        let local_const_based_slice: &str = str::from_utf8(&LOCAL_CONST_ARR).unwrap();
+        assert!(!ptr::eq(local_const_based_slice, STR_NDD_CIAO.get()));
+    }
+
+    #[test]
+    #[cfg(any(debug_assertions, miri))]
+    #[should_panic(
+        expected = "Do not use for local variables, const, or on heap. Use for static variables only."
+    )]
+    fn drop_panics_in_debug_and_miri() {
+        let _: NonDeDuplicated<()> = NonDeDuplicated::new(());
+    }
+
+    #[cfg(not(any(debug_assertions, miri)))]
+    #[test]
+    fn drop_silent_in_release() {
+        let _: NonDeDuplicated<()> = NonDeDuplicated::new(());
+    }
+}