15764358096

Committed 19 Jun 2025 06:35PM UTC coverage: 61.285% (+0.2%) from 61.09%

Build # 15764358096

Build Type

push

github

Committed by

fasterthanlime

Commit Message

Remove tests

Run Details

10489 of 17115 relevant lines covered (61.29%)

155.27 hits per line

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

76.58

/facet-core/src/impls_alloc/btreeset.rs

use alloc::boxed::Box;
use alloc::collections::BTreeSet;

use crate::ptr::{PtrConst, PtrMut};

use crate::{
    Def, Facet, IterVTable, MarkerTraits, SetDef, SetVTable, Shape, Type, TypeParam, UserType,
    ValueVTable,
};

type BTreeSetIterator<'mem, T> = alloc::collections::btree_set::Iter<'mem, T>;

unsafe impl<'a, T> Facet<'a> for BTreeSet<T>
where
    T: Facet<'a> + core::cmp::Eq + core::cmp::Ord,
{
    const VTABLE: &'static ValueVTable = &const {
        ValueVTable::builder::<Self>()
            .marker_traits(|| {
                MarkerTraits::SEND
                    .union(MarkerTraits::SYNC)
                    .union(MarkerTraits::EQ)
                    .union(MarkerTraits::UNPIN)
                    .intersection(T::SHAPE.vtable.marker_traits())
            })
            .type_name(|f, opts| {
                if let Some(opts) = opts.for_children() {
                    write!(f, "{}<", Self::SHAPE.type_identifier)?;
                    T::SHAPE.vtable.type_name()(f, opts)?;
                    write!(f, ">")
                } else {
                    write!(f, "{}<⋯>", Self::SHAPE.type_identifier)
                }
            })
            .default_in_place(|| Some(|target| unsafe { target.put(Self::default()) }))
            .build()
    };

    const SHAPE: &'static Shape<'static> = &const {
        Shape::builder_for_sized::<Self>()
            .type_identifier("BTreeSet")
            .type_params(&[TypeParam {
                name: "T",
                shape: || T::SHAPE,
            }])
            .ty(Type::User(UserType::Opaque))
            .def(Def::Set(
                SetDef::builder()
                    .t(|| T::SHAPE)
                    .vtable(
                        &const {
                            SetVTable::builder()
                                .init_in_place_with_capacity(|uninit, _capacity| unsafe {
                                    uninit.put(Self::new())
                                })
                                .insert(|ptr, item| unsafe {
                                    let set = ptr.as_mut::<BTreeSet<T>>();
                                    let item = item.read::<T>();
                                    set.insert(item)
                                })
                                .len(|ptr| unsafe {
                                    let set = ptr.get::<BTreeSet<T>>();
                                    set.len()
                                })
                                .contains(|ptr, item| unsafe {
                                    let set = ptr.get::<BTreeSet<T>>();
                                    set.contains(item.get())
                                })
                                .iter_vtable(
                                    IterVTable::builder()
                                        .init_with_value(|ptr| {
                                            let set = unsafe { ptr.get::<BTreeSet<T>>() };
                                            let iter: BTreeSetIterator<'_, T> = set.iter();
                                            let iter_state = Box::new(iter);
                                            PtrMut::new(Box::into_raw(iter_state) as *mut u8)
                                        })
                                        .next(|iter_ptr| {
                                            let state = unsafe {
                                                iter_ptr.as_mut::<BTreeSetIterator<'_, T>>()
                                            };
                                            state
                                                .next()
                                                .map(|value| PtrConst::new(value as *const T))
                                        })
                                        .next_back(|iter_ptr| {
                                            let state = unsafe {
                                                iter_ptr.as_mut::<BTreeSetIterator<'_, T>>()
                                            };
                                            state
                                                .next_back()
                                                .map(|value| PtrConst::new(value as *const T))
                                        })
                                        .dealloc(|iter_ptr| unsafe {
                                            drop(Box::from_raw(
                                                iter_ptr.as_ptr::<BTreeSetIterator<'_, T>>()
                                                    as *mut BTreeSetIterator<'_, T>,
                                            ));
                                        })
                                        .build(),
                                )
                                .build()
                        },
                    )
                    .build(),
            ))
            .build()
    };
}

#[cfg(test)]
mod tests {
    use alloc::collections::BTreeSet;
    use alloc::string::String;
    use alloc::vec::Vec;

    use super::*;

    #[test]
    fn test_btreesetset_type_params() {
        let [type_param_1] = <BTreeSet<i32>>::SHAPE.type_params else {
            panic!("BTreeSet<T> should have 1 type param")
        };
        assert_eq!(type_param_1.shape(), i32::SHAPE);
    }

