fix memory leak with empty iter

Author: orxfun

src/concurrent_pinned_vec/into_iter_ptr_slices.rs

@@ -26,16 +26,7 @@ where
     G: GrowthWithConstantTimeAccess,
 {
     fn drop(&mut self) {
-        for f in 0..self.fragments.len() {
-            let ptr = unsafe { *self.fragments[f].get() };
-            match ptr.is_null() {
-                true => break,
-                false => {
-                    let capacity = self.capacity_of(f);
-                    let _fragment_to_drop = unsafe { fragment_from_raw(ptr, 0, capacity) };
-                }
-            }
-        }
+        Self::drop_fragments(&self.growth, &mut self.fragments);
     }
 }
 
@@ -77,7 +68,7 @@ where
 
     pub fn new(
         capacity: usize,
-        fragments: Vec<UnsafeCell<*mut T>>,
+        mut fragments: Vec<UnsafeCell<*mut T>>,
         growth: G,
         range: Range<usize>,
     ) -> Self {
@@ -87,7 +78,10 @@ where
         let b = min(capacity, range_end(&range, capacity));
 
         match b.saturating_sub(a) {
-            0 => Self::empty(),
+            0 => {
+                Self::drop_fragments(&growth, &mut fragments);
+                Self::empty()
+            }
             _ => {
                 let (sf, si) = fragment_and_inner_indices(a);
                 let (ef, ei) = fragment_and_inner_indices(b - 1);
@@ -112,6 +106,19 @@ where
         }
     }
 
+    fn drop_fragments(growth: &G, fragments: &mut Vec<UnsafeCell<*mut T>>) {
+        for f in 0..fragments.len() {
+            let ptr = unsafe { *fragments[f].get() };
+            match ptr.is_null() {
+                true => continue,
+                false => {
+                    let capacity = growth.fragment_capacity_of(f);
+                    let _fragment_to_drop = unsafe { fragment_from_raw(ptr, 0, capacity) };
+                }
+            }
+        }
+    }
+
     #[inline(always)]
     fn remaining_len(&self) -> usize {
         (1 + self.ef).saturating_sub(self.f)

src/concurrent_pinned_vec/tests/into_iter.rs

@@ -6,24 +6,49 @@ use orx_pinned_vec::{ConcurrentPinnedVec, IntoConcurrentPinnedVec, PinnedVec};
 use std::string::{String, ToString};
 use test_case::test_matrix;
 
-fn vec_doubling() -> SplitVec<String, Doubling> {
-    (0..20).map(|x| x.to_string()).collect()
+fn vec_doubling(n: usize) -> SplitVec<String, Doubling> {
+    (0..n).map(|x| x.to_string()).collect()
 }
 
-fn vec_linear() -> SplitVec<String, Linear> {
+fn vec_linear(n: usize) -> SplitVec<String, Linear> {
     let mut vec = SplitVec::with_linear_growth(2);
-    vec.extend((0..20).map(|x| x.to_string()));
+    vec.extend((0..n).map(|x| x.to_string()));
     vec
 }
 
+#[test_matrix([vec_doubling, vec_linear])]
+fn into_iter_empty<G, F>(vec: F)
+where
+    G: GrowthWithConstantTimeAccess,
+    F: Fn(usize) -> SplitVec<String, G>,
+{
+    let iter = || {
+        let vec = vec(0);
+        let range = 0..vec.len();
+        let convec = vec.into_concurrent();
+        let (growth, data, capacity) = convec.destruct();
+        ConcurrentSplitVecIntoIter::new(capacity, data, growth, range)
+    };
+
+    let consume_all = iter().count();
+    assert_eq!(consume_all, 0);
+
+    let mut consume_half = iter();
+    for _ in 0..10 {
+        _ = consume_half.next();
+    }
+
+    let _consume_none = iter();
+}
+
 #[test_matrix([vec_doubling, vec_linear])]
 fn into_iter_non_taken<G, F>(vec: F)
 where
     G: GrowthWithConstantTimeAccess,
-    F: Fn() -> SplitVec<String, G>,
+    F: Fn(usize) -> SplitVec<String, G>,
 {
     let iter = || {
-        let vec = vec();
+        let vec = vec(20);
         let range = 0..vec.len();
         let convec = vec.into_concurrent();
         let (growth, data, capacity) = convec.destruct();
@@ -45,10 +70,10 @@ where
 fn into_iter_taken_from_beg<G, F>(vec: F)
 where
     G: GrowthWithConstantTimeAccess,
-    F: Fn() -> SplitVec<String, G>,
+    F: Fn(usize) -> SplitVec<String, G>,
 {
     let iter = || {
-        let vec = vec();
+        let vec = vec(20);
         let range = 5..vec.len();
         let convec = vec.into_concurrent();
 
@@ -76,10 +101,10 @@ where
 fn into_iter_taken_from_end<G, F>(vec: F)
 where
     G: GrowthWithConstantTimeAccess,
-    F: Fn() -> SplitVec<String, G>,
+    F: Fn(usize) -> SplitVec<String, G>,
 {
     let iter = || {
-        let vec = vec();
+        let vec = vec(20);
         let vec_len = vec.len();
         let range = 0..15;
         let convec = vec.into_concurrent();
@@ -108,10 +133,10 @@ where
 fn into_iter_taken_from_both_ends<G, F>(vec: F)
 where
     G: GrowthWithConstantTimeAccess,
-    F: Fn() -> SplitVec<String, G>,
+    F: Fn(usize) -> SplitVec<String, G>,
 {
     let iter = || {
-        let vec = vec();
+        let vec = vec(20);
         let vec_len = vec.len();
         let range = 4..15;
         let convec = vec.into_concurrent();