Add `Pointer::aligned_to` test.

- Derive the `Align` newtype.

src/block.rs

@@ -9,6 +9,7 @@ use core::{ptr, cmp, mem, fmt};
 
 use ptr;
 
+// Derive the size newtype.
 usize_newtype!(pub Size);
 
 /// A contiguous memory block.
@@ -316,7 +317,7 @@ impl Drop for Block {
 
 #[cfg(test)]
 mod test {
-    use super::*;
+    use super::Block;
 
     use brk;
 

src/brk.rs

@@ -192,11 +192,11 @@ fn current_brk() -> Pointer<u8> {
 
 #[cfg(test)]
 mod test {
-    use super::*;
+    use super;
 
     #[test]
     fn ordered() {
-        let brk = lock().canonical_brk(20, 1);
+        let brk = brk::lock().canonical_brk(20, 1);
 
         assert!(brk.0 <= brk.1);
         assert!(brk.1 <= brk.2);
@@ -205,8 +205,8 @@ mod test {
     #[test]
     fn brk_grow_up() {
         unsafe {
-            let brk1 = lock().sbrk(5).unwrap();
-            let brk2 = lock().sbrk(100).unwrap();
+            let brk1 = brk::lock().sbrk(5).unwrap();
+            let brk2 = brk::lock().sbrk(100).unwrap();
 
             assert!(*brk1 < *brk2);
         }
@@ -215,12 +215,12 @@ mod test {
     #[test]
     fn brk_right_segment_change() {
         unsafe {
-            let brk1 = lock().sbrk(5).unwrap();
-            let brk2 = lock().sbrk(100).unwrap();
+            let brk1 = brk::lock().sbrk(5).unwrap();
+            let brk2 = brk::lock().sbrk(100).unwrap();
 
             assert_eq!(brk1.offset(5), brk2);
             assert_eq!(brk2.offset(100), current_brk());
-            assert_eq!(lock().sbrk(0), current_brk());
+            assert_eq!(brk::lock().sbrk(0), current_brk());
         }
     }
 }

src/cell.rs

@@ -53,7 +53,7 @@ impl<T> MoveCell<T> {
 
 #[cfg(test)]
 mod test {
-    use super::*;
+    use super::MoveCell;
 
     #[test]
     fn replace() {

src/fail.rs

@@ -84,7 +84,7 @@ pub fn set_thread_oom_handler(handler: fn() -> !) {
 
 #[cfg(test)]
 mod test {
-    use super::*;
+    use super;
 
     #[test]
     #[should_panic]
@@ -93,8 +93,8 @@ mod test {
             panic!("cats are not cute.");
         }
 
-        set_oom_handler(panic);
-        oom();
+        fail::set_oom_handler(panic);
+        fail::oom();
     }
 
     #[test]
@@ -109,8 +109,8 @@ mod test {
             panic!("cats are not cute.");
         }
 
-        set_oom_handler(infinite);
-        set_thread_oom_handler(panic);
-        oom();
+        fail::set_oom_handler(infinite);
+        fail::set_thread_oom_handler(panic);
+        fail::oom();
     }
 }

src/lazy_init.rs

@@ -72,7 +72,7 @@ impl<F: FnMut() -> T, T> LazyInit<F, T> {
 
 #[cfg(test)]
 mod test {
-    use super::*;
+    use super::LazyInit;
 
     use core::cell::Cell;
 

src/ptr.rs

@@ -5,6 +5,9 @@ use prelude::*;
 use core::nonzero::NonZero;
 use core::{ops, marker, mem};
 
+// Derive the align newtype.
+usize_newtype!(pub Align);
+
 /// A pointer wrapper type.
 ///
 /// A wrapper around a raw non-null `*mut T` that indicates that the possessor of this wrapper owns
@@ -88,7 +91,7 @@ impl<T> Pointer<T> {
 
     /// Is this pointer aligned to `align`?
     #[inline]
-    pub fn aligned_to(&self, align: usize) -> bool {
+    pub fn aligned_to(&self, align: Align) -> bool {
         *self.ptr as usize % align == 0
     }
 }
@@ -224,7 +227,7 @@ impl<T: Leak> Drop for Jar<T> {
 
 #[cfg(test)]
 mod test {
-    use super::*;
+    use super::{self, Pointer};
 
     #[test]
     fn pointer() {
@@ -250,4 +253,12 @@ mod test {
     fn empty() {
         assert_eq!(*Pointer::<u8>::empty() as usize, 1);
     }
+
+    #[test]
+    fn aligned_to() {
+        let mut int = 34u16;
+        assert!(Pointer::from(&mut int).aligned_to(ptr::Align(2)));
+        let mut int = 34u32;
+        assert!(Pointer::from(&mut int).aligned_to(ptr::Align(4)));
+    }
 }