ref(tests): Move tests under cfg(test)

This way, tests are not compiled into binaries except when testing.

Author: szokeasaurusrex

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]);
+    }
 }

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");
 }

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);
+    }
 }