17050456606

Committed 18 Aug 2025 07:32PM UTC coverage: 47.596%. First build

Build Type

github

Committed by GitHub

Commit Message

Merge afbf04d54 into 7eb8ac9fa

Pull Request Pull Request #4177:

Run Details

555 of 1372 new or added lines in 154 files covered. (40.45%)

18648 of 39180 relevant lines covered (47.6%)

234900.69 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

41.67

/vortex-array/src/arrays/bool/ops.rs

// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: Copyright the Vortex contributors

use vortex_scalar::Scalar;

use crate::arrays::{BoolArray, BoolVTable};
use crate::vtable::{OperationsVTable, ValidityHelper};
use crate::{ArrayRef, IntoArray};

impl OperationsVTable<BoolVTable> for BoolVTable {
    fn slice(array: &BoolArray, start: usize, stop: usize) -> ArrayRef {
        BoolArray::new(
            array.boolean_buffer().slice(start, stop - start),
            array.validity().slice(start, stop),
        )
        .into_array()
    }

    fn scalar_at(array: &BoolArray, index: usize) -> Scalar {
        Scalar::bool(
            array.boolean_buffer().value(index),
            array.dtype().nullability(),
        )
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::ToCanonical;

    #[test]
    fn test_slice_large() {
        let arr = BoolArray::from_iter(std::iter::repeat_n(Some(true), 100));
        let sliced_arr = arr.slice(8, 16).to_bool().unwrap();
        assert_eq!(sliced_arr.len(), 8);
        assert_eq!(sliced_arr.boolean_buffer().len(), 8);
        assert_eq!(sliced_arr.boolean_buffer().offset(), 0);
    }

    #[test]
    fn test_slice() {
        let arr = BoolArray::from_iter([Some(true), Some(true), None, Some(false), None]);
        let sliced_arr = arr.slice(1, 4).to_bool().unwrap();

        assert_eq!(sliced_arr.len(), 3);

        let s = sliced_arr.scalar_at(0);
        assert_eq!(s.as_bool().value(), Some(true));

        let s = sliced_arr.scalar_at(1);
        assert!(!sliced_arr.is_valid(1).unwrap());
        assert!(s.is_null());

        let s = sliced_arr.scalar_at(2);
        assert_eq!(s.as_bool().value(), Some(false));
    }
}

1	// SPDX-License-Identifier: Apache-2.0
2	// SPDX-FileCopyrightText: Copyright the Vortex contributors
3
4	use vortex_scalar::Scalar;
5
6	use crate::arrays::{BoolArray, BoolVTable};
7	use crate::vtable::{OperationsVTable, ValidityHelper};
8	use crate::{ArrayRef, IntoArray};
9
10	impl OperationsVTable<BoolVTable> for BoolVTable {
NEW 11	fn slice(array: &BoolArray, start: usize, stop: usize) -> ArrayRef {	×
NEW 12	BoolArray::new(	×
13	array.boolean_buffer().slice(start, stop - start),	×
NEW 14	array.validity().slice(start, stop),	×
15	)	×
NEW 16	.into_array()	×
17	}	×
18
19	fn scalar_at(array: &BoolArray, index: usize) -> Scalar {	810✔
20	Scalar::bool(	810✔
21	array.boolean_buffer().value(index),	810✔
22	array.dtype().nullability(),	810✔
23	)
24	}	810✔
25	}
26
27	#[cfg(test)]
28	mod tests {
29	use super::*;
30	use crate::ToCanonical;
31
32	#[test]
33	fn test_slice_large() {
34	let arr = BoolArray::from_iter(std::iter::repeat_n(Some(true), 100));
35	let sliced_arr = arr.slice(8, 16).to_bool().unwrap();
36	assert_eq!(sliced_arr.len(), 8);
37	assert_eq!(sliced_arr.boolean_buffer().len(), 8);
38	assert_eq!(sliced_arr.boolean_buffer().offset(), 0);
39	}
40
41	#[test]
42	fn test_slice() {
43	let arr = BoolArray::from_iter([Some(true), Some(true), None, Some(false), None]);
44	let sliced_arr = arr.slice(1, 4).to_bool().unwrap();
45
46	assert_eq!(sliced_arr.len(), 3);
47
48	let s = sliced_arr.scalar_at(0);
49	assert_eq!(s.as_bool().value(), Some(true));
50
51	let s = sliced_arr.scalar_at(1);
52	assert!(!sliced_arr.is_valid(1).unwrap());
53	assert!(s.is_null());
54
55	let s = sliced_arr.scalar_at(2);
56	assert_eq!(s.as_bool().value(), Some(false));
57	}
58	}

vortex-data / vortex / 17050456606

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous