consolidate helpers

Author: grod220

pinocchio/interface/tests/helpers/layout.rs

@@ -62,6 +62,34 @@ pub fn assert_meta_compat(new: &Meta, legacy: &LegacyMeta) {
     );
 }
 
+pub fn overwrite_tail(bytes: &mut [u8], tail: [u8; 4]) -> [u8; 4] {
+    bytes[PADDING_OFFSET..STATE_LEN].copy_from_slice(&tail);
+    tail
+}
+
+pub fn assert_tail(layout_bytes: &[u8], tail: [u8; 4]) {
+    assert_eq!(&layout_bytes[PADDING_OFFSET..STATE_LEN], &tail);
+}
+
+pub fn assert_tail_zeroed(layout_bytes: &[u8]) {
+    assert_eq!(&layout_bytes[PADDING_OFFSET..STATE_LEN], &[0u8; 4]);
+}
+
+/// Verifies that the deserialized layout is a true zero-copy borrow into the original byte slice.
+pub fn assert_borrows_at<T>(borrow: &T, bytes: &[u8], offset: usize) {
+    let ptr = borrow as *const T;
+    let expected = unsafe { bytes.as_ptr().add(offset) };
+    assert_eq!(ptr as *const u8, expected);
+}
+
+/// Verifies that the deserialized mutable view is a true zero-copy borrow into the original
+/// byte slice at the given offset.
+pub fn assert_mut_borrows_at<T>(borrow: &mut T, base_ptr: *mut u8, offset: usize) {
+    let ptr = borrow as *mut T as *mut u8;
+    let expected = unsafe { base_ptr.add(offset) };
+    assert_eq!(ptr, expected);
+}
+
 pub fn assert_stake_compat(new: &Stake, legacy: &LegacyStake) {
     assert_eq!(
         new.delegation.voter_pubkey.to_bytes(),

pinocchio/interface/tests/transitions.rs

@@ -22,27 +22,22 @@ use {
     test_case::test_case,
 };
 
-fn assert_tail_zeroed(layout_bytes: &[u8]) {
-    assert_eq!(&layout_bytes[PADDING_OFFSET..STATE_LEN], &[0u8; 4]);
-}
-
-fn assert_tail(layout_bytes: &[u8], tail: [u8; 4]) {
-    assert_eq!(&layout_bytes[PADDING_OFFSET..STATE_LEN], &tail);
-}
-
-#[test]
-fn short_buffer_decode() {
-    let mut data = vec![0u8; STATE_LEN - 1];
-    let err = StakeStateV2::from_bytes_mut(&mut data).unwrap_err();
-    assert!(matches!(err, StakeStateError::Decode));
-}
-
-#[test]
-fn invalid_tag_err() {
-    let mut data = [0u8; STATE_LEN];
-    data[0..4].copy_from_slice(&999u32.to_le_bytes());
-    let err = StakeStateV2::from_bytes_mut(&mut data).unwrap_err();
-    assert!(matches!(err, StakeStateError::InvalidTag(999)));
+/// Creates a test buffer with the given base bytes placed at an optional 1-byte offset
+/// (for unaligned access testing) and trailing bytes filled with the given value.
+///
+/// Returns `(buffer, start)` where `start` is the offset of the layout bytes.
+fn test_buffer(
+    base: &[u8],
+    unaligned: bool,
+    trailing_len: usize,
+    trailing_fill: u8,
+) -> (Vec<u8>, usize) {
+    assert_eq!(base.len(), STATE_LEN);
+    let start = if unaligned { 1 } else { 0 };
+    let mut buffer = vec![238u8; start + STATE_LEN + trailing_len];
+    buffer[start..start + STATE_LEN].copy_from_slice(base);
+    buffer[start + STATE_LEN..].fill(trailing_fill);
+    (buffer, start)
 }
 
 #[test]
@@ -149,16 +144,12 @@ fn invalid_transitions_err(unaligned: bool, trailing_len: usize) {
         StakeStateV2Tag::RewardsPool,
     ];
 
-    let start = if unaligned { 1 } else { 0 };
-
     for from in tags {
         for &op in &[Op::ToInitialized, Op::ToStake] {
             let mut base = empty_state_bytes(from);
             base[PADDING_OFFSET..STATE_LEN].copy_from_slice(&[250, 251, 252, 253]);
 
-            let mut buffer = vec![238u8; start + STATE_LEN + trailing_len];
-            buffer[start..start + STATE_LEN].copy_from_slice(&base);
-            buffer[start + STATE_LEN..start + STATE_LEN + trailing_len].fill(123);
+            let (mut buffer, start) = test_buffer(&base, unaligned, trailing_len, 123);
 
             let expected_layout = buffer[start..start + STATE_LEN].to_vec();
             let expected_trailing =
@@ -214,10 +205,7 @@ fn uninitialized_to_initialized(unaligned: bool, trailing_len: usize) {
     let mut base = [170u8; STATE_LEN];
     write_tag(&mut base, StakeStateV2Tag::Uninitialized);
 
-    let start = if unaligned { 1 } else { 0 };
-    let mut buffer = vec![238u8; start + STATE_LEN + trailing_len];
-    buffer[start..start + STATE_LEN].copy_from_slice(&base);
-    buffer[start + STATE_LEN..start + STATE_LEN + trailing_len].fill(124);
+    let (mut buffer, start) = test_buffer(&base, unaligned, trailing_len, 124);
 
     let expected_trailing = buffer[start + STATE_LEN..start + STATE_LEN + trailing_len].to_vec();
 
@@ -292,10 +280,7 @@ fn initialized_to_stake(unaligned: bool, trailing_len: usize) {
     let preserved_tail: [u8; 4] = [1, 222, 173, 190];
     base[PADDING_OFFSET..STATE_LEN].copy_from_slice(&preserved_tail);
 
-    let start = if unaligned { 1 } else { 0 };
-    let mut buffer = vec![238u8; start + STATE_LEN + trailing_len];
-    buffer[start..start + STATE_LEN].copy_from_slice(&base);
-    buffer[start + STATE_LEN..start + STATE_LEN + trailing_len].fill(125);
+    let (mut buffer, start) = test_buffer(&base, unaligned, trailing_len, 125);
 
     let expected_trailing = buffer[start + STATE_LEN..start + STATE_LEN + trailing_len].to_vec();
 
@@ -393,10 +378,7 @@ fn initialized_to_stake_meta_mut_works(unaligned: bool, trailing_len: usize) {
     let preserved_tail: [u8; 4] = [1, 222, 173, 190];
     base[PADDING_OFFSET..STATE_LEN].copy_from_slice(&preserved_tail);
 
-    let start = if unaligned { 1 } else { 0 };
-    let mut buffer = vec![238u8; start + STATE_LEN + trailing_len];
-    buffer[start..start + STATE_LEN].copy_from_slice(&base);
-    buffer[start + STATE_LEN..start + STATE_LEN + trailing_len].fill(99);
+    let (mut buffer, start) = test_buffer(&base, unaligned, trailing_len, 99);
 
     let trailing_before = buffer[start + STATE_LEN..start + STATE_LEN + trailing_len].to_vec();
 
@@ -560,10 +542,7 @@ fn stake_to_stake_preserves_tail(unaligned: bool, trailing_len: usize) {
     let preserved_tail: [u8; 4] = [1, 222, 173, 190];
     base[PADDING_OFFSET..STATE_LEN].copy_from_slice(&preserved_tail);
 
-    let start = if unaligned { 1 } else { 0 };
-    let mut buffer = vec![238u8; start + STATE_LEN + trailing_len];
-    buffer[start..start + STATE_LEN].copy_from_slice(&base);
-    buffer[start + STATE_LEN..start + STATE_LEN + trailing_len].fill(126);
+    let (mut buffer, start) = test_buffer(&base, unaligned, trailing_len, 126);
 
     let expected_trailing = buffer[start + STATE_LEN..start + STATE_LEN + trailing_len].to_vec();
 

pinocchio/interface/tests/view.rs

@@ -23,17 +23,6 @@ use {
     test_case::test_case,
 };
 
-// Verifies that the deserialized layout is a true zero-copy borrow into the original byte slice.
-fn assert_borrows_at<T>(borrow: &T, bytes: &[u8], offset: usize) {
-    let ptr = borrow as *const T;
-    let expected = unsafe { bytes.as_ptr().add(offset) };
-    assert_eq!(ptr as *const u8, expected);
-}
-
-fn overwrite_tail(bytes: &mut [u8], tail: [u8; 4]) {
-    bytes[PADDING_OFFSET..STATE_LEN].copy_from_slice(&tail);
-}
-
 #[test]
 fn len_constant_is_200() {
     assert_eq!(StakeStateV2::LEN, 200);

pinocchio/interface/tests/view_mut.rs

@@ -24,17 +24,19 @@ use {
     test_case::test_case,
 };
 
-// Verifies that the deserialized mutable view is a true zero-copy borrow into the original
-// byte slice at the given offset.
-fn assert_mut_borrows_at<T>(borrow: &mut T, base_ptr: *mut u8, offset: usize) {
-    let ptr = borrow as *mut T as *mut u8;
-    let expected = unsafe { base_ptr.add(offset) };
-    assert_eq!(ptr, expected);
+#[test]
+fn short_buffer_returns_decode() {
+    let mut data = vec![0u8; STATE_LEN - 1];
+    let err = StakeStateV2::from_bytes_mut(&mut data).unwrap_err();
+    assert!(matches!(err, StakeStateError::Decode));
 }
 
-fn overwrite_tail(bytes: &mut [u8], tail: [u8; 4]) -> [u8; 4] {
-    bytes[PADDING_OFFSET..STATE_LEN].copy_from_slice(&tail);
-    tail
+#[test]
+fn invalid_tag_returns_error() {
+    let mut data = [0u8; STATE_LEN];
+    data[0..4].copy_from_slice(&999u32.to_le_bytes());
+    let err = StakeStateV2::from_bytes_mut(&mut data).unwrap_err();
+    assert!(matches!(err, StakeStateError::InvalidTag(999)));
 }
 
 #[test_case(StakeStateV2Tag::Uninitialized)]