Refactor progressive list tests to only include supported operations

Co-authored-by: michaelsproul <4452260+michaelsproul@users.noreply.github.com>

Author: Copilot

src/tests/proptest/operations.rs

@@ -198,50 +198,32 @@ where
 }
 
 /// Strategy for generating operations for ProgressiveList.
-/// Since ProgressiveList has no length limit, we use a fixed index range.
-fn arb_op_progressive<'a, T, S>(strategy: &'a S, n: usize) -> impl Strategy<Value = Op<T>> + 'a
+/// Only includes operations that are currently implemented for ProgressiveList.
+fn arb_op_progressive<'a, T, S>(strategy: &'a S) -> impl Strategy<Value = Op<T>> + 'a
 where
     T: Debug + Clone + 'a,
     S: Strategy<Value = T> + 'a,
 {
-    // For ProgressiveList, we mainly want to test push, len, iter, and tree_hash
-    // since get, set, iter_from, pop_front, etc. are not implemented yet.
-    let a_block = prop_oneof![
+    // Only include operations that are currently implemented for ProgressiveList:
+    // Len, Push, Iter, TreeHash, and Debase (SSZ roundtrip)
+    prop_oneof![
         Just(Op::Len),
-        arb_index(n).prop_map(Op::Get),
-        (arb_index(n), strategy).prop_map(|(index, value)| Op::Set(index, value)),
-        (arb_index(n), strategy).prop_map(|(index, value)| Op::SetCowWithIntoMut(index, value)),
-        (arb_index(n), strategy).prop_map(|(index, value)| Op::SetCowWithMakeMut(index, value)),
         strategy.prop_map(Op::Push),
         Just(Op::Iter),
-        arb_index(n).prop_map(Op::IterFrom),
-        arb_index(n).prop_map(Op::PopFront),
-        Just(Op::ApplyUpdates),
-    ];
-    let b_block = prop_oneof![
         Just(Op::TreeHash),
-        Just(Op::Checkpoint),
-        Just(Op::Rebase),
         Just(Op::Debase),
-        Just(Op::FromIntoRoundtrip),
-        Just(Op::IntraRebase),
-    ];
-    prop_oneof![
-        10 => a_block,
-        6 => b_block
     ]
 }
 
 fn arb_ops_progressive<'a, T, S>(
     strategy: &'a S,
-    n: usize,
     limit: usize,
 ) -> impl Strategy<Value = Vec<Op<T>>> + 'a
 where
     T: Debug + Clone + 'a,
     S: Strategy<Value = T> + 'a,
 {
-    proptest::collection::vec(arb_op_progressive(strategy, n), 1..limit)
+    proptest::collection::vec(arb_op_progressive(strategy), 1..limit)
 }
 
 fn apply_ops_progressive_list<T>(
@@ -251,63 +233,40 @@ fn apply_ops_progressive_list<T>(
 ) where
     T: Value + Debug + Send + Sync,
 {
-    let mut checkpoint = list.clone();
-
     for op in ops {
         match op {
             Op::Len => {
                 assert_eq!(list.len(), spec.len());
             }
-            Op::Get(_) => {
-                // No-op: ProgressiveList doesn't implement get yet
-            }
-            Op::Set(_, _) => {
-                // No-op: ProgressiveList doesn't implement set yet
-            }
-            Op::SetCowWithIntoMut(_, _) => {
-                // No-op: ProgressiveList doesn't implement set yet
-            }
-            Op::SetCowWithMakeMut(_, _) => {
-                // No-op: ProgressiveList doesn't implement set yet
-            }
             Op::Push(value) => {
                 list.push(value.clone()).expect("push should succeed");
                 spec.push(value);
             }
             Op::Iter => {
                 assert!(list.iter().eq(spec.iter()));
             }
-            Op::IterFrom(_) => {
-                // No-op: ProgressiveList doesn't implement iter_from yet
-            }
-            Op::PopFront(_) => {
-                // No-op: ProgressiveList doesn't implement pop_front yet
-            }
-            Op::ApplyUpdates => {
-                // No-op: ProgressiveList doesn't have apply_updates
-            }
-            Op::Checkpoint => {
-                checkpoint = list.clone();
-            }
             Op::TreeHash => {
                 list.tree_hash_root();
             }
-            Op::Rebase => {
-                // No-op: ProgressiveList doesn't implement rebase yet
-                let _ = &checkpoint;
-            }
             Op::Debase => {
                 let ssz_bytes = list.as_ssz_bytes();
                 let new_list = ProgressiveList::from_ssz_bytes(&ssz_bytes).expect("SSZ decode");
                 assert_eq!(new_list, *list);
                 *list = new_list;
             }
-            Op::FromIntoRoundtrip => {
-                // No-op: No corresponding Vector type for ProgressiveList
-            }
-            Op::IntraRebase => {
-                // No-op: ProgressiveList doesn't implement intra_rebase yet
-            }
+            // These operations are not implemented for ProgressiveList yet and
+            // are not generated by arb_op_progressive, but we handle them for completeness.
+            Op::Get(_)
+            | Op::Set(_, _)
+            | Op::SetCowWithIntoMut(_, _)
+            | Op::SetCowWithMakeMut(_, _)
+            | Op::IterFrom(_)
+            | Op::PopFront(_)
+            | Op::ApplyUpdates
+            | Op::Checkpoint
+            | Op::Rebase
+            | Op::FromIntoRoundtrip
+            | Op::IntraRebase => {}
         }
     }
 }
@@ -632,8 +591,9 @@ mod vect {
     vect_test!(large_1024, Large, U1024, arb_large());
 }
 
-/// Maximum length for progressive list tests.
-/// We use smaller sizes than the regular list tests since progressive lists can grow unbounded.
+/// Maximum initial length for progressive list tests.
+/// This is used to cap the initial list size for reasonable test execution time.
+/// Compare to list tests which can use up to 1024 elements (U1024).
 const PROGRESSIVE_LIST_MAX_LEN: usize = 128;
 
 macro_rules! progressive_list_test {
@@ -646,7 +606,7 @@ macro_rules! progressive_list_test {
             #[test]
             fn $name(
                 init in arb_progressive_list::<$T, _>(&$strat, PROGRESSIVE_LIST_MAX_LEN),
-                ops in arb_ops_progressive::<$T, _>(&$strat, PROGRESSIVE_LIST_MAX_LEN, OP_LIMIT)
+                ops in arb_ops_progressive::<$T, _>(&$strat, OP_LIMIT)
             ) {
                 let mut list = ProgressiveList::<$T>::try_from_iter(init.clone()).unwrap();
                 let mut spec = ProgressiveSpec::<$T>::new(init);