    #[test]
    fn test_btreeset_vtable_1_new_insert_iter_drop() -> eyre::Result<()> {
        facet_testhelpers::setup();

        let btreeset_shape = <BTreeSet<String>>::SHAPE;
        let btreeset_def = btreeset_shape
            .def
            .into_set()
            .expect("BTreeSet<T> should have a set definition");

        // Allocate memory for the BTreeSet
        let btreeset_uninit_ptr = btreeset_shape.allocate()?;

        // Create the BTreeSet
        let btreeset_ptr =
            unsafe { (btreeset_def.vtable.init_in_place_with_capacity_fn)(btreeset_uninit_ptr, 0) };

        // The BTreeSet is empty, so ensure its length is 0
        let btreeset_actual_length =
            unsafe { (btreeset_def.vtable.len_fn)(btreeset_ptr.as_const()) };
        assert_eq!(btreeset_actual_length, 0);

        // 5 sample values to insert
        let strings = ["foo", "bar", "bazz", "fizzbuzz", "fifth thing"];

        // Insert the 5 values into the BTreeSet
        let mut btreeset_length = 0;
        for string in strings {
            // Create the value
            let mut new_value = string.to_string();

            // Insert the value
            let did_insert = unsafe {
                (btreeset_def.vtable.insert_fn)(btreeset_ptr, PtrMut::new(&raw mut new_value))
            };

            // The value now belongs to the BTreeSet, so forget it
            core::mem::forget(new_value);

            assert!(did_insert, "expected value to be inserted in the BTreeSet");

            // Ensure the BTreeSet's length increased by 1
            btreeset_length += 1;
            let btreeset_actual_length =
                unsafe { (btreeset_def.vtable.len_fn)(btreeset_ptr.as_const()) };
            assert_eq!(btreeset_actual_length, btreeset_length);
        }

        // Insert the same 5 values again, ensuring they are deduplicated
        for string in strings {
            // Create the value
            let mut new_value = string.to_string();

            // Try to insert the value
            let did_insert = unsafe {
                (btreeset_def.vtable.insert_fn)(btreeset_ptr, PtrMut::new(&raw mut new_value))
            };

            // The value now belongs to the BTreeSet, so forget it
            core::mem::forget(new_value);

            assert!(
                !did_insert,
                "expected value to not be inserted in the BTreeSet"
            );

            // Ensure the BTreeSet's length did not increase
            let btreeset_actual_length =
                unsafe { (btreeset_def.vtable.len_fn)(btreeset_ptr.as_const()) };
            assert_eq!(btreeset_actual_length, btreeset_length);
        }

        // Create a new iterator over the BTreeSet
        let iter_init_with_value_fn = btreeset_def.vtable.iter_vtable.init_with_value.unwrap();
        let btreeset_iter_ptr = unsafe { iter_init_with_value_fn(btreeset_ptr.as_const()) };

        // Collect all the items from the BTreeSet's iterator
        let mut iter_items = Vec::<&str>::new();
        loop {
            // Get the next item from the iterator
            let item_ptr = unsafe { (btreeset_def.vtable.iter_vtable.next)(btreeset_iter_ptr) };
            let Some(item_ptr) = item_ptr else {
                break;
            };

            let item = unsafe { item_ptr.get::<String>() };

            // Add the item into the list of items returned from the iterator
            iter_items.push(&**item);
        }

        // Deallocate the iterator
        unsafe {
            (btreeset_def.vtable.iter_vtable.dealloc)(btreeset_iter_ptr);
        }

        // BTrees iterate in sorted order, so ensure the iterator returned
        // each item in order
        let mut strings_sorted = strings.to_vec();
        strings_sorted.sort();
        assert_eq!(iter_items, strings_sorted);

        // Get the function pointer for dropping the BTreeSet
        let drop_fn = (btreeset_shape.vtable.sized().unwrap().drop_in_place)()
            .expect("BTreeSet<T> should have drop_in_place");

        // Drop the BTreeSet in place
        unsafe { drop_fn(btreeset_ptr) };

        // Deallocate the memory
        unsafe { btreeset_shape.deallocate_mut(btreeset_ptr)? };

        Ok(())
    }
}

