Merge pull request #15 from dapper91/fix/sorting-stability

sorting stability bug fixed.

Author: dapper91

src/merger.rs

@@ -65,7 +65,7 @@ where
     C: IntoIterator<Item = Result<T, E>>,
 {
     // binary heap is max-heap by default so we reverse it to convert it to min-heap
-    items: BinaryHeap<(std::cmp::Reverse<OrderedWrapper<T, F>>, usize)>,
+    items: BinaryHeap<(std::cmp::Reverse<OrderedWrapper<T, F>>, std::cmp::Reverse<usize>)>,
     chunks: Vec<C::IntoIter>,
     initiated: bool,
     compare: F,
@@ -114,7 +114,7 @@ where
                     match item {
                         Ok(item) => self
                             .items
-                            .push((std::cmp::Reverse(OrderedWrapper::wrap(item, self.compare)), idx)),
+                            .push((std::cmp::Reverse(OrderedWrapper::wrap(item, self.compare)), std::cmp::Reverse(idx))),
                         Err(err) => return Some(Err(err)),
                     }
                 }
@@ -123,7 +123,7 @@ where
         }
 
         let (result, idx) = self.items.pop()?;
-        if let Some(item) = self.chunks[idx].next() {
+        if let Some(item) = self.chunks[idx.0].next() {
             match item {
                 Ok(item) => self
                     .items

src/sort.rs

@@ -348,8 +348,10 @@ mod test {
     fn test_external_sorter(#[case] reversed: bool) {
         let input_sorted = 0..100;
 
-        let mut input: Vec<Result<i32, io::Error>> = Vec::from_iter(input_sorted.clone().map(|item| Ok(item)));
-        input.shuffle(&mut rand::thread_rng());
+        let mut input_shuffled = Vec::from_iter(input_sorted.clone());
+        input_shuffled.shuffle(&mut rand::thread_rng());
+
+        let input: Vec<Result<i32, io::Error>> = Vec::from_iter(input_shuffled.into_iter().map(|item| Ok(item)));
 
         let sorter: ExternalSorter<i32, _> = ExternalSorterBuilder::new()
             .with_buffer(LimitedBufferBuilder::new(8, true))
@@ -376,4 +378,43 @@ mod test {
 
         assert_eq!(actual_result, expected_result)
     }
+
+    #[rstest]
+    #[case(false)]
+    #[case(true)]
+    fn test_external_sorter_stability(#[case] reversed: bool) {
+        let input_sorted = (0..20).flat_map(|x|(0..5).map(move |y| (x, y)));
+
+        let mut input_shuffled = Vec::from_iter(input_sorted.clone());
+        input_shuffled.shuffle(&mut rand::thread_rng());
+        // sort input by the second field to check sorting stability
+        input_shuffled.sort_by(|a: &(i32, i32), b: &(i32, i32)| if reversed {a.1.cmp(&b.1).reverse()} else {a.1.cmp(&b.1)});
+
+        let input: Vec<Result<(i32, i32), io::Error>> = Vec::from_iter(input_shuffled.into_iter().map(|item| Ok(item)));
+
+        let sorter: ExternalSorter<(i32, i32), _> = ExternalSorterBuilder::new()
+            .with_buffer(LimitedBufferBuilder::new(8, true))
+            .with_threads_number(2)
+            .with_tmp_dir(Path::new("./"))
+            .build()
+            .unwrap();
+
+        let compare = if reversed {
+            |a: &(i32, i32), b: &(i32, i32)| a.0.cmp(&b.0).reverse()
+        } else {
+            |a: &(i32, i32), b: &(i32, i32)| a.0.cmp(&b.0)
+        };
+
+        let result = sorter.sort_by(input, compare).unwrap();
+
+        let actual_result: Result<Vec<(i32, i32)>, _> = result.collect();
+        let actual_result = actual_result.unwrap();
+        let expected_result = if reversed {
+            Vec::from_iter(input_sorted.clone().rev())
+        } else {
+            Vec::from_iter(input_sorted.clone())
+        };
+
+        assert_eq!(actual_result, expected_result)
+    }
 }