diff --git a/src/decoder.rs b/src/decoder.rs
index 6a360d5..77df8bd 100644
--- a/src/decoder.rs
+++ b/src/decoder.rs
@@ -338,49 +338,53 @@ pub fn decode_data_url(url: &str) -> Result<DecodedMap> {
     decode_slice(&data[..])
 }
 
-#[test]
-fn test_strip_header() {
-    use std::io::BufRead;
-    let input: &[_] = b")]}garbage\r\n[1, 2, 3]";
-    let mut reader = io::BufReader::new(StripHeaderReader::new(input));
-    let mut text = String::new();
-    reader.read_line(&mut text).ok();
-    assert_eq!(text, "[1, 2, 3]");
-}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::{self, BufRead};
+
+    #[test]
+    fn test_strip_header() {
+        let input: &[_] = b")]}garbage\r\n[1, 2, 3]";
+        let mut reader = io::BufReader::new(StripHeaderReader::new(input));
+        let mut text = String::new();
+        reader.read_line(&mut text).ok();
+        assert_eq!(text, "[1, 2, 3]");
+    }
 
-#[test]
-fn test_bad_newline() {
-    use std::io::BufRead;
-    let input: &[_] = b")]}'\r[1, 2, 3]";
-    let mut reader = io::BufReader::new(StripHeaderReader::new(input));
-    let mut text = String::new();
-    match reader.read_line(&mut text) {
-        Err(err) => {
-            assert_eq!(err.kind(), io::ErrorKind::InvalidData);
-        }
-        Ok(_) => {
-            panic!("Expected failure");
+    #[test]
+    fn test_bad_newline() {
+        let input: &[_] = b")]}'\r[1, 2, 3]";
+        let mut reader = io::BufReader::new(StripHeaderReader::new(input));
+        let mut text = String::new();
+        match reader.read_line(&mut text) {
+            Err(err) => {
+                assert_eq!(err.kind(), io::ErrorKind::InvalidData);
+            }
+            Ok(_) => {
+                panic!("Expected failure");
+            }
         }
     }
-}
 
-#[test]
-fn test_decode_rmi() {
-    fn decode(rmi_str: &str) -> Vec<usize> {
-        let mut out = bitvec::bitvec![u8, Lsb0; 0; 0];
-        decode_rmi(rmi_str, &mut out).expect("failed to decode");
+    #[test]
+    fn test_decode_rmi() {
+        fn decode(rmi_str: &str) -> Vec<usize> {
+            let mut out = bitvec::bitvec![u8, Lsb0; 0; 0];
+            decode_rmi(rmi_str, &mut out).expect("failed to decode");
 
-        let mut res = vec![];
-        for (idx, bit) in out.iter().enumerate() {
-            if *bit {
-                res.push(idx);
+            let mut res = vec![];
+            for (idx, bit) in out.iter().enumerate() {
+                if *bit {
+                    res.push(idx);
+                }
             }
+            res
         }
-        res
-    }
 
-    // This is 0-based index of the bits
-    assert_eq!(decode("AAB"), vec![12]);
-    assert_eq!(decode("g"), vec![5]);
-    assert_eq!(decode("Bg"), vec![0, 11]);
+        // This is 0-based index of the bits
+        assert_eq!(decode("AAB"), vec![12]);
+        assert_eq!(decode("g"), vec![5]);
+        assert_eq!(decode("Bg"), vec![0, 11]);
+    }
 }
diff --git a/src/encoder.rs b/src/encoder.rs
index e61fe8d..b2bc0ff 100644
--- a/src/encoder.rs
+++ b/src/encoder.rs
@@ -229,25 +229,30 @@ impl Encodable for DecodedMap {
     }
 }
 
-#[test]
-fn test_encode_rmi() {
-    fn encode(indices: &[usize]) -> String {
-        let mut out = vec![];
+#[cfg(test)]
+mod tests {
+    use super::*;
 
-        // Fill with zeros while testing
-        let mut data = vec![0; 256];
+    #[test]
+    fn test_encode_rmi() {
+        fn encode(indices: &[usize]) -> String {
+            let mut out = vec![];
 
-        let bits = data.view_bits_mut::<Lsb0>();
-        for &i in indices {
-            bits.set(i, true);
+            // Fill with zeros while testing
+            let mut data = vec![0; 256];
+
+            let bits = data.view_bits_mut::<Lsb0>();
+            for &i in indices {
+                bits.set(i, true);
+            }
+
+            encode_rmi(&mut out, &data);
+            String::from_utf8(out).unwrap()
         }
 
-        encode_rmi(&mut out, &data);
-        String::from_utf8(out).unwrap()
+        // This is 0-based index
+        assert_eq!(encode(&[12]), "AAB");
+        assert_eq!(encode(&[5]), "g");
+        assert_eq!(encode(&[0, 11]), "Bg");
     }
-
-    // This is 0-based index
-    assert_eq!(encode(&[12]), "AAB");
-    assert_eq!(encode(&[5]), "g");
-    assert_eq!(encode(&[0, 11]), "Bg");
 }
diff --git a/src/js_identifiers.rs b/src/js_identifiers.rs
index d44b282..9ab7cb8 100644
--- a/src/js_identifiers.rs
+++ b/src/js_identifiers.rs
@@ -63,20 +63,23 @@ pub fn get_javascript_token(source_line: &str) -> Option<&str> {
     }
 }
 
-#[test]
-fn test_is_valid_javascript_identifier() {
-    // assert_eq!(is_valid_javascript_identifier("foo 123"));
-    assert!(is_valid_javascript_identifier("foo_$123"));
-    assert!(!is_valid_javascript_identifier(" foo"));
-    assert!(!is_valid_javascript_identifier("foo "));
-    assert!(!is_valid_javascript_identifier("[123]"));
-    assert!(!is_valid_javascript_identifier("foo.bar"));
-    // Should these pass?
-    // assert!(is_valid_javascript_identifier("foo [bar]"));
-    // assert!(is_valid_javascript_identifier("foo[bar]"));
+#[cfg(test)]
+mod tests {
+    use super::*;
 
-    assert_eq!(get_javascript_token("foo "), Some("foo"));
-    assert_eq!(get_javascript_token("f _hi"), Some("f"));
-    assert_eq!(get_javascript_token("foo.bar"), Some("foo"));
-    assert_eq!(get_javascript_token("[foo,bar]"), None);
+    #[test]
+    fn test_is_valid_javascript_identifier() {
+        // assert_eq!(is_valid_javascript_identifier("foo 123"));
+        assert!(is_valid_javascript_identifier("foo_$123"));
+        assert!(!is_valid_javascript_identifier(" foo"));
+        assert!(!is_valid_javascript_identifier("foo "));
+        assert!(!is_valid_javascript_identifier("[123]"));
+        assert!(!is_valid_javascript_identifier("foo.bar"));
+        // Should these pass?
+        // assert!(is_valid_javascript_identifier("foo [bar]"));
+        assert_eq!(get_javascript_token("foo "), Some("foo"));
+        assert_eq!(get_javascript_token("f _hi"), Some("f"));
+        assert_eq!(get_javascript_token("foo.bar"), Some("foo"));
+        assert_eq!(get_javascript_token("[foo,bar]"), None);
+    }
 }
diff --git a/src/ram_bundle.rs b/src/ram_bundle.rs
index c01a3d7..d37af65 100644
--- a/src/ram_bundle.rs
+++ b/src/ram_bundle.rs
@@ -491,125 +491,132 @@ pub fn is_unbundle_path(bundle_path: &Path) -> bool {
     bundle_magic == RAM_BUNDLE_MAGIC.to_le_bytes()
 }
 
-#[test]
-fn test_indexed_ram_bundle_parse() -> std::result::Result<(), Box<dyn std::error::Error>> {
-    let mut bundle_file =
-        File::open("./tests/fixtures/ram_bundle/indexed_bundle_1/basic.jsbundle")?;
-    let mut bundle_data = Vec::new();
-    bundle_file.read_to_end(&mut bundle_data)?;
-    assert!(is_ram_bundle_slice(&bundle_data));
-    let ram_bundle = RamBundle::parse_indexed_from_slice(&bundle_data)?;
-
-    let indexed_ram_bundle = match ram_bundle.repr.clone() {
-        RamBundleImpl::Indexed(bundle) => bundle,
-        _ => {
-            panic!("Invalid RamBundleImpl type");
-        }
-    };
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs::File;
+    use std::io::Read;
+
+    #[test]
+    fn test_indexed_ram_bundle_parse() -> std::result::Result<(), Box<dyn std::error::Error>> {
+        let mut bundle_file =
+            File::open("./tests/fixtures/ram_bundle/indexed_bundle_1/basic.jsbundle")?;
+        let mut bundle_data = Vec::new();
+        bundle_file.read_to_end(&mut bundle_data)?;
+        assert!(is_ram_bundle_slice(&bundle_data));
+        let ram_bundle = RamBundle::parse_indexed_from_slice(&bundle_data)?;
+
+        let indexed_ram_bundle = match ram_bundle.repr.clone() {
+            RamBundleImpl::Indexed(bundle) => bundle,
+            _ => {
+                panic!("Invalid RamBundleImpl type");
+            }
+        };
 
-    // Header checks
-    assert_eq!(indexed_ram_bundle.startup_code_size, 0x7192);
-    assert_eq!(indexed_ram_bundle.startup_code_offset, 0x34);
-
-    assert_eq!(ram_bundle.module_count(), 5);
-
-    // Check first modules
-    let mut module_iter = ram_bundle.iter_modules();
-
-    let module_0 = module_iter.next().unwrap()?;
-    let module_0_data = module_0.data();
-    assert_eq!(module_0.id(), 0);
-    assert_eq!(module_0_data.len(), 0xa8 - 1);
-    assert_eq!(
-        &module_0_data[0..60],
-        "__d(function(g,r,i,a,m,e,d){\"use strict\";const o=r(d[0]),s=r".as_bytes()
-    );
-
-    let module_3 = module_iter.next().unwrap()?;
-    let module_3_data = module_3.data();
-    assert_eq!(module_3.id(), 3);
-    assert_eq!(module_3_data.len(), 0x6b - 1);
-    assert_eq!(
-        &module_3_data[0..60],
-        "__d(function(g,r,i,a,m,e,d){\"use strict\";console.log('inside".as_bytes()
-    );
-
-    let module_1 = ram_bundle.get_module(1)?;
-    assert!(module_1.is_none());
-
-    Ok(())
-}
+        // Header checks
+        assert_eq!(indexed_ram_bundle.startup_code_size, 0x7192);
+        assert_eq!(indexed_ram_bundle.startup_code_offset, 0x34);
+
+        assert_eq!(ram_bundle.module_count(), 5);
+
+        // Check first modules
+        let mut module_iter = ram_bundle.iter_modules();
+
+        let module_0 = module_iter.next().unwrap()?;
+        let module_0_data = module_0.data();
+        assert_eq!(module_0.id(), 0);
+        assert_eq!(module_0_data.len(), 0xa8 - 1);
+        assert_eq!(
+            &module_0_data[0..60],
+            "__d(function(g,r,i,a,m,e,d){\"use strict\";const o=r(d[0]),s=r".as_bytes()
+        );
+
+        let module_3 = module_iter.next().unwrap()?;
+        let module_3_data = module_3.data();
+        assert_eq!(module_3.id(), 3);
+        assert_eq!(module_3_data.len(), 0x6b - 1);
+        assert_eq!(
+            &module_3_data[0..60],
+            "__d(function(g,r,i,a,m,e,d){\"use strict\";console.log('inside".as_bytes()
+        );
+
+        let module_1 = ram_bundle.get_module(1)?;
+        assert!(module_1.is_none());
+
+        Ok(())
+    }
 
-#[test]
-fn test_indexed_ram_bundle_split() -> std::result::Result<(), Box<dyn std::error::Error>> {
-    let ram_bundle = RamBundle::parse_indexed_from_path(Path::new(
-        "./tests/fixtures/ram_bundle/indexed_bundle_1/basic.jsbundle",
-    ))?;
+    #[test]
+    fn test_indexed_ram_bundle_split() -> std::result::Result<(), Box<dyn std::error::Error>> {
+        let ram_bundle = RamBundle::parse_indexed_from_path(Path::new(
+            "./tests/fixtures/ram_bundle/indexed_bundle_1/basic.jsbundle",
+        ))?;
 
-    let sourcemap_file =
-        File::open("./tests/fixtures/ram_bundle/indexed_bundle_1/basic.jsbundle.map")?;
-    let ism = SourceMapIndex::from_reader(sourcemap_file)?;
+        let sourcemap_file =
+            File::open("./tests/fixtures/ram_bundle/indexed_bundle_1/basic.jsbundle.map")?;
+        let ism = SourceMapIndex::from_reader(sourcemap_file)?;
 
-    assert!(ism.is_for_ram_bundle());
+        assert!(ism.is_for_ram_bundle());
 
-    let x_facebook_offsets = ism.x_facebook_offsets().unwrap();
-    assert_eq!(x_facebook_offsets.len(), 5);
+        let x_facebook_offsets = ism.x_facebook_offsets().unwrap();
+        assert_eq!(x_facebook_offsets.len(), 5);
 
-    let x_metro_module_paths = ism.x_metro_module_paths().unwrap();
-    assert_eq!(x_metro_module_paths.len(), 7);
+        let x_metro_module_paths = ism.x_metro_module_paths().unwrap();
+        assert_eq!(x_metro_module_paths.len(), 7);
 
-    // Modules 0, 3, 4
-    assert_eq!(split_ram_bundle(&ram_bundle, &ism)?.count(), 3);
+        // Modules 0, 3, 4
+        assert_eq!(split_ram_bundle(&ram_bundle, &ism)?.count(), 3);
 
-    let mut ram_bundle_iter = split_ram_bundle(&ram_bundle, &ism)?;
+        let mut ram_bundle_iter = split_ram_bundle(&ram_bundle, &ism)?;
 
-    let (name, sourceview, sourcemap) = ram_bundle_iter.next().unwrap()?;
-    assert_eq!(name, "0.js");
-    assert_eq!(
-        &sourceview.source()[0..60],
-        "__d(function(g,r,i,a,m,e,d){\"use strict\";const o=r(d[0]),s=r"
-    );
-    assert_eq!(
-        &sourcemap.get_source_contents(0).unwrap()[0..60],
-        "const f = require(\"./other\");\nconst isWindows = require(\"is-"
-    );
+        let (name, sourceview, sourcemap) = ram_bundle_iter.next().unwrap()?;
+        assert_eq!(name, "0.js");
+        assert_eq!(
+            &sourceview.source()[0..60],
+            "__d(function(g,r,i,a,m,e,d){\"use strict\";const o=r(d[0]),s=r"
+        );
+        assert_eq!(
+            &sourcemap.get_source_contents(0).unwrap()[0..60],
+            "const f = require(\"./other\");\nconst isWindows = require(\"is-"
+        );
 
-    Ok(())
-}
+        Ok(())
+    }
 
-#[test]
-fn test_file_ram_bundle_parse() -> std::result::Result<(), Box<dyn std::error::Error>> {
-    let valid_bundle_path = Path::new("./tests/fixtures/ram_bundle/file_bundle_1/basic.bundle");
-    assert!(is_unbundle_path(valid_bundle_path));
+    #[test]
+    fn test_file_ram_bundle_parse() -> std::result::Result<(), Box<dyn std::error::Error>> {
+        let valid_bundle_path = Path::new("./tests/fixtures/ram_bundle/file_bundle_1/basic.bundle");
+        assert!(is_unbundle_path(valid_bundle_path));
 
-    assert!(!is_unbundle_path(Path::new("./tmp/invalid/bundle/path")));
+        assert!(!is_unbundle_path(Path::new("./tmp/invalid/bundle/path")));
 
-    let ram_bundle = RamBundle::parse_unbundle_from_path(valid_bundle_path)?;
+        let ram_bundle = RamBundle::parse_unbundle_from_path(valid_bundle_path)?;
 
-    match ram_bundle.repr {
-        RamBundleImpl::Unbundle(_) => (),
-        _ => {
-            panic!("Invalid RamBundleImpl type");
-        }
-    };
+        match ram_bundle.repr {
+            RamBundleImpl::Unbundle(_) => (),
+            _ => {
+                panic!("Invalid RamBundleImpl type");
+            }
+        };
 
-    assert_eq!(ram_bundle.module_count(), 4);
+        assert_eq!(ram_bundle.module_count(), 4);
 
-    let startup_code = ram_bundle.startup_code()?;
-    assert_eq!(
-        startup_code[0..60].to_vec(),
-        b"var __DEV__=false,__BUNDLE_START_TIME__=this.nativePerforman".to_vec()
-    );
+        let startup_code = ram_bundle.startup_code()?;
+        assert_eq!(
+            startup_code[0..60].to_vec(),
+            b"var __DEV__=false,__BUNDLE_START_TIME__=this.nativePerforman".to_vec()
+        );
 
-    let module_0 = ram_bundle.get_module(0)?.unwrap();
-    let module_0_data = module_0.data();
-    assert_eq!(
-        module_0_data[0..60].to_vec(),
-        b"__d(function(g,r,i,a,m,e,d){'use strict';var t=Date.now();r(".to_vec()
-    );
+        let module_0 = ram_bundle.get_module(0)?.unwrap();
+        let module_0_data = module_0.data();
+        assert_eq!(
+            module_0_data[0..60].to_vec(),
+            b"__d(function(g,r,i,a,m,e,d){'use strict';var t=Date.now();r(".to_vec()
+        );
 
-    let module_1 = ram_bundle.get_module(1)?;
-    assert!(module_1.is_none());
+        let module_1 = ram_bundle.get_module(1)?;
+        assert!(module_1.is_none());
 
-    Ok(())
+        Ok(())
+    }
 }
diff --git a/src/sourceview.rs b/src/sourceview.rs
index 2fdddb0..20fcc1f 100644
--- a/src/sourceview.rs
+++ b/src/sourceview.rs
@@ -314,48 +314,53 @@ impl SourceView {
     }
 }
 
-#[test]
-#[allow(clippy::cognitive_complexity)]
-fn test_minified_source_view() {
-    let view = SourceView::new("a\nb\nc".into());
-    assert_eq!(view.get_line(0), Some("a"));
-    assert_eq!(view.get_line(0), Some("a"));
-    assert_eq!(view.get_line(2), Some("c"));
-    assert_eq!(view.get_line(1), Some("b"));
-    assert_eq!(view.get_line(3), None);
-
-    assert_eq!(view.line_count(), 3);
-
-    let view = SourceView::new("a\r\nb\r\nc".into());
-    assert_eq!(view.get_line(0), Some("a"));
-    assert_eq!(view.get_line(0), Some("a"));
-    assert_eq!(view.get_line(2), Some("c"));
-    assert_eq!(view.get_line(1), Some("b"));
-    assert_eq!(view.get_line(3), None);
-
-    assert_eq!(view.line_count(), 3);
-
-    let view = SourceView::new("abc👌def\nblah".into());
-    assert_eq!(view.get_line_slice(0, 0, 3), Some("abc"));
-    assert_eq!(view.get_line_slice(0, 3, 1), Some("👌"));
-    assert_eq!(view.get_line_slice(0, 3, 2), Some("👌"));
-    assert_eq!(view.get_line_slice(0, 3, 3), Some("👌d"));
-    assert_eq!(view.get_line_slice(0, 0, 4), Some("abc👌"));
-    assert_eq!(view.get_line_slice(0, 0, 5), Some("abc👌"));
-    assert_eq!(view.get_line_slice(0, 0, 6), Some("abc👌d"));
-    assert_eq!(view.get_line_slice(1, 0, 4), Some("blah"));
-    assert_eq!(view.get_line_slice(1, 0, 5), None);
-    assert_eq!(view.get_line_slice(1, 0, 12), None);
-
-    let view = SourceView::new("a\nb\nc\n".into());
-    assert_eq!(view.get_line(0), Some("a"));
-    assert_eq!(view.get_line(1), Some("b"));
-    assert_eq!(view.get_line(2), Some("c"));
-    assert_eq!(view.get_line(3), Some(""));
-    assert_eq!(view.get_line(4), None);
-
-    fn is_send<T: Send>() {}
-    fn is_sync<T: Sync>() {}
-    is_send::<SourceView>();
-    is_sync::<SourceView>();
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    #[allow(clippy::cognitive_complexity)]
+    fn test_minified_source_view() {
+        let view = SourceView::new("a\nb\nc".into());
+        assert_eq!(view.get_line(0), Some("a"));
+        assert_eq!(view.get_line(0), Some("a"));
+        assert_eq!(view.get_line(2), Some("c"));
+        assert_eq!(view.get_line(1), Some("b"));
+        assert_eq!(view.get_line(3), None);
+
+        assert_eq!(view.line_count(), 3);
+
+        let view = SourceView::new("a\r\nb\r\nc".into());
+        assert_eq!(view.get_line(0), Some("a"));
+        assert_eq!(view.get_line(0), Some("a"));
+        assert_eq!(view.get_line(2), Some("c"));
+        assert_eq!(view.get_line(1), Some("b"));
+        assert_eq!(view.get_line(3), None);
+
+        assert_eq!(view.line_count(), 3);
+
+        let view = SourceView::new("abc👌def\nblah".into());
+        assert_eq!(view.get_line_slice(0, 0, 3), Some("abc"));
+        assert_eq!(view.get_line_slice(0, 3, 1), Some("👌"));
+        assert_eq!(view.get_line_slice(0, 3, 2), Some("👌"));
+        assert_eq!(view.get_line_slice(0, 3, 3), Some("👌d"));
+        assert_eq!(view.get_line_slice(0, 0, 4), Some("abc👌"));
+        assert_eq!(view.get_line_slice(0, 0, 5), Some("abc👌"));
+        assert_eq!(view.get_line_slice(0, 0, 6), Some("abc👌d"));
+        assert_eq!(view.get_line_slice(1, 0, 4), Some("blah"));
+        assert_eq!(view.get_line_slice(1, 0, 5), None);
+        assert_eq!(view.get_line_slice(1, 0, 12), None);
+
+        let view = SourceView::new("a\nb\nc\n".into());
+        assert_eq!(view.get_line(0), Some("a"));
+        assert_eq!(view.get_line(1), Some("b"));
+        assert_eq!(view.get_line(2), Some("c"));
+        assert_eq!(view.get_line(3), Some(""));
+        assert_eq!(view.get_line(4), None);
+
+        fn is_send<T: Send>() {}
+        fn is_sync<T: Sync>() {}
+        is_send::<SourceView>();
+        is_sync::<SourceView>();
+    }
 }
diff --git a/src/utils.rs b/src/utils.rs
index bdb5bd1..bd911c2 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -141,87 +141,94 @@ pub fn greatest_lower_bound<'a, T, K: Ord, F: Fn(&'a T) -> K>(
     slice.get(idx).map(|res| (idx, res))
 }
 
-#[test]
-fn test_is_abs_path() {
-    assert!(is_abs_path("C:\\foo.txt"));
-    assert!(is_abs_path("d:/foo.txt"));
-    assert!(!is_abs_path("foo.txt"));
-    assert!(is_abs_path("/foo.txt"));
-    assert!(is_abs_path("/"));
-}
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_is_abs_path() {
+        assert!(is_abs_path("C:\\foo.txt"));
+        assert!(is_abs_path("d:/foo.txt"));
+        assert!(!is_abs_path("foo.txt"));
+        assert!(is_abs_path("/foo.txt"));
+        assert!(is_abs_path("/"));
+    }
 
-#[test]
-fn test_split_path() {
-    assert_eq!(split_path("/foo/bar/baz"), &["", "/foo", "/bar", "/baz"]);
-}
+    #[test]
+    fn test_split_path() {
+        assert_eq!(split_path("/foo/bar/baz"), &["", "/foo", "/bar", "/baz"]);
+    }
 
-#[test]
-fn test_find_common_prefix() {
-    let rv = find_common_prefix(vec!["/foo/bar/baz", "/foo/bar/baz/blah"].into_iter());
-    assert_eq!(rv, Some("/foo/bar/baz".into()));
+    #[test]
+    fn test_find_common_prefix() {
+        let rv = find_common_prefix(vec!["/foo/bar/baz", "/foo/bar/baz/blah"].into_iter());
+        assert_eq!(rv, Some("/foo/bar/baz".into()));
 
-    let rv = find_common_prefix(vec!["/foo/bar/baz", "/foo/bar/baz/blah", "/meh"].into_iter());
-    assert_eq!(rv, None);
+        let rv = find_common_prefix(vec!["/foo/bar/baz", "/foo/bar/baz/blah", "/meh"].into_iter());
+        assert_eq!(rv, None);
 
-    let rv = find_common_prefix(vec!["/foo/bar/baz", "/foo/bar/baz/blah", "/foo"].into_iter());
-    assert_eq!(rv, Some("/foo".into()));
+        let rv = find_common_prefix(vec!["/foo/bar/baz", "/foo/bar/baz/blah", "/foo"].into_iter());
+        assert_eq!(rv, Some("/foo".into()));
 
-    let rv = find_common_prefix(vec!["/foo/bar/baz", "/foo/bar/baz/blah", "foo"].into_iter());
-    assert_eq!(rv, Some("/foo/bar/baz".into()));
+        let rv = find_common_prefix(vec!["/foo/bar/baz", "/foo/bar/baz/blah", "foo"].into_iter());
+        assert_eq!(rv, Some("/foo/bar/baz".into()));
 
-    let rv =
-        find_common_prefix(vec!["/foo/bar/baz", "/foo/bar/baz/blah", "/blah", "foo"].into_iter());
-    assert_eq!(rv, None);
+        let rv = find_common_prefix(
+            vec!["/foo/bar/baz", "/foo/bar/baz/blah", "/blah", "foo"].into_iter(),
+        );
+        assert_eq!(rv, None);
 
-    let rv =
-        find_common_prefix(vec!["/foo/bar/baz", "/foo/bar/baz/blah", "/blah", "foo"].into_iter());
-    assert_eq!(rv, None);
-}
+        let rv = find_common_prefix(
+            vec!["/foo/bar/baz", "/foo/bar/baz/blah", "/blah", "foo"].into_iter(),
+        );
+        assert_eq!(rv, None);
+    }
 
-#[test]
-fn test_make_relative_path() {
-    assert_eq!(
-        &make_relative_path("/foo/bar/baz.js", "/foo/bar/baz.map"),
-        "baz.map"
-    );
-    assert_eq!(
-        &make_relative_path("/foo/bar/.", "/foo/bar/baz.map"),
-        "baz.map"
-    );
-    assert_eq!(
-        &make_relative_path("/foo/bar/baz.js", "/foo/baz.map"),
-        "../baz.map"
-    );
-    assert_eq!(&make_relative_path("foo.txt", "foo.js"), "foo.js");
-    assert_eq!(&make_relative_path("blah/foo.txt", "foo.js"), "../foo.js");
-}
+    #[test]
+    fn test_make_relative_path() {
+        assert_eq!(
+            &make_relative_path("/foo/bar/baz.js", "/foo/bar/baz.map"),
+            "baz.map"
+        );
+        assert_eq!(
+            &make_relative_path("/foo/bar/.", "/foo/bar/baz.map"),
+            "baz.map"
+        );
+        assert_eq!(
+            &make_relative_path("/foo/bar/baz.js", "/foo/baz.map"),
+            "../baz.map"
+        );
+        assert_eq!(&make_relative_path("foo.txt", "foo.js"), "foo.js");
+        assert_eq!(&make_relative_path("blah/foo.txt", "foo.js"), "../foo.js");
+    }
 
-#[test]
-fn test_greatest_lower_bound() {
-    let cmp = |&(i, _id)| i;
-
-    let haystack = vec![(1, 1)];
-    assert_eq!(greatest_lower_bound(&haystack, &1, cmp).unwrap().1, &(1, 1));
-    assert_eq!(greatest_lower_bound(&haystack, &2, cmp).unwrap().1, &(1, 1));
-    assert_eq!(greatest_lower_bound(&haystack, &0, cmp), None);
-
-    let haystack = vec![(1, 1), (1, 2)];
-    assert_eq!(greatest_lower_bound(&haystack, &1, cmp).unwrap().1, &(1, 1));
-    assert_eq!(greatest_lower_bound(&haystack, &2, cmp).unwrap().1, &(1, 2));
-    assert_eq!(greatest_lower_bound(&haystack, &0, cmp), None);
-
-    let haystack = vec![(1, 1), (1, 2), (1, 3)];
-    assert_eq!(greatest_lower_bound(&haystack, &1, cmp).unwrap().1, &(1, 1));
-    assert_eq!(greatest_lower_bound(&haystack, &2, cmp).unwrap().1, &(1, 3));
-    assert_eq!(greatest_lower_bound(&haystack, &0, cmp), None);
-
-    let haystack = vec![(1, 1), (1, 2), (1, 3), (1, 4)];
-    assert_eq!(greatest_lower_bound(&haystack, &1, cmp).unwrap().1, &(1, 1));
-    assert_eq!(greatest_lower_bound(&haystack, &2, cmp).unwrap().1, &(1, 4));
-    assert_eq!(greatest_lower_bound(&haystack, &0, cmp), None);
-
-    let haystack = vec![(1, 1), (1, 2), (1, 3), (1, 4), (1, 5)];
-    assert_eq!(greatest_lower_bound(&haystack, &1, cmp).unwrap().1, &(1, 1));
-    assert_eq!(greatest_lower_bound(&haystack, &2, cmp).unwrap().1, &(1, 5));
-    assert_eq!(greatest_lower_bound(&haystack, &0, cmp), None);
+    #[test]
+    fn test_greatest_lower_bound() {
+        let cmp = |&(i, _id)| i;
+
+        let haystack = vec![(1, 1)];
+        assert_eq!(greatest_lower_bound(&haystack, &1, cmp).unwrap().1, &(1, 1));
+        assert_eq!(greatest_lower_bound(&haystack, &2, cmp).unwrap().1, &(1, 1));
+        assert_eq!(greatest_lower_bound(&haystack, &0, cmp), None);
+
+        let haystack = vec![(1, 1), (1, 2)];
+        assert_eq!(greatest_lower_bound(&haystack, &1, cmp).unwrap().1, &(1, 1));
+        assert_eq!(greatest_lower_bound(&haystack, &2, cmp).unwrap().1, &(1, 2));
+        assert_eq!(greatest_lower_bound(&haystack, &0, cmp), None);
+
+        let haystack = vec![(1, 1), (1, 2), (1, 3)];
+        assert_eq!(greatest_lower_bound(&haystack, &1, cmp).unwrap().1, &(1, 1));
+        assert_eq!(greatest_lower_bound(&haystack, &2, cmp).unwrap().1, &(1, 3));
+        assert_eq!(greatest_lower_bound(&haystack, &0, cmp), None);
+
+        let haystack = vec![(1, 1), (1, 2), (1, 3), (1, 4)];
+        assert_eq!(greatest_lower_bound(&haystack, &1, cmp).unwrap().1, &(1, 1));
+        assert_eq!(greatest_lower_bound(&haystack, &2, cmp).unwrap().1, &(1, 4));
+        assert_eq!(greatest_lower_bound(&haystack, &0, cmp), None);
+
+        let haystack = vec![(1, 1), (1, 2), (1, 3), (1, 4), (1, 5)];
+        assert_eq!(greatest_lower_bound(&haystack, &1, cmp).unwrap().1, &(1, 1));
+        assert_eq!(greatest_lower_bound(&haystack, &2, cmp).unwrap().1, &(1, 5));
+        assert_eq!(greatest_lower_bound(&haystack, &0, cmp), None);
+    }
 }
diff --git a/src/vlq.rs b/src/vlq.rs
index 66d80d2..cca51ca 100644
--- a/src/vlq.rs
+++ b/src/vlq.rs
@@ -328,28 +328,33 @@ pub(crate) fn encode_vlq(out: &mut String, num: i64) {
     }
 }
 
-#[test]
-fn test_vlq_decode() {
-    let rv = parse_vlq_segment("AAAA").unwrap();
-    assert_eq!(rv, vec![0, 0, 0, 0]);
-    let rv = parse_vlq_segment("GAAIA").unwrap();
-    assert_eq!(rv, vec![3, 0, 0, 4, 0]);
-}
+#[cfg(test)]
+mod tests {
+    use super::*;
 
-#[test]
-fn test_vlq_encode() {
-    let rv = generate_vlq_segment(&[0, 0, 0, 0]).unwrap();
-    assert_eq!(rv.as_str(), "AAAA");
-    let rv = generate_vlq_segment(&[3, 0, 0, 4, 0]).unwrap();
-    assert_eq!(rv.as_str(), "GAAIA");
-}
+    #[test]
+    fn test_vlq_decode() {
+        let rv = parse_vlq_segment("AAAA").unwrap();
+        assert_eq!(rv, vec![0, 0, 0, 0]);
+        let rv = parse_vlq_segment("GAAIA").unwrap();
+        assert_eq!(rv, vec![3, 0, 0, 4, 0]);
+    }
 
-#[test]
-fn test_overflow() {
-    match parse_vlq_segment("00000000000000") {
-        Err(Error::VlqOverflow) => {}
-        e => {
-            panic!("Unexpeted result: {:?}", e);
+    #[test]
+    fn test_vlq_encode() {
+        let rv = generate_vlq_segment(&[0, 0, 0, 0]).unwrap();
+        assert_eq!(rv.as_str(), "AAAA");
+        let rv = generate_vlq_segment(&[3, 0, 0, 4, 0]).unwrap();
+        assert_eq!(rv.as_str(), "GAAIA");
+    }
+
+    #[test]
+    fn test_overflow() {
+        match parse_vlq_segment("00000000000000") {
+            Err(Error::VlqOverflow) => {}
+            e => {
+                panic!("Unexpeted result: {:?}", e);
+            }
         }
     }
 }