library/term/src/terminfo/parm/tests.rs

   1 use super::*;
   2
   3 use std::result::Result::Ok;
   4
   5 #[test]
   6 fn test_basic_setabf() {
   7     let s = b"\\E[48;5;%p1%dm";
   8     assert_eq!(
   9         expand(s, &[Number(1)], &mut Variables::new()).unwrap(),
  10         "\\E[48;5;1m".bytes().collect::<Vec<_>>()
  11     );
  12 }
  13
  14 #[test]
  15 fn test_multiple_int_constants() {
  16     assert_eq!(
  17         expand(b"%{1}%{2}%d%d", &[], &mut Variables::new()).unwrap(),
  18         "21".bytes().collect::<Vec<_>>()
  19     );
  20 }
  21
  22 #[test]
  23 fn test_op_i() {
  24     let mut vars = Variables::new();
  25     assert_eq!(
  26         expand(b"%p1%d%p2%d%p3%d%i%p1%d%p2%d%p3%d", &[Number(1), Number(2), Number(3)], &mut vars),
  27         Ok("123233".bytes().collect::<Vec<_>>())
  28     );
  29     assert_eq!(
  30         expand(b"%p1%d%p2%d%i%p1%d%p2%d", &[], &mut vars),
  31         Ok("0011".bytes().collect::<Vec<_>>())
  32     );
  33 }
  34
  35 #[test]
  36 fn test_param_stack_failure_conditions() {
  37     let mut varstruct = Variables::new();
  38     let vars = &mut varstruct;
  39     fn get_res(
  40         fmt: &str,
  41         cap: &str,
  42         params: &[Param],
  43         vars: &mut Variables,
  44     ) -> Result<Vec<u8>, String> {
  45         let mut u8v: Vec<_> = fmt.bytes().collect();
  46         u8v.extend(cap.as_bytes().iter().map(|&b| b));
  47         expand(&u8v, params, vars)
  48     }
  49
  50     let caps = ["%d", "%c", "%s", "%Pa", "%l", "%!", "%~"];
  51     for &cap in caps.iter() {
  52         let res = get_res("", cap, &[], vars);
  53         assert!(res.is_err(), "Op {} succeeded incorrectly with 0 stack entries", cap);
  54         let p = if cap == "%s" || cap == "%l" { Words("foo".to_string()) } else { Number(97) };
  55         let res = get_res("%p1", cap, &[p], vars);
  56         assert!(res.is_ok(), "Op {} failed with 1 stack entry: {}", cap, res.unwrap_err());
  57     }
  58     let caps = ["%+", "%-", "%*", "%/", "%m", "%&", "%|", "%A", "%O"];
  59     for &cap in caps.iter() {
  60         let res = expand(cap.as_bytes(), &[], vars);
  61         assert!(res.is_err(), "Binop {} succeeded incorrectly with 0 stack entries", cap);
  62         let res = get_res("%{1}", cap, &[], vars);
  63         assert!(res.is_err(), "Binop {} succeeded incorrectly with 1 stack entry", cap);
  64         let res = get_res("%{1}%{2}", cap, &[], vars);
  65         assert!(res.is_ok(), "Binop {} failed with 2 stack entries: {}", cap, res.unwrap_err());
  66     }
  67 }
  68
  69 #[test]
  70 fn test_push_bad_param() {
  71     assert!(expand(b"%pa", &[], &mut Variables::new()).is_err());
  72 }
  73
  74 #[test]
  75 fn test_comparison_ops() {
  76     let v = [('<', [1u8, 0u8, 0u8]), ('=', [0u8, 1u8, 0u8]), ('>', [0u8, 0u8, 1u8])];
  77     for &(op, bs) in v.iter() {
  78         let s = format!("%{{1}}%{{2}}%{}%d", op);
  79         let res = expand(s.as_bytes(), &[], &mut Variables::new());
  80         assert!(res.is_ok(), "{}", res.unwrap_err());
  81         assert_eq!(res.unwrap(), vec![b'0' + bs[0]]);
  82         let s = format!("%{{1}}%{{1}}%{}%d", op);
  83         let res = expand(s.as_bytes(), &[], &mut Variables::new());
  84         assert!(res.is_ok(), "{}", res.unwrap_err());
  85         assert_eq!(res.unwrap(), vec![b'0' + bs[1]]);
  86         let s = format!("%{{2}}%{{1}}%{}%d", op);
  87         let res = expand(s.as_bytes(), &[], &mut Variables::new());
  88         assert!(res.is_ok(), "{}", res.unwrap_err());
  89         assert_eq!(res.unwrap(), vec![b'0' + bs[2]]);
  90     }
  91 }
  92
  93 #[test]
  94 fn test_conditionals() {
  95     let mut vars = Variables::new();
  96     let s = b"\\E[%?%p1%{8}%<%t3%p1%d%e%p1%{16}%<%t9%p1%{8}%-%d%e38;5;%p1%d%;m";
  97     let res = expand(s, &[Number(1)], &mut vars);
  98     assert!(res.is_ok(), "{}", res.unwrap_err());
  99     assert_eq!(res.unwrap(), "\\E[31m".bytes().collect::<Vec<_>>());
 100     let res = expand(s, &[Number(8)], &mut vars);
 101     assert!(res.is_ok(), "{}", res.unwrap_err());
 102     assert_eq!(res.unwrap(), "\\E[90m".bytes().collect::<Vec<_>>());
 103     let res = expand(s, &[Number(42)], &mut vars);
 104     assert!(res.is_ok(), "{}", res.unwrap_err());
 105     assert_eq!(res.unwrap(), "\\E[38;5;42m".bytes().collect::<Vec<_>>());
 106 }
 107
 108 #[test]
 109 fn test_format() {
 110     let mut varstruct = Variables::new();
 111     let vars = &mut varstruct;
 112     assert_eq!(
 113         expand(
 114             b"%p1%s%p2%2s%p3%2s%p4%.2s",
 115             &[
 116                 Words("foo".to_string()),
 117                 Words("foo".to_string()),
 118                 Words("f".to_string()),
 119                 Words("foo".to_string())
 120             ],
 121             vars
 122         ),
 123         Ok("foofoo ffo".bytes().collect::<Vec<_>>())
 124     );
 125     assert_eq!(
 126         expand(b"%p1%:-4.2s", &[Words("foo".to_string())], vars),
 127         Ok("fo  ".bytes().collect::<Vec<_>>())
 128     );
 129
 130     assert_eq!(
 131         expand(b"%p1%d%p1%.3d%p1%5d%p1%:+d", &[Number(1)], vars),
 132         Ok("1001    1+1".bytes().collect::<Vec<_>>())
 133     );
 134     assert_eq!(
 135         expand(b"%p1%o%p1%#o%p2%6.4x%p2%#6.4X", &[Number(15), Number(27)], vars),
 136         Ok("17017  001b0X001B".bytes().collect::<Vec<_>>())
 137     );
 138 }