1 files changed, 3 insertions, 79 deletions
diff --git a/src/liballoc/raw_vec.rs b/src/liballoc/raw_vec.rs
index 24336db6b25..0abab45e920 100644
--- a/src/liballoc/raw_vec.rs
+++ b/src/liballoc/raw_vec.rs
@@ -11,6 +11,9 @@ use crate::alloc::{Alloc, Layout, Global, handle_alloc_error};
 use crate::collections::CollectionAllocErr::{self, *};
 use crate::boxed::Box;
 
+#[cfg(test)]
+mod tests;
+
 /// A low-level utility for more ergonomically allocating, reallocating, and deallocating
 /// a buffer of memory on the heap without having to worry about all the corner cases
 /// involved. This type is excellent for building your own data structures like Vec and VecDeque.
@@ -748,82 +751,3 @@ fn alloc_guard(alloc_size: usize) -> Result<(), CollectionAllocErr> {
 fn capacity_overflow() -> ! {
     panic!("capacity overflow")
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn allocator_param() {
-        use crate::alloc::AllocErr;
-
-        // Writing a test of integration between third-party
-        // allocators and RawVec is a little tricky because the RawVec
-        // API does not expose fallible allocation methods, so we
-        // cannot check what happens when allocator is exhausted
-        // (beyond detecting a panic).
-        //
-        // Instead, this just checks that the RawVec methods do at
-        // least go through the Allocator API when it reserves
-        // storage.
-
-        // A dumb allocator that consumes a fixed amount of fuel
-        // before allocation attempts start failing.
-        struct BoundedAlloc { fuel: usize }
-        unsafe impl Alloc for BoundedAlloc {
-            unsafe fn alloc(&mut self, layout: Layout) -> Result<NonNull<u8>, AllocErr> {
-                let size = layout.size();
-                if size > self.fuel {
-                    return Err(AllocErr);
-                }
-                match Global.alloc(layout) {
-                    ok @ Ok(_) => { self.fuel -= size; ok }
-                    err @ Err(_) => err,
-                }
-            }
-            unsafe fn dealloc(&mut self, ptr: NonNull<u8>, layout: Layout) {
-                Global.dealloc(ptr, layout)
-            }
-        }
-
-        let a = BoundedAlloc { fuel: 500 };
-        let mut v: RawVec<u8, _> = RawVec::with_capacity_in(50, a);
-        assert_eq!(v.a.fuel, 450);
-        v.reserve(50, 150); // (causes a realloc, thus using 50 + 150 = 200 units of fuel)
-        assert_eq!(v.a.fuel, 250);
-    }
-
-    #[test]
-    fn reserve_does_not_overallocate() {
-        {
-            let mut v: RawVec<u32> = RawVec::new();
-            // First `reserve` allocates like `reserve_exact`
-            v.reserve(0, 9);
-            assert_eq!(9, v.capacity());
-        }
-
-        {
-            let mut v: RawVec<u32> = RawVec::new();
-            v.reserve(0, 7);
-            assert_eq!(7, v.capacity());
-            // 97 if more than double of 7, so `reserve` should work
-            // like `reserve_exact`.
-            v.reserve(7, 90);
-            assert_eq!(97, v.capacity());
-        }
-
-        {
-            let mut v: RawVec<u32> = RawVec::new();
-            v.reserve(0, 12);
-            assert_eq!(12, v.capacity());
-            v.reserve(12, 3);
-            // 3 is less than half of 12, so `reserve` must grow
-            // exponentially. At the time of writing this test grow
-            // factor is 2, so new capacity is 24, however, grow factor
-            // of 1.5 is OK too. Hence `>= 18` in assert.
-            assert!(v.capacity() >= 12 + 12 / 2);
-        }
-    }
-
-
-}