frozen_collections_core/sets/
iterators.rs

1use crate::traits::{Set, SetIteration, SetOps};
2use core::cmp::{max, min};
3use core::fmt::{Debug, Formatter};
4use core::iter::{Chain, FusedIterator};
5
6/// An iterator over the values of a set.
7pub struct Iter<'a, T> {
8    inner: crate::maps::Iter<'a, T, ()>,
9}
10
11impl<'a, T> Iter<'a, T> {
12    pub(crate) const fn new(inner: crate::maps::Iter<'a, T, ()>) -> Self {
13        Self { inner }
14    }
15}
16
17impl<'a, T> Iterator for Iter<'a, T> {
18    type Item = &'a T;
19
20    fn next(&mut self) -> Option<Self::Item> {
21        self.inner.next().map(|entry| entry.0)
22    }
23
24    fn size_hint(&self) -> (usize, Option<usize>) {
25        self.inner.size_hint()
26    }
27
28    fn count(self) -> usize {
29        self.inner.count()
30    }
31
32    fn fold<B, F>(self, init: B, mut f: F) -> B
33    where
34        F: FnMut(B, Self::Item) -> B,
35    {
36        self.inner.fold(init, |acc, (k, ())| f(acc, k))
37    }
38}
39
40impl<T> DoubleEndedIterator for Iter<'_, T> {
41    fn next_back(&mut self) -> Option<Self::Item> {
42        self.inner.next_back().map(|entry| entry.0)
43    }
44
45    fn rfold<B, F>(self, init: B, mut f: F) -> B
46    where
47        F: FnMut(B, Self::Item) -> B,
48    {
49        self.inner.rfold(init, |acc, (k, ())| f(acc, k))
50    }
51}
52
53impl<T> ExactSizeIterator for Iter<'_, T> {
54    fn len(&self) -> usize {
55        self.inner.len()
56    }
57}
58
59impl<T> FusedIterator for Iter<'_, T> {}
60
61impl<T> Clone for Iter<'_, T> {
62    fn clone(&self) -> Self {
63        Self { inner: self.inner.clone() }
64    }
65}
66
67impl<T> Debug for Iter<'_, T>
68where
69    T: Debug,
70{
71    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
72        f.debug_list().entries((*self).clone()).finish()
73    }
74}
75
76/// A consuming iterator over the values of a set.
77#[derive(Debug)]
78pub struct IntoIter<T> {
79    inner: crate::maps::IntoIter<T, ()>,
80}
81
82impl<T> IntoIter<T> {
83    pub(crate) const fn new(inner: crate::maps::IntoIter<T, ()>) -> Self {
84        Self { inner }
85    }
86}
87
88impl<T> Iterator for IntoIter<T> {
89    type Item = T;
90
91    fn next(&mut self) -> Option<Self::Item> {
92        self.inner.next().map(|entry| entry.0)
93    }
94
95    fn size_hint(&self) -> (usize, Option<usize>) {
96        self.inner.size_hint()
97    }
98
99    fn count(self) -> usize {
100        self.inner.count()
101    }
102
103    fn fold<B, F>(self, init: B, mut f: F) -> B
104    where
105        F: FnMut(B, Self::Item) -> B,
106    {
107        self.inner.fold(init, |acc, (k, ())| f(acc, k))
108    }
109}
110
111impl<T> DoubleEndedIterator for IntoIter<T> {
112    fn next_back(&mut self) -> Option<Self::Item> {
113        self.inner.next_back().map(|entry| entry.0)
114    }
115
116    fn rfold<B, F>(self, init: B, mut f: F) -> B
117    where
118        F: FnMut(B, Self::Item) -> B,
119    {
120        self.inner.rfold(init, |acc, (k, ())| f(acc, k))
121    }
122}
123
124impl<T> ExactSizeIterator for IntoIter<T> {
125    fn len(&self) -> usize {
126        self.inner.len()
127    }
128}
129
130impl<T> FusedIterator for IntoIter<T> {}
131
132/// An iterator that returns the union between two sets.
133pub struct Union<'a, S1, S2, T>
134where
135    S1: Set<T>,
136    S2: Set<T>,
137    T: 'a,
138{
139    s1: &'a S1,
140    s1_iter: <S1 as SetIteration<T>>::Iterator<'a>,
141    s2: &'a S2,
142    s2_iter: <S2 as SetIteration<T>>::Iterator<'a>,
143}
144
145impl<'a, S1, S2, T> Union<'a, S1, S2, T>
146where
147    S1: Set<T>,
148    S2: Set<T>,
149{
150    pub(crate) fn new(s1: &'a S1, s2: &'a S2) -> Self {
151        Self {
152            s1_iter: s1.iter(),
153            s1,
154            s2_iter: s2.iter(),
155            s2,
156        }
157    }
158}
159
160impl<'a, S1, S2, T> Iterator for Union<'a, S1, S2, T>
161where
162    S1: Set<T>,
163    S2: Set<T>,
164{
165    type Item = &'a T;
166
167    #[mutants::skip]
168    fn next(&mut self) -> Option<Self::Item> {
169        if self.s1.len() > self.s2.len() {
170            let item = self.s1_iter.next();
171            if item.is_some() {
172                return item;
173            }
174
175            loop {
176                let item = self.s2_iter.next()?;
177                if !self.s1.contains(item) {
178                    return Some(item);
179                }
180            }
181        } else {
182            let item = self.s2_iter.next();
183            if item.is_some() {
184                return item;
185            }
186
187            loop {
188                let item = self.s1_iter.next()?;
189                if !self.s2.contains(item) {
190                    return Some(item);
191                }
192            }
193        }
194    }
195
196    fn size_hint(&self) -> (usize, Option<usize>) {
197        let h1 = self.s1_iter.size_hint();
198        let h2 = self.s2_iter.size_hint();
199
200        let max_bound = if let Some(h1x) = h1.1
201            && let Some(h2x) = h2.1
202        {
203            h1x.checked_add(h2x)
204        } else {
205            None
206        };
207
208        (max(h1.0, h2.0), max_bound)
209    }
210}
211
212impl<'a, S1, S2, T> Clone for Union<'a, S1, S2, T>
213where
214    S1: Set<T>,
215    S2: Set<T>,
216    <S1 as SetIteration<T>>::Iterator<'a>: Clone,
217    <S2 as SetIteration<T>>::Iterator<'a>: Clone,
218{
219    fn clone(&self) -> Self {
220        Self {
221            s1: self.s1,
222            s1_iter: self.s1_iter.clone(),
223            s2: self.s2,
224            s2_iter: self.s2_iter.clone(),
225        }
226    }
227}
228
229impl<S1, S2, T> FusedIterator for Union<'_, S1, S2, T>
230where
231    S1: Set<T>,
232    S2: Set<T>,
233{
234}
235
236impl<'a, S1, S2, T> Debug for Union<'a, S1, S2, T>
237where
238    S1: Set<T>,
239    S2: Set<T>,
240    <S1 as SetIteration<T>>::Iterator<'a>: Clone,
241    <S2 as SetIteration<T>>::Iterator<'a>: Clone,
242    T: Debug,
243{
244    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
245        f.debug_list().entries((*self).clone()).finish()
246    }
247}
248
249/// An iterator that returns the symmetric difference between two sets.
250pub struct SymmetricDifference<'a, S1, S2, T>
251where
252    S1: Set<T>,
253    S2: Set<T>,
254    T: 'a,
255{
256    iter: Chain<Difference<'a, S1, S2, T>, Difference<'a, S2, S1, T>>,
257}
258
259impl<'a, S1, S2, T> SymmetricDifference<'a, S1, S2, T>
260where
261    S1: Set<T>,
262    S2: Set<T>,
263{
264    pub(crate) fn new(s1: &'a S1, s2: &'a S2) -> Self {
265        Self {
266            iter: s1.difference(s2).chain(s2.difference(s1)),
267        }
268    }
269}
270
271impl<'a, S1, S2, T> Iterator for SymmetricDifference<'a, S1, S2, T>
272where
273    S1: Set<T>,
274    S2: Set<T>,
275{
276    type Item = &'a T;
277
278    fn next(&mut self) -> Option<&'a T> {
279        self.iter.next()
280    }
281
282    fn size_hint(&self) -> (usize, Option<usize>) {
283        self.iter.size_hint()
284    }
285
286    fn count(self) -> usize {
287        self.iter.count()
288    }
289}
290
291impl<'a, S1, S2, T> Clone for SymmetricDifference<'a, S1, S2, T>
292where
293    S1: Set<T>,
294    S2: Set<T>,
295    <S1 as SetIteration<T>>::Iterator<'a>: Clone,
296    <S2 as SetIteration<T>>::Iterator<'a>: Clone,
297{
298    fn clone(&self) -> Self {
299        Self { iter: self.iter.clone() }
300    }
301}
302
303impl<S1, S2, T> FusedIterator for SymmetricDifference<'_, S1, S2, T>
304where
305    S1: Set<T>,
306    S2: Set<T>,
307{
308}
309
310impl<'a, S1, S2, T> Debug for SymmetricDifference<'a, S1, S2, T>
311where
312    S1: Set<T>,
313    S2: Set<T>,
314    <S1 as SetIteration<T>>::Iterator<'a>: Clone,
315    <S2 as SetIteration<T>>::Iterator<'a>: Clone,
316    T: Debug,
317{
318    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
319        f.debug_list().entries((*self).clone()).finish()
320    }
321}
322
323/// An iterator that returns the difference between two sets.
324pub struct Difference<'a, S1, S2, T>
325where
326    S1: Set<T>,
327    S2: Set<T>,
328    T: 'a,
329{
330    s1: &'a S1,
331    s1_iter: <S1 as SetIteration<T>>::Iterator<'a>,
332    s2: &'a S2,
333}
334
335impl<'a, S1, S2, T> Difference<'a, S1, S2, T>
336where
337    S1: Set<T>,
338    S2: Set<T>,
339{
340    pub(crate) fn new(s1: &'a S1, s2: &'a S2) -> Self {
341        Self {
342            s1_iter: s1.iter(),
343            s1,
344            s2,
345        }
346    }
347}
348
349impl<'a, S1, S2, T> Iterator for Difference<'a, S1, S2, T>
350where
351    S1: Set<T>,
352    S2: Set<T>,
353{
354    type Item = &'a T;
355
356    fn next(&mut self) -> Option<Self::Item> {
357        loop {
358            let item = self.s1_iter.next()?;
359            if !self.s2.contains(item) {
360                return Some(item);
361            }
362        }
363    }
364
365    fn size_hint(&self) -> (usize, Option<usize>) {
366        let (_, upper) = self.s1_iter.size_hint();
367        (0, upper)
368    }
369}
370
371impl<'a, S1, S2, T> Clone for Difference<'a, S1, S2, T>
372where
373    S1: Set<T>,
374    S2: Set<T>,
375    <S1 as SetIteration<T>>::Iterator<'a>: Clone,
376    <S2 as SetIteration<T>>::Iterator<'a>: Clone,
377{
378    fn clone(&self) -> Self {
379        Self {
380            s1: self.s1,
381            s1_iter: self.s1_iter.clone(),
382            s2: self.s2,
383        }
384    }
385}
386
387impl<S1, S2, T> FusedIterator for Difference<'_, S1, S2, T>
388where
389    S1: Set<T>,
390    S2: Set<T>,
391{
392}
393
394impl<'a, S1, S2, T> Debug for Difference<'a, S1, S2, T>
395where
396    S1: Set<T>,
397    S2: Set<T>,
398    <S1 as SetIteration<T>>::Iterator<'a>: Clone,
399    <S2 as SetIteration<T>>::Iterator<'a>: Clone,
400    T: Debug,
401{
402    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
403        f.debug_list().entries((*self).clone()).finish()
404    }
405}
406
407/// An iterator that returns the intersection between two sets.
408pub struct Intersection<'a, S1, S2, T>
409where
410    S1: Set<T>,
411    S2: Set<T>,
412    T: 'a,
413{
414    s1: &'a S1,
415    s1_iter: <S1 as SetIteration<T>>::Iterator<'a>,
416    s2: &'a S2,
417    s2_iter: <S2 as SetIteration<T>>::Iterator<'a>,
418}
419
420impl<'a, S1, S2, T> Intersection<'a, S1, S2, T>
421where
422    S1: Set<T>,
423    S2: Set<T>,
424{
425    pub(crate) fn new(s1: &'a S1, s2: &'a S2) -> Self {
426        Self {
427            s1_iter: s1.iter(),
428            s1,
429            s2_iter: s2.iter(),
430            s2,
431        }
432    }
433}
434
435impl<'a, S1, S2, T> Iterator for Intersection<'a, S1, S2, T>
436where
437    S1: Set<T>,
438    S2: Set<T>,
439{
440    type Item = &'a T;
441
442    #[mutants::skip]
443    fn next(&mut self) -> Option<Self::Item> {
444        if self.s1.len() < self.s2.len() {
445            loop {
446                let item = self.s1_iter.next()?;
447                if self.s2.contains(item) {
448                    return Some(item);
449                }
450            }
451        } else {
452            loop {
453                let item = self.s2_iter.next()?;
454                if self.s1.contains(item) {
455                    return Some(item);
456                }
457            }
458        }
459    }
460
461    fn size_hint(&self) -> (usize, Option<usize>) {
462        (0, Some(min(self.s1.len(), self.s2.len())))
463    }
464}
465
466impl<'a, S1, S2, T> Clone for Intersection<'a, S1, S2, T>
467where
468    S1: Set<T>,
469    S2: Set<T>,
470    <S1 as SetIteration<T>>::Iterator<'a>: Clone,
471    <S2 as SetIteration<T>>::Iterator<'a>: Clone,
472{
473    fn clone(&self) -> Self {
474        Self {
475            s1: self.s1,
476            s1_iter: self.s1_iter.clone(),
477            s2: self.s2,
478            s2_iter: self.s2_iter.clone(),
479        }
480    }
481}
482
483impl<S1, S2, T> FusedIterator for Intersection<'_, S1, S2, T>
484where
485    S1: Set<T>,
486    S2: Set<T>,
487{
488}
489
490impl<'a, S1, S2, T> Debug for Intersection<'a, S1, S2, T>
491where
492    S1: Set<T>,
493    S2: Set<T>,
494    <S1 as SetIteration<T>>::Iterator<'a>: Clone,
495    <S2 as SetIteration<T>>::Iterator<'a>: Clone,
496    T: Debug,
497{
498    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
499        f.debug_list().entries((*self).clone()).finish()
500    }
501}
502
503#[cfg(test)]
504mod tests {
505    use super::*;
506    use crate::maps::{IntoIter as MapIntoIter, Iter as MapIter};
507    use crate::traits::{Len, SetExtras, SetQuery};
508    use alloc::{format, vec};
509    use hashbrown::HashSet as HashbrownSet;
510
511    /// A wrapper around `HashbrownSet` whose iterator reports an unbounded upper size hint.
512    struct UnboundedHintSet<T>(HashbrownSet<T>);
513
514    struct UnboundedHintIter<'a, T>(hashbrown::hash_set::Iter<'a, T>);
515
516    impl<'a, T> Iterator for UnboundedHintIter<'a, T> {
517        type Item = &'a T;
518
519        fn next(&mut self) -> Option<Self::Item> {
520            self.0.next()
521        }
522
523        fn size_hint(&self) -> (usize, Option<usize>) {
524            (self.0.size_hint().0, None)
525        }
526    }
527
528    impl<T> Len for UnboundedHintSet<T> {
529        fn len(&self) -> usize {
530            self.0.len()
531        }
532    }
533
534    impl<T: core::hash::Hash + Eq> SetQuery<T> for UnboundedHintSet<T> {
535        fn contains(&self, value: &T) -> bool {
536            self.0.contains(value)
537        }
538    }
539
540    impl<T: core::hash::Hash + Eq> SetIteration<T> for UnboundedHintSet<T> {
541        type Iterator<'a>
542            = UnboundedHintIter<'a, T>
543        where
544            T: 'a,
545            Self: 'a;
546
547        fn iter(&self) -> Self::Iterator<'_> {
548            UnboundedHintIter(self.0.iter())
549        }
550    }
551
552    impl<T: core::hash::Hash + Eq> SetExtras<T> for UnboundedHintSet<T> {
553        fn get(&self, value: &T) -> Option<&T> {
554            self.0.get(value)
555        }
556    }
557
558    impl<T: core::hash::Hash + Eq> IntoIterator for UnboundedHintSet<T> {
559        type Item = T;
560        type IntoIter = hashbrown::hash_set::IntoIter<T>;
561
562        fn into_iter(self) -> Self::IntoIter {
563            self.0.into_iter()
564        }
565    }
566
567    impl<T: core::hash::Hash + Eq> Set<T> for UnboundedHintSet<T> {}
568
569    #[test]
570    fn test_iter() {
571        let entries = vec![("Alice", ()), ("Bob", ())];
572        let map_iter = MapIter::new(&entries);
573        let iter = Iter::new(map_iter);
574
575        let collected: Vec<_> = iter.collect();
576        assert_eq!(collected, vec![&"Alice", &"Bob"]);
577    }
578
579    #[test]
580    fn test_iter_empty() {
581        let entries: Vec<(&str, ())> = vec![];
582        let map_iter = MapIter::new(&entries);
583        let mut iter = Iter::new(map_iter);
584
585        assert_eq!(iter.next(), None);
586    }
587
588    #[test]
589    fn test_iter_size_hint() {
590        let entries = vec![("Alice", ()), ("Bob", ())];
591        let map_iter = MapIter::new(&entries);
592        let iter = Iter::new(map_iter);
593
594        assert_eq!(iter.size_hint(), (2, Some(2)));
595    }
596
597    #[test]
598    fn test_iter_clone() {
599        let entries = vec![("Alice", ()), ("Bob", ())];
600        let map_iter = MapIter::new(&entries);
601        let iter = Iter::new(map_iter);
602        let iter_clone = iter.clone();
603
604        let collected: Vec<_> = iter_clone.collect();
605        assert_eq!(collected, vec![&"Alice", &"Bob"]);
606    }
607
608    #[test]
609    fn test_iter_debug() {
610        let entries = vec![("Alice", ()), ("Bob", ())];
611        let map_iter = MapIter::new(&entries);
612        let iter = Iter::new(map_iter);
613
614        let debug_str = format!("{iter:?}");
615        assert!(debug_str.contains("Alice"));
616        assert!(debug_str.contains("Bob"));
617    }
618
619    #[test]
620    fn test_into_iter() {
621        let entries = vec![("Alice", ()), ("Bob", ())];
622        let map_into_iter = MapIntoIter::new(entries.into_boxed_slice());
623        let into_iter = IntoIter::new(map_into_iter);
624
625        let collected: Vec<_> = into_iter.collect();
626        assert_eq!(collected, vec!["Alice", "Bob"]);
627    }
628
629    #[test]
630    fn test_into_iter_empty() {
631        let entries: Vec<(&str, ())> = vec![];
632        let map_into_iter = MapIntoIter::new(entries.into_boxed_slice());
633        let mut into_iter = IntoIter::new(map_into_iter);
634
635        assert_eq!(into_iter.next(), None);
636    }
637
638    #[test]
639    fn test_into_iter_size_hint() {
640        let entries = vec![("Alice", ()), ("Bob", ())];
641        let map_into_iter = MapIntoIter::new(entries.into_boxed_slice());
642        let into_iter = IntoIter::new(map_into_iter);
643
644        assert_eq!(into_iter.size_hint(), (2, Some(2)));
645    }
646
647    #[test]
648    fn test_union() {
649        let set1 = vec!["Alice", "Bob"].into_iter().collect::<HashbrownSet<_>>();
650        let set2 = vec!["Bob", "Charlie"].into_iter().collect::<HashbrownSet<_>>();
651        let union = Union::new(&set1, &set2);
652
653        assert_eq!((2, Some(4)), union.size_hint());
654        assert_eq!(3, union.clone().count());
655
656        let mut collected: Vec<_> = union.collect();
657        collected.sort();
658        assert_eq!(collected, vec![&"Alice", &"Bob", &"Charlie"]);
659    }
660
661    #[test]
662    fn test_union_empty() {
663        let set1: HashbrownSet<&str> = HashbrownSet::new();
664        let set2: HashbrownSet<&str> = HashbrownSet::new();
665        let union = Union::new(&set1, &set2);
666
667        assert_eq!(union.count(), 0);
668    }
669
670    #[test]
671    fn test_symmetric_difference() {
672        let set1 = vec!["Alice", "Bob"].into_iter().collect::<HashbrownSet<_>>();
673        let set2 = vec!["Bob", "Charlie"].into_iter().collect::<HashbrownSet<_>>();
674        let symmetric_difference = SymmetricDifference::new(&set1, &set2);
675
676        assert_eq!((0, Some(4)), symmetric_difference.size_hint());
677        assert_eq!(2, symmetric_difference.clone().count());
678
679        let collected: Vec<_> = symmetric_difference.collect();
680        assert_eq!(collected, vec![&"Alice", &"Charlie"]);
681    }
682
683    #[test]
684    fn test_symmetric_difference_empty() {
685        let set1: HashbrownSet<&str> = HashbrownSet::new();
686        let set2: HashbrownSet<&str> = HashbrownSet::new();
687        let symmetric_difference = SymmetricDifference::new(&set1, &set2);
688
689        assert_eq!(symmetric_difference.count(), 0);
690    }
691
692    #[test]
693    fn test_difference() {
694        let set1 = vec!["Alice", "Bob"].into_iter().collect::<HashbrownSet<_>>();
695        let set2 = vec!["Bob", "Charlie"].into_iter().collect::<HashbrownSet<_>>();
696        let difference = Difference::new(&set1, &set2);
697
698        assert_eq!((0, Some(2)), difference.size_hint());
699        assert_eq!(1, difference.clone().count());
700
701        let collected: Vec<_> = difference.collect();
702        assert_eq!(collected, vec![&"Alice"]);
703    }
704
705    #[test]
706    fn test_difference_empty() {
707        let set1: HashbrownSet<&str> = HashbrownSet::new();
708        let set2: HashbrownSet<&str> = HashbrownSet::new();
709        let difference = Difference::new(&set1, &set2);
710
711        assert_eq!(difference.count(), 0);
712    }
713
714    #[test]
715    fn test_intersection() {
716        let set1 = vec!["Alice", "Bob"].into_iter().collect::<HashbrownSet<_>>();
717        let set2 = vec!["Bob", "Charlie"].into_iter().collect::<HashbrownSet<_>>();
718        let intersection = Intersection::new(&set1, &set2);
719
720        assert_eq!((0, Some(2)), intersection.size_hint());
721        assert_eq!(1, intersection.clone().count());
722
723        let collected: Vec<_> = intersection.collect();
724        assert_eq!(collected, vec![&"Bob"]);
725    }
726
727    #[test]
728    fn test_intersection_empty() {
729        let set1: HashbrownSet<&str> = HashbrownSet::new();
730        let set2: HashbrownSet<&str> = HashbrownSet::new();
731        let intersection = Intersection::new(&set1, &set2);
732
733        assert_eq!(intersection.count(), 0);
734    }
735
736    #[test]
737    fn test_difference_clone() {
738        let set1 = vec!["Alice", "Bob"].into_iter().collect::<HashbrownSet<_>>();
739        let set2 = vec!["Bob", "Charlie"].into_iter().collect::<HashbrownSet<_>>();
740        let difference = Difference::new(&set1, &set2);
741        let difference_clone = difference.clone();
742
743        let collected: Vec<_> = difference_clone.collect();
744        assert_eq!(collected, vec![&"Alice"]);
745    }
746
747    #[test]
748    fn test_intersection_clone() {
749        let set1 = vec!["Alice", "Bob"].into_iter().collect::<HashbrownSet<_>>();
750        let set2 = vec!["Bob", "Charlie"].into_iter().collect::<HashbrownSet<_>>();
751        let intersection = Intersection::new(&set1, &set2);
752        let intersection_clone = intersection.clone();
753
754        let collected: Vec<_> = intersection_clone.collect();
755        assert_eq!(collected, vec![&"Bob"]);
756    }
757
758    #[test]
759    fn test_symmetric_difference_clone() {
760        let set1 = vec!["Alice", "Bob"].into_iter().collect::<HashbrownSet<_>>();
761        let set2 = vec!["Bob", "Charlie"].into_iter().collect::<HashbrownSet<_>>();
762        let symmetric_difference = SymmetricDifference::new(&set1, &set2);
763        let symmetric_difference_clone = symmetric_difference.clone();
764
765        let collected: Vec<_> = symmetric_difference_clone.collect();
766        assert_eq!(collected, vec![&"Alice", &"Charlie"]);
767    }
768
769    #[test]
770    fn test_union_clone() {
771        let set1 = vec!["Alice", "Bob"].into_iter().collect::<HashbrownSet<_>>();
772        let set2 = vec!["Bob", "Charlie"].into_iter().collect::<HashbrownSet<_>>();
773        let union = Union::new(&set1, &set2);
774        let union_clone = union.clone();
775
776        let mut collected: Vec<_> = union_clone.collect();
777        collected.sort();
778        assert_eq!(collected, vec![&"Alice", &"Bob", &"Charlie"]);
779    }
780
781    #[test]
782    fn test_union_fmt() {
783        let set1 = vec!["Alice", "Bob"].into_iter().collect::<HashbrownSet<_>>();
784        let set2 = vec!["Bob", "Charlie"].into_iter().collect::<HashbrownSet<_>>();
785        let union = Union::new(&set1, &set2);
786
787        let debug_str = format!("{union:?}");
788        assert!(debug_str.contains("Alice"));
789        assert!(debug_str.contains("Bob"));
790        assert!(debug_str.contains("Charlie"));
791    }
792
793    #[test]
794    fn test_symmetric_difference_fmt() {
795        let set1 = vec!["Alice", "Bob"].into_iter().collect::<HashbrownSet<_>>();
796        let set2 = vec!["Bob", "Charlie"].into_iter().collect::<HashbrownSet<_>>();
797        let symmetric_difference = SymmetricDifference::new(&set1, &set2);
798
799        let debug_str = format!("{symmetric_difference:?}");
800        assert!(debug_str.contains("Alice"));
801        assert!(debug_str.contains("Charlie"));
802    }
803
804    #[test]
805    fn test_difference_fmt() {
806        let set1 = vec!["Alice", "Bob"].into_iter().collect::<HashbrownSet<_>>();
807        let set2 = vec!["Bob", "Charlie"].into_iter().collect::<HashbrownSet<_>>();
808        let difference = Difference::new(&set1, &set2);
809
810        let debug_str = format!("{difference:?}");
811        assert!(debug_str.contains("Alice"));
812    }
813
814    #[test]
815    fn test_intersection_fmt() {
816        let set1 = vec!["Alice", "Bob"].into_iter().collect::<HashbrownSet<_>>();
817        let set2 = vec!["Bob", "Charlie"].into_iter().collect::<HashbrownSet<_>>();
818        let intersection = Intersection::new(&set1, &set2);
819
820        let debug_str = format!("{intersection:?}");
821        assert!(debug_str.contains("Bob"));
822    }
823
824    #[test]
825    fn test_iter_fold() {
826        let entries = vec![("Alice", ()), ("Bob", ())];
827        let map_iter = MapIter::new(&entries);
828        let iter = Iter::new(map_iter);
829
830        let result = iter.fold(String::new(), |mut acc, &name| {
831            acc.push_str(name);
832            acc
833        });
834        assert!(result.eq("AliceBob") || result.eq("BobAlice"));
835    }
836
837    #[test]
838    fn test_iter_len() {
839        let entries = vec![("Alice", ()), ("Bob", ())];
840        let map_iter = MapIter::new(&entries);
841        let iter = Iter::new(map_iter);
842
843        assert_eq!(iter.len(), 2);
844    }
845
846    #[test]
847    fn test_into_iter_fold() {
848        let entries = vec![("Alice", ()), ("Bob", ())];
849        let map_into_iter = MapIntoIter::new(entries.into_boxed_slice());
850        let into_iter = IntoIter::new(map_into_iter);
851
852        let result = into_iter.fold(String::new(), |mut acc, name| {
853            acc.push_str(name);
854            acc
855        });
856        assert!(result.eq("AliceBob") || result.eq("BobAlice"));
857    }
858
859    #[test]
860    fn test_into_iter_len() {
861        let entries = vec![("Alice", ()), ("Bob", ())];
862        let map_into_iter = MapIntoIter::new(entries.into_boxed_slice());
863        let into_iter = IntoIter::new(map_into_iter);
864
865        assert_eq!(into_iter.len(), 2);
866    }
867
868    #[test]
869    fn test_union_size_hint_with_unbounded_iterator() {
870        let set1 = UnboundedHintSet(vec!["Alice", "Bob"].into_iter().collect());
871        let set2 = vec!["Bob", "Charlie"].into_iter().collect::<HashbrownSet<_>>();
872
873        // Exercise all UnboundedHintSet trait methods for coverage
874        assert_eq!(set1.len(), 2);
875        assert!(set1.contains(&"Alice"));
876        assert_eq!(set1.get(&"Alice"), Some(&"Alice"));
877
878        let union = Union::new(&set1, &set2);
879        let (lower, upper) = union.size_hint();
880        assert_eq!(lower, 2);
881        assert_eq!(upper, None);
882
883        // Iterate to exercise UnboundedHintIter::next
884        assert_eq!(union.count(), 3);
885
886        // Exercise IntoIterator
887        let set3 = UnboundedHintSet(vec![1, 2].into_iter().collect());
888        assert_eq!(set3.into_iter().count(), 2);
889    }
890
891    #[test]
892    fn test_iter_rev() {
893        let entries = vec![("Alice", ()), ("Bob", ()), ("Sandy", ())];
894        let map_iter = MapIter::new(&entries);
895        let iter = Iter::new(map_iter);
896        let collected: Vec<_> = iter.rev().collect();
897        assert_eq!(collected, vec![&"Sandy", &"Bob", &"Alice"]);
898    }
899
900    #[test]
901    fn test_iter_next_back() {
902        let entries = vec![("Alice", ()), ("Bob", ()), ("Sandy", ())];
903        let map_iter = MapIter::new(&entries);
904        let mut iter = Iter::new(map_iter);
905        assert_eq!(iter.next(), Some(&"Alice"));
906        assert_eq!(iter.next_back(), Some(&"Sandy"));
907        assert_eq!(iter.next(), Some(&"Bob"));
908        assert_eq!(iter.next_back(), None);
909    }
910
911    #[test]
912    fn test_iter_rfold() {
913        let entries = vec![("Alice", ()), ("Bob", ())];
914        let map_iter = MapIter::new(&entries);
915        let iter = Iter::new(map_iter);
916        let result = iter.rfold(String::new(), |mut acc, &name| {
917            acc.push_str(name);
918            acc
919        });
920        assert_eq!(result, "BobAlice");
921    }
922
923    #[test]
924    fn test_into_iter_rev() {
925        let entries = vec![("Alice", ()), ("Bob", ()), ("Sandy", ())];
926        let map_into_iter = MapIntoIter::new(entries.into_boxed_slice());
927        let into_iter = IntoIter::new(map_into_iter);
928        let collected: Vec<_> = into_iter.rev().collect();
929        assert_eq!(collected, vec!["Sandy", "Bob", "Alice"]);
930    }
931
932    #[test]
933    fn test_into_iter_next_back() {
934        let entries = vec![("Alice", ()), ("Bob", ()), ("Sandy", ())];
935        let map_into_iter = MapIntoIter::new(entries.into_boxed_slice());
936        let mut into_iter = IntoIter::new(map_into_iter);
937        assert_eq!(into_iter.next(), Some("Alice"));
938        assert_eq!(into_iter.next_back(), Some("Sandy"));
939        assert_eq!(into_iter.next(), Some("Bob"));
940        assert_eq!(into_iter.next_back(), None);
941    }
942
943    #[test]
944    fn test_into_iter_rfold() {
945        let entries = vec![("Alice", ()), ("Bob", ())];
946        let map_into_iter = MapIntoIter::new(entries.into_boxed_slice());
947        let into_iter = IntoIter::new(map_into_iter);
948        let result = into_iter.rfold(String::new(), |mut acc, name| {
949            acc.push_str(name);
950            acc
951        });
952        assert_eq!(result, "BobAlice");
953    }
954}
frozen_collections_core/sets/iterators.rs

frozen_collections_core/sets/
iterators.rs
