libterm: Unconfigure tests during normal build

Author: petrochenkov

src/libterm/terminfo/parm.rs

@@ -5,6 +5,9 @@ use self::States::*;
 
 use std::iter::repeat;
 
+#[cfg(test)]
+mod tests;
+
 #[derive(Clone, Copy, PartialEq)]
 enum States {
     Nothing,
@@ -526,144 +529,3 @@ fn format(val: Param, op: FormatOp, flags: Flags) -> Result<Vec<u8>, String> {
     }
     Ok(s)
 }
-
-#[cfg(test)]
-mod test {
-    use super::{expand, Variables};
-    use super::Param::{self, Words, Number};
-    use std::result::Result::Ok;
-
-    #[test]
-    fn test_basic_setabf() {
-        let s = b"\\E[48;5;%p1%dm";
-        assert_eq!(expand(s, &[Number(1)], &mut Variables::new()).unwrap(),
-                   "\\E[48;5;1m".bytes().collect::<Vec<_>>());
-    }
-
-    #[test]
-    fn test_multiple_int_constants() {
-        assert_eq!(expand(b"%{1}%{2}%d%d", &[], &mut Variables::new()).unwrap(),
-                   "21".bytes().collect::<Vec<_>>());
-    }
-
-    #[test]
-    fn test_op_i() {
-        let mut vars = Variables::new();
-        assert_eq!(expand(b"%p1%d%p2%d%p3%d%i%p1%d%p2%d%p3%d",
-                          &[Number(1), Number(2), Number(3)],
-                          &mut vars),
-                   Ok("123233".bytes().collect::<Vec<_>>()));
-        assert_eq!(expand(b"%p1%d%p2%d%i%p1%d%p2%d", &[], &mut vars),
-                   Ok("0011".bytes().collect::<Vec<_>>()));
-    }
-
-    #[test]
-    fn test_param_stack_failure_conditions() {
-        let mut varstruct = Variables::new();
-        let vars = &mut varstruct;
-        fn get_res(fmt: &str,
-                   cap: &str,
-                   params: &[Param],
-                   vars: &mut Variables)
-                   -> Result<Vec<u8>, String> {
-            let mut u8v: Vec<_> = fmt.bytes().collect();
-            u8v.extend(cap.as_bytes().iter().map(|&b| b));
-            expand(&u8v, params, vars)
-        }
-
-        let caps = ["%d", "%c", "%s", "%Pa", "%l", "%!", "%~"];
-        for &cap in caps.iter() {
-            let res = get_res("", cap, &[], vars);
-            assert!(res.is_err(),
-                    "Op {} succeeded incorrectly with 0 stack entries",
-                    cap);
-            let p = if cap == "%s" || cap == "%l" {
-                Words("foo".to_string())
-            } else {
-                Number(97)
-            };
-            let res = get_res("%p1", cap, &[p], vars);
-            assert!(res.is_ok(),
-                    "Op {} failed with 1 stack entry: {}",
-                    cap,
-                    res.unwrap_err());
-        }
-        let caps = ["%+", "%-", "%*", "%/", "%m", "%&", "%|", "%A", "%O"];
-        for &cap in caps.iter() {
-            let res = expand(cap.as_bytes(), &[], vars);
-            assert!(res.is_err(),
-                    "Binop {} succeeded incorrectly with 0 stack entries",
-                    cap);
-            let res = get_res("%{1}", cap, &[], vars);
-            assert!(res.is_err(),
-                    "Binop {} succeeded incorrectly with 1 stack entry",
-                    cap);
-            let res = get_res("%{1}%{2}", cap, &[], vars);
-            assert!(res.is_ok(),
-                    "Binop {} failed with 2 stack entries: {}",
-                    cap,
-                    res.unwrap_err());
-        }
-    }
-
-    #[test]
-    fn test_push_bad_param() {
-        assert!(expand(b"%pa", &[], &mut Variables::new()).is_err());
-    }
-
-    #[test]
-    fn test_comparison_ops() {
-        let v = [('<', [1u8, 0u8, 0u8]), ('=', [0u8, 1u8, 0u8]), ('>', [0u8, 0u8, 1u8])];
-        for &(op, bs) in v.iter() {
-            let s = format!("%{{1}}%{{2}}%{}%d", op);
-            let res = expand(s.as_bytes(), &[], &mut Variables::new());
-            assert!(res.is_ok(), res.unwrap_err());
-            assert_eq!(res.unwrap(), vec![b'0' + bs[0]]);
-            let s = format!("%{{1}}%{{1}}%{}%d", op);
-            let res = expand(s.as_bytes(), &[], &mut Variables::new());
-            assert!(res.is_ok(), res.unwrap_err());
-            assert_eq!(res.unwrap(), vec![b'0' + bs[1]]);
-            let s = format!("%{{2}}%{{1}}%{}%d", op);
-            let res = expand(s.as_bytes(), &[], &mut Variables::new());
-            assert!(res.is_ok(), res.unwrap_err());
-            assert_eq!(res.unwrap(), vec![b'0' + bs[2]]);
-        }
-    }
-
-    #[test]
-    fn test_conditionals() {
-        let mut vars = Variables::new();
-        let s = b"\\E[%?%p1%{8}%<%t3%p1%d%e%p1%{16}%<%t9%p1%{8}%-%d%e38;5;%p1%d%;m";
-        let res = expand(s, &[Number(1)], &mut vars);
-        assert!(res.is_ok(), res.unwrap_err());
-        assert_eq!(res.unwrap(), "\\E[31m".bytes().collect::<Vec<_>>());
-        let res = expand(s, &[Number(8)], &mut vars);
-        assert!(res.is_ok(), res.unwrap_err());
-        assert_eq!(res.unwrap(), "\\E[90m".bytes().collect::<Vec<_>>());
-        let res = expand(s, &[Number(42)], &mut vars);
-        assert!(res.is_ok(), res.unwrap_err());
-        assert_eq!(res.unwrap(), "\\E[38;5;42m".bytes().collect::<Vec<_>>());
-    }
-
-    #[test]
-    fn test_format() {
-        let mut varstruct = Variables::new();
-        let vars = &mut varstruct;
-        assert_eq!(expand(b"%p1%s%p2%2s%p3%2s%p4%.2s",
-                          &[Words("foo".to_string()),
-                            Words("foo".to_string()),
-                            Words("f".to_string()),
-                            Words("foo".to_string())],
-                          vars),
-                   Ok("foofoo ffo".bytes().collect::<Vec<_>>()));
-        assert_eq!(expand(b"%p1%:-4.2s", &[Words("foo".to_string())], vars),
-                   Ok("fo  ".bytes().collect::<Vec<_>>()));
-
-        assert_eq!(expand(b"%p1%d%p1%.3d%p1%5d%p1%:+d", &[Number(1)], vars),
-                   Ok("1001    1+1".bytes().collect::<Vec<_>>()));
-        assert_eq!(expand(b"%p1%o%p1%#o%p2%6.4x%p2%#6.4X",
-                          &[Number(15), Number(27)],
-                          vars),
-                   Ok("17017  001b0X001B".bytes().collect::<Vec<_>>()));
-    }
-}

