collect to Buffer instead of Vec

Signed-off-by: Andrew Duffy <andrew@a10y.dev>

Author: a10y

vortex-cuda/src/kernel/encodings/alp.rs

@@ -278,25 +278,28 @@ mod tests {
         Ok(())
     }
 
-    /// Multi-chunk ALP (> 1024 elements) with patches scattered across chunks.
-    /// Exercises the fused kernel's per-block patches cursor math when more
-    /// than one block is launched.
+    /// Multi-chunk ALP (> 1024 elements) with patches in chunks 0 and 2 but
+    /// none in chunk 1. Exercises the `PatchesCursor` branch where a
+    /// non-trailing chunk has `chunk_offsets[c] == chunk_offsets[c+1]`
+    /// (zero patches) via the offset math rather than the NULL sentinel.
     #[crate::test]
-    async fn test_cuda_alp_multi_chunk_with_patches() -> VortexResult<()> {
+    async fn test_cuda_alp_multi_chunk_sparse_patches() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
 
         // 3072 values (3 chunks). Inject exceptions (values ALP can't encode
-        // losslessly) at a handful of positions spread across chunks.
-        let mut values: Vec<f32> = Vec::with_capacity(3072);
-        for i in 0u32..3072 {
-            if matches!(i, 0 | 100 | 1023 | 1024 | 2000 | 3071) {
-                values.push(1.0_f32 / 7.0 + i as f32);
-            } else {
-                values.push(i as f32);
-            }
-        }
-        let prim = PrimitiveArray::new(Buffer::from(values), Validity::NonNullable);
+        // losslessly) only in chunks 0 and 2; chunk 1 stays exception-free so
+        // its cursor slice is empty despite patches existing in the array.
+        let values: Buffer<f32> = (0u32..3072)
+            .map(|i| {
+                if matches!(i, 0 | 100 | 1023 | 3071) {
+                    1.0_f32 / 7.0 + i as f32
+                } else {
+                    i as f32
+                }
+            })
+            .collect();
+        let prim = PrimitiveArray::new(values, Validity::NonNullable);
         let alp_array = alp_encode(
             prim.as_view(),
             None,
@@ -330,15 +333,16 @@ mod tests {
             .vortex_expect("failed to create execution context");
 
         // 3072 values (3 chunks). Sprinkle exceptions into each chunk.
-        let mut values: Vec<f64> = Vec::with_capacity(3072);
-        for i in 0u32..3072 {
-            if matches!(i, 0 | 500 | 1024 | 1500 | 2048 | 3071) {
-                values.push(1.0_f64 / 3.0 + i as f64);
-            } else {
-                values.push(i as f64);
-            }
-        }
-        let prim = PrimitiveArray::new(Buffer::from(values), Validity::NonNullable);
+        let values: Buffer<f64> = (0u32..3072)
+            .map(|i| {
+                if matches!(i, 0 | 500 | 1024 | 1500 | 2048 | 3071) {
+                    1.0_f64 / 3.0 + i as f64
+                } else {
+                    i as f64
+                }
+            })
+            .collect();
+        let prim = PrimitiveArray::new(values, Validity::NonNullable);
         let alp_array = alp_encode(
             prim.as_view(),
             None,
@@ -420,15 +424,10 @@ mod tests {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
 
-        let mut values: Vec<f64> = Vec::with_capacity(1500);
-        for i in 0u32..1500 {
-            if i == 1400 {
-                values.push(1.0_f64 / 3.0);
-            } else {
-                values.push(i as f64);
-            }
-        }
-        let prim = PrimitiveArray::new(Buffer::from(values), Validity::NonNullable);
+        let values: Buffer<f64> = (0u32..1500)
+            .map(|i| if i == 1400 { 1.0_f64 / 3.0 } else { i as f64 })
+            .collect();
+        let prim = PrimitiveArray::new(values, Validity::NonNullable);
         let alp_array = alp_encode(
             prim.as_view(),
             None,