diff --git a/src/region_pool.rs b/src/region_pool.rs
index f6fa3b4..df5a026 100644
--- a/src/region_pool.rs
+++ b/src/region_pool.rs
@@ -185,232 +185,234 @@
 }
 
 #[cfg(test)]
-#[derive(Debug, PartialEq, Eq)]
-struct RegionExample {
-    base: usize,
-    length: usize,
-    used: bool,
-}
+mod tests {
+    use super::*;
 
-#[cfg(test)]
-impl RegionExample {
-    fn new(base: usize, length: usize, used: bool) -> Self {
-        Self { base, length, used }
-    }
-}
-
-#[cfg(test)]
-impl Region for RegionExample {
-    type Resource = ();
-
-    fn base(&self) -> usize {
-        self.base
-    }
-
-    fn length(&self) -> usize {
-        self.length
-    }
-
-    fn used(&self) -> bool {
-        self.used
-    }
-
-    fn contains(&self, base: usize, length: usize) -> bool {
-        self.base <= base && base + length <= self.base + self.length
-    }
-
-    fn try_append(&mut self, other: &Self) -> bool {
-        if self.used == other.used && self.base + self.length == other.base {
-            self.length += other.length;
-            true
-        } else {
-            false
-        }
-    }
-
-    fn create_split(
-        &self,
+    #[derive(Debug, PartialEq, Eq)]
+    struct RegionExample {
         base: usize,
         length: usize,
-        resource: Option<Self::Resource>,
-    ) -> (Self, Vec<Self>) {
-        let mut res = Vec::new();
-        if self.base != base {
-            res.push(RegionExample::new(self.base, base - self.base, self.used));
-        }
-        res.push(RegionExample::new(base, length, resource.is_some()));
-        if self.base + self.length != base + length {
-            res.push(RegionExample::new(
-                base + length,
-                (self.base + self.length) - (base + length),
-                self.used,
-            ));
-        }
-
-        (RegionExample::new(base, length, resource.is_some()), res)
+        used: bool,
     }
-}
 
-#[test]
-fn test_region_contains() {
-    let region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
+    impl RegionExample {
+        fn new(base: usize, length: usize, used: bool) -> Self {
+            Self { base, length, used }
+        }
+    }
 
-    assert!(region.contains(0x4000_0000, 0x1000_0000));
-    assert!(!region.contains(0x4000_0000 - 1, 0x1000_0000 + 1));
-    assert!(!region.contains(0x4000_0000, 0x1000_0000 + 1));
-    assert!(region.contains(0x4000_0000 + 1, 0x1000_0000 - 1));
-}
+    impl Region for RegionExample {
+        type Resource = ();
 
-#[test]
-fn test_region_try_append() {
-    // Normal append
-    let mut region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
-    let appending = RegionExample::new(0x5000_0000, 0x0000_1000, false);
+        fn base(&self) -> usize {
+            self.base
+        }
 
-    assert!(region.try_append(&appending));
-    assert_eq!(RegionExample::new(0x4000_0000, 0x1000_1000, false), region);
+        fn length(&self) -> usize {
+            self.length
+        }
 
-    // Different used flags
-    let mut region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
-    let appending = RegionExample::new(0x5000_0000, 0x0000_1000, true);
+        fn used(&self) -> bool {
+            self.used
+        }
 
-    assert!(!region.try_append(&appending));
-    assert_eq!(RegionExample::new(0x4000_0000, 0x1000_0000, false), region);
+        fn contains(&self, base: usize, length: usize) -> bool {
+            self.base <= base && base + length <= self.base + self.length
+        }
 
-    // Not continious
-    let mut region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
-    let appending = RegionExample::new(0x5000_1000, 0x0000_1000, false);
+        fn try_append(&mut self, other: &Self) -> bool {
+            if self.used == other.used && self.base + self.length == other.base {
+                self.length += other.length;
+                true
+            } else {
+                false
+            }
+        }
 
-    assert!(!region.try_append(&appending));
-    assert_eq!(RegionExample::new(0x4000_0000, 0x1000_0000, false), region);
-}
+        fn create_split(
+            &self,
+            base: usize,
+            length: usize,
+            resource: Option<Self::Resource>,
+        ) -> (Self, Vec<Self>) {
+            let mut res = Vec::new();
+            if self.base != base {
+                res.push(RegionExample::new(self.base, base - self.base, self.used));
+            }
+            res.push(RegionExample::new(base, length, resource.is_some()));
+            if self.base + self.length != base + length {
+                res.push(RegionExample::new(
+                    base + length,
+                    (self.base + self.length) - (base + length),
+                    self.used,
+                ));
+            }
 
-#[test]
-fn test_region_create_split() {
-    // Cut first part
-    let region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
+            (RegionExample::new(base, length, resource.is_some()), res)
+        }
+    }
 
-    let res = region.create_split(0x4000_0000, 0x0000_1000, Some(())).1;
-    assert_eq!(RegionExample::new(0x4000_0000, 0x0000_1000, true), res[0]);
-    assert_eq!(RegionExample::new(0x4000_1000, 0x0fff_f000, false), res[1]);
+    #[test]
+    fn test_region_contains() {
+        let region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
 
-    // Cut last part
-    let region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
+        assert!(region.contains(0x4000_0000, 0x1000_0000));
+        assert!(!region.contains(0x4000_0000 - 1, 0x1000_0000 + 1));
+        assert!(!region.contains(0x4000_0000, 0x1000_0000 + 1));
+        assert!(region.contains(0x4000_0000 + 1, 0x1000_0000 - 1));
+    }
 
-    let res = region.create_split(0x4fff_f000, 0x0000_1000, Some(())).1;
-    assert_eq!(RegionExample::new(0x4000_0000, 0x0fff_f000, false), res[0]);
-    assert_eq!(RegionExample::new(0x4fff_f000, 0x0000_1000, true), res[1]);
+    #[test]
+    fn test_region_try_append() {
+        // Normal append
+        let mut region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
+        let appending = RegionExample::new(0x5000_0000, 0x0000_1000, false);
 
-    // Cut middle part
-    let region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
+        assert!(region.try_append(&appending));
+        assert_eq!(RegionExample::new(0x4000_0000, 0x1000_1000, false), region);
 
-    let res = region.create_split(0x4020_0000, 0x0000_1000, Some(())).1;
-    assert_eq!(RegionExample::new(0x4000_0000, 0x0020_0000, false), res[0]);
-    assert_eq!(RegionExample::new(0x4020_0000, 0x0000_1000, true), res[1]);
-    assert_eq!(RegionExample::new(0x4020_1000, 0x0fdf_f000, false), res[2]);
-}
+        // Different used flags
+        let mut region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
+        let appending = RegionExample::new(0x5000_0000, 0x0000_1000, true);
 
-#[test]
-fn test_region_pool_add() {
-    let mut pool = RegionPool::new();
-    assert_eq!(
-        Ok(()),
+        assert!(!region.try_append(&appending));
+        assert_eq!(RegionExample::new(0x4000_0000, 0x1000_0000, false), region);
+
+        // Not continious
+        let mut region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
+        let appending = RegionExample::new(0x5000_1000, 0x0000_1000, false);
+
+        assert!(!region.try_append(&appending));
+        assert_eq!(RegionExample::new(0x4000_0000, 0x1000_0000, false), region);
+    }
+
+    #[test]
+    fn test_region_create_split() {
+        // Cut first part
+        let region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
+
+        let res = region.create_split(0x4000_0000, 0x0000_1000, Some(())).1;
+        assert_eq!(RegionExample::new(0x4000_0000, 0x0000_1000, true), res[0]);
+        assert_eq!(RegionExample::new(0x4000_1000, 0x0fff_f000, false), res[1]);
+
+        // Cut last part
+        let region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
+
+        let res = region.create_split(0x4fff_f000, 0x0000_1000, Some(())).1;
+        assert_eq!(RegionExample::new(0x4000_0000, 0x0fff_f000, false), res[0]);
+        assert_eq!(RegionExample::new(0x4fff_f000, 0x0000_1000, true), res[1]);
+
+        // Cut middle part
+        let region = RegionExample::new(0x4000_0000, 0x1000_0000, false);
+
+        let res = region.create_split(0x4020_0000, 0x0000_1000, Some(())).1;
+        assert_eq!(RegionExample::new(0x4000_0000, 0x0020_0000, false), res[0]);
+        assert_eq!(RegionExample::new(0x4020_0000, 0x0000_1000, true), res[1]);
+        assert_eq!(RegionExample::new(0x4020_1000, 0x0fdf_f000, false), res[2]);
+    }
+
+    #[test]
+    fn test_region_pool_add() {
+        let mut pool = RegionPool::new();
+        assert_eq!(
+            Ok(()),
+            pool.add(RegionExample::new(0x4000_0000, 0x1000_0000, false))
+        );
+        assert_eq!(
+            Ok(()),
+            pool.add(RegionExample::new(0x5000_0000, 0x1000_0000, false))
+        );
+        assert_eq!(
+            Err(RegionPoolError::AlreadyUsed),
+            pool.add(RegionExample::new(0x4000_1000, 0x1000, false))
+        );
+    }
+
+    #[test]
+    fn test_pool_allocate() {
+        let mut pool = RegionPool::new();
         pool.add(RegionExample::new(0x4000_0000, 0x1000_0000, false))
-    );
-    assert_eq!(
-        Ok(()),
-        pool.add(RegionExample::new(0x5000_0000, 0x1000_0000, false))
-    );
-    assert_eq!(
-        Err(RegionPoolError::AlreadyUsed),
-        pool.add(RegionExample::new(0x4000_1000, 0x1000, false))
-    );
-}
+            .unwrap();
 
-#[test]
-fn test_pool_allocate() {
-    let mut pool = RegionPool::new();
-    pool.add(RegionExample::new(0x4000_0000, 0x1000_0000, false))
-        .unwrap();
+        let res = pool.allocate(0x1000, ());
+        assert_eq!(Ok(RegionExample::new(0x4000_0000, 0x1000, true)), res);
+        let res = pool.allocate(0x1_0000, ());
+        assert_eq!(Ok(RegionExample::new(0x4000_1000, 0x1_0000, true)), res);
+        let res = pool.allocate(0x2000_0000, ());
+        assert_eq!(Err(RegionPoolError::NoSpace), res);
+    }
 
-    let res = pool.allocate(0x1000, ());
-    assert_eq!(Ok(RegionExample::new(0x4000_0000, 0x1000, true)), res);
-    let res = pool.allocate(0x1_0000, ());
-    assert_eq!(Ok(RegionExample::new(0x4000_1000, 0x1_0000, true)), res);
-    let res = pool.allocate(0x2000_0000, ());
-    assert_eq!(Err(RegionPoolError::NoSpace), res);
-}
+    #[test]
+    fn test_region_pool_acquire() {
+        let mut pool = RegionPool::new();
+        pool.add(RegionExample::new(0x4000_0000, 0x1000_0000, false))
+            .unwrap();
 
-#[test]
-fn test_region_pool_acquire() {
-    let mut pool = RegionPool::new();
-    pool.add(RegionExample::new(0x4000_0000, 0x1000_0000, false))
-        .unwrap();
+        let res = pool.acquire(0x4000_1000, 0x1000, ());
+        assert_eq!(Ok(RegionExample::new(0x4000_1000, 0x1000, true)), res);
+        let res = pool.allocate(0x1_0000, ());
+        assert_eq!(Ok(RegionExample::new(0x4000_2000, 0x10000, true)), res);
+        let res = pool.acquire(0x4000_1000, 0x1000, ());
+        assert_eq!(Err(RegionPoolError::AlreadyUsed), res);
+    }
 
-    let res = pool.acquire(0x4000_1000, 0x1000, ());
-    assert_eq!(Ok(RegionExample::new(0x4000_1000, 0x1000, true)), res);
-    let res = pool.allocate(0x1_0000, ());
-    assert_eq!(Ok(RegionExample::new(0x4000_2000, 0x10000, true)), res);
-    let res = pool.acquire(0x4000_1000, 0x1000, ());
-    assert_eq!(Err(RegionPoolError::AlreadyUsed), res);
-}
+    #[test]
+    fn test_region_pool_release() {
+        let mut pool = RegionPool::new();
+        pool.add(RegionExample::new(0x4000_0000, 0x1000_0000, false))
+            .unwrap();
 
-#[test]
-fn test_region_pool_release() {
-    let mut pool = RegionPool::new();
-    pool.add(RegionExample::new(0x4000_0000, 0x1000_0000, false))
-        .unwrap();
+        let res = pool.allocate(0x1000, ());
+        assert_eq!(Ok(RegionExample::new(0x4000_0000, 0x1000, true)), res);
+        assert_eq!(Ok(()), pool.release(res.unwrap()));
 
-    let res = pool.allocate(0x1000, ());
-    assert_eq!(Ok(RegionExample::new(0x4000_0000, 0x1000, true)), res);
-    assert_eq!(Ok(()), pool.release(res.unwrap()));
+        let res = pool.allocate(0x1_0000, ());
+        assert_eq!(Ok(RegionExample::new(0x4000_0000, 0x10000, true)), res);
+        assert_eq!(Ok(()), pool.release(res.unwrap()));
 
-    let res = pool.allocate(0x1_0000, ());
-    assert_eq!(Ok(RegionExample::new(0x4000_0000, 0x10000, true)), res);
-    assert_eq!(Ok(()), pool.release(res.unwrap()));
+        assert_eq!(
+            Err(RegionPoolError::NotFound),
+            pool.release(RegionExample::new(0x4000_0000, 0x1000, true))
+        );
+    }
 
-    assert_eq!(
-        Err(RegionPoolError::NotFound),
-        pool.release(RegionExample::new(0x4000_0000, 0x1000, true))
-    );
-}
+    #[test]
+    #[should_panic]
+    fn test_region_pool_release_not_used() {
+        let mut pool = RegionPool::new();
+        pool.release(RegionExample::new(0x4000_0000, 0x1000, false))
+            .unwrap();
+    }
 
-#[test]
-#[should_panic]
-fn test_region_pool_release_not_used() {
-    let mut pool = RegionPool::new();
-    pool.release(RegionExample::new(0x4000_0000, 0x1000, false))
-        .unwrap();
-}
+    #[test]
+    fn test_region_pool_find_containing_region() {
+        let mut pool = RegionPool::<RegionExample>::new();
+        pool.add(RegionExample::new(0x4000_0000, 0x1000_0000, false))
+            .unwrap();
 
-#[test]
-fn test_region_pool_find_containing_region() {
-    let mut pool = RegionPool::<RegionExample>::new();
-    pool.add(RegionExample::new(0x4000_0000, 0x1000_0000, false))
-        .unwrap();
+        assert_eq!(
+            Err(RegionPoolError::NotFound),
+            pool.find_containing_region(0x0000_0000, 0x1000)
+        );
 
-    assert_eq!(
-        Err(RegionPoolError::NotFound),
-        pool.find_containing_region(0x0000_0000, 0x1000)
-    );
+        assert_eq!(
+            Err(RegionPoolError::NotFound),
+            pool.find_containing_region(0x5000_0000, 0x1000)
+        );
 
-    assert_eq!(
-        Err(RegionPoolError::NotFound),
-        pool.find_containing_region(0x5000_0000, 0x1000)
-    );
+        assert_eq!(
+            Err(RegionPoolError::NotFound),
+            pool.find_containing_region(0x4000_0000, 0x2000_0000)
+        );
 
-    assert_eq!(
-        Err(RegionPoolError::NotFound),
-        pool.find_containing_region(0x4000_0000, 0x2000_0000)
-    );
+        assert_eq!(
+            Ok(&RegionExample::new(0x4000_0000, 0x1000_0000, false)),
+            pool.find_containing_region(0x4000_0000, 0x1000_0000)
+        );
 
-    assert_eq!(
-        Ok(&RegionExample::new(0x4000_0000, 0x1000_0000, false)),
-        pool.find_containing_region(0x4000_0000, 0x1000_0000)
-    );
-
-    assert_eq!(
-        Ok(&RegionExample::new(0x4000_0000, 0x1000_0000, false)),
-        pool.find_containing_region(0x4000_1000, 0x1000)
-    );
+        assert_eq!(
+            Ok(&RegionExample::new(0x4000_0000, 0x1000_0000, false)),
+            pool.find_containing_region(0x4000_1000, 0x1000)
+        );
+    }
 }