1	use alloc::boxed::Box;
2	use alloc::collections::BTreeSet;
3
4	use crate::ptr::{PtrConst, PtrMut};
5
6	use crate::{
7	Def, Facet, IterVTable, MarkerTraits, SetDef, SetVTable, Shape, Type, TypeParam, UserType,
8	ValueVTable,
9	};
10
11	type BTreeSetIterator<'mem, T> = alloc::collections::btree_set::Iter<'mem, T>;
12
13	unsafe impl<'a, T> Facet<'a> for BTreeSet<T>
14	where
15	T: Facet<'a> + core::cmp::Eq + core::cmp::Ord,
16	{
17	const VTABLE: &'static ValueVTable = &const {
18	ValueVTable::builder::<Self>()
19	.marker_traits(\|\| {	×
20	MarkerTraits::SEND
21	.union(MarkerTraits::SYNC)	×
22	.union(MarkerTraits::EQ)	×
23	.union(MarkerTraits::UNPIN)	×
24	.intersection(T::SHAPE.vtable.marker_traits())	×
25	})	×
26	.type_name(\|f, opts\| {	×
27	if let Some(opts) = opts.for_children() {	×
28	write!(f, "{}<", Self::SHAPE.type_identifier)?;	×
29	T::SHAPE.vtable.type_name()(f, opts)?;	×
30	write!(f, ">")	×
31	} else {
32	write!(f, "{}<⋯>", Self::SHAPE.type_identifier)	×
33	}
34	})	×
35	.default_in_place(\|\| Some(\|target\| unsafe { target.put(Self::default()) }))	×
36	.build()
37	};
38
39	const SHAPE: &'static Shape<'static> = &const {
40	Shape::builder_for_sized::<Self>()
41	.type_identifier("BTreeSet")
42	.type_params(&[TypeParam {
43	name: "T",
44	shape: \|\| T::SHAPE,
45	}])
46	.ty(Type::User(UserType::Opaque))
47	.def(Def::Set(
48	SetDef::builder()
49	.t(\|\| T::SHAPE)
50	.vtable(
51	&const {
52	SetVTable::builder()
53	.init_in_place_with_capacity(\|uninit, _capacity\| unsafe {
54	uninit.put(Self::new())	1✔
55	})	1✔
56	.insert(\|ptr, item\| unsafe {
57	let set = ptr.as_mut::<BTreeSet<T>>();	10✔
58	let item = item.read::<T>();	10✔
59	set.insert(item)	10✔
60	})	10✔
61	.len(\|ptr\| unsafe {
62	let set = ptr.get::<BTreeSet<T>>();	11✔
63	set.len()	11✔
64	})	11✔
65	.contains(\|ptr, item\| unsafe {
66	let set = ptr.get::<BTreeSet<T>>();	×
67	set.contains(item.get())	×
68	})	×
69	.iter_vtable(
70	IterVTable::builder()
71	.init_with_value(\|ptr\| {	1✔
72	let set = unsafe { ptr.get::<BTreeSet<T>>() };	1✔
73	let iter: BTreeSetIterator<'_, T> = set.iter();	1✔
74	let iter_state = Box::new(iter);	1✔
75	PtrMut::new(Box::into_raw(iter_state) as *mut u8)	1✔
76	})	1✔
77	.next(\|iter_ptr\| {	6✔
78	let state = unsafe {	6✔
79	iter_ptr.as_mut::<BTreeSetIterator<'_, T>>()	6✔
80	};
81	state	6✔
82	.next()	6✔
83	.map(\|value\| PtrConst::new(value as *const T))	6✔
84	})	6✔
85	.next_back(\|iter_ptr\| {	×
86	let state = unsafe {	×
87	iter_ptr.as_mut::<BTreeSetIterator<'_, T>>()	×
88	};
89	state	×
90	.next_back()	×
91	.map(\|value\| PtrConst::new(value as *const T))	×
92	})	×
93	.dealloc(\|iter_ptr\| unsafe {
94	drop(Box::from_raw(	1✔
95	iter_ptr.as_ptr::<BTreeSetIterator<'_, T>>()	1✔
96	as *mut BTreeSetIterator<'_, T>,	1✔
97	));
98	})	1✔
99	.build(),
100	)
101	.build()
102	},
103	)
104	.build(),
105	))
106	.build()
107	};
108	}
109
110	#[cfg(test)]
111	mod tests {
112	use alloc::collections::BTreeSet;
113	use alloc::string::String;
114	use alloc::vec::Vec;
115
116	use super::*;
117
118	#[test]
119	fn test_btreesetset_type_params() {	1✔
120	let [type_param_1] = <BTreeSet<i32>>::SHAPE.type_params else {	1✔
121	panic!("BTreeSet<T> should have 1 type param")	×
122	};
123	assert_eq!(type_param_1.shape(), i32::SHAPE);	1✔
124	}	1✔
125
126	#[test]
127	fn test_btreeset_vtable_1_new_insert_iter_drop() -> eyre::Result<()> {	1✔
128	facet_testhelpers::setup();	1✔
129
130	let btreeset_shape = <BTreeSet<String>>::SHAPE;	1✔
131	let btreeset_def = btreeset_shape	1✔
132	.def	1✔
133	.into_set()	1✔
134	.expect("BTreeSet<T> should have a set definition");	1✔
135
136	// Allocate memory for the BTreeSet
137	let btreeset_uninit_ptr = btreeset_shape.allocate()?;	1✔
138
139	// Create the BTreeSet
140	let btreeset_ptr =	1✔
141	unsafe { (btreeset_def.vtable.init_in_place_with_capacity_fn)(btreeset_uninit_ptr, 0) };	1✔
142
143	// The BTreeSet is empty, so ensure its length is 0
144	let btreeset_actual_length =	1✔
145	unsafe { (btreeset_def.vtable.len_fn)(btreeset_ptr.as_const()) };	1✔
146	assert_eq!(btreeset_actual_length, 0);	1✔
147
148	// 5 sample values to insert
149	let strings = ["foo", "bar", "bazz", "fizzbuzz", "fifth thing"];	1✔
150
151	// Insert the 5 values into the BTreeSet
152	let mut btreeset_length = 0;	1✔
153	for string in strings {	6✔
154	// Create the value
155	let mut new_value = string.to_string();	5✔
156
157	// Insert the value
158	let did_insert = unsafe {	5✔
159	(btreeset_def.vtable.insert_fn)(btreeset_ptr, PtrMut::new(&raw mut new_value))	5✔
160	};
161
162	// The value now belongs to the BTreeSet, so forget it
163	core::mem::forget(new_value);	5✔
164
165	assert!(did_insert, "expected value to be inserted in the BTreeSet");	5✔
166
167	// Ensure the BTreeSet's length increased by 1
168	btreeset_length += 1;	5✔
169	let btreeset_actual_length =	5✔
170	unsafe { (btreeset_def.vtable.len_fn)(btreeset_ptr.as_const()) };	5✔
171	assert_eq!(btreeset_actual_length, btreeset_length);	5✔
172	}
173
174	// Insert the same 5 values again, ensuring they are deduplicated
175	for string in strings {	6✔
176	// Create the value
177	let mut new_value = string.to_string();	5✔
178
179	// Try to insert the value
180	let did_insert = unsafe {	5✔
181	(btreeset_def.vtable.insert_fn)(btreeset_ptr, PtrMut::new(&raw mut new_value))	5✔
182	};
183
184	// The value now belongs to the BTreeSet, so forget it
185	core::mem::forget(new_value);	5✔
186
187	assert!(	5✔
188	!did_insert,	5✔
189	"expected value to not be inserted in the BTreeSet"	×
190	);
191
192	// Ensure the BTreeSet's length did not increase
193	let btreeset_actual_length =	5✔
194	unsafe { (btreeset_def.vtable.len_fn)(btreeset_ptr.as_const()) };	5✔
195	assert_eq!(btreeset_actual_length, btreeset_length);	5✔
196	}
197
198	// Create a new iterator over the BTreeSet
199	let iter_init_with_value_fn = btreeset_def.vtable.iter_vtable.init_with_value.unwrap();	1✔
200	let btreeset_iter_ptr = unsafe { iter_init_with_value_fn(btreeset_ptr.as_const()) };	1✔
201
202	// Collect all the items from the BTreeSet's iterator
203	let mut iter_items = Vec::<&str>::new();	1✔
204	loop {
205	// Get the next item from the iterator
206	let item_ptr = unsafe { (btreeset_def.vtable.iter_vtable.next)(btreeset_iter_ptr) };	6✔
207	let Some(item_ptr) = item_ptr else {	6✔
208	break;	1✔
209	};
210
211	let item = unsafe { item_ptr.get::<String>() };	5✔
212
213	// Add the item into the list of items returned from the iterator
214	iter_items.push(&**item);	5✔
215	}
216
217	// Deallocate the iterator
218	unsafe {	1✔
219	(btreeset_def.vtable.iter_vtable.dealloc)(btreeset_iter_ptr);	1✔
220	}	1✔
221
222	// BTrees iterate in sorted order, so ensure the iterator returned
223	// each item in order
224	let mut strings_sorted = strings.to_vec();	1✔
225	strings_sorted.sort();	1✔
226	assert_eq!(iter_items, strings_sorted);	1✔
227
228	// Get the function pointer for dropping the BTreeSet
229	let drop_fn = (btreeset_shape.vtable.sized().unwrap().drop_in_place)()	1✔
230	.expect("BTreeSet<T> should have drop_in_place");	1✔
231
232	// Drop the BTreeSet in place
233	unsafe { drop_fn(btreeset_ptr) };	1✔
234
235	// Deallocate the memory
236	unsafe { btreeset_shape.deallocate_mut(btreeset_ptr)? };	1✔
237
238	Ok(())	1✔
239	}	1✔
240	}

facet-rs / facet / 15764358096

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