Cover Debug with similar tests too

JelteF · Jan 19, 2025 · 6966174 · 6966174
1 parent 1006baf
commit 6966174
Showing 1 changed file with 238 additions and 0 deletions.
diff --git a/tests/debug.rs b/tests/debug.rs
@@ -419,6 +419,84 @@ mod structs {
             }
         }
 
+        mod r#unsized {
+            #[cfg(not(feature = "std"))]
+            use alloc::format;
+            use core::ptr;
+
+            use derive_more::Debug;
+
+            #[derive(Debug)]
+            struct Tuple(str);
+
+            #[derive(Debug)]
+            struct Struct {
+                tail: str,
+            }
+
+            #[test]
+            fn assert() {
+                let dat = "14";
+
+                let t =
+                    unsafe { &*(ptr::addr_of!(*dat) as *const [i32] as *const Tuple) };
+                assert_eq!(format!("{t:?}"), r#"Tuple("14")"#);
+                let s =
+                    unsafe { &*(ptr::addr_of!(*dat) as *const [i32] as *const Struct) };
+                assert_eq!(format!("{s:?}"), r#"Struct { tail: "14" }"#);
+            }
+
+            mod interpolated {
+                #[cfg(not(feature = "std"))]
+                use alloc::format;
+                use core::ptr;
+
+                use derive_more::Debug;
+
+                #[derive(Debug)]
+                #[debug("{}.", _0)]
+                struct Tuple1(str);
+
+                #[derive(Debug)]
+                #[debug("{_0}.")]
+                struct Tuple2(str);
+
+                #[derive(Debug)]
+                #[debug("{}.", tail)]
+                struct Struct1 {
+                    tail: str,
+                }
+
+                #[derive(Debug)]
+                #[debug("{tail}.")]
+                struct Struct2 {
+                    tail: str,
+                }
+
+                #[test]
+                fn assert() {
+                    let dat = "14";
+
+                    let t1 = unsafe {
+                        &*(ptr::addr_of!(*dat) as *const [i32] as *const Tuple1)
+                    };
+                    assert_eq!(format!("{t1:?}"), "14.");
+                    let t2 = unsafe {
+                        &*(ptr::addr_of!(*dat) as *const [i32] as *const Tuple2)
+                    };
+                    assert_eq!(format!("{t2:?}"), "14.");
+                    let s1 = unsafe {
+                        &*(ptr::addr_of!(*dat) as *const [i32] as *const Struct1)
+                    };
+                    assert_eq!(format!("{s1:?}"), "14.");
+                    let s2 = unsafe {
+                        &*(ptr::addr_of!(*dat) as *const [i32] as *const Struct2)
+                    };
+                    assert_eq!(format!("{s2:?}"), "14.");
+                }
+            }
+        }
+
         #[cfg(nightly)]
         mod never {
             use derive_more::Debug;
@@ -691,6 +769,87 @@ mod structs {
             }
         }
 
+        mod r#unsized {
+            #[cfg(not(feature = "std"))]
+            use alloc::format;
+            use core::ptr;
+
+            use derive_more::Debug;
+
+            #[derive(Debug)]
+            struct Tuple(char, str);
+
+            #[derive(Debug)]
+            struct Struct {
+                head: char,
+                tail: str,
+            }
+
+            #[test]
+            fn assert() {
+                let dat = [51i32, 3028017];
+
+                let t =
+                    unsafe { &*(ptr::addr_of!(dat) as *const [i32] as *const Tuple) };
+                assert_eq!(format!("{t:?}"), r#"Tuple('3', "14")"#);
+                let s =
+                    unsafe { &*(ptr::addr_of!(dat) as *const [i32] as *const Struct) };
+                assert_eq!(format!("{s:?}"), r#"Struct { head: '3', tail: "14" }"#);
+            }
+
+            mod interpolated {
+                #[cfg(not(feature = "std"))]
+                use alloc::format;
+                use core::ptr;
+
+                use derive_more::Debug;
+
+                #[derive(Debug)]
+                #[debug("{}.{}", _0, _1)]
+                struct Tuple1(char, str);
+
+                #[derive(Debug)]
+                #[debug("{_0}.{_1}")]
+                struct Tuple2(char, str);
+
+                #[derive(Debug)]
+                #[debug("{}.{}", head, tail)]
+                struct Struct1 {
+                    head: char,
+                    tail: str,
+                }
+
+                #[derive(Debug)]
+                #[debug("{head}.{tail}")]
+                struct Struct2 {
+                    head: char,
+                    tail: str,
+                }
+
+                #[test]
+                fn assert() {
+                    let dat = [51i32, 3028017];
+
+                    let t1 = unsafe {
+                        &*(ptr::addr_of!(dat) as *const [i32] as *const Tuple1)
+                    };
+                    assert_eq!(format!("{t1:?}"), "3.14");
+                    let t2 = unsafe {
+                        &*(ptr::addr_of!(dat) as *const [i32] as *const Tuple2)
+                    };
+                    assert_eq!(format!("{t2:?}"), "3.14");
+                    let s1 = unsafe {
+                        &*(ptr::addr_of!(dat) as *const [i32] as *const Struct1)
+                    };
+                    assert_eq!(format!("{s1:?}"), "3.14");
+                    let s2 = unsafe {
+                        &*(ptr::addr_of!(dat) as *const [i32] as *const Struct2)
+                    };
+                    assert_eq!(format!("{s2:?}"), "3.14");
+                }
+            }
+        }
+
         #[cfg(nightly)]
         mod never {
             use derive_more::Debug;
@@ -2178,6 +2337,85 @@ mod generic {
             }
         }
     }
+
+    mod r#unsized {
+        #[cfg(not(feature = "std"))]
+        use alloc::format;
+        use core::ptr;
+
+        use derive_more::Debug;
+
+        #[derive(Debug)]
+        struct Tuple<T: ?Sized>(T);
+
+        #[derive(Debug)]
+        struct Struct<T: ?Sized> {
+            tail: T,
+        }
+
+        #[test]
+        fn assert() {
+            let dat = "14";
+
+            let t =
+                unsafe { &*(ptr::addr_of!(*dat) as *const [i32] as *const Tuple<str>) };
+            assert_eq!(format!("{t:?}"), r#"Tuple("14")"#);
+            let s = unsafe {
+                &*(ptr::addr_of!(*dat) as *const [i32] as *const Struct<str>)
+            };
+            assert_eq!(format!("{s:?}"), r#"Struct { tail: "14" }"#);
+        }
+
+        mod interpolated {
+            #[cfg(not(feature = "std"))]
+            use alloc::format;
+            use core::ptr;
+
+            use derive_more::Debug;
+
+            #[derive(Debug)]
+            #[debug("{}.", _0)]
+            struct Tuple1<T: ?Sized>(T);
+
+            #[derive(Debug)]
+            #[debug("{_0}.")]
+            struct Tuple2<T: ?Sized>(T);
+
+            #[derive(Debug)]
+            #[debug("{}.", tail)]
+            struct Struct1<T: ?Sized> {
+                tail: T,
+            }
+
+            #[derive(Debug)]
+            #[debug("{tail}.")]
+            struct Struct2<T: ?Sized> {
+                tail: T,
+            }
+
+            #[test]
+            fn assert() {
+                let dat = "14";
+
+                let t1 = unsafe {
+                    &*(ptr::addr_of!(*dat) as *const [i32] as *const Tuple1<str>)
+                };
+                assert_eq!(format!("{t1:?}"), "14.");
+                let t2 = unsafe {
+                    &*(ptr::addr_of!(*dat) as *const [i32] as *const Tuple2<str>)
+                };
+                assert_eq!(format!("{t2:?}"), "14.");
+                let s1 = unsafe {
+                    &*(ptr::addr_of!(*dat) as *const [i32] as *const Struct1<str>)
+                };
+                assert_eq!(format!("{s1:?}"), "14.");
+                let s2 = unsafe {
+                    &*(ptr::addr_of!(*dat) as *const [i32] as *const Struct2<str>)
+                };
+                assert_eq!(format!("{s2:?}"), "14.");
+            }
+        }
+    }
 }
 
 // See: https://github.com/JelteF/derive_more/issues/301