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:/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)
 }