fix: preserve case and padding on truncated hex formatting

Fixes a bug where hex slices formatted with precision and uppercase
specifiers (e.g., `{:.4X}`) incorrectly output lowercase prefix bytes.
Creates a buffer on the stack and delegates formatting to `f.pad()` to preserve system
alignment/padding flags.

Closes #249

Author: alexgrad42

src/display.rs

@@ -30,6 +30,8 @@ use alloc::string::String;
 use core::borrow::Borrow;
 use core::fmt;
 
+use fmt::Write;
+
 use super::Case;
 #[cfg(feature = "std")]
 use super::Table;
@@ -106,6 +108,48 @@ pub trait DisplayHex {
     fn hex_reserve_suggestion(&self) -> usize;
 }
 
+/// Formats and writes a truncated hex slice directly into the stack buffer
+/// based on the requested precision limit and character case.
+struct TruncatedHexBuf {
+    buf: [u8; 1024],
+    len: usize,
+}
+
+impl TruncatedHexBuf {
+    fn new() -> Self { Self { buf: [0; 1024], len: 0 } }
+
+    fn as_str(&self) -> &str { core::str::from_utf8(&self.buf[..self.len]).unwrap() }
+
+    fn write_truncated_hex(&mut self, bytes: &[u8], case: Case, max: usize) -> fmt::Result {
+        let prefix_len = max / 2;
+
+        for &b in &bytes[..prefix_len] {
+            let chars = case.table().byte_to_chars(b);
+            self.write_char(chars[0])?;
+            self.write_char(chars[1])?;
+        }
+
+        if max % 2 == 1 {
+            let chars = case.table().byte_to_chars(bytes[prefix_len]);
+            self.write_char(chars[0])?;
+        }
+
+        Ok(())
+    }
+}
+
+impl fmt::Write for TruncatedHexBuf {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        let bytes = s.as_bytes();
+        if self.len + bytes.len() > self.buf.len() {
+            return Err(fmt::Error);
+        }
+        self.buf[self.len..self.len + bytes.len()].copy_from_slice(bytes);
+        self.len += bytes.len();
+        Ok(())
+    }
+}
+
 fn internal_display(bytes: &[u8], f: &mut fmt::Formatter, case: Case) -> fmt::Result {
     use fmt::Write;
     // There are at least two optimizations left:
@@ -123,10 +167,9 @@ fn internal_display(bytes: &[u8], f: &mut fmt::Formatter, case: Case) -> fmt::Re
     }
     match f.precision() {
         Some(max) if bytes.len() > max / 2 => {
-            write!(f, "{}", bytes[..(max / 2)].as_hex())?;
-            if max % 2 == 1 {
-                f.write_char(case.table().byte_to_chars(bytes[max / 2])[0])?;
-            }
+            let mut stack_str = TruncatedHexBuf::new();
+            stack_str.write_truncated_hex(bytes, case, max)?;
+            return f.pad(stack_str.as_str());
         }
         Some(_) | None => {
             let mut chunks = bytes.chunks_exact(512);
@@ -918,6 +961,45 @@ mod tests {
             assert_eq!(bytes.to_upper_hex_string(), upper);
             assert_eq!(bytes.to_lower_hex_string(), lower);
         }
+
+        #[test]
+        fn upper_hex_precision_preserves_case() {
+            let bytes: [u8; 4] = [0xab, 0xcd, 0xef, 0x12];
+            let slice: &[u8] = &bytes;
+            assert_eq!(format!("{:.4X}", slice.as_hex()), "ABCD");
+            assert_eq!(format!("{:.5X}", slice.as_hex()), "ABCDE");
+        }
+
+        #[test]
+        fn lower_hex_precision_works_correctly_with_lowecase() {
+            let bytes: [u8; 4] = [0xab, 0xcd, 0xef, 0x12];
+            let slice: &[u8] = &bytes;
+            assert_eq!(format!("{:.4x}", slice.as_hex()), "abcd");
+            assert_eq!(format!("{:.5x}", slice.as_hex()), "abcde");
+        }
+
+        #[test]
+        fn hex_precision_extreme_boundaries() {
+            let bytes: [u8; 2] = [0xaa, 0xbb];
+            let slice: &[u8] = &bytes;
+
+            // zero precision
+            assert_eq!(format!("{:.0X}", slice.as_hex()), "");
+            assert_eq!(format!("{:.0x}", slice.as_hex()), "");
+
+            // 1-nibble precision (odd, edge case)
+            assert_eq!(format!("{:.1X}", slice.as_hex()), "A");
+            assert_eq!(format!("{:.1x}", slice.as_hex()), "a");
+        }
+
+        #[test]
+        fn hex_precision_greater_than_length() {
+            let bytes: [u8; 2] = [0xab, 0xcd];
+            let slice: &[u8] = &bytes;
+
+            assert_eq!(format!("{:.10X}", slice.as_hex()), "ABCD");
+            assert_eq!(format!("{:.10x}", slice.as_hex()), "abcd");
+        }
     }
 
     #[cfg(feature = "std")]