src/libterm/terminfo/parm/tests.rs

@@ -0,0 +1,137 @@
+use super::*;
+
+use std::result::Result::Ok;
+
+#[test]
+fn test_basic_setabf() {
+    let s = b"\\E[48;5;%p1%dm";
+    assert_eq!(expand(s, &[Number(1)], &mut Variables::new()).unwrap(),
+                "\\E[48;5;1m".bytes().collect::<Vec<_>>());
+}
+
+#[test]
+fn test_multiple_int_constants() {
+    assert_eq!(expand(b"%{1}%{2}%d%d", &[], &mut Variables::new()).unwrap(),
+                "21".bytes().collect::<Vec<_>>());
+}
+
+#[test]
+fn test_op_i() {
+    let mut vars = Variables::new();
+    assert_eq!(expand(b"%p1%d%p2%d%p3%d%i%p1%d%p2%d%p3%d",
+                        &[Number(1), Number(2), Number(3)],
+                        &mut vars),
+                Ok("123233".bytes().collect::<Vec<_>>()));
+    assert_eq!(expand(b"%p1%d%p2%d%i%p1%d%p2%d", &[], &mut vars),
+                Ok("0011".bytes().collect::<Vec<_>>()));
+}
+
+#[test]
+fn test_param_stack_failure_conditions() {
+    let mut varstruct = Variables::new();
+    let vars = &mut varstruct;
+    fn get_res(fmt: &str,
+                cap: &str,
+                params: &[Param],
+                vars: &mut Variables)
+                -> Result<Vec<u8>, String> {
+        let mut u8v: Vec<_> = fmt.bytes().collect();
+        u8v.extend(cap.as_bytes().iter().map(|&b| b));
+        expand(&u8v, params, vars)
+    }
+
+    let caps = ["%d", "%c", "%s", "%Pa", "%l", "%!", "%~"];
+    for &cap in caps.iter() {
+        let res = get_res("", cap, &[], vars);
+        assert!(res.is_err(),
+                "Op {} succeeded incorrectly with 0 stack entries",
+                cap);
+        let p = if cap == "%s" || cap == "%l" {
+            Words("foo".to_string())
+        } else {
+            Number(97)
+        };
+        let res = get_res("%p1", cap, &[p], vars);
+        assert!(res.is_ok(),
+                "Op {} failed with 1 stack entry: {}",
+                cap,
+                res.unwrap_err());
+    }
+    let caps = ["%+", "%-", "%*", "%/", "%m", "%&", "%|", "%A", "%O"];
+    for &cap in caps.iter() {
+        let res = expand(cap.as_bytes(), &[], vars);
+        assert!(res.is_err(),
+                "Binop {} succeeded incorrectly with 0 stack entries",
+                cap);
+        let res = get_res("%{1}", cap, &[], vars);
+        assert!(res.is_err(),
+                "Binop {} succeeded incorrectly with 1 stack entry",
+                cap);
+        let res = get_res("%{1}%{2}", cap, &[], vars);
+        assert!(res.is_ok(),
+                "Binop {} failed with 2 stack entries: {}",
+                cap,
+                res.unwrap_err());
+    }
+}
+
+#[test]
+fn test_push_bad_param() {
+    assert!(expand(b"%pa", &[], &mut Variables::new()).is_err());
+}
+
+#[test]
+fn test_comparison_ops() {
+    let v = [('<', [1u8, 0u8, 0u8]), ('=', [0u8, 1u8, 0u8]), ('>', [0u8, 0u8, 1u8])];
+    for &(op, bs) in v.iter() {
+        let s = format!("%{{1}}%{{2}}%{}%d", op);
+        let res = expand(s.as_bytes(), &[], &mut Variables::new());
+        assert!(res.is_ok(), res.unwrap_err());
+        assert_eq!(res.unwrap(), vec![b'0' + bs[0]]);
+        let s = format!("%{{1}}%{{1}}%{}%d", op);
+        let res = expand(s.as_bytes(), &[], &mut Variables::new());
+        assert!(res.is_ok(), res.unwrap_err());
+        assert_eq!(res.unwrap(), vec![b'0' + bs[1]]);
+        let s = format!("%{{2}}%{{1}}%{}%d", op);
+        let res = expand(s.as_bytes(), &[], &mut Variables::new());
+        assert!(res.is_ok(), res.unwrap_err());
+        assert_eq!(res.unwrap(), vec![b'0' + bs[2]]);
+    }
+}
+
+#[test]
+fn test_conditionals() {
+    let mut vars = Variables::new();
+    let s = b"\\E[%?%p1%{8}%<%t3%p1%d%e%p1%{16}%<%t9%p1%{8}%-%d%e38;5;%p1%d%;m";
+    let res = expand(s, &[Number(1)], &mut vars);
+    assert!(res.is_ok(), res.unwrap_err());
+    assert_eq!(res.unwrap(), "\\E[31m".bytes().collect::<Vec<_>>());
+    let res = expand(s, &[Number(8)], &mut vars);
+    assert!(res.is_ok(), res.unwrap_err());
+    assert_eq!(res.unwrap(), "\\E[90m".bytes().collect::<Vec<_>>());
+    let res = expand(s, &[Number(42)], &mut vars);
+    assert!(res.is_ok(), res.unwrap_err());
+    assert_eq!(res.unwrap(), "\\E[38;5;42m".bytes().collect::<Vec<_>>());
+}
+
+#[test]
+fn test_format() {
+    let mut varstruct = Variables::new();
+    let vars = &mut varstruct;
+    assert_eq!(expand(b"%p1%s%p2%2s%p3%2s%p4%.2s",
+                        &[Words("foo".to_string()),
+                        Words("foo".to_string()),
+                        Words("f".to_string()),
+                        Words("foo".to_string())],
+                        vars),
+                Ok("foofoo ffo".bytes().collect::<Vec<_>>()));
+    assert_eq!(expand(b"%p1%:-4.2s", &[Words("foo".to_string())], vars),
+                Ok("fo  ".bytes().collect::<Vec<_>>()));
+
+    assert_eq!(expand(b"%p1%d%p1%.3d%p1%5d%p1%:+d", &[Number(1)], vars),
+                Ok("1001    1+1".bytes().collect::<Vec<_>>()));
+    assert_eq!(expand(b"%p1%o%p1%#o%p2%6.4x%p2%#6.4X",
+                        &[Number(15), Number(27)],
+                        vars),
+                Ok("17017  001b0X001B".bytes().collect::<Vec<_>>()));
+}

