Added tests

Author: octavonce

.travis.yml

@@ -24,5 +24,5 @@ matrix:
   fast_finish: true
 
 script:
-  - cargo build --release
-  - cargo build --release --features no_secure
+  - cargo test --all
+  - cargo test --all --features no_secure

Cargo.toml

@@ -4,12 +4,15 @@ version = "0.1.0"
 authors = ["Octavian Oncescu <[email protected]>"]
 edition = "2018"
 repository = "https://github.com/purpleprotocol/mimalloc_rust"
-keywords = ["allocator", "encrypted-heap", "performance"]
-categories = ["allocator"]
+keywords = ["mimalloc", "allocator", "encrypted-heap", "performance"]
+categories = ["memory-management", "api-bindings"]
 description = "Performance and security oriented drop-in allocator"
 license = "MIT"
 readme = "README.md"
 
+[badges]
+travis-ci = { repository = "purpleprotocol/mimalloc_rust" }
+
 [dependencies]
 libc = "0.2"
 libmimalloc-sys = { path = "libmimalloc-sys", version = "0.1.0" }

libmimalloc-sys/src/lib.rs

@@ -7,4 +7,28 @@ extern "C" {
    pub fn mi_malloc_aligned(size: size_t, alignment: size_t) -> *const c_void;
    pub fn mi_realloc_aligned(p: *const c_void, size: size_t, alignment: size_t) -> *const c_void;
    pub fn mi_free(p: *const c_void) -> c_void;
+}
+
+#[cfg(test)]
+mod tests {
+   use super::*;
+
+   #[test]
+   fn it_frees_memory_malloc() {
+      let ptr = unsafe { mi_malloc_aligned(8, 8) } as *mut u8;
+      unsafe { mi_free(ptr as *const c_void) };
+   }
+
+   #[test]
+   fn it_frees_memory_zalloc() {
+      let ptr = unsafe { mi_zalloc_aligned(8, 8) } as *mut u8;
+      unsafe { mi_free(ptr as *const c_void) };
+   }
+
+   #[test]
+   fn it_frees_memory_realloc() {
+      let ptr = unsafe { mi_malloc_aligned(8, 8) } as *mut u8;
+      let ptr = unsafe { mi_realloc_aligned(ptr as *const c_void, 8, 8) } as *mut u8;
+      unsafe { mi_free(ptr as *const c_void) };
+   }
 }

src/lib.rs

@@ -4,7 +4,7 @@
 //! Mimalloc is a general purpose, performance oriented allocator built by Microsoft.
 //! 
 //! ## Usage
-//! ```rust
+//! ```rust,ignore
 //! use mimalloc::MiMalloc;
 //!
 //! #[global_allocator]
@@ -16,7 +16,7 @@
 //! heap allocations are encrypted, but this results in a 3% increase in overhead.
 //! 
 //! In `Cargo.toml`:
-//! ```rust
+//! ```rust,ignore
 //! [dependencies]
 //! mimalloc = { version = "*", features = ["no_secure"] }
 //! ```
@@ -51,7 +51,7 @@ const MIN_ALIGN: usize = 16;
 /// Drop-in mimalloc global allocator.
 /// 
 /// ## Usage
-/// ```rust
+/// ```rust,ignore
 /// use mimalloc::MiMalloc;
 ///
 /// #[global_allocator]
@@ -97,4 +97,43 @@ unsafe impl GlobalAlloc for MiMalloc {
 
         mi_realloc_aligned(ptr as *const c_void, new_size, align) as *mut u8
     }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_frees_allocated_memory() {
+        unsafe {
+            let layout = Layout::from_size_align(8, 8).unwrap();
+            let alloc = MiMalloc;
+
+            let ptr = alloc.alloc(layout.clone());
+            alloc.dealloc(ptr, layout);
+        }
+    }
+
+    #[test]
+    fn it_frees_zero_allocated_memory() {
+        unsafe {
+            let layout = Layout::from_size_align(8, 8).unwrap();
+            let alloc = MiMalloc;
+
+            let ptr = alloc.alloc_zeroed(layout.clone());
+            alloc.dealloc(ptr, layout);
+        }
+    }
+
+    #[test]
+    fn it_frees_reallocated_memory() {
+        unsafe {
+            let layout = Layout::from_size_align(8, 8).unwrap();
+            let alloc = MiMalloc;
+
+            let ptr = alloc.alloc(layout.clone());
+            let ptr = alloc.realloc(ptr, layout.clone(), 16);
+            alloc.dealloc(ptr, layout);
+        }
+    }
 }