]>
Commit | Line | Data |
---|---|---|
064997fb FG |
1 | //! Generated by `sourcegen_assists_docs`, do not edit by hand. |
2 | ||
3 | use super::check_doc_test; | |
4 | ||
5 | #[test] | |
6 | fn doctest_add_explicit_type() { | |
7 | check_doc_test( | |
8 | "add_explicit_type", | |
9 | r#####" | |
10 | fn main() { | |
11 | let x$0 = 92; | |
12 | } | |
13 | "#####, | |
14 | r#####" | |
15 | fn main() { | |
16 | let x: i32 = 92; | |
17 | } | |
18 | "#####, | |
19 | ) | |
20 | } | |
21 | ||
22 | #[test] | |
23 | fn doctest_add_hash() { | |
24 | check_doc_test( | |
25 | "add_hash", | |
26 | r#####" | |
27 | fn main() { | |
28 | r#"Hello,$0 World!"#; | |
29 | } | |
30 | "#####, | |
31 | r#####" | |
32 | fn main() { | |
33 | r##"Hello, World!"##; | |
34 | } | |
35 | "#####, | |
36 | ) | |
37 | } | |
38 | ||
39 | #[test] | |
40 | fn doctest_add_impl_default_members() { | |
41 | check_doc_test( | |
42 | "add_impl_default_members", | |
43 | r#####" | |
44 | trait Trait { | |
45 | type X; | |
46 | fn foo(&self); | |
47 | fn bar(&self) {} | |
48 | } | |
49 | ||
50 | impl Trait for () { | |
51 | type X = (); | |
52 | fn foo(&self) {}$0 | |
53 | } | |
54 | "#####, | |
55 | r#####" | |
56 | trait Trait { | |
57 | type X; | |
58 | fn foo(&self); | |
59 | fn bar(&self) {} | |
60 | } | |
61 | ||
62 | impl Trait for () { | |
63 | type X = (); | |
64 | fn foo(&self) {} | |
65 | ||
66 | $0fn bar(&self) {} | |
67 | } | |
68 | "#####, | |
69 | ) | |
70 | } | |
71 | ||
72 | #[test] | |
73 | fn doctest_add_impl_missing_members() { | |
74 | check_doc_test( | |
75 | "add_impl_missing_members", | |
76 | r#####" | |
77 | trait Trait<T> { | |
78 | type X; | |
79 | fn foo(&self) -> T; | |
80 | fn bar(&self) {} | |
81 | } | |
82 | ||
83 | impl Trait<u32> for () {$0 | |
84 | ||
85 | } | |
86 | "#####, | |
87 | r#####" | |
88 | trait Trait<T> { | |
89 | type X; | |
90 | fn foo(&self) -> T; | |
91 | fn bar(&self) {} | |
92 | } | |
93 | ||
94 | impl Trait<u32> for () { | |
95 | $0type X; | |
96 | ||
97 | fn foo(&self) -> u32 { | |
98 | todo!() | |
99 | } | |
100 | } | |
101 | "#####, | |
102 | ) | |
103 | } | |
104 | ||
105 | #[test] | |
106 | fn doctest_add_label_to_loop() { | |
107 | check_doc_test( | |
108 | "add_label_to_loop", | |
109 | r#####" | |
110 | fn main() { | |
111 | loop$0 { | |
112 | break; | |
113 | continue; | |
114 | } | |
115 | } | |
116 | "#####, | |
117 | r#####" | |
118 | fn main() { | |
119 | 'l: loop { | |
120 | break 'l; | |
121 | continue 'l; | |
122 | } | |
123 | } | |
124 | "#####, | |
125 | ) | |
126 | } | |
127 | ||
128 | #[test] | |
129 | fn doctest_add_lifetime_to_type() { | |
130 | check_doc_test( | |
131 | "add_lifetime_to_type", | |
132 | r#####" | |
133 | struct Point { | |
134 | x: &$0u32, | |
135 | y: u32, | |
136 | } | |
137 | "#####, | |
138 | r#####" | |
139 | struct Point<'a> { | |
140 | x: &'a u32, | |
141 | y: u32, | |
142 | } | |
143 | "#####, | |
144 | ) | |
145 | } | |
146 | ||
147 | #[test] | |
148 | fn doctest_add_missing_match_arms() { | |
149 | check_doc_test( | |
150 | "add_missing_match_arms", | |
151 | r#####" | |
152 | enum Action { Move { distance: u32 }, Stop } | |
153 | ||
154 | fn handle(action: Action) { | |
155 | match action { | |
156 | $0 | |
157 | } | |
158 | } | |
159 | "#####, | |
160 | r#####" | |
161 | enum Action { Move { distance: u32 }, Stop } | |
162 | ||
163 | fn handle(action: Action) { | |
164 | match action { | |
165 | $0Action::Move { distance } => todo!(), | |
166 | Action::Stop => todo!(), | |
167 | } | |
168 | } | |
169 | "#####, | |
170 | ) | |
171 | } | |
172 | ||
173 | #[test] | |
174 | fn doctest_add_return_type() { | |
175 | check_doc_test( | |
176 | "add_return_type", | |
177 | r#####" | |
178 | fn foo() { 4$02i32 } | |
179 | "#####, | |
180 | r#####" | |
181 | fn foo() -> i32 { 42i32 } | |
182 | "#####, | |
183 | ) | |
184 | } | |
185 | ||
186 | #[test] | |
187 | fn doctest_add_turbo_fish() { | |
188 | check_doc_test( | |
189 | "add_turbo_fish", | |
190 | r#####" | |
191 | fn make<T>() -> T { todo!() } | |
192 | fn main() { | |
193 | let x = make$0(); | |
194 | } | |
195 | "#####, | |
196 | r#####" | |
197 | fn make<T>() -> T { todo!() } | |
198 | fn main() { | |
199 | let x = make::<${0:_}>(); | |
200 | } | |
201 | "#####, | |
202 | ) | |
203 | } | |
204 | ||
205 | #[test] | |
206 | fn doctest_apply_demorgan() { | |
207 | check_doc_test( | |
208 | "apply_demorgan", | |
209 | r#####" | |
210 | fn main() { | |
211 | if x != 4 ||$0 y < 3.14 {} | |
212 | } | |
213 | "#####, | |
214 | r#####" | |
215 | fn main() { | |
216 | if !(x == 4 && y >= 3.14) {} | |
217 | } | |
218 | "#####, | |
219 | ) | |
220 | } | |
221 | ||
222 | #[test] | |
223 | fn doctest_auto_import() { | |
224 | check_doc_test( | |
225 | "auto_import", | |
226 | r#####" | |
227 | fn main() { | |
228 | let map = HashMap$0::new(); | |
229 | } | |
230 | pub mod std { pub mod collections { pub struct HashMap { } } } | |
231 | "#####, | |
232 | r#####" | |
233 | use std::collections::HashMap; | |
234 | ||
235 | fn main() { | |
236 | let map = HashMap::new(); | |
237 | } | |
238 | pub mod std { pub mod collections { pub struct HashMap { } } } | |
239 | "#####, | |
240 | ) | |
241 | } | |
242 | ||
243 | #[test] | |
244 | fn doctest_change_visibility() { | |
245 | check_doc_test( | |
246 | "change_visibility", | |
247 | r#####" | |
248 | $0fn frobnicate() {} | |
249 | "#####, | |
250 | r#####" | |
251 | pub(crate) fn frobnicate() {} | |
252 | "#####, | |
253 | ) | |
254 | } | |
255 | ||
256 | #[test] | |
257 | fn doctest_convert_bool_then_to_if() { | |
258 | check_doc_test( | |
259 | "convert_bool_then_to_if", | |
260 | r#####" | |
261 | //- minicore: bool_impl | |
262 | fn main() { | |
263 | (0 == 0).then$0(|| val) | |
264 | } | |
265 | "#####, | |
266 | r#####" | |
267 | fn main() { | |
268 | if 0 == 0 { | |
269 | Some(val) | |
270 | } else { | |
271 | None | |
272 | } | |
273 | } | |
274 | "#####, | |
275 | ) | |
276 | } | |
277 | ||
278 | #[test] | |
279 | fn doctest_convert_for_loop_with_for_each() { | |
280 | check_doc_test( | |
281 | "convert_for_loop_with_for_each", | |
282 | r#####" | |
283 | fn main() { | |
284 | let x = vec![1, 2, 3]; | |
285 | for$0 v in x { | |
286 | let y = v * 2; | |
287 | } | |
288 | } | |
289 | "#####, | |
290 | r#####" | |
291 | fn main() { | |
292 | let x = vec![1, 2, 3]; | |
293 | x.into_iter().for_each(|v| { | |
294 | let y = v * 2; | |
295 | }); | |
296 | } | |
297 | "#####, | |
298 | ) | |
299 | } | |
300 | ||
301 | #[test] | |
302 | fn doctest_convert_if_to_bool_then() { | |
303 | check_doc_test( | |
304 | "convert_if_to_bool_then", | |
305 | r#####" | |
306 | //- minicore: option | |
307 | fn main() { | |
308 | if$0 cond { | |
309 | Some(val) | |
310 | } else { | |
311 | None | |
312 | } | |
313 | } | |
314 | "#####, | |
315 | r#####" | |
316 | fn main() { | |
317 | cond.then(|| val) | |
318 | } | |
319 | "#####, | |
320 | ) | |
321 | } | |
322 | ||
323 | #[test] | |
324 | fn doctest_convert_integer_literal() { | |
325 | check_doc_test( | |
326 | "convert_integer_literal", | |
327 | r#####" | |
328 | const _: i32 = 10$0; | |
329 | "#####, | |
330 | r#####" | |
331 | const _: i32 = 0b1010; | |
332 | "#####, | |
333 | ) | |
334 | } | |
335 | ||
336 | #[test] | |
337 | fn doctest_convert_into_to_from() { | |
338 | check_doc_test( | |
339 | "convert_into_to_from", | |
340 | r#####" | |
341 | //- minicore: from | |
342 | impl $0Into<Thing> for usize { | |
343 | fn into(self) -> Thing { | |
344 | Thing { | |
345 | b: self.to_string(), | |
346 | a: self | |
347 | } | |
348 | } | |
349 | } | |
350 | "#####, | |
351 | r#####" | |
352 | impl From<usize> for Thing { | |
353 | fn from(val: usize) -> Self { | |
354 | Thing { | |
355 | b: val.to_string(), | |
356 | a: val | |
357 | } | |
358 | } | |
359 | } | |
360 | "#####, | |
361 | ) | |
362 | } | |
363 | ||
364 | #[test] | |
365 | fn doctest_convert_iter_for_each_to_for() { | |
366 | check_doc_test( | |
367 | "convert_iter_for_each_to_for", | |
368 | r#####" | |
369 | //- minicore: iterators | |
370 | use core::iter; | |
371 | fn main() { | |
372 | let iter = iter::repeat((9, 2)); | |
373 | iter.for_each$0(|(x, y)| { | |
374 | println!("x: {}, y: {}", x, y); | |
375 | }); | |
376 | } | |
377 | "#####, | |
378 | r#####" | |
379 | use core::iter; | |
380 | fn main() { | |
381 | let iter = iter::repeat((9, 2)); | |
382 | for (x, y) in iter { | |
383 | println!("x: {}, y: {}", x, y); | |
384 | } | |
385 | } | |
386 | "#####, | |
387 | ) | |
388 | } | |
389 | ||
390 | #[test] | |
391 | fn doctest_convert_let_else_to_match() { | |
392 | check_doc_test( | |
393 | "convert_let_else_to_match", | |
394 | r#####" | |
395 | fn main() { | |
396 | let Ok(mut x) = f() else$0 { return }; | |
397 | } | |
398 | "#####, | |
399 | r#####" | |
400 | fn main() { | |
401 | let mut x = match f() { | |
402 | Ok(x) => x, | |
403 | _ => return, | |
404 | }; | |
405 | } | |
406 | "#####, | |
407 | ) | |
408 | } | |
409 | ||
2b03887a FG |
410 | #[test] |
411 | fn doctest_convert_named_struct_to_tuple_struct() { | |
412 | check_doc_test( | |
413 | "convert_named_struct_to_tuple_struct", | |
414 | r#####" | |
415 | struct Point$0 { x: f32, y: f32 } | |
416 | ||
417 | impl Point { | |
418 | pub fn new(x: f32, y: f32) -> Self { | |
419 | Point { x, y } | |
420 | } | |
421 | ||
422 | pub fn x(&self) -> f32 { | |
423 | self.x | |
424 | } | |
425 | ||
426 | pub fn y(&self) -> f32 { | |
427 | self.y | |
428 | } | |
429 | } | |
430 | "#####, | |
431 | r#####" | |
432 | struct Point(f32, f32); | |
433 | ||
434 | impl Point { | |
435 | pub fn new(x: f32, y: f32) -> Self { | |
436 | Point(x, y) | |
437 | } | |
438 | ||
439 | pub fn x(&self) -> f32 { | |
440 | self.0 | |
441 | } | |
442 | ||
443 | pub fn y(&self) -> f32 { | |
444 | self.1 | |
445 | } | |
446 | } | |
447 | "#####, | |
448 | ) | |
449 | } | |
450 | ||
064997fb FG |
451 | #[test] |
452 | fn doctest_convert_to_guarded_return() { | |
453 | check_doc_test( | |
454 | "convert_to_guarded_return", | |
455 | r#####" | |
456 | fn main() { | |
457 | $0if cond { | |
458 | foo(); | |
459 | bar(); | |
460 | } | |
461 | } | |
462 | "#####, | |
463 | r#####" | |
464 | fn main() { | |
465 | if !cond { | |
466 | return; | |
467 | } | |
468 | foo(); | |
469 | bar(); | |
470 | } | |
471 | "#####, | |
472 | ) | |
473 | } | |
474 | ||
475 | #[test] | |
476 | fn doctest_convert_tuple_struct_to_named_struct() { | |
477 | check_doc_test( | |
478 | "convert_tuple_struct_to_named_struct", | |
479 | r#####" | |
480 | struct Point$0(f32, f32); | |
481 | ||
482 | impl Point { | |
483 | pub fn new(x: f32, y: f32) -> Self { | |
484 | Point(x, y) | |
485 | } | |
486 | ||
487 | pub fn x(&self) -> f32 { | |
488 | self.0 | |
489 | } | |
490 | ||
491 | pub fn y(&self) -> f32 { | |
492 | self.1 | |
493 | } | |
494 | } | |
495 | "#####, | |
496 | r#####" | |
497 | struct Point { field1: f32, field2: f32 } | |
498 | ||
499 | impl Point { | |
500 | pub fn new(x: f32, y: f32) -> Self { | |
501 | Point { field1: x, field2: y } | |
502 | } | |
503 | ||
504 | pub fn x(&self) -> f32 { | |
505 | self.field1 | |
506 | } | |
507 | ||
508 | pub fn y(&self) -> f32 { | |
509 | self.field2 | |
510 | } | |
511 | } | |
512 | "#####, | |
513 | ) | |
514 | } | |
515 | ||
f2b60f7d FG |
516 | #[test] |
517 | fn doctest_convert_two_arm_bool_match_to_matches_macro() { | |
518 | check_doc_test( | |
519 | "convert_two_arm_bool_match_to_matches_macro", | |
520 | r#####" | |
521 | fn main() { | |
522 | match scrutinee$0 { | |
523 | Some(val) if val.cond() => true, | |
524 | _ => false, | |
525 | } | |
526 | } | |
527 | "#####, | |
528 | r#####" | |
529 | fn main() { | |
530 | matches!(scrutinee, Some(val) if val.cond()) | |
531 | } | |
532 | "#####, | |
533 | ) | |
534 | } | |
535 | ||
064997fb FG |
536 | #[test] |
537 | fn doctest_convert_while_to_loop() { | |
538 | check_doc_test( | |
539 | "convert_while_to_loop", | |
540 | r#####" | |
541 | fn main() { | |
542 | $0while cond { | |
543 | foo(); | |
544 | } | |
545 | } | |
546 | "#####, | |
547 | r#####" | |
548 | fn main() { | |
549 | loop { | |
550 | if !cond { | |
551 | break; | |
552 | } | |
553 | foo(); | |
554 | } | |
555 | } | |
556 | "#####, | |
557 | ) | |
558 | } | |
559 | ||
560 | #[test] | |
561 | fn doctest_destructure_tuple_binding() { | |
562 | check_doc_test( | |
563 | "destructure_tuple_binding", | |
564 | r#####" | |
565 | fn main() { | |
566 | let $0t = (1,2); | |
567 | let v = t.0; | |
568 | } | |
569 | "#####, | |
570 | r#####" | |
571 | fn main() { | |
572 | let ($0_0, _1) = (1,2); | |
573 | let v = _0; | |
574 | } | |
575 | "#####, | |
576 | ) | |
577 | } | |
578 | ||
579 | #[test] | |
580 | fn doctest_expand_glob_import() { | |
581 | check_doc_test( | |
582 | "expand_glob_import", | |
583 | r#####" | |
584 | mod foo { | |
585 | pub struct Bar; | |
586 | pub struct Baz; | |
587 | } | |
588 | ||
589 | use foo::*$0; | |
590 | ||
591 | fn qux(bar: Bar, baz: Baz) {} | |
592 | "#####, | |
593 | r#####" | |
594 | mod foo { | |
595 | pub struct Bar; | |
596 | pub struct Baz; | |
597 | } | |
598 | ||
599 | use foo::{Bar, Baz}; | |
600 | ||
601 | fn qux(bar: Bar, baz: Baz) {} | |
602 | "#####, | |
603 | ) | |
604 | } | |
605 | ||
606 | #[test] | |
607 | fn doctest_extract_function() { | |
608 | check_doc_test( | |
609 | "extract_function", | |
610 | r#####" | |
611 | fn main() { | |
612 | let n = 1; | |
613 | $0let m = n + 2; | |
614 | // calculate | |
615 | let k = m + n;$0 | |
616 | let g = 3; | |
617 | } | |
618 | "#####, | |
619 | r#####" | |
620 | fn main() { | |
621 | let n = 1; | |
622 | fun_name(n); | |
623 | let g = 3; | |
624 | } | |
625 | ||
626 | fn $0fun_name(n: i32) { | |
627 | let m = n + 2; | |
628 | // calculate | |
629 | let k = m + n; | |
630 | } | |
631 | "#####, | |
632 | ) | |
633 | } | |
634 | ||
635 | #[test] | |
636 | fn doctest_extract_module() { | |
637 | check_doc_test( | |
638 | "extract_module", | |
639 | r#####" | |
640 | $0fn foo(name: i32) -> i32 { | |
641 | name + 1 | |
642 | }$0 | |
643 | ||
644 | fn bar(name: i32) -> i32 { | |
645 | name + 2 | |
646 | } | |
647 | "#####, | |
648 | r#####" | |
649 | mod modname { | |
650 | pub(crate) fn foo(name: i32) -> i32 { | |
651 | name + 1 | |
652 | } | |
653 | } | |
654 | ||
655 | fn bar(name: i32) -> i32 { | |
656 | name + 2 | |
657 | } | |
658 | "#####, | |
659 | ) | |
660 | } | |
661 | ||
662 | #[test] | |
663 | fn doctest_extract_struct_from_enum_variant() { | |
664 | check_doc_test( | |
665 | "extract_struct_from_enum_variant", | |
666 | r#####" | |
667 | enum A { $0One(u32, u32) } | |
668 | "#####, | |
669 | r#####" | |
670 | struct One(u32, u32); | |
671 | ||
672 | enum A { One(One) } | |
673 | "#####, | |
674 | ) | |
675 | } | |
676 | ||
677 | #[test] | |
678 | fn doctest_extract_type_alias() { | |
679 | check_doc_test( | |
680 | "extract_type_alias", | |
681 | r#####" | |
682 | struct S { | |
683 | field: $0(u8, u8, u8)$0, | |
684 | } | |
685 | "#####, | |
686 | r#####" | |
687 | type $0Type = (u8, u8, u8); | |
688 | ||
689 | struct S { | |
690 | field: Type, | |
691 | } | |
692 | "#####, | |
693 | ) | |
694 | } | |
695 | ||
696 | #[test] | |
697 | fn doctest_extract_variable() { | |
698 | check_doc_test( | |
699 | "extract_variable", | |
700 | r#####" | |
701 | fn main() { | |
702 | $0(1 + 2)$0 * 4; | |
703 | } | |
704 | "#####, | |
705 | r#####" | |
706 | fn main() { | |
707 | let $0var_name = (1 + 2); | |
708 | var_name * 4; | |
709 | } | |
710 | "#####, | |
711 | ) | |
712 | } | |
713 | ||
714 | #[test] | |
715 | fn doctest_fix_visibility() { | |
716 | check_doc_test( | |
717 | "fix_visibility", | |
718 | r#####" | |
719 | mod m { | |
720 | fn frobnicate() {} | |
721 | } | |
722 | fn main() { | |
723 | m::frobnicate$0() {} | |
724 | } | |
725 | "#####, | |
726 | r#####" | |
727 | mod m { | |
728 | $0pub(crate) fn frobnicate() {} | |
729 | } | |
730 | fn main() { | |
731 | m::frobnicate() {} | |
732 | } | |
733 | "#####, | |
734 | ) | |
735 | } | |
736 | ||
737 | #[test] | |
738 | fn doctest_flip_binexpr() { | |
739 | check_doc_test( | |
740 | "flip_binexpr", | |
741 | r#####" | |
742 | fn main() { | |
743 | let _ = 90 +$0 2; | |
744 | } | |
745 | "#####, | |
746 | r#####" | |
747 | fn main() { | |
748 | let _ = 2 + 90; | |
749 | } | |
750 | "#####, | |
751 | ) | |
752 | } | |
753 | ||
754 | #[test] | |
755 | fn doctest_flip_comma() { | |
756 | check_doc_test( | |
757 | "flip_comma", | |
758 | r#####" | |
759 | fn main() { | |
760 | ((1, 2),$0 (3, 4)); | |
761 | } | |
762 | "#####, | |
763 | r#####" | |
764 | fn main() { | |
765 | ((3, 4), (1, 2)); | |
766 | } | |
767 | "#####, | |
768 | ) | |
769 | } | |
770 | ||
771 | #[test] | |
772 | fn doctest_flip_trait_bound() { | |
773 | check_doc_test( | |
774 | "flip_trait_bound", | |
775 | r#####" | |
776 | fn foo<T: Clone +$0 Copy>() { } | |
777 | "#####, | |
778 | r#####" | |
779 | fn foo<T: Copy + Clone>() { } | |
780 | "#####, | |
781 | ) | |
782 | } | |
783 | ||
784 | #[test] | |
785 | fn doctest_generate_constant() { | |
786 | check_doc_test( | |
787 | "generate_constant", | |
788 | r#####" | |
789 | struct S { i: usize } | |
790 | impl S { pub fn new(n: usize) {} } | |
791 | fn main() { | |
792 | let v = S::new(CAPA$0CITY); | |
793 | } | |
794 | "#####, | |
795 | r#####" | |
796 | struct S { i: usize } | |
797 | impl S { pub fn new(n: usize) {} } | |
798 | fn main() { | |
799 | const CAPACITY: usize = $0; | |
800 | let v = S::new(CAPACITY); | |
801 | } | |
802 | "#####, | |
803 | ) | |
804 | } | |
805 | ||
806 | #[test] | |
807 | fn doctest_generate_default_from_enum_variant() { | |
808 | check_doc_test( | |
809 | "generate_default_from_enum_variant", | |
810 | r#####" | |
811 | enum Version { | |
812 | Undefined, | |
813 | Minor$0, | |
814 | Major, | |
815 | } | |
816 | "#####, | |
817 | r#####" | |
818 | enum Version { | |
819 | Undefined, | |
820 | Minor, | |
821 | Major, | |
822 | } | |
823 | ||
824 | impl Default for Version { | |
825 | fn default() -> Self { | |
826 | Self::Minor | |
827 | } | |
828 | } | |
829 | "#####, | |
830 | ) | |
831 | } | |
832 | ||
833 | #[test] | |
834 | fn doctest_generate_default_from_new() { | |
835 | check_doc_test( | |
836 | "generate_default_from_new", | |
837 | r#####" | |
838 | struct Example { _inner: () } | |
839 | ||
840 | impl Example { | |
841 | pub fn n$0ew() -> Self { | |
842 | Self { _inner: () } | |
843 | } | |
844 | } | |
845 | "#####, | |
846 | r#####" | |
847 | struct Example { _inner: () } | |
848 | ||
849 | impl Example { | |
850 | pub fn new() -> Self { | |
851 | Self { _inner: () } | |
852 | } | |
853 | } | |
854 | ||
855 | impl Default for Example { | |
856 | fn default() -> Self { | |
857 | Self::new() | |
858 | } | |
859 | } | |
860 | "#####, | |
861 | ) | |
862 | } | |
863 | ||
864 | #[test] | |
865 | fn doctest_generate_delegate_methods() { | |
866 | check_doc_test( | |
867 | "generate_delegate_methods", | |
868 | r#####" | |
869 | struct Age(u8); | |
870 | impl Age { | |
871 | fn age(&self) -> u8 { | |
872 | self.0 | |
873 | } | |
874 | } | |
875 | ||
876 | struct Person { | |
877 | ag$0e: Age, | |
878 | } | |
879 | "#####, | |
880 | r#####" | |
881 | struct Age(u8); | |
882 | impl Age { | |
883 | fn age(&self) -> u8 { | |
884 | self.0 | |
885 | } | |
886 | } | |
887 | ||
888 | struct Person { | |
889 | age: Age, | |
890 | } | |
891 | ||
892 | impl Person { | |
893 | $0fn age(&self) -> u8 { | |
894 | self.age.age() | |
895 | } | |
896 | } | |
897 | "#####, | |
898 | ) | |
899 | } | |
900 | ||
901 | #[test] | |
902 | fn doctest_generate_deref() { | |
903 | check_doc_test( | |
904 | "generate_deref", | |
905 | r#####" | |
906 | //- minicore: deref, deref_mut | |
907 | struct A; | |
908 | struct B { | |
909 | $0a: A | |
910 | } | |
911 | "#####, | |
912 | r#####" | |
913 | struct A; | |
914 | struct B { | |
915 | a: A | |
916 | } | |
917 | ||
918 | impl core::ops::Deref for B { | |
919 | type Target = A; | |
920 | ||
921 | fn deref(&self) -> &Self::Target { | |
922 | &self.a | |
923 | } | |
924 | } | |
925 | "#####, | |
926 | ) | |
927 | } | |
928 | ||
929 | #[test] | |
930 | fn doctest_generate_derive() { | |
931 | check_doc_test( | |
932 | "generate_derive", | |
933 | r#####" | |
934 | struct Point { | |
935 | x: u32, | |
936 | y: u32,$0 | |
937 | } | |
938 | "#####, | |
939 | r#####" | |
940 | #[derive($0)] | |
941 | struct Point { | |
942 | x: u32, | |
943 | y: u32, | |
944 | } | |
945 | "#####, | |
946 | ) | |
947 | } | |
948 | ||
949 | #[test] | |
950 | fn doctest_generate_doc_example() { | |
951 | check_doc_test( | |
952 | "generate_doc_example", | |
953 | r#####" | |
954 | /// Adds two numbers.$0 | |
955 | pub fn add(a: i32, b: i32) -> i32 { a + b } | |
956 | "#####, | |
957 | r#####" | |
958 | /// Adds two numbers. | |
959 | /// | |
960 | /// # Examples | |
961 | /// | |
962 | /// ``` | |
963 | /// use test::add; | |
964 | /// | |
965 | /// assert_eq!(add(a, b), ); | |
966 | /// ``` | |
967 | pub fn add(a: i32, b: i32) -> i32 { a + b } | |
968 | "#####, | |
969 | ) | |
970 | } | |
971 | ||
972 | #[test] | |
973 | fn doctest_generate_documentation_template() { | |
974 | check_doc_test( | |
975 | "generate_documentation_template", | |
976 | r#####" | |
977 | pub struct S; | |
978 | impl S { | |
979 | pub unsafe fn set_len$0(&mut self, len: usize) -> Result<(), std::io::Error> { | |
980 | /* ... */ | |
981 | } | |
982 | } | |
983 | "#####, | |
984 | r#####" | |
985 | pub struct S; | |
986 | impl S { | |
987 | /// Sets the length of this [`S`]. | |
988 | /// | |
989 | /// # Errors | |
990 | /// | |
991 | /// This function will return an error if . | |
992 | /// | |
993 | /// # Safety | |
994 | /// | |
995 | /// . | |
996 | pub unsafe fn set_len(&mut self, len: usize) -> Result<(), std::io::Error> { | |
997 | /* ... */ | |
998 | } | |
999 | } | |
1000 | "#####, | |
1001 | ) | |
1002 | } | |
1003 | ||
1004 | #[test] | |
1005 | fn doctest_generate_enum_as_method() { | |
1006 | check_doc_test( | |
1007 | "generate_enum_as_method", | |
1008 | r#####" | |
1009 | enum Value { | |
1010 | Number(i32), | |
1011 | Text(String)$0, | |
1012 | } | |
1013 | "#####, | |
1014 | r#####" | |
1015 | enum Value { | |
1016 | Number(i32), | |
1017 | Text(String), | |
1018 | } | |
1019 | ||
1020 | impl Value { | |
1021 | fn as_text(&self) -> Option<&String> { | |
1022 | if let Self::Text(v) = self { | |
1023 | Some(v) | |
1024 | } else { | |
1025 | None | |
1026 | } | |
1027 | } | |
1028 | } | |
1029 | "#####, | |
1030 | ) | |
1031 | } | |
1032 | ||
1033 | #[test] | |
1034 | fn doctest_generate_enum_is_method() { | |
1035 | check_doc_test( | |
1036 | "generate_enum_is_method", | |
1037 | r#####" | |
1038 | enum Version { | |
1039 | Undefined, | |
1040 | Minor$0, | |
1041 | Major, | |
1042 | } | |
1043 | "#####, | |
1044 | r#####" | |
1045 | enum Version { | |
1046 | Undefined, | |
1047 | Minor, | |
1048 | Major, | |
1049 | } | |
1050 | ||
1051 | impl Version { | |
1052 | /// Returns `true` if the version is [`Minor`]. | |
1053 | /// | |
1054 | /// [`Minor`]: Version::Minor | |
1055 | #[must_use] | |
1056 | fn is_minor(&self) -> bool { | |
1057 | matches!(self, Self::Minor) | |
1058 | } | |
1059 | } | |
1060 | "#####, | |
1061 | ) | |
1062 | } | |
1063 | ||
1064 | #[test] | |
1065 | fn doctest_generate_enum_try_into_method() { | |
1066 | check_doc_test( | |
1067 | "generate_enum_try_into_method", | |
1068 | r#####" | |
1069 | enum Value { | |
1070 | Number(i32), | |
1071 | Text(String)$0, | |
1072 | } | |
1073 | "#####, | |
1074 | r#####" | |
1075 | enum Value { | |
1076 | Number(i32), | |
1077 | Text(String), | |
1078 | } | |
1079 | ||
1080 | impl Value { | |
1081 | fn try_into_text(self) -> Result<String, Self> { | |
1082 | if let Self::Text(v) = self { | |
1083 | Ok(v) | |
1084 | } else { | |
1085 | Err(self) | |
1086 | } | |
1087 | } | |
1088 | } | |
1089 | "#####, | |
1090 | ) | |
1091 | } | |
1092 | ||
1093 | #[test] | |
1094 | fn doctest_generate_enum_variant() { | |
1095 | check_doc_test( | |
1096 | "generate_enum_variant", | |
1097 | r#####" | |
1098 | enum Countries { | |
1099 | Ghana, | |
1100 | } | |
1101 | ||
1102 | fn main() { | |
1103 | let country = Countries::Lesotho$0; | |
1104 | } | |
1105 | "#####, | |
1106 | r#####" | |
1107 | enum Countries { | |
1108 | Ghana, | |
1109 | Lesotho, | |
1110 | } | |
1111 | ||
1112 | fn main() { | |
1113 | let country = Countries::Lesotho; | |
1114 | } | |
1115 | "#####, | |
1116 | ) | |
1117 | } | |
1118 | ||
1119 | #[test] | |
1120 | fn doctest_generate_from_impl_for_enum() { | |
1121 | check_doc_test( | |
1122 | "generate_from_impl_for_enum", | |
1123 | r#####" | |
1124 | enum A { $0One(u32) } | |
1125 | "#####, | |
1126 | r#####" | |
1127 | enum A { One(u32) } | |
1128 | ||
1129 | impl From<u32> for A { | |
1130 | fn from(v: u32) -> Self { | |
1131 | Self::One(v) | |
1132 | } | |
1133 | } | |
1134 | "#####, | |
1135 | ) | |
1136 | } | |
1137 | ||
1138 | #[test] | |
1139 | fn doctest_generate_function() { | |
1140 | check_doc_test( | |
1141 | "generate_function", | |
1142 | r#####" | |
1143 | struct Baz; | |
1144 | fn baz() -> Baz { Baz } | |
1145 | fn foo() { | |
1146 | bar$0("", baz()); | |
1147 | } | |
1148 | ||
1149 | "#####, | |
1150 | r#####" | |
1151 | struct Baz; | |
1152 | fn baz() -> Baz { Baz } | |
1153 | fn foo() { | |
1154 | bar("", baz()); | |
1155 | } | |
1156 | ||
1157 | fn bar(arg: &str, baz: Baz) ${0:-> _} { | |
1158 | todo!() | |
1159 | } | |
1160 | ||
1161 | "#####, | |
1162 | ) | |
1163 | } | |
1164 | ||
1165 | #[test] | |
1166 | fn doctest_generate_getter() { | |
1167 | check_doc_test( | |
1168 | "generate_getter", | |
1169 | r#####" | |
1170 | //- minicore: as_ref | |
1171 | pub struct String; | |
1172 | impl AsRef<str> for String { | |
1173 | fn as_ref(&self) -> &str { | |
1174 | "" | |
1175 | } | |
1176 | } | |
1177 | ||
1178 | struct Person { | |
1179 | nam$0e: String, | |
1180 | } | |
1181 | "#####, | |
1182 | r#####" | |
1183 | pub struct String; | |
1184 | impl AsRef<str> for String { | |
1185 | fn as_ref(&self) -> &str { | |
1186 | "" | |
1187 | } | |
1188 | } | |
1189 | ||
1190 | struct Person { | |
1191 | name: String, | |
1192 | } | |
1193 | ||
1194 | impl Person { | |
1195 | fn $0name(&self) -> &str { | |
1196 | self.name.as_ref() | |
1197 | } | |
1198 | } | |
1199 | "#####, | |
1200 | ) | |
1201 | } | |
1202 | ||
1203 | #[test] | |
1204 | fn doctest_generate_getter_mut() { | |
1205 | check_doc_test( | |
1206 | "generate_getter_mut", | |
1207 | r#####" | |
1208 | struct Person { | |
1209 | nam$0e: String, | |
1210 | } | |
1211 | "#####, | |
1212 | r#####" | |
1213 | struct Person { | |
1214 | name: String, | |
1215 | } | |
1216 | ||
1217 | impl Person { | |
1218 | fn $0name_mut(&mut self) -> &mut String { | |
1219 | &mut self.name | |
1220 | } | |
1221 | } | |
1222 | "#####, | |
1223 | ) | |
1224 | } | |
1225 | ||
1226 | #[test] | |
1227 | fn doctest_generate_impl() { | |
1228 | check_doc_test( | |
1229 | "generate_impl", | |
1230 | r#####" | |
1231 | struct Ctx<T: Clone> { | |
1232 | data: T,$0 | |
1233 | } | |
1234 | "#####, | |
1235 | r#####" | |
1236 | struct Ctx<T: Clone> { | |
1237 | data: T, | |
1238 | } | |
1239 | ||
1240 | impl<T: Clone> Ctx<T> { | |
1241 | $0 | |
1242 | } | |
1243 | "#####, | |
1244 | ) | |
1245 | } | |
1246 | ||
1247 | #[test] | |
1248 | fn doctest_generate_is_empty_from_len() { | |
1249 | check_doc_test( | |
1250 | "generate_is_empty_from_len", | |
1251 | r#####" | |
1252 | struct MyStruct { data: Vec<String> } | |
1253 | ||
1254 | impl MyStruct { | |
1255 | #[must_use] | |
1256 | p$0ub fn len(&self) -> usize { | |
1257 | self.data.len() | |
1258 | } | |
1259 | } | |
1260 | "#####, | |
1261 | r#####" | |
1262 | struct MyStruct { data: Vec<String> } | |
1263 | ||
1264 | impl MyStruct { | |
1265 | #[must_use] | |
1266 | pub fn len(&self) -> usize { | |
1267 | self.data.len() | |
1268 | } | |
1269 | ||
1270 | #[must_use] | |
1271 | pub fn is_empty(&self) -> bool { | |
1272 | self.len() == 0 | |
1273 | } | |
1274 | } | |
1275 | "#####, | |
1276 | ) | |
1277 | } | |
1278 | ||
1279 | #[test] | |
1280 | fn doctest_generate_new() { | |
1281 | check_doc_test( | |
1282 | "generate_new", | |
1283 | r#####" | |
1284 | struct Ctx<T: Clone> { | |
1285 | data: T,$0 | |
1286 | } | |
1287 | "#####, | |
1288 | r#####" | |
1289 | struct Ctx<T: Clone> { | |
1290 | data: T, | |
1291 | } | |
1292 | ||
1293 | impl<T: Clone> Ctx<T> { | |
1294 | fn $0new(data: T) -> Self { Self { data } } | |
1295 | } | |
1296 | "#####, | |
1297 | ) | |
1298 | } | |
1299 | ||
1300 | #[test] | |
1301 | fn doctest_generate_setter() { | |
1302 | check_doc_test( | |
1303 | "generate_setter", | |
1304 | r#####" | |
1305 | struct Person { | |
1306 | nam$0e: String, | |
1307 | } | |
1308 | "#####, | |
1309 | r#####" | |
1310 | struct Person { | |
1311 | name: String, | |
1312 | } | |
1313 | ||
1314 | impl Person { | |
1315 | fn set_name(&mut self, name: String) { | |
1316 | self.name = name; | |
1317 | } | |
1318 | } | |
1319 | "#####, | |
1320 | ) | |
1321 | } | |
1322 | ||
1323 | #[test] | |
1324 | fn doctest_inline_call() { | |
1325 | check_doc_test( | |
1326 | "inline_call", | |
1327 | r#####" | |
1328 | //- minicore: option | |
1329 | fn foo(name: Option<&str>) { | |
1330 | let name = name.unwrap$0(); | |
1331 | } | |
1332 | "#####, | |
1333 | r#####" | |
1334 | fn foo(name: Option<&str>) { | |
1335 | let name = match name { | |
1336 | Some(val) => val, | |
1337 | None => panic!("called `Option::unwrap()` on a `None` value"), | |
1338 | }; | |
1339 | } | |
1340 | "#####, | |
1341 | ) | |
1342 | } | |
1343 | ||
1344 | #[test] | |
1345 | fn doctest_inline_into_callers() { | |
1346 | check_doc_test( | |
1347 | "inline_into_callers", | |
1348 | r#####" | |
1349 | fn print(_: &str) {} | |
1350 | fn foo$0(word: &str) { | |
1351 | if !word.is_empty() { | |
1352 | print(word); | |
1353 | } | |
1354 | } | |
1355 | fn bar() { | |
1356 | foo("안녕하세요"); | |
1357 | foo("여러분"); | |
1358 | } | |
1359 | "#####, | |
1360 | r#####" | |
1361 | fn print(_: &str) {} | |
1362 | ||
1363 | fn bar() { | |
1364 | { | |
1365 | let word = "안녕하세요"; | |
1366 | if !word.is_empty() { | |
1367 | print(word); | |
1368 | } | |
1369 | }; | |
1370 | { | |
1371 | let word = "여러분"; | |
1372 | if !word.is_empty() { | |
1373 | print(word); | |
1374 | } | |
1375 | }; | |
1376 | } | |
1377 | "#####, | |
1378 | ) | |
1379 | } | |
1380 | ||
1381 | #[test] | |
1382 | fn doctest_inline_local_variable() { | |
1383 | check_doc_test( | |
1384 | "inline_local_variable", | |
1385 | r#####" | |
1386 | fn main() { | |
1387 | let x$0 = 1 + 2; | |
1388 | x * 4; | |
1389 | } | |
1390 | "#####, | |
1391 | r#####" | |
1392 | fn main() { | |
1393 | (1 + 2) * 4; | |
1394 | } | |
1395 | "#####, | |
1396 | ) | |
1397 | } | |
1398 | ||
1399 | #[test] | |
1400 | fn doctest_inline_type_alias() { | |
1401 | check_doc_test( | |
1402 | "inline_type_alias", | |
1403 | r#####" | |
1404 | type A<T = u32> = Vec<T>; | |
1405 | ||
1406 | fn main() { | |
1407 | let a: $0A; | |
1408 | } | |
1409 | "#####, | |
1410 | r#####" | |
1411 | type A<T = u32> = Vec<T>; | |
1412 | ||
1413 | fn main() { | |
1414 | let a: Vec<u32>; | |
1415 | } | |
1416 | "#####, | |
1417 | ) | |
1418 | } | |
1419 | ||
f2b60f7d FG |
1420 | #[test] |
1421 | fn doctest_inline_type_alias_uses() { | |
1422 | check_doc_test( | |
1423 | "inline_type_alias_uses", | |
1424 | r#####" | |
1425 | type $0A = i32; | |
1426 | fn id(x: A) -> A { | |
1427 | x | |
1428 | }; | |
1429 | fn foo() { | |
1430 | let _: A = 3; | |
1431 | } | |
1432 | "#####, | |
1433 | r#####" | |
1434 | ||
1435 | fn id(x: i32) -> i32 { | |
1436 | x | |
1437 | }; | |
1438 | fn foo() { | |
1439 | let _: i32 = 3; | |
1440 | } | |
1441 | "#####, | |
1442 | ) | |
1443 | } | |
1444 | ||
064997fb FG |
1445 | #[test] |
1446 | fn doctest_introduce_named_generic() { | |
1447 | check_doc_test( | |
1448 | "introduce_named_generic", | |
1449 | r#####" | |
1450 | fn foo(bar: $0impl Bar) {} | |
1451 | "#####, | |
1452 | r#####" | |
1453 | fn foo<B: Bar>(bar: B) {} | |
1454 | "#####, | |
1455 | ) | |
1456 | } | |
1457 | ||
1458 | #[test] | |
1459 | fn doctest_introduce_named_lifetime() { | |
1460 | check_doc_test( | |
1461 | "introduce_named_lifetime", | |
1462 | r#####" | |
1463 | impl Cursor<'_$0> { | |
1464 | fn node(self) -> &SyntaxNode { | |
1465 | match self { | |
1466 | Cursor::Replace(node) | Cursor::Before(node) => node, | |
1467 | } | |
1468 | } | |
1469 | } | |
1470 | "#####, | |
1471 | r#####" | |
1472 | impl<'a> Cursor<'a> { | |
1473 | fn node(self) -> &SyntaxNode { | |
1474 | match self { | |
1475 | Cursor::Replace(node) | Cursor::Before(node) => node, | |
1476 | } | |
1477 | } | |
1478 | } | |
1479 | "#####, | |
1480 | ) | |
1481 | } | |
1482 | ||
1483 | #[test] | |
1484 | fn doctest_invert_if() { | |
1485 | check_doc_test( | |
1486 | "invert_if", | |
1487 | r#####" | |
1488 | fn main() { | |
1489 | if$0 !y { A } else { B } | |
1490 | } | |
1491 | "#####, | |
1492 | r#####" | |
1493 | fn main() { | |
1494 | if y { B } else { A } | |
1495 | } | |
1496 | "#####, | |
1497 | ) | |
1498 | } | |
1499 | ||
1500 | #[test] | |
1501 | fn doctest_line_to_block() { | |
1502 | check_doc_test( | |
1503 | "line_to_block", | |
1504 | r#####" | |
1505 | // Multi-line$0 | |
1506 | // comment | |
1507 | "#####, | |
1508 | r#####" | |
1509 | /* | |
1510 | Multi-line | |
1511 | comment | |
1512 | */ | |
1513 | "#####, | |
1514 | ) | |
1515 | } | |
1516 | ||
1517 | #[test] | |
1518 | fn doctest_make_raw_string() { | |
1519 | check_doc_test( | |
1520 | "make_raw_string", | |
1521 | r#####" | |
1522 | fn main() { | |
1523 | "Hello,$0 World!"; | |
1524 | } | |
1525 | "#####, | |
1526 | r#####" | |
1527 | fn main() { | |
1528 | r#"Hello, World!"#; | |
1529 | } | |
1530 | "#####, | |
1531 | ) | |
1532 | } | |
1533 | ||
1534 | #[test] | |
1535 | fn doctest_make_usual_string() { | |
1536 | check_doc_test( | |
1537 | "make_usual_string", | |
1538 | r#####" | |
1539 | fn main() { | |
1540 | r#"Hello,$0 "World!""#; | |
1541 | } | |
1542 | "#####, | |
1543 | r#####" | |
1544 | fn main() { | |
1545 | "Hello, \"World!\""; | |
1546 | } | |
1547 | "#####, | |
1548 | ) | |
1549 | } | |
1550 | ||
1551 | #[test] | |
1552 | fn doctest_merge_imports() { | |
1553 | check_doc_test( | |
1554 | "merge_imports", | |
1555 | r#####" | |
1556 | use std::$0fmt::Formatter; | |
1557 | use std::io; | |
1558 | "#####, | |
1559 | r#####" | |
1560 | use std::{fmt::Formatter, io}; | |
1561 | "#####, | |
1562 | ) | |
1563 | } | |
1564 | ||
1565 | #[test] | |
1566 | fn doctest_merge_match_arms() { | |
1567 | check_doc_test( | |
1568 | "merge_match_arms", | |
1569 | r#####" | |
1570 | enum Action { Move { distance: u32 }, Stop } | |
1571 | ||
1572 | fn handle(action: Action) { | |
1573 | match action { | |
1574 | $0Action::Move(..) => foo(), | |
1575 | Action::Stop => foo(), | |
1576 | } | |
1577 | } | |
1578 | "#####, | |
1579 | r#####" | |
1580 | enum Action { Move { distance: u32 }, Stop } | |
1581 | ||
1582 | fn handle(action: Action) { | |
1583 | match action { | |
1584 | Action::Move(..) | Action::Stop => foo(), | |
1585 | } | |
1586 | } | |
1587 | "#####, | |
1588 | ) | |
1589 | } | |
1590 | ||
1591 | #[test] | |
1592 | fn doctest_move_arm_cond_to_match_guard() { | |
1593 | check_doc_test( | |
1594 | "move_arm_cond_to_match_guard", | |
1595 | r#####" | |
1596 | enum Action { Move { distance: u32 }, Stop } | |
1597 | ||
1598 | fn handle(action: Action) { | |
1599 | match action { | |
1600 | Action::Move { distance } => $0if distance > 10 { foo() }, | |
1601 | _ => (), | |
1602 | } | |
1603 | } | |
1604 | "#####, | |
1605 | r#####" | |
1606 | enum Action { Move { distance: u32 }, Stop } | |
1607 | ||
1608 | fn handle(action: Action) { | |
1609 | match action { | |
1610 | Action::Move { distance } if distance > 10 => foo(), | |
1611 | _ => (), | |
1612 | } | |
1613 | } | |
1614 | "#####, | |
1615 | ) | |
1616 | } | |
1617 | ||
1618 | #[test] | |
1619 | fn doctest_move_bounds_to_where_clause() { | |
1620 | check_doc_test( | |
1621 | "move_bounds_to_where_clause", | |
1622 | r#####" | |
1623 | fn apply<T, U, $0F: FnOnce(T) -> U>(f: F, x: T) -> U { | |
1624 | f(x) | |
1625 | } | |
1626 | "#####, | |
1627 | r#####" | |
1628 | fn apply<T, U, F>(f: F, x: T) -> U where F: FnOnce(T) -> U { | |
1629 | f(x) | |
1630 | } | |
1631 | "#####, | |
1632 | ) | |
1633 | } | |
1634 | ||
2b03887a FG |
1635 | #[test] |
1636 | fn doctest_move_format_string_arg() { | |
1637 | check_doc_test( | |
1638 | "move_format_string_arg", | |
1639 | r#####" | |
1640 | macro_rules! format_args { | |
1641 | ($lit:literal $(tt:tt)*) => { 0 }, | |
1642 | } | |
1643 | macro_rules! print { | |
1644 | ($($arg:tt)*) => (std::io::_print(format_args!($($arg)*))); | |
1645 | } | |
1646 | ||
1647 | fn main() { | |
1648 | print!("{x + 1}$0"); | |
1649 | } | |
1650 | "#####, | |
1651 | r#####" | |
1652 | macro_rules! format_args { | |
1653 | ($lit:literal $(tt:tt)*) => { 0 }, | |
1654 | } | |
1655 | macro_rules! print { | |
1656 | ($($arg:tt)*) => (std::io::_print(format_args!($($arg)*))); | |
1657 | } | |
1658 | ||
1659 | fn main() { | |
1660 | print!("{}"$0, x + 1); | |
1661 | } | |
1662 | "#####, | |
1663 | ) | |
1664 | } | |
1665 | ||
064997fb FG |
1666 | #[test] |
1667 | fn doctest_move_from_mod_rs() { | |
1668 | check_doc_test( | |
1669 | "move_from_mod_rs", | |
1670 | r#####" | |
1671 | //- /main.rs | |
1672 | mod a; | |
1673 | //- /a/mod.rs | |
1674 | $0fn t() {}$0 | |
1675 | "#####, | |
1676 | r#####" | |
1677 | fn t() {} | |
1678 | "#####, | |
1679 | ) | |
1680 | } | |
1681 | ||
1682 | #[test] | |
1683 | fn doctest_move_guard_to_arm_body() { | |
1684 | check_doc_test( | |
1685 | "move_guard_to_arm_body", | |
1686 | r#####" | |
1687 | enum Action { Move { distance: u32 }, Stop } | |
1688 | ||
1689 | fn handle(action: Action) { | |
1690 | match action { | |
1691 | Action::Move { distance } $0if distance > 10 => foo(), | |
1692 | _ => (), | |
1693 | } | |
1694 | } | |
1695 | "#####, | |
1696 | r#####" | |
1697 | enum Action { Move { distance: u32 }, Stop } | |
1698 | ||
1699 | fn handle(action: Action) { | |
1700 | match action { | |
1701 | Action::Move { distance } => if distance > 10 { | |
1702 | foo() | |
1703 | }, | |
1704 | _ => (), | |
1705 | } | |
1706 | } | |
1707 | "#####, | |
1708 | ) | |
1709 | } | |
1710 | ||
1711 | #[test] | |
1712 | fn doctest_move_module_to_file() { | |
1713 | check_doc_test( | |
1714 | "move_module_to_file", | |
1715 | r#####" | |
1716 | mod $0foo { | |
1717 | fn t() {} | |
1718 | } | |
1719 | "#####, | |
1720 | r#####" | |
1721 | mod foo; | |
1722 | "#####, | |
1723 | ) | |
1724 | } | |
1725 | ||
1726 | #[test] | |
1727 | fn doctest_move_to_mod_rs() { | |
1728 | check_doc_test( | |
1729 | "move_to_mod_rs", | |
1730 | r#####" | |
1731 | //- /main.rs | |
1732 | mod a; | |
1733 | //- /a.rs | |
1734 | $0fn t() {}$0 | |
1735 | "#####, | |
1736 | r#####" | |
1737 | fn t() {} | |
1738 | "#####, | |
1739 | ) | |
1740 | } | |
1741 | ||
1742 | #[test] | |
1743 | fn doctest_promote_local_to_const() { | |
1744 | check_doc_test( | |
1745 | "promote_local_to_const", | |
1746 | r#####" | |
1747 | fn main() { | |
1748 | let foo$0 = true; | |
1749 | ||
1750 | if foo { | |
1751 | println!("It's true"); | |
1752 | } else { | |
1753 | println!("It's false"); | |
1754 | } | |
1755 | } | |
1756 | "#####, | |
1757 | r#####" | |
1758 | fn main() { | |
1759 | const $0FOO: bool = true; | |
1760 | ||
1761 | if FOO { | |
1762 | println!("It's true"); | |
1763 | } else { | |
1764 | println!("It's false"); | |
1765 | } | |
1766 | } | |
1767 | "#####, | |
1768 | ) | |
1769 | } | |
1770 | ||
1771 | #[test] | |
1772 | fn doctest_pull_assignment_up() { | |
1773 | check_doc_test( | |
1774 | "pull_assignment_up", | |
1775 | r#####" | |
1776 | fn main() { | |
1777 | let mut foo = 6; | |
1778 | ||
1779 | if true { | |
1780 | $0foo = 5; | |
1781 | } else { | |
1782 | foo = 4; | |
1783 | } | |
1784 | } | |
1785 | "#####, | |
1786 | r#####" | |
1787 | fn main() { | |
1788 | let mut foo = 6; | |
1789 | ||
1790 | foo = if true { | |
1791 | 5 | |
1792 | } else { | |
1793 | 4 | |
1794 | }; | |
1795 | } | |
1796 | "#####, | |
1797 | ) | |
1798 | } | |
1799 | ||
1800 | #[test] | |
1801 | fn doctest_qualify_method_call() { | |
1802 | check_doc_test( | |
1803 | "qualify_method_call", | |
1804 | r#####" | |
1805 | struct Foo; | |
1806 | impl Foo { | |
1807 | fn foo(&self) {} | |
1808 | } | |
1809 | fn main() { | |
1810 | let foo = Foo; | |
1811 | foo.fo$0o(); | |
1812 | } | |
1813 | "#####, | |
1814 | r#####" | |
1815 | struct Foo; | |
1816 | impl Foo { | |
1817 | fn foo(&self) {} | |
1818 | } | |
1819 | fn main() { | |
1820 | let foo = Foo; | |
1821 | Foo::foo(&foo); | |
1822 | } | |
1823 | "#####, | |
1824 | ) | |
1825 | } | |
1826 | ||
1827 | #[test] | |
1828 | fn doctest_qualify_path() { | |
1829 | check_doc_test( | |
1830 | "qualify_path", | |
1831 | r#####" | |
1832 | fn main() { | |
1833 | let map = HashMap$0::new(); | |
1834 | } | |
1835 | pub mod std { pub mod collections { pub struct HashMap { } } } | |
1836 | "#####, | |
1837 | r#####" | |
1838 | fn main() { | |
1839 | let map = std::collections::HashMap::new(); | |
1840 | } | |
1841 | pub mod std { pub mod collections { pub struct HashMap { } } } | |
1842 | "#####, | |
1843 | ) | |
1844 | } | |
1845 | ||
1846 | #[test] | |
1847 | fn doctest_reformat_number_literal() { | |
1848 | check_doc_test( | |
1849 | "reformat_number_literal", | |
1850 | r#####" | |
1851 | const _: i32 = 1012345$0; | |
1852 | "#####, | |
1853 | r#####" | |
1854 | const _: i32 = 1_012_345; | |
1855 | "#####, | |
1856 | ) | |
1857 | } | |
1858 | ||
1859 | #[test] | |
1860 | fn doctest_remove_dbg() { | |
1861 | check_doc_test( | |
1862 | "remove_dbg", | |
1863 | r#####" | |
1864 | fn main() { | |
1865 | $0dbg!(92); | |
1866 | } | |
1867 | "#####, | |
1868 | r#####" | |
1869 | fn main() { | |
1870 | 92; | |
1871 | } | |
1872 | "#####, | |
1873 | ) | |
1874 | } | |
1875 | ||
1876 | #[test] | |
1877 | fn doctest_remove_hash() { | |
1878 | check_doc_test( | |
1879 | "remove_hash", | |
1880 | r#####" | |
1881 | fn main() { | |
1882 | r#"Hello,$0 World!"#; | |
1883 | } | |
1884 | "#####, | |
1885 | r#####" | |
1886 | fn main() { | |
1887 | r"Hello, World!"; | |
1888 | } | |
1889 | "#####, | |
1890 | ) | |
1891 | } | |
1892 | ||
1893 | #[test] | |
1894 | fn doctest_remove_mut() { | |
1895 | check_doc_test( | |
1896 | "remove_mut", | |
1897 | r#####" | |
1898 | impl Walrus { | |
1899 | fn feed(&mut$0 self, amount: u32) {} | |
1900 | } | |
1901 | "#####, | |
1902 | r#####" | |
1903 | impl Walrus { | |
1904 | fn feed(&self, amount: u32) {} | |
1905 | } | |
1906 | "#####, | |
1907 | ) | |
1908 | } | |
1909 | ||
1910 | #[test] | |
1911 | fn doctest_remove_unused_param() { | |
1912 | check_doc_test( | |
1913 | "remove_unused_param", | |
1914 | r#####" | |
1915 | fn frobnicate(x: i32$0) {} | |
1916 | ||
1917 | fn main() { | |
1918 | frobnicate(92); | |
1919 | } | |
1920 | "#####, | |
1921 | r#####" | |
1922 | fn frobnicate() {} | |
1923 | ||
1924 | fn main() { | |
1925 | frobnicate(); | |
1926 | } | |
1927 | "#####, | |
1928 | ) | |
1929 | } | |
1930 | ||
1931 | #[test] | |
1932 | fn doctest_reorder_fields() { | |
1933 | check_doc_test( | |
1934 | "reorder_fields", | |
1935 | r#####" | |
1936 | struct Foo {foo: i32, bar: i32}; | |
1937 | const test: Foo = $0Foo {bar: 0, foo: 1} | |
1938 | "#####, | |
1939 | r#####" | |
1940 | struct Foo {foo: i32, bar: i32}; | |
1941 | const test: Foo = Foo {foo: 1, bar: 0} | |
1942 | "#####, | |
1943 | ) | |
1944 | } | |
1945 | ||
1946 | #[test] | |
1947 | fn doctest_reorder_impl_items() { | |
1948 | check_doc_test( | |
1949 | "reorder_impl_items", | |
1950 | r#####" | |
1951 | trait Foo { | |
1952 | type A; | |
1953 | const B: u8; | |
1954 | fn c(); | |
1955 | } | |
1956 | ||
1957 | struct Bar; | |
1958 | $0impl Foo for Bar { | |
1959 | const B: u8 = 17; | |
1960 | fn c() {} | |
1961 | type A = String; | |
1962 | } | |
1963 | "#####, | |
1964 | r#####" | |
1965 | trait Foo { | |
1966 | type A; | |
1967 | const B: u8; | |
1968 | fn c(); | |
1969 | } | |
1970 | ||
1971 | struct Bar; | |
1972 | impl Foo for Bar { | |
1973 | type A = String; | |
1974 | const B: u8 = 17; | |
1975 | fn c() {} | |
1976 | } | |
1977 | "#####, | |
1978 | ) | |
1979 | } | |
1980 | ||
1981 | #[test] | |
1982 | fn doctest_replace_char_with_string() { | |
1983 | check_doc_test( | |
1984 | "replace_char_with_string", | |
1985 | r#####" | |
1986 | fn main() { | |
1987 | find('{$0'); | |
1988 | } | |
1989 | "#####, | |
1990 | r#####" | |
1991 | fn main() { | |
1992 | find("{"); | |
1993 | } | |
1994 | "#####, | |
1995 | ) | |
1996 | } | |
1997 | ||
1998 | #[test] | |
1999 | fn doctest_replace_derive_with_manual_impl() { | |
2000 | check_doc_test( | |
2001 | "replace_derive_with_manual_impl", | |
2002 | r#####" | |
2003 | //- minicore: derive | |
2004 | trait Debug { fn fmt(&self, f: &mut Formatter) -> Result<()>; } | |
2005 | #[derive(Deb$0ug, Display)] | |
2006 | struct S; | |
2007 | "#####, | |
2008 | r#####" | |
2009 | trait Debug { fn fmt(&self, f: &mut Formatter) -> Result<()>; } | |
2010 | #[derive(Display)] | |
2011 | struct S; | |
2012 | ||
2013 | impl Debug for S { | |
2014 | $0fn fmt(&self, f: &mut Formatter) -> Result<()> { | |
2015 | f.debug_struct("S").finish() | |
2016 | } | |
2017 | } | |
2018 | "#####, | |
2019 | ) | |
2020 | } | |
2021 | ||
2022 | #[test] | |
2023 | fn doctest_replace_if_let_with_match() { | |
2024 | check_doc_test( | |
2025 | "replace_if_let_with_match", | |
2026 | r#####" | |
2027 | enum Action { Move { distance: u32 }, Stop } | |
2028 | ||
2029 | fn handle(action: Action) { | |
2030 | $0if let Action::Move { distance } = action { | |
2031 | foo(distance) | |
2032 | } else { | |
2033 | bar() | |
2034 | } | |
2035 | } | |
2036 | "#####, | |
2037 | r#####" | |
2038 | enum Action { Move { distance: u32 }, Stop } | |
2039 | ||
2040 | fn handle(action: Action) { | |
2041 | match action { | |
2042 | Action::Move { distance } => foo(distance), | |
2043 | _ => bar(), | |
2044 | } | |
2045 | } | |
2046 | "#####, | |
2047 | ) | |
2048 | } | |
2049 | ||
2050 | #[test] | |
2051 | fn doctest_replace_let_with_if_let() { | |
2052 | check_doc_test( | |
2053 | "replace_let_with_if_let", | |
2054 | r#####" | |
2055 | enum Option<T> { Some(T), None } | |
2056 | ||
2057 | fn main(action: Action) { | |
2058 | $0let x = compute(); | |
2059 | } | |
2060 | ||
2061 | fn compute() -> Option<i32> { None } | |
2062 | "#####, | |
2063 | r#####" | |
2064 | enum Option<T> { Some(T), None } | |
2065 | ||
2066 | fn main(action: Action) { | |
2067 | if let Some(x) = compute() { | |
2068 | } | |
2069 | } | |
2070 | ||
2071 | fn compute() -> Option<i32> { None } | |
2072 | "#####, | |
2073 | ) | |
2074 | } | |
2075 | ||
2076 | #[test] | |
2077 | fn doctest_replace_match_with_if_let() { | |
2078 | check_doc_test( | |
2079 | "replace_match_with_if_let", | |
2080 | r#####" | |
2081 | enum Action { Move { distance: u32 }, Stop } | |
2082 | ||
2083 | fn handle(action: Action) { | |
2084 | $0match action { | |
2085 | Action::Move { distance } => foo(distance), | |
2086 | _ => bar(), | |
2087 | } | |
2088 | } | |
2089 | "#####, | |
2090 | r#####" | |
2091 | enum Action { Move { distance: u32 }, Stop } | |
2092 | ||
2093 | fn handle(action: Action) { | |
2094 | if let Action::Move { distance } = action { | |
2095 | foo(distance) | |
2096 | } else { | |
2097 | bar() | |
2098 | } | |
2099 | } | |
2100 | "#####, | |
2101 | ) | |
2102 | } | |
2103 | ||
f2b60f7d FG |
2104 | #[test] |
2105 | fn doctest_replace_or_else_with_or() { | |
2106 | check_doc_test( | |
2107 | "replace_or_else_with_or", | |
2108 | r#####" | |
2109 | //- minicore:option | |
2110 | fn foo() { | |
2111 | let a = Some(1); | |
2112 | a.unwra$0p_or_else(|| 2); | |
2113 | } | |
2114 | "#####, | |
2115 | r#####" | |
2116 | fn foo() { | |
2117 | let a = Some(1); | |
2118 | a.unwrap_or(2); | |
2119 | } | |
2120 | "#####, | |
2121 | ) | |
2122 | } | |
2123 | ||
2124 | #[test] | |
2125 | fn doctest_replace_or_with_or_else() { | |
2126 | check_doc_test( | |
2127 | "replace_or_with_or_else", | |
2128 | r#####" | |
2129 | //- minicore:option | |
2130 | fn foo() { | |
2131 | let a = Some(1); | |
2132 | a.unwra$0p_or(2); | |
2133 | } | |
2134 | "#####, | |
2135 | r#####" | |
2136 | fn foo() { | |
2137 | let a = Some(1); | |
2138 | a.unwrap_or_else(|| 2); | |
2139 | } | |
2140 | "#####, | |
2141 | ) | |
2142 | } | |
2143 | ||
064997fb FG |
2144 | #[test] |
2145 | fn doctest_replace_qualified_name_with_use() { | |
2146 | check_doc_test( | |
2147 | "replace_qualified_name_with_use", | |
2148 | r#####" | |
2149 | mod std { pub mod collections { pub struct HashMap<T, U>(T, U); } } | |
2150 | fn process(map: std::collections::$0HashMap<String, String>) {} | |
2151 | "#####, | |
2152 | r#####" | |
2153 | use std::collections::HashMap; | |
2154 | ||
2155 | mod std { pub mod collections { pub struct HashMap<T, U>(T, U); } } | |
2156 | fn process(map: HashMap<String, String>) {} | |
2157 | "#####, | |
2158 | ) | |
2159 | } | |
2160 | ||
2161 | #[test] | |
2162 | fn doctest_replace_string_with_char() { | |
2163 | check_doc_test( | |
2164 | "replace_string_with_char", | |
2165 | r#####" | |
2166 | fn main() { | |
2167 | find("{$0"); | |
2168 | } | |
2169 | "#####, | |
2170 | r#####" | |
2171 | fn main() { | |
2172 | find('{'); | |
2173 | } | |
2174 | "#####, | |
2175 | ) | |
2176 | } | |
2177 | ||
2178 | #[test] | |
2179 | fn doctest_replace_try_expr_with_match() { | |
2180 | check_doc_test( | |
2181 | "replace_try_expr_with_match", | |
2182 | r#####" | |
2183 | //- minicore:option | |
2184 | fn handle() { | |
2185 | let pat = Some(true)$0?; | |
2186 | } | |
2187 | "#####, | |
2188 | r#####" | |
2189 | fn handle() { | |
2190 | let pat = match Some(true) { | |
2191 | Some(it) => it, | |
2192 | None => return None, | |
2193 | }; | |
2194 | } | |
2195 | "#####, | |
2196 | ) | |
2197 | } | |
2198 | ||
2199 | #[test] | |
2200 | fn doctest_replace_turbofish_with_explicit_type() { | |
2201 | check_doc_test( | |
2202 | "replace_turbofish_with_explicit_type", | |
2203 | r#####" | |
2204 | fn make<T>() -> T { ) } | |
2205 | fn main() { | |
2206 | let a = make$0::<i32>(); | |
2207 | } | |
2208 | "#####, | |
2209 | r#####" | |
2210 | fn make<T>() -> T { ) } | |
2211 | fn main() { | |
2212 | let a: i32 = make(); | |
2213 | } | |
2214 | "#####, | |
2215 | ) | |
2216 | } | |
2217 | ||
2218 | #[test] | |
2219 | fn doctest_sort_items() { | |
2220 | check_doc_test( | |
2221 | "sort_items", | |
2222 | r#####" | |
2223 | struct $0Foo$0 { second: u32, first: String } | |
2224 | "#####, | |
2225 | r#####" | |
2226 | struct Foo { first: String, second: u32 } | |
2227 | "#####, | |
2228 | ) | |
2229 | } | |
2230 | ||
2231 | #[test] | |
2232 | fn doctest_sort_items_1() { | |
2233 | check_doc_test( | |
2234 | "sort_items", | |
2235 | r#####" | |
2236 | trait $0Bar$0 { | |
2237 | fn second(&self) -> u32; | |
2238 | fn first(&self) -> String; | |
2239 | } | |
2240 | "#####, | |
2241 | r#####" | |
2242 | trait Bar { | |
2243 | fn first(&self) -> String; | |
2244 | fn second(&self) -> u32; | |
2245 | } | |
2246 | "#####, | |
2247 | ) | |
2248 | } | |
2249 | ||
2250 | #[test] | |
2251 | fn doctest_sort_items_2() { | |
2252 | check_doc_test( | |
2253 | "sort_items", | |
2254 | r#####" | |
2255 | struct Baz; | |
2256 | impl $0Baz$0 { | |
2257 | fn second(&self) -> u32; | |
2258 | fn first(&self) -> String; | |
2259 | } | |
2260 | "#####, | |
2261 | r#####" | |
2262 | struct Baz; | |
2263 | impl Baz { | |
2264 | fn first(&self) -> String; | |
2265 | fn second(&self) -> u32; | |
2266 | } | |
2267 | "#####, | |
2268 | ) | |
2269 | } | |
2270 | ||
2271 | #[test] | |
2272 | fn doctest_sort_items_3() { | |
2273 | check_doc_test( | |
2274 | "sort_items", | |
2275 | r#####" | |
2276 | enum $0Animal$0 { | |
2277 | Dog(String, f64), | |
2278 | Cat { weight: f64, name: String }, | |
2279 | } | |
2280 | "#####, | |
2281 | r#####" | |
2282 | enum Animal { | |
2283 | Cat { weight: f64, name: String }, | |
2284 | Dog(String, f64), | |
2285 | } | |
2286 | "#####, | |
2287 | ) | |
2288 | } | |
2289 | ||
2290 | #[test] | |
2291 | fn doctest_sort_items_4() { | |
2292 | check_doc_test( | |
2293 | "sort_items", | |
2294 | r#####" | |
2295 | enum Animal { | |
2296 | Dog(String, f64), | |
2297 | Cat $0{ weight: f64, name: String }$0, | |
2298 | } | |
2299 | "#####, | |
2300 | r#####" | |
2301 | enum Animal { | |
2302 | Dog(String, f64), | |
2303 | Cat { name: String, weight: f64 }, | |
2304 | } | |
2305 | "#####, | |
2306 | ) | |
2307 | } | |
2308 | ||
2309 | #[test] | |
2310 | fn doctest_split_import() { | |
2311 | check_doc_test( | |
2312 | "split_import", | |
2313 | r#####" | |
2314 | use std::$0collections::HashMap; | |
2315 | "#####, | |
2316 | r#####" | |
2317 | use std::{collections::HashMap}; | |
2318 | "#####, | |
2319 | ) | |
2320 | } | |
2321 | ||
2322 | #[test] | |
2323 | fn doctest_toggle_ignore() { | |
2324 | check_doc_test( | |
2325 | "toggle_ignore", | |
2326 | r#####" | |
2327 | $0#[test] | |
2328 | fn arithmetics { | |
2329 | assert_eq!(2 + 2, 5); | |
2330 | } | |
2331 | "#####, | |
2332 | r#####" | |
2333 | #[test] | |
2334 | #[ignore] | |
2335 | fn arithmetics { | |
2336 | assert_eq!(2 + 2, 5); | |
2337 | } | |
2338 | "#####, | |
2339 | ) | |
2340 | } | |
2341 | ||
f2b60f7d FG |
2342 | #[test] |
2343 | fn doctest_unmerge_match_arm() { | |
2344 | check_doc_test( | |
2345 | "unmerge_match_arm", | |
2346 | r#####" | |
2347 | enum Action { Move { distance: u32 }, Stop } | |
2348 | ||
2349 | fn handle(action: Action) { | |
2350 | match action { | |
2351 | Action::Move(..) $0| Action::Stop => foo(), | |
2352 | } | |
2353 | } | |
2354 | "#####, | |
2355 | r#####" | |
2356 | enum Action { Move { distance: u32 }, Stop } | |
2357 | ||
2358 | fn handle(action: Action) { | |
2359 | match action { | |
2360 | Action::Move(..) => foo(), | |
2361 | Action::Stop => foo(), | |
2362 | } | |
2363 | } | |
2364 | "#####, | |
2365 | ) | |
2366 | } | |
2367 | ||
064997fb FG |
2368 | #[test] |
2369 | fn doctest_unmerge_use() { | |
2370 | check_doc_test( | |
2371 | "unmerge_use", | |
2372 | r#####" | |
2373 | use std::fmt::{Debug, Display$0}; | |
2374 | "#####, | |
2375 | r#####" | |
2376 | use std::fmt::{Debug}; | |
2377 | use std::fmt::Display; | |
2378 | "#####, | |
2379 | ) | |
2380 | } | |
2381 | ||
2382 | #[test] | |
2383 | fn doctest_unnecessary_async() { | |
2384 | check_doc_test( | |
2385 | "unnecessary_async", | |
2386 | r#####" | |
2387 | pub async f$0n foo() {} | |
2388 | pub async fn bar() { foo().await } | |
2389 | "#####, | |
2390 | r#####" | |
2391 | pub fn foo() {} | |
2392 | pub async fn bar() { foo() } | |
2393 | "#####, | |
2394 | ) | |
2395 | } | |
2396 | ||
2397 | #[test] | |
2398 | fn doctest_unwrap_block() { | |
2399 | check_doc_test( | |
2400 | "unwrap_block", | |
2401 | r#####" | |
2402 | fn foo() { | |
2403 | if true {$0 | |
2404 | println!("foo"); | |
2405 | } | |
2406 | } | |
2407 | "#####, | |
2408 | r#####" | |
2409 | fn foo() { | |
2410 | println!("foo"); | |
2411 | } | |
2412 | "#####, | |
2413 | ) | |
2414 | } | |
2415 | ||
2416 | #[test] | |
2417 | fn doctest_unwrap_result_return_type() { | |
2418 | check_doc_test( | |
2419 | "unwrap_result_return_type", | |
2420 | r#####" | |
2421 | //- minicore: result | |
2422 | fn foo() -> Result<i32>$0 { Ok(42i32) } | |
2423 | "#####, | |
2424 | r#####" | |
2425 | fn foo() -> i32 { 42i32 } | |
2426 | "#####, | |
2427 | ) | |
2428 | } | |
2429 | ||
2b03887a FG |
2430 | #[test] |
2431 | fn doctest_unwrap_tuple() { | |
2432 | check_doc_test( | |
2433 | "unwrap_tuple", | |
2434 | r#####" | |
2435 | //- minicore: result | |
2436 | fn main() { | |
2437 | $0let (foo, bar) = ("Foo", "Bar"); | |
2438 | } | |
2439 | "#####, | |
2440 | r#####" | |
2441 | fn main() { | |
2442 | let foo = "Foo"; | |
2443 | let bar = "Bar"; | |
2444 | } | |
2445 | "#####, | |
2446 | ) | |
2447 | } | |
2448 | ||
064997fb FG |
2449 | #[test] |
2450 | fn doctest_wrap_return_type_in_result() { | |
2451 | check_doc_test( | |
2452 | "wrap_return_type_in_result", | |
2453 | r#####" | |
2454 | //- minicore: result | |
2455 | fn foo() -> i32$0 { 42i32 } | |
2456 | "#####, | |
2457 | r#####" | |
2458 | fn foo() -> Result<i32, ${0:_}> { Ok(42i32) } | |
2459 | "#####, | |
2460 | ) | |
2461 | } |