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