compiler/rustc_builtin_macros/src/format_foreign/printf/tests.rs

   1 use super::{iter_subs, parse_next_substitution as pns, Format as F, Num as N, Substitution as S};
   2
   3 macro_rules! assert_eq_pnsat {
   4     ($lhs:expr, $rhs:expr) => {
   5         assert_eq!(
   6             pns($lhs).and_then(|(s, _)| s.translate().ok()),
   7             $rhs.map(<String as From<&str>>::from)
   8         )
   9     };
  10 }
  11
  12 #[test]
  13 fn test_escape() {
  14     assert_eq!(pns("has no escapes"), None);
  15     assert_eq!(pns("has no escapes, either %"), None);
  16     assert_eq!(pns("*so* has a %% escape"), Some((S::Escape((11, 13)), " escape")));
  17     assert_eq!(pns("%% leading escape"), Some((S::Escape((0, 2)), " leading escape")));
  18     assert_eq!(pns("trailing escape %%"), Some((S::Escape((16, 18)), "")));
  19 }
  20
  21 #[test]
  22 fn test_parse() {
  23     macro_rules! assert_pns_eq_sub {
  24         ($in_:expr, {
  25             $param:expr, $flags:expr,
  26             $width:expr, $prec:expr, $len:expr, $type_:expr,
  27             $pos:expr,
  28         }) => {
  29             assert_eq!(
  30                 pns(concat!($in_, "!")),
  31                 Some((
  32                     S::Format(F {
  33                         span: $in_,
  34                         parameter: $param,
  35                         flags: $flags,
  36                         width: $width,
  37                         precision: $prec,
  38                         length: $len,
  39                         type_: $type_,
  40                         position: rustc_span::InnerSpan::new($pos.0, $pos.1),
  41                     }),
  42                     "!"
  43                 ))
  44             )
  45         };
  46     }
  47
  48     assert_pns_eq_sub!("%!",
  49         { None, "", None, None, None, "!", (0, 2), });
  50     assert_pns_eq_sub!("%c",
  51         { None, "", None, None, None, "c", (0, 2), });
  52     assert_pns_eq_sub!("%s",
  53         { None, "", None, None, None, "s", (0, 2), });
  54     assert_pns_eq_sub!("%06d",
  55         { None, "0", Some(N::Num(6)), None, None, "d", (0, 4), });
  56     assert_pns_eq_sub!("%4.2f",
  57         { None, "", Some(N::Num(4)), Some(N::Num(2)), None, "f", (0, 5), });
  58     assert_pns_eq_sub!("%#x",
  59         { None, "#", None, None, None, "x", (0, 3), });
  60     assert_pns_eq_sub!("%-10s",
  61         { None, "-", Some(N::Num(10)), None, None, "s", (0, 5), });
  62     assert_pns_eq_sub!("%*s",
  63         { None, "", Some(N::Next), None, None, "s", (0, 3), });
  64     assert_pns_eq_sub!("%-10.*s",
  65         { None, "-", Some(N::Num(10)), Some(N::Next), None, "s", (0, 7), });
  66     assert_pns_eq_sub!("%-*.*s",
  67         { None, "-", Some(N::Next), Some(N::Next), None, "s", (0, 6), });
  68     assert_pns_eq_sub!("%.6i",
  69         { None, "", None, Some(N::Num(6)), None, "i", (0, 4), });
  70     assert_pns_eq_sub!("%+i",
  71         { None, "+", None, None, None, "i", (0, 3), });
  72     assert_pns_eq_sub!("%08X",
  73         { None, "0", Some(N::Num(8)), None, None, "X", (0, 4), });
  74     assert_pns_eq_sub!("%lu",
  75         { None, "", None, None, Some("l"), "u", (0, 3), });
  76     assert_pns_eq_sub!("%Iu",
  77         { None, "", None, None, Some("I"), "u", (0, 3), });
  78     assert_pns_eq_sub!("%I32u",
  79         { None, "", None, None, Some("I32"), "u", (0, 5), });
  80     assert_pns_eq_sub!("%I64u",
  81         { None, "", None, None, Some("I64"), "u", (0, 5), });
  82     assert_pns_eq_sub!("%'d",
  83         { None, "'", None, None, None, "d", (0, 3), });
  84     assert_pns_eq_sub!("%10s",
  85         { None, "", Some(N::Num(10)), None, None, "s", (0, 4), });
  86     assert_pns_eq_sub!("%-10.10s",
  87         { None, "-", Some(N::Num(10)), Some(N::Num(10)), None, "s", (0, 8), });
  88     assert_pns_eq_sub!("%1$d",
  89         { Some(1), "", None, None, None, "d", (0, 4), });
  90     assert_pns_eq_sub!("%2$.*3$d",
  91         { Some(2), "", None, Some(N::Arg(3)), None, "d", (0, 8), });
  92     assert_pns_eq_sub!("%1$*2$.*3$d",
  93         { Some(1), "", Some(N::Arg(2)), Some(N::Arg(3)), None, "d", (0, 11), });
  94     assert_pns_eq_sub!("%-8ld",
  95         { None, "-", Some(N::Num(8)), None, Some("l"), "d", (0, 5), });
  96 }
  97
  98 #[test]
  99 fn test_iter() {
 100     let s = "The %d'th word %% is: `%.*s` %!\n";
 101     let subs: Vec<_> = iter_subs(s, 0).map(|sub| sub.translate().ok()).collect();
 102     assert_eq!(
 103         subs.iter().map(Option::as_deref).collect::<Vec<_>>(),
 104         vec![Some("{}"), None, Some("{:.*}"), None]
 105     );
 106 }
 107
 108 /// Checks that the translations are what we expect.
 109 #[test]
 110 fn test_translation() {
 111     assert_eq_pnsat!("%c", Some("{}"));
 112     assert_eq_pnsat!("%d", Some("{}"));
 113     assert_eq_pnsat!("%u", Some("{}"));
 114     assert_eq_pnsat!("%x", Some("{:x}"));
 115     assert_eq_pnsat!("%X", Some("{:X}"));
 116     assert_eq_pnsat!("%e", Some("{:e}"));
 117     assert_eq_pnsat!("%E", Some("{:E}"));
 118     assert_eq_pnsat!("%f", Some("{}"));
 119     assert_eq_pnsat!("%g", Some("{:e}"));
 120     assert_eq_pnsat!("%G", Some("{:E}"));
 121     assert_eq_pnsat!("%s", Some("{}"));
 122     assert_eq_pnsat!("%p", Some("{:p}"));
 123
 124     assert_eq_pnsat!("%06d", Some("{:06}"));
 125     assert_eq_pnsat!("%4.2f", Some("{:4.2}"));
 126     assert_eq_pnsat!("%#x", Some("{:#x}"));
 127     assert_eq_pnsat!("%-10s", Some("{:<10}"));
 128     assert_eq_pnsat!("%*s", None);
 129     assert_eq_pnsat!("%-10.*s", Some("{:<10.*}"));
 130     assert_eq_pnsat!("%-*.*s", None);
 131     assert_eq_pnsat!("%.6i", Some("{:06}"));
 132     assert_eq_pnsat!("%+i", Some("{:+}"));
 133     assert_eq_pnsat!("%08X", Some("{:08X}"));
 134     assert_eq_pnsat!("%lu", Some("{}"));
 135     assert_eq_pnsat!("%Iu", Some("{}"));
 136     assert_eq_pnsat!("%I32u", Some("{}"));
 137     assert_eq_pnsat!("%I64u", Some("{}"));
 138     assert_eq_pnsat!("%'d", None);
 139     assert_eq_pnsat!("%10s", Some("{:>10}"));
 140     assert_eq_pnsat!("%-10.10s", Some("{:<10.10}"));
 141     assert_eq_pnsat!("%1$d", Some("{0}"));
 142     assert_eq_pnsat!("%2$.*3$d", Some("{1:02$}"));
 143     assert_eq_pnsat!("%1$*2$.*3$s", Some("{0:>1$.2$}"));
 144     assert_eq_pnsat!("%-8ld", Some("{:<8}"));
 145 }