fixed merge tests

Author: asder8215

library/alloc/src/collections/btree/map/tests.rs

@@ -1,9 +1,9 @@
 use core::assert_matches;
-use std::iter;
 use std::ops::Bound::{Excluded, Included, Unbounded};
 use std::panic::{AssertUnwindSafe, catch_unwind};
 use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering::SeqCst;
+use std::{cmp, iter};
 
 use super::*;
 use crate::boxed::Box;
@@ -2144,45 +2144,59 @@ macro_rules! create_merge_test {
 
             a.merge(b, |_, a_val, b_val| a_val + b_val);
 
-            assert_eq!(a.len(), $len);
-            assert_eq!(b.len(), 0);
+            assert_eq!(a.len(), cmp::max($len, 8));
 
-            for i in 0..$len {
+            for i in 0..cmp::max($len, 8) {
                 if i < 5 {
                     assert_eq!(a[&i], i);
                 } else {
-                    assert_eq!(a[&i], i + 2 * i);
+                    if i < cmp::min($len, 8) {
+                        assert_eq!(a[&i], i + 2 * i);
+                    } else if i >= $len {
+                        assert_eq!(a[&i], i);
+                    } else {
+                        assert_eq!(a[&i], 2 * i);
+                    }
                 }
             }
 
             a.check();
-            assert_eq!(a.remove(&($len - 1)), Some(($len - 1) + 2 * ($len - 1)));
+            assert_eq!(
+                a.remove(&($len - 1)),
+                if $len >= 5 && $len < 8 {
+                    Some(($len - 1) + 2 * ($len - 1))
+                } else {
+                    Some(2 * ($len - 1))
+                }
+            );
             assert_eq!(a.insert($len - 1, 20), None);
             a.check();
         }
     };
 }
 
 // These are mostly for testing the algorithm that "fixes" the right edge after insertion.
+// Single node, merge conflicting key values.
+create_merge_test!(test_merge_7, 7);
 // Single node.
-create_merge_test!(test_append_9, 9);
+create_merge_test!(test_merge_9, 9);
 // Two leafs that don't need fixing.
-create_merge_test!(test_append_17, 17);
+create_merge_test!(test_merge_17, 17);
 // Two leafs where the second one ends up underfull and needs stealing at the end.
-create_merge_test!(test_append_14, 14);
+create_merge_test!(test_merge_14, 14);
 // Two leafs where the second one ends up empty because the insertion finished at the root.
-create_merge_test!(test_append_12, 12);
+create_merge_test!(test_merge_12, 12);
 // Three levels; insertion finished at the root.
-create_merge_test!(test_append_144, 144);
+create_merge_test!(test_merge_144, 144);
 // Three levels; insertion finished at leaf while there is an empty node on the second level.
-create_merge_test!(test_append_145, 145);
+create_merge_test!(test_merge_145, 145);
 // Tests for several randomly chosen sizes.
-create_merge_test!(test_append_170, 170);
-create_merge_test!(test_append_181, 181);
+create_merge_test!(test_merge_170, 170);
+create_merge_test!(test_merge_181, 181);
 #[cfg(not(miri))] // Miri is too slow
-create_merge_test!(test_append_239, 239);
+create_merge_test!(test_merge_239, 239);
 #[cfg(not(miri))] // Miri is too slow
-create_merge_test!(test_append_1700, 1700);
+create_merge_test!(test_merge_1700, 1700);
 
 #[test]
 #[cfg_attr(not(panic = "unwind"), ignore = "test requires unwinding support")]
@@ -2680,10 +2694,10 @@ fn test_id_based_merge() {
     lhs.insert(IdBased { id: 0, name: "lhs_k".to_string() }, "1".to_string());
     rhs.insert(IdBased { id: 0, name: "rhs_k".to_string() }, "2".to_string());
 
-    lhs.merge(rhs, |_, lhs_val, rhs_val| {
-        lhs_val.push_str(rhs_val);
+    lhs.merge(rhs, |_, mut lhs_val, rhs_val| {
+        lhs_val.push_str(&rhs_val);
         lhs_val
     });
 
-    assert_eq!(lhs.pop_first().unwrap().0.name, "12".to_string());
+    assert_eq!(lhs.pop_first().unwrap().0.name, "lhs_k".to_string());
 }

library/alloctests/tests/lib.rs

@@ -1,5 +1,6 @@
 #![feature(allocator_api)]
 #![feature(binary_heap_pop_if)]
+#![feature(btree_merge)]
 #![feature(const_heap)]
 #![feature(deque_extend_front)]
 #![feature(iter_array_chunks)]