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 invalid_position() {
  62     musterr("{18446744073709551616}");
  63 }
  64
  65 #[test]
  66 fn invalid_width() {
  67     musterr("{:18446744073709551616}");
  68 }
  69
  70 #[test]
  71 fn invalid_precision() {
  72     musterr("{:.18446744073709551616}");
  73 }
  74
  75 #[test]
  76 fn format_nothing() {
  77     same(
  78         "{}",
  79         &[NextArgument(Box::new(Argument {
  80             position: ArgumentImplicitlyIs(0),
  81             position_span: InnerSpan { start: 2, end: 2 },
  82             format: fmtdflt(),
  83         }))],
  84     );
  85 }
  86 #[test]
  87 fn format_position() {
  88     same(
  89         "{3}",
  90         &[NextArgument(Box::new(Argument {
  91             position: ArgumentIs(3),
  92             position_span: InnerSpan { start: 2, end: 3 },
  93             format: fmtdflt(),
  94         }))],
  95     );
  96 }
  97 #[test]
  98 fn format_position_nothing_else() {
  99     same(
 100         "{3:}",
 101         &[NextArgument(Box::new(Argument {
 102             position: ArgumentIs(3),
 103             position_span: InnerSpan { start: 2, end: 3 },
 104             format: fmtdflt(),
 105         }))],
 106     );
 107 }
 108 #[test]
 109 fn format_named() {
 110     same(
 111         "{name}",
 112         &[NextArgument(Box::new(Argument {
 113             position: ArgumentNamed("name"),
 114             position_span: InnerSpan { start: 2, end: 6 },
 115             format: fmtdflt(),
 116         }))],
 117     )
 118 }
 119 #[test]
 120 fn format_type() {
 121     same(
 122         "{3:x}",
 123         &[NextArgument(Box::new(Argument {
 124             position: ArgumentIs(3),
 125             position_span: InnerSpan { start: 2, end: 3 },
 126             format: FormatSpec {
 127                 fill: None,
 128                 align: AlignUnknown,
 129                 flags: 0,
 130                 precision: CountImplied,
 131                 width: CountImplied,
 132                 precision_span: None,
 133                 width_span: None,
 134                 ty: "x",
 135                 ty_span: None,
 136             },
 137         }))],
 138     );
 139 }
 140 #[test]
 141 fn format_align_fill() {
 142     same(
 143         "{3:>}",
 144         &[NextArgument(Box::new(Argument {
 145             position: ArgumentIs(3),
 146             position_span: InnerSpan { start: 2, end: 3 },
 147             format: FormatSpec {
 148                 fill: None,
 149                 align: AlignRight,
 150                 flags: 0,
 151                 precision: CountImplied,
 152                 width: CountImplied,
 153                 precision_span: None,
 154                 width_span: None,
 155                 ty: "",
 156                 ty_span: None,
 157             },
 158         }))],
 159     );
 160     same(
 161         "{3:0<}",
 162         &[NextArgument(Box::new(Argument {
 163             position: ArgumentIs(3),
 164             position_span: InnerSpan { start: 2, end: 3 },
 165             format: FormatSpec {
 166                 fill: Some('0'),
 167                 align: AlignLeft,
 168                 flags: 0,
 169                 precision: CountImplied,
 170                 width: CountImplied,
 171                 precision_span: None,
 172                 width_span: None,
 173                 ty: "",
 174                 ty_span: None,
 175             },
 176         }))],
 177     );
 178     same(
 179         "{3:*<abcd}",
 180         &[NextArgument(Box::new(Argument {
 181             position: ArgumentIs(3),
 182             position_span: InnerSpan { start: 2, end: 3 },
 183             format: FormatSpec {
 184                 fill: Some('*'),
 185                 align: AlignLeft,
 186                 flags: 0,
 187                 precision: CountImplied,
 188                 width: CountImplied,
 189                 precision_span: None,
 190                 width_span: None,
 191                 ty: "abcd",
 192                 ty_span: Some(InnerSpan::new(6, 10)),
 193             },
 194         }))],
 195     );
 196 }
 197 #[test]
 198 fn format_counts() {
 199     same(
 200         "{:10x}",
 201         &[NextArgument(Box::new(Argument {
 202             position: ArgumentImplicitlyIs(0),
 203             position_span: InnerSpan { start: 2, end: 2 },
 204             format: FormatSpec {
 205                 fill: None,
 206                 align: AlignUnknown,
 207                 flags: 0,
 208                 precision: CountImplied,
 209                 precision_span: None,
 210                 width: CountIs(10),
 211                 width_span: Some(InnerSpan { start: 3, end: 5 }),
 212                 ty: "x",
 213                 ty_span: None,
 214             },
 215         }))],
 216     );
 217     same(
 218         "{:10$.10x}",
 219         &[NextArgument(Box::new(Argument {
 220             position: ArgumentImplicitlyIs(0),
 221             position_span: InnerSpan { start: 2, end: 2 },
 222             format: FormatSpec {
 223                 fill: None,
 224                 align: AlignUnknown,
 225                 flags: 0,
 226                 precision: CountIs(10),
 227                 precision_span: Some(InnerSpan { start: 6, end: 9 }),
 228                 width: CountIsParam(10),
 229                 width_span: Some(InnerSpan { start: 3, end: 6 }),
 230                 ty: "x",
 231                 ty_span: None,
 232             },
 233         }))],
 234     );
 235     same(
 236         "{1:0$.10x}",
 237         &[NextArgument(Box::new(Argument {
 238             position: ArgumentIs(1),
 239             position_span: InnerSpan { start: 2, end: 3 },
 240             format: FormatSpec {
 241                 fill: None,
 242                 align: AlignUnknown,
 243                 flags: 0,
 244                 precision: CountIs(10),
 245                 precision_span: Some(InnerSpan { start: 6, end: 9 }),
 246                 width: CountIsParam(0),
 247                 width_span: Some(InnerSpan { start: 4, end: 6 }),
 248                 ty: "x",
 249                 ty_span: None,
 250             },
 251         }))],
 252     );
 253     same(
 254         "{:.*x}",
 255         &[NextArgument(Box::new(Argument {
 256             position: ArgumentImplicitlyIs(1),
 257             position_span: InnerSpan { start: 2, end: 2 },
 258             format: FormatSpec {
 259                 fill: None,
 260                 align: AlignUnknown,
 261                 flags: 0,
 262                 precision: CountIsStar(0),
 263                 precision_span: Some(InnerSpan { start: 3, end: 5 }),
 264                 width: CountImplied,
 265                 width_span: None,
 266                 ty: "x",
 267                 ty_span: None,
 268             },
 269         }))],
 270     );
 271     same(
 272         "{:.10$x}",
 273         &[NextArgument(Box::new(Argument {
 274             position: ArgumentImplicitlyIs(0),
 275             position_span: InnerSpan { start: 2, end: 2 },
 276             format: FormatSpec {
 277                 fill: None,
 278                 align: AlignUnknown,
 279                 flags: 0,
 280                 precision: CountIsParam(10),
 281                 width: CountImplied,
 282                 precision_span: Some(InnerSpan::new(3, 7)),
 283                 width_span: None,
 284                 ty: "x",
 285                 ty_span: None,
 286             },
 287         }))],
 288     );
 289     same(
 290         "{:a$.b$?}",
 291         &[NextArgument(Box::new(Argument {
 292             position: ArgumentImplicitlyIs(0),
 293             position_span: InnerSpan { start: 2, end: 2 },
 294             format: FormatSpec {
 295                 fill: None,
 296                 align: AlignUnknown,
 297                 flags: 0,
 298                 precision: CountIsName("b", InnerSpan { start: 6, end: 7 }),
 299                 precision_span: Some(InnerSpan { start: 5, end: 8 }),
 300                 width: CountIsName("a", InnerSpan { start: 3, end: 4 }),
 301                 width_span: Some(InnerSpan { start: 3, end: 5 }),
 302                 ty: "?",
 303                 ty_span: None,
 304             },
 305         }))],
 306     );
 307     same(
 308         "{:.4}",
 309         &[NextArgument(Box::new(Argument {
 310             position: ArgumentImplicitlyIs(0),
 311             position_span: InnerSpan { start: 2, end: 2 },
 312             format: FormatSpec {
 313                 fill: None,
 314                 align: AlignUnknown,
 315                 flags: 0,
 316                 precision: CountIs(4),
 317                 precision_span: Some(InnerSpan { start: 3, end: 5 }),
 318                 width: CountImplied,
 319                 width_span: None,
 320                 ty: "",
 321                 ty_span: None,
 322             },
 323         }))],
 324     )
 325 }
 326 #[test]
 327 fn format_flags() {
 328     same(
 329         "{:-}",
 330         &[NextArgument(Box::new(Argument {
 331             position: ArgumentImplicitlyIs(0),
 332             position_span: InnerSpan { start: 2, end: 2 },
 333             format: FormatSpec {
 334                 fill: None,
 335                 align: AlignUnknown,
 336                 flags: (1 << FlagSignMinus as u32),
 337                 precision: CountImplied,
 338                 width: CountImplied,
 339                 precision_span: None,
 340                 width_span: None,
 341                 ty: "",
 342                 ty_span: None,
 343             },
 344         }))],
 345     );
 346     same(
 347         "{:+#}",
 348         &[NextArgument(Box::new(Argument {
 349             position: ArgumentImplicitlyIs(0),
 350             position_span: InnerSpan { start: 2, end: 2 },
 351             format: FormatSpec {
 352                 fill: None,
 353                 align: AlignUnknown,
 354                 flags: (1 << FlagSignPlus as u32) | (1 << FlagAlternate as u32),
 355                 precision: CountImplied,
 356                 width: CountImplied,
 357                 precision_span: None,
 358                 width_span: None,
 359                 ty: "",
 360                 ty_span: None,
 361             },
 362         }))],
 363     );
 364 }
 365 #[test]
 366 fn format_mixture() {
 367     same(
 368         "abcd {3:x} efg",
 369         &[
 370             String("abcd "),
 371             NextArgument(Box::new(Argument {
 372                 position: ArgumentIs(3),
 373                 position_span: InnerSpan { start: 7, end: 8 },
 374                 format: FormatSpec {
 375                     fill: None,
 376                     align: AlignUnknown,
 377                     flags: 0,
 378                     precision: CountImplied,
 379                     width: CountImplied,
 380                     precision_span: None,
 381                     width_span: None,
 382                     ty: "x",
 383                     ty_span: None,
 384                 },
 385             })),
 386             String(" efg"),
 387         ],
 388     );
 389 }
 390 #[test]
 391 fn format_whitespace() {
 392     same(
 393         "{ }",
 394         &[NextArgument(Box::new(Argument {
 395             position: ArgumentImplicitlyIs(0),
 396             position_span: InnerSpan { start: 2, end: 3 },
 397             format: fmtdflt(),
 398         }))],
 399     );
 400     same(
 401         "{  }",
 402         &[NextArgument(Box::new(Argument {
 403             position: ArgumentImplicitlyIs(0),
 404             position_span: InnerSpan { start: 2, end: 4 },
 405             format: fmtdflt(),
 406         }))],
 407     );
 408 }