compiler/rustc_parse_format/src/tests.rs

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