refactor(parquet-datasource): extract ExpectedPruning into a shared test_util module

`ExpectedPruning` is the only test helper shared between the row-group
statistics tests and the bloom-filter tests. Move it into a new
`#[cfg(test)] mod test_util` so the bloom-filter tests can be relocated
into `bloom_filter.rs` without it.

Its `assert` method previously reached into the private `access_plan`
field of `RowGroupAccessPlanFilter`; add a test-only `pub(crate)`
`access_plan()` accessor so the helper works from a sibling module
without widening the field's visibility.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: adriangb

datafusion/datasource-parquet/src/mod.rs

@@ -38,6 +38,8 @@ mod row_group_filter;
 mod sort;
 pub mod source;
 mod supported_predicates;
+#[cfg(test)]
+mod test_util;
 mod writer;
 
 pub use access_plan::{ParquetAccessPlan, RowGroupAccess};

datafusion/datasource-parquet/src/row_group_filter.rs

@@ -75,6 +75,15 @@ impl RowGroupAccessPlanFilter {
         self.access_plan
     }
 
+    /// Returns a reference to the inner access plan.
+    ///
+    /// Test-only accessor used by the shared assertion helpers in
+    /// [`crate::test_util`].
+    #[cfg(test)]
+    pub(crate) fn access_plan(&self) -> &ParquetAccessPlan {
+        &self.access_plan
+    }
+
     /// Returns the is_fully_matched vector.
     pub fn is_fully_matched(&self) -> &Vec<bool> {
         self.access_plan.fully_matched()
@@ -519,6 +528,7 @@ mod tests {
 
     use super::*;
     use crate::reader::ParquetFileReader;
+    use crate::test_util::ExpectedPruning;
 
     use arrow::datatypes::DataType::Decimal128;
     use arrow::datatypes::{DataType, Field};
@@ -1525,54 +1535,6 @@ mod tests {
             .await
     }
 
-    // What row groups are expected to be left after pruning
-    #[derive(Debug)]
-    enum ExpectedPruning {
-        All,
-        /// Only the specified row groups are expected to REMAIN (not what is pruned)
-        Some(Vec<usize>),
-        None,
-    }
-
-    impl ExpectedPruning {
-        /// asserts that the pruned row group match this expectation
-        fn assert(&self, row_groups: &RowGroupAccessPlanFilter) {
-            let num_row_groups = row_groups.access_plan.len();
-            assert!(num_row_groups > 0);
-            let num_pruned = (0..num_row_groups)
-                .filter_map(|i| {
-                    if row_groups.access_plan.should_scan(i) {
-                        None
-                    } else {
-                        Some(1)
-                    }
-                })
-                .sum::<usize>();
-
-            match self {
-                Self::All => {
-                    assert_eq!(
-                        num_row_groups, num_pruned,
-                        "Expected all row groups to be pruned, but got {row_groups:?}"
-                    );
-                }
-                ExpectedPruning::None => {
-                    assert_eq!(
-                        num_pruned, 0,
-                        "Expected no row groups to be pruned, but got {row_groups:?}"
-                    );
-                }
-                ExpectedPruning::Some(expected) => {
-                    let actual = row_groups.access_plan.row_group_indexes();
-                    assert_eq!(
-                        expected, &actual,
-                        "Unexpected row groups pruned. Expected {expected:?}, got {actual:?}"
-                    );
-                }
-            }
-        }
-    }
-
     fn assert_pruned(row_groups: RowGroupAccessPlanFilter, expected: ExpectedPruning) {
         expected.assert(&row_groups);
     }

datafusion/datasource-parquet/src/test_util.rs

@@ -0,0 +1,71 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+//! Test helpers shared across the Parquet datasource crate.
+
+use crate::row_group_filter::RowGroupAccessPlanFilter;
+
+/// What row groups are expected to be left after pruning.
+#[derive(Debug)]
+pub(crate) enum ExpectedPruning {
+    /// All row groups are expected to be pruned.
+    All,
+    /// Only the specified row groups are expected to REMAIN (not what is pruned).
+    Some(Vec<usize>),
+    /// No row groups are expected to be pruned.
+    None,
+}
+
+impl ExpectedPruning {
+    /// Asserts that the pruned row groups match this expectation.
+    pub(crate) fn assert(&self, row_groups: &RowGroupAccessPlanFilter) {
+        let access_plan = row_groups.access_plan();
+        let num_row_groups = access_plan.len();
+        assert!(num_row_groups > 0);
+        let num_pruned = (0..num_row_groups)
+            .filter_map(|i| {
+                if access_plan.should_scan(i) {
+                    None
+                } else {
+                    Some(1)
+                }
+            })
+            .sum::<usize>();
+
+        match self {
+            Self::All => {
+                assert_eq!(
+                    num_row_groups, num_pruned,
+                    "Expected all row groups to be pruned, but got {row_groups:?}"
+                );
+            }
+            ExpectedPruning::None => {
+                assert_eq!(
+                    num_pruned, 0,
+                    "Expected no row groups to be pruned, but got {row_groups:?}"
+                );
+            }
+            ExpectedPruning::Some(expected) => {
+                let actual = access_plan.row_group_indexes();
+                assert_eq!(
+                    expected, &actual,
+                    "Unexpected row groups pruned. Expected {expected:?}, got {actual:?}"
+                );
+            }
+        }
+    }
+}