Add opt in for weaker tests, for non-jemalloc allocators.

Fix #74

Distributions packages can maintain a local patch
that sets ASSUME_JEMALLOC to false.

tests/tests.rs

@@ -9,14 +9,27 @@ extern crate heapsize;
 use heapsize::{HeapSizeOf, heap_size_of};
 use std::os::raw::c_void;
 
-pub const EMPTY: *mut () = 0x1 as *mut ();
+const EMPTY: *mut () = 0x1 as *mut ();
+
+/// https://github.com/servo/heapsize/issues/74
+const ASSUME_JEMALLOC: bool = true;
+
+fn assert_size(actual: usize, expected: usize) {
+    if ASSUME_JEMALLOC {
+        assert_eq!(actual, expected)
+    } else {
+        // Some allocators give more than requested
+        assert!(actual >= expected, "expected {:?} >= {:?}", actual, expected)
+    }
+}
 
 #[cfg(feature = "unstable")]
 mod unstable {
     extern crate alloc;
 
     use heapsize::heap_size_of;
     use std::os::raw::c_void;
+    use super::assert_size;
 
     #[repr(C, simd)]
     struct OverAligned(u64, u64, u64, u64);
@@ -32,22 +45,22 @@ mod unstable {
         unsafe {
             // A 64 byte request is allocated exactly.
             let x = alloc::heap::allocate(64, 0);
-            assert_eq!(heap_size_of(x as *const c_void), 64);
+            assert_size(heap_size_of(x as *const c_void), 64);
             alloc::heap::deallocate(x, 64, 0);
 
             // A 255 byte request is rounded up to 256 bytes.
             let x = alloc::heap::allocate(255, 0);
-            assert_eq!(heap_size_of(x as *const c_void), 256);
+            assert_size(heap_size_of(x as *const c_void), 256);
             alloc::heap::deallocate(x, 255, 0);
 
             // A 1MiB request is allocated exactly.
             let x = alloc::heap::allocate(1024 * 1024, 0);
-            assert_eq!(heap_size_of(x as *const c_void), 1024 * 1024);
+            assert_size(heap_size_of(x as *const c_void), 1024 * 1024);
             alloc::heap::deallocate(x, 1024 * 1024, 0);
 
             // An overaligned 1MiB request is allocated exactly.
             let x = alloc::heap::allocate(1024 * 1024, 32);
-            assert_eq!(heap_size_of(x as *const c_void), 1024 * 1024);
+            assert_size(heap_size_of(x as *const c_void), 1024 * 1024);
             alloc::heap::deallocate(x, 1024 * 1024, 32);
         }
     }
@@ -58,22 +71,22 @@ mod unstable {
         unsafe {
             // A 64 byte request is allocated exactly.
             let x = alloc::heap::allocate(64, 0);
-            assert_eq!(heap_size_of(x as *const c_void), 64);
+            assert_size(heap_size_of(x as *const c_void), 64);
             alloc::heap::deallocate(x, 64, 0);
 
             // A 255 byte request is allocated exactly.
             let x = alloc::heap::allocate(255, 0);
-            assert_eq!(heap_size_of(x as *const c_void), 255);
+            assert_size(heap_size_of(x as *const c_void), 255);
             alloc::heap::deallocate(x, 255, 0);
 
             // A 1MiB request is allocated exactly.
             let x = alloc::heap::allocate(1024 * 1024, 0);
-            assert_eq!(heap_size_of(x as *const c_void), 1024 * 1024);
+            assert_size(heap_size_of(x as *const c_void), 1024 * 1024);
             alloc::heap::deallocate(x, 1024 * 1024, 0);
 
             // An overaligned 1MiB request is over-allocated.
             let x = alloc::heap::allocate(1024 * 1024, 32);
-            assert_eq!(heap_size_of(x as *const c_void), 1024 * 1024 + 32);
+            assert_size(heap_size_of(x as *const c_void), 1024 * 1024 + 32);
             alloc::heap::deallocate(x, 1024 * 1024, 32);
         }
     }
@@ -82,21 +95,21 @@ mod unstable {
     #[test]
     fn test_simd() {
         let x = Box::new(OverAligned(0, 0, 0, 0));
-        assert_eq!(unsafe { heap_size_of(&*x as *const _ as *const c_void) }, 32);
+        assert_size(unsafe { heap_size_of(&*x as *const _ as *const c_void) }, 32);
     }
 
     #[cfg(target_os = "windows")]
     #[test]
     fn test_simd() {
         let x = Box::new(OverAligned(0, 0, 0, 0));
-        assert_eq!(unsafe { heap_size_of(&*x as *const _ as *const c_void) }, 32 + 32);
+        assert_size(unsafe { heap_size_of(&*x as *const _ as *const c_void) }, 32 + 32);
     }
 }
 
 #[test]
 fn test_boxed_str() {
     let x = "raclette".to_owned().into_boxed_str();
-    assert_eq!(x.heap_size_of_children(), 8);
+    assert_size(x.heap_size_of_children(), 8);
 }
 
 #[test]
@@ -111,61 +124,61 @@ fn test_heap_size() {
 
     unsafe {
         // EMPTY is the special non-null address used to represent zero-size allocations.
-        assert_eq!(heap_size_of(EMPTY as *const c_void), 0);
+        assert_size(heap_size_of(EMPTY as *const c_void), 0);
     }
 
     //-----------------------------------------------------------------------
     // Test HeapSizeOf implementations for various built-in types.
 
     // Not on the heap; 0 bytes.
     let x = 0i64;
-    assert_eq!(x.heap_size_of_children(), 0);
+    assert_size(x.heap_size_of_children(), 0);
 
     // An i64 is 8 bytes.
     let x = Box::new(0i64);
-    assert_eq!(x.heap_size_of_children(), 8);
+    assert_size(x.heap_size_of_children(), 8);
 
     // An ascii string with 16 chars is 16 bytes in UTF-8.
     let string = String::from("0123456789abcdef");
-    assert_eq!(string.heap_size_of_children(), 16);
+    assert_size(string.heap_size_of_children(), 16);
 
     let string_ref: (&String, ()) = (&string, ());
-    assert_eq!(string_ref.heap_size_of_children(), 0);
+    assert_size(string_ref.heap_size_of_children(), 0);
 
     let slice: &str = &*string;
-    assert_eq!(slice.heap_size_of_children(), 0);
+    assert_size(slice.heap_size_of_children(), 0);
 
     // Not on the heap.
     let x: Option<i32> = None;
-    assert_eq!(x.heap_size_of_children(), 0);
+    assert_size(x.heap_size_of_children(), 0);
 
     // Not on the heap.
     let x = Some(0i64);
-    assert_eq!(x.heap_size_of_children(), 0);
+    assert_size(x.heap_size_of_children(), 0);
 
     // The `Some` is not on the heap, but the Box is.
     let x = Some(Box::new(0i64));
-    assert_eq!(x.heap_size_of_children(), 8);
+    assert_size(x.heap_size_of_children(), 8);
 
     // Not on the heap.
     let x = ::std::sync::Arc::new(0i64);
-    assert_eq!(x.heap_size_of_children(), 0);
+    assert_size(x.heap_size_of_children(), 0);
 
     // The `Arc` is not on the heap, but the Box is.
     let x = ::std::sync::Arc::new(Box::new(0i64));
-    assert_eq!(x.heap_size_of_children(), 8);
+    assert_size(x.heap_size_of_children(), 8);
 
     // Zero elements, no heap storage.
     let x: Vec<i64> = vec![];
-    assert_eq!(x.heap_size_of_children(), 0);
+    assert_size(x.heap_size_of_children(), 0);
 
     // Four elements, 8 bytes per element.
     let x = vec![0i64, 1i64, 2i64, 3i64];
-    assert_eq!(x.heap_size_of_children(), 32);
+    assert_size(x.heap_size_of_children(), 32);
 }
 
 #[test]
 fn test_boxed_slice() {
     let x = vec![1i64, 2i64].into_boxed_slice();
-    assert_eq!(x.heap_size_of_children(), 16)
+    assert_size(x.heap_size_of_children(), 16)
 }