compiler/rustc_parse_format/src/tests.rs

   1 use super::*;
   2
   3 #[track_caller]
   4 fn same(fmt: &'static str, p: &[Piece<'static>]) {
   5     let parser = Parser::new(fmt, None, None, false, ParseMode::Format);
   6     assert_eq!(parser.collect::<Vec<Piece<'static>>>(), p);
   7 }
   8
   9 fn fmtdflt() -> FormatSpec<'static> {
  10     return FormatSpec {
  11         fill: None,
  12         align: AlignUnknown,
  13         flags: 0,
  14         precision: CountImplied,
  15         width: CountImplied,
  16         precision_span: None,
  17         width_span: None,
  18         ty: "",
  19         ty_span: None,
  20     };
  21 }
  22
  23 fn musterr(s: &str) {
  24     let mut p = Parser::new(s, None, None, false, ParseMode::Format);
  25     p.next();
  26     assert!(!p.errors.is_empty());
  27 }
  28
  29 #[test]
  30 fn simple() {
  31     same("asdf", &[String("asdf")]);
  32     same("a{{b", &[String("a"), String("{b")]);
  33     same("a}}b", &[String("a"), String("}b")]);
  34     same("a}}", &[String("a"), String("}")]);
  35     same("}}", &[String("}")]);
  36     same("\\}}", &[String("\\"), String("}")]);
  37 }
  38
  39 #[test]
  40 fn invalid01() {
  41     musterr("{")
  42 }
  43 #[test]
  44 fn invalid02() {
  45     musterr("}")
  46 }
  47 #[test]
  48 fn invalid04() {
  49     musterr("{3a}")
  50 }
  51 #[test]
  52 fn invalid05() {
  53     musterr("{:|}")
  54 }
  55 #[test]
  56 fn invalid06() {
  57     musterr("{:>>>}")
  58 }
  59
  60 #[test]
  61 fn format_nothing() {
  62     same(
  63         "{}",
  64         &[NextArgument(Argument {
  65             position: ArgumentImplicitlyIs(0),
  66             position_span: InnerSpan { start: 2, end: 2 },
  67             format: fmtdflt(),
  68         })],
  69     );
  70 }
  71 #[test]
  72 fn format_position() {
  73     same(
  74         "{3}",
  75         &[NextArgument(Argument {
  76             position: ArgumentIs(3),
  77             position_span: InnerSpan { start: 2, end: 3 },
  78             format: fmtdflt(),
  79         })],
  80     );
  81 }
  82 #[test]
  83 fn format_position_nothing_else() {
  84     same(
  85         "{3:}",
  86         &[NextArgument(Argument {
  87             position: ArgumentIs(3),
  88             position_span: InnerSpan { start: 2, end: 3 },
  89             format: fmtdflt(),
  90         })],
  91     );
  92 }
  93 #[test]
  94 fn format_named() {
  95     same(
  96         "{name}",
  97         &[NextArgument(Argument {
  98             position: ArgumentNamed("name"),
  99             position_span: InnerSpan { start: 2, end: 6 },
 100             format: fmtdflt(),
 101         })],
 102     )
 103 }
 104 #[test]
 105 fn format_type() {
 106     same(
 107         "{3:x}",
 108         &[NextArgument(Argument {
 109             position: ArgumentIs(3),
 110             position_span: InnerSpan { start: 2, end: 3 },
 111             format: FormatSpec {
 112                 fill: None,
 113                 align: AlignUnknown,
 114                 flags: 0,
 115                 precision: CountImplied,
 116                 width: CountImplied,
 117                 precision_span: None,
 118                 width_span: None,
 119                 ty: "x",
 120                 ty_span: None,
 121             },
 122         })],
 123     );
 124 }
 125 #[test]
 126 fn format_align_fill() {
 127     same(
 128         "{3:>}",
 129         &[NextArgument(Argument {
 130             position: ArgumentIs(3),
 131             position_span: InnerSpan { start: 2, end: 3 },
 132             format: FormatSpec {
 133                 fill: None,
 134                 align: AlignRight,
 135                 flags: 0,
 136                 precision: CountImplied,
 137                 width: CountImplied,
 138                 precision_span: None,
 139                 width_span: None,
 140                 ty: "",
 141                 ty_span: None,
 142             },
 143         })],
 144     );
 145     same(
 146         "{3:0<}",
 147         &[NextArgument(Argument {
 148             position: ArgumentIs(3),
 149             position_span: InnerSpan { start: 2, end: 3 },
 150             format: FormatSpec {
 151                 fill: Some('0'),
 152                 align: AlignLeft,
 153                 flags: 0,
 154                 precision: CountImplied,
 155                 width: CountImplied,
 156                 precision_span: None,
 157                 width_span: None,
 158                 ty: "",
 159                 ty_span: None,
 160             },
 161         })],
 162     );
 163     same(
 164         "{3:*<abcd}",
 165         &[NextArgument(Argument {
 166             position: ArgumentIs(3),
 167             position_span: InnerSpan { start: 2, end: 3 },
 168             format: FormatSpec {
 169                 fill: Some('*'),
 170                 align: AlignLeft,
 171                 flags: 0,
 172                 precision: CountImplied,
 173                 width: CountImplied,
 174                 precision_span: None,
 175                 width_span: None,
 176                 ty: "abcd",
 177                 ty_span: Some(InnerSpan::new(6, 10)),
 178             },
 179         })],
 180     );
 181 }
 182 #[test]
 183 fn format_counts() {
 184     same(
 185         "{:10x}",
 186         &[NextArgument(Argument {
 187             position: ArgumentImplicitlyIs(0),
 188             position_span: InnerSpan { start: 2, end: 2 },
 189             format: FormatSpec {
 190                 fill: None,
 191                 align: AlignUnknown,
 192                 flags: 0,
 193                 precision: CountImplied,
 194                 precision_span: None,
 195                 width: CountIs(10),
 196                 width_span: Some(InnerSpan { start: 3, end: 5 }),
 197                 ty: "x",
 198                 ty_span: None,
 199             },
 200         })],
 201     );
 202     same(
 203         "{:10$.10x}",
 204         &[NextArgument(Argument {
 205             position: ArgumentImplicitlyIs(0),
 206             position_span: InnerSpan { start: 2, end: 2 },
 207             format: FormatSpec {
 208                 fill: None,
 209                 align: AlignUnknown,
 210                 flags: 0,
 211                 precision: CountIs(10),
 212                 precision_span: Some(InnerSpan { start: 6, end: 9 }),
 213                 width: CountIsParam(10),
 214                 width_span: Some(InnerSpan { start: 3, end: 6 }),
 215                 ty: "x",
 216                 ty_span: None,
 217             },
 218         })],
 219     );
 220     same(
 221         "{1:0$.10x}",
 222         &[NextArgument(Argument {
 223             position: ArgumentIs(1),
 224             position_span: InnerSpan { start: 2, end: 3 },
 225             format: FormatSpec {
 226                 fill: None,
 227                 align: AlignUnknown,
 228                 flags: 0,
 229                 precision: CountIs(10),
 230                 precision_span: Some(InnerSpan { start: 6, end: 9 }),
 231                 width: CountIsParam(0),
 232                 width_span: Some(InnerSpan { start: 4, end: 6 }),
 233                 ty: "x",
 234                 ty_span: None,
 235             },
 236         })],
 237     );
 238     same(
 239         "{:.*x}",
 240         &[NextArgument(Argument {
 241             position: ArgumentImplicitlyIs(1),
 242             position_span: InnerSpan { start: 2, end: 2 },
 243             format: FormatSpec {
 244                 fill: None,
 245                 align: AlignUnknown,
 246                 flags: 0,
 247                 precision: CountIsStar(0),
 248                 precision_span: Some(InnerSpan { start: 3, end: 5 }),
 249                 width: CountImplied,
 250                 width_span: None,
 251                 ty: "x",
 252                 ty_span: None,
 253             },
 254         })],
 255     );
 256     same(
 257         "{:.10$x}",
 258         &[NextArgument(Argument {
 259             position: ArgumentImplicitlyIs(0),
 260             position_span: InnerSpan { start: 2, end: 2 },
 261             format: FormatSpec {
 262                 fill: None,
 263                 align: AlignUnknown,
 264                 flags: 0,
 265                 precision: CountIsParam(10),
 266                 width: CountImplied,
 267                 precision_span: Some(InnerSpan::new(3, 7)),
 268                 width_span: None,
 269                 ty: "x",
 270                 ty_span: None,
 271             },
 272         })],
 273     );
 274     same(
 275         "{:a$.b$?}",
 276         &[NextArgument(Argument {
 277             position: ArgumentImplicitlyIs(0),
 278             position_span: InnerSpan { start: 2, end: 2 },
 279             format: FormatSpec {
 280                 fill: None,
 281                 align: AlignUnknown,
 282                 flags: 0,
 283                 precision: CountIsName("b", InnerSpan { start: 6, end: 7 }),
 284                 precision_span: Some(InnerSpan { start: 5, end: 8 }),
 285                 width: CountIsName("a", InnerSpan { start: 3, end: 4 }),
 286                 width_span: Some(InnerSpan { start: 3, end: 5 }),
 287                 ty: "?",
 288                 ty_span: None,
 289             },
 290         })],
 291     );
 292     same(
 293         "{:.4}",
 294         &[NextArgument(Argument {
 295             position: ArgumentImplicitlyIs(0),
 296             position_span: InnerSpan { start: 2, end: 2 },
 297             format: FormatSpec {
 298                 fill: None,
 299                 align: AlignUnknown,
 300                 flags: 0,
 301                 precision: CountIs(4),
 302                 precision_span: Some(InnerSpan { start: 3, end: 5 }),
 303                 width: CountImplied,
 304                 width_span: None,
 305                 ty: "",
 306                 ty_span: None,
 307             },
 308         })],
 309     )
 310 }
 311 #[test]
 312 fn format_flags() {
 313     same(
 314         "{:-}",
 315         &[NextArgument(Argument {
 316             position: ArgumentImplicitlyIs(0),
 317             position_span: InnerSpan { start: 2, end: 2 },
 318             format: FormatSpec {
 319                 fill: None,
 320                 align: AlignUnknown,
 321                 flags: (1 << FlagSignMinus as u32),
 322                 precision: CountImplied,
 323                 width: CountImplied,
 324                 precision_span: None,
 325                 width_span: None,
 326                 ty: "",
 327                 ty_span: None,
 328             },
 329         })],
 330     );
 331     same(
 332         "{:+#}",
 333         &[NextArgument(Argument {
 334             position: ArgumentImplicitlyIs(0),
 335             position_span: InnerSpan { start: 2, end: 2 },
 336             format: FormatSpec {
 337                 fill: None,
 338                 align: AlignUnknown,
 339                 flags: (1 << FlagSignPlus as u32) | (1 << FlagAlternate as u32),
 340                 precision: CountImplied,
 341                 width: CountImplied,
 342                 precision_span: None,
 343                 width_span: None,
 344                 ty: "",
 345                 ty_span: None,
 346             },
 347         })],
 348     );
 349 }
 350 #[test]
 351 fn format_mixture() {
 352     same(
 353         "abcd {3:x} efg",
 354         &[
 355             String("abcd "),
 356             NextArgument(Argument {
 357                 position: ArgumentIs(3),
 358                 position_span: InnerSpan { start: 7, end: 8 },
 359                 format: FormatSpec {
 360                     fill: None,
 361                     align: AlignUnknown,
 362                     flags: 0,
 363                     precision: CountImplied,
 364                     width: CountImplied,
 365                     precision_span: None,
 366                     width_span: None,
 367                     ty: "x",
 368                     ty_span: None,
 369                 },
 370             }),
 371             String(" efg"),
 372         ],
 373     );
 374 }
 375 #[test]
 376 fn format_whitespace() {
 377     same(
 378         "{ }",
 379         &[NextArgument(Argument {
 380             position: ArgumentImplicitlyIs(0),
 381             position_span: InnerSpan { start: 2, end: 3 },
 382             format: fmtdflt(),
 383         })],
 384     );
 385     same(
 386         "{  }",
 387         &[NextArgument(Argument {
 388             position: ArgumentImplicitlyIs(0),
 389             position_span: InnerSpan { start: 2, end: 4 },
 390             format: fmtdflt(),
 391         })],
 392     );
 393 }