src/libterm/terminfo/parser/compiled.rs

@@ -7,6 +7,9 @@ use std::io;
 use std::io::prelude::*;
 use super::super::TermInfo;
 
+#[cfg(test)]
+mod tests;
+
 // These are the orders ncurses uses in its compiled format (as of 5.9). Not sure if portable.
 
 #[rustfmt::skip]
@@ -331,16 +334,3 @@ pub fn msys_terminfo() -> TermInfo {
         strings,
     }
 }
-
-#[cfg(test)]
-mod test {
-
-    use super::{boolnames, boolfnames, numnames, numfnames, stringnames, stringfnames};
-
-    #[test]
-    fn test_veclens() {
-        assert_eq!(boolfnames.len(), boolnames.len());
-        assert_eq!(numfnames.len(), numnames.len());
-        assert_eq!(stringfnames.len(), stringnames.len());
-    }
-}

src/libterm/terminfo/parser/compiled/tests.rs

@@ -0,0 +1,8 @@
+use super::*;
+
+#[test]
+fn test_veclens() {
+    assert_eq!(boolfnames.len(), boolnames.len());
+    assert_eq!(numfnames.len(), numnames.len());
+    assert_eq!(stringfnames.len(), stringnames.len());
+}

src/libterm/terminfo/searcher.rs

@@ -6,6 +6,9 @@ use std::env;
 use std::fs;
 use std::path::PathBuf;
 
+#[cfg(test)]
+mod tests;
+
 /// Return path to database entry for `term`
 #[allow(deprecated)]
 pub fn get_dbpath_for_term(term: &str) -> Option<PathBuf> {
@@ -64,21 +67,3 @@ pub fn get_dbpath_for_term(term: &str) -> Option<PathBuf> {
     }
     None
 }
-
-#[test]
-#[ignore = "buildbots don't have ncurses installed and I can't mock everything I need"]
-fn test_get_dbpath_for_term() {
-    // woefully inadequate test coverage
-    // note: current tests won't work with non-standard terminfo hierarchies (e.g., macOS's)
-    use std::env;
-    // FIXME (#9639): This needs to handle non-utf8 paths
-    fn x(t: &str) -> String {
-        let p = get_dbpath_for_term(t).expect("no terminfo entry found");
-        p.to_str().unwrap().to_string()
-    }
-    assert!(x("screen") == "/usr/share/terminfo/s/screen");
-    assert!(get_dbpath_for_term("") == None);
-    env::set_var("TERMINFO_DIRS", ":");
-    assert!(x("screen") == "/usr/share/terminfo/s/screen");
-    env::remove_var("TERMINFO_DIRS");
-}

src/libterm/terminfo/searcher/tests.rs

@@ -0,0 +1,19 @@
+use super::*;
+
+#[test]
+#[ignore = "buildbots don't have ncurses installed and I can't mock everything I need"]
+fn test_get_dbpath_for_term() {
+    // woefully inadequate test coverage
+    // note: current tests won't work with non-standard terminfo hierarchies (e.g., macOS's)
+    use std::env;
+    // FIXME (#9639): This needs to handle non-utf8 paths
+    fn x(t: &str) -> String {
+        let p = get_dbpath_for_term(t).expect("no terminfo entry found");
+        p.to_str().unwrap().to_string()
+    }
+    assert!(x("screen") == "/usr/share/terminfo/s/screen");
+    assert!(get_dbpath_for_term("") == None);
+    env::set_var("TERMINFO_DIRS", ":");
+    assert!(x("screen") == "/usr/share/terminfo/s/screen");
+    env::remove_var("TERMINFO_DIRS");
+}

src/tools/tidy/src/unit_tests.rs

@@ -38,7 +38,6 @@ pub fn check(root_path: &Path, bad: &mut bool) {
         "libstd",
         "libsyntax",
         "libsyntax_pos",
-        "libterm/terminfo",
     ];
 
     let mut skip = |path: &Path| {