8 impl fmt::Debug for Foo {
9 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
10 fmt.debug_struct("Foo").finish()
14 assert_eq!("Foo", format!("{:?}", Foo));
15 assert_eq!("Foo", format!("{:#?}", Foo));
22 impl fmt::Debug for Foo {
23 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
24 fmt.debug_struct("Foo").field("bar", &true).finish()
28 assert_eq!("Foo { bar: true }", format!("{:?}", Foo));
41 impl fmt::Debug for Foo {
42 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
43 fmt.debug_struct("Foo")
45 .field("baz", &format_args!("{}/{}", 10, 20))
50 assert_eq!("Foo { bar: true, baz: 10/20 }", format!("{:?}", Foo));
64 impl fmt::Debug for Foo {
65 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
66 fmt.debug_struct("Foo")
68 .field("baz", &format_args!("{}/{}", 10, 20))
75 impl fmt::Debug for Bar {
76 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
77 fmt.debug_struct("Bar").field("foo", &Foo).field("hello", &"world").finish()
82 "Bar { foo: Foo { bar: true, baz: 10/20 }, hello: \"world\" }",
98 fn test_only_non_exhaustive() {
101 impl fmt::Debug for Foo {
102 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
103 fmt.debug_struct("Foo").finish_non_exhaustive()
107 assert_eq!("Foo { .. }", format!("{:?}", Foo));
108 assert_eq!("Foo { .. }", format!("{:#?}", Foo));
112 fn test_multiple_and_non_exhaustive() {
115 impl fmt::Debug for Foo {
116 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
117 fmt.debug_struct("Foo")
119 .field("baz", &format_args!("{}/{}", 10, 20))
120 .finish_non_exhaustive()
124 assert_eq!("Foo { bar: true, baz: 10/20, .. }", format!("{:?}", Foo));
131 format!("{:#?}", Foo)
136 fn test_nested_non_exhaustive() {
139 impl fmt::Debug for Foo {
140 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
141 fmt.debug_struct("Foo")
143 .field("baz", &format_args!("{}/{}", 10, 20))
144 .finish_non_exhaustive()
150 impl fmt::Debug for Bar {
151 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
152 fmt.debug_struct("Bar")
154 .field("hello", &"world")
155 .finish_non_exhaustive()
160 "Bar { foo: Foo { bar: true, baz: 10/20, .. }, hello: \"world\", .. }",
173 format!("{:#?}", Bar)
185 impl fmt::Debug for Foo {
186 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
187 fmt.debug_tuple("Foo").finish()
191 assert_eq!("Foo", format!("{:?}", Foo));
192 assert_eq!("Foo", format!("{:#?}", Foo));
199 impl fmt::Debug for Foo {
200 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
201 fmt.debug_tuple("Foo").field(&true).finish()
205 assert_eq!("Foo(true)", format!("{:?}", Foo));
210 format!("{:#?}", Foo)
218 impl fmt::Debug for Foo {
219 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
220 fmt.debug_tuple("Foo").field(&true).field(&format_args!("{}/{}", 10, 20)).finish()
224 assert_eq!("Foo(true, 10/20)", format!("{:?}", Foo));
230 format!("{:#?}", Foo)
238 impl fmt::Debug for Foo {
239 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
240 fmt.debug_tuple("Foo").field(&true).field(&format_args!("{}/{}", 10, 20)).finish()
246 impl fmt::Debug for Bar {
247 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
248 fmt.debug_tuple("Bar").field(&Foo).field(&"world").finish()
252 assert_eq!("Bar(Foo(true, 10/20), \"world\")", format!("{:?}", Bar));
261 format!("{:#?}", Bar)
273 impl fmt::Debug for Foo {
274 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
275 fmt.debug_map().finish()
279 assert_eq!("{}", format!("{:?}", Foo));
280 assert_eq!("{}", format!("{:#?}", Foo));
287 impl fmt::Debug for Entry {
288 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
289 fmt.debug_map().entry(&"bar", &true).finish()
295 impl fmt::Debug for KeyValue {
296 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
297 fmt.debug_map().key(&"bar").value(&true).finish()
301 assert_eq!(format!("{:?}", Entry), format!("{:?}", KeyValue));
302 assert_eq!(format!("{:#?}", Entry), format!("{:#?}", KeyValue));
304 assert_eq!("{\"bar\": true}", format!("{:?}", Entry));
309 format!("{:#?}", Entry)
317 impl fmt::Debug for Entry {
318 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
320 .entry(&"bar", &true)
321 .entry(&10, &format_args!("{}/{}", 10, 20))
328 impl fmt::Debug for KeyValue {
329 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
334 .value(&format_args!("{}/{}", 10, 20))
339 assert_eq!(format!("{:?}", Entry), format!("{:?}", KeyValue));
340 assert_eq!(format!("{:#?}", Entry), format!("{:#?}", KeyValue));
342 assert_eq!("{\"bar\": true, 10: 10/20}", format!("{:?}", Entry));
348 format!("{:#?}", Entry)
356 impl fmt::Debug for Foo {
357 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
359 .entry(&"bar", &true)
360 .entry(&10, &format_args!("{}/{}", 10, 20))
367 impl fmt::Debug for Bar {
368 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
369 fmt.debug_map().entry(&"foo", &Foo).entry(&Foo, &"world").finish()
374 "{\"foo\": {\"bar\": true, 10: 10/20}, \
375 {\"bar\": true, 10: 10/20}: \"world\"}",
389 format!("{:#?}", Bar)
394 fn test_entry_err() {
395 // Ensure errors in a map entry don't trigger panics (#65231)
400 impl fmt::Debug for ErrorFmt {
401 fn fmt(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result {
406 struct KeyValue<K, V>(usize, K, V);
408 impl<K, V> fmt::Debug for KeyValue<K, V>
413 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
414 let mut map = fmt.debug_map();
417 map.entry(&self.1, &self.2);
424 let mut buf = String::new();
426 assert!(write!(&mut buf, "{:?}", KeyValue(1, ErrorFmt, "bar")).is_err());
427 assert!(write!(&mut buf, "{:?}", KeyValue(1, "foo", ErrorFmt)).is_err());
429 assert!(write!(&mut buf, "{:?}", KeyValue(2, ErrorFmt, "bar")).is_err());
430 assert!(write!(&mut buf, "{:?}", KeyValue(2, "foo", ErrorFmt)).is_err());
435 fn test_invalid_key_when_entry_is_incomplete() {
438 impl fmt::Debug for Foo {
439 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
440 fmt.debug_map().key(&"bar").key(&"invalid").finish()
444 format!("{:?}", Foo);
449 fn test_invalid_finish_incomplete_entry() {
452 impl fmt::Debug for Foo {
453 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
454 fmt.debug_map().key(&"bar").finish()
458 format!("{:?}", Foo);
463 fn test_invalid_value_before_key() {
466 impl fmt::Debug for Foo {
467 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
468 fmt.debug_map().value(&"invalid").key(&"bar").finish()
472 format!("{:?}", Foo);
483 impl fmt::Debug for Foo {
484 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
485 fmt.debug_set().finish()
489 assert_eq!("{}", format!("{:?}", Foo));
490 assert_eq!("{}", format!("{:#?}", Foo));
497 impl fmt::Debug for Foo {
498 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
499 fmt.debug_set().entry(&true).finish()
503 assert_eq!("{true}", format!("{:?}", Foo));
508 format!("{:#?}", Foo)
516 impl fmt::Debug for Foo {
517 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
518 fmt.debug_set().entry(&true).entry(&format_args!("{}/{}", 10, 20)).finish()
522 assert_eq!("{true, 10/20}", format!("{:?}", Foo));
528 format!("{:#?}", Foo)
536 impl fmt::Debug for Foo {
537 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
538 fmt.debug_set().entry(&true).entry(&format_args!("{}/{}", 10, 20)).finish()
544 impl fmt::Debug for Bar {
545 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
546 fmt.debug_set().entry(&Foo).entry(&"world").finish()
550 assert_eq!("{{true, 10/20}, \"world\"}", format!("{:?}", Bar));
559 format!("{:#?}", Bar)
571 impl fmt::Debug for Foo {
572 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
573 fmt.debug_list().finish()
577 assert_eq!("[]", format!("{:?}", Foo));
578 assert_eq!("[]", format!("{:#?}", Foo));
585 impl fmt::Debug for Foo {
586 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
587 fmt.debug_list().entry(&true).finish()
591 assert_eq!("[true]", format!("{:?}", Foo));
596 format!("{:#?}", Foo)
604 impl fmt::Debug for Foo {
605 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
606 fmt.debug_list().entry(&true).entry(&format_args!("{}/{}", 10, 20)).finish()
610 assert_eq!("[true, 10/20]", format!("{:?}", Foo));
616 format!("{:#?}", Foo)
624 impl fmt::Debug for Foo {
625 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
626 fmt.debug_list().entry(&true).entry(&format_args!("{}/{}", 10, 20)).finish()
632 impl fmt::Debug for Bar {
633 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
634 fmt.debug_list().entry(&Foo).entry(&"world").finish()
638 assert_eq!("[[true, 10/20], \"world\"]", format!("{:?}", Bar));
647 format!("{:#?}", Bar)
653 fn test_formatting_parameters_are_forwarded() {
654 use std::collections::{BTreeMap, BTreeSet};
661 let struct_ = Foo { bar: 1024, baz: 7 };
662 let tuple = (1024, 7);
663 let list = [1024, 7];
664 let mut map = BTreeMap::new();
665 map.insert("bar", 1024);
666 map.insert("baz", 7);
667 let mut set = BTreeSet::new();
671 assert_eq!(format!("{:03?}", struct_), "Foo { bar: 1024, baz: 007 }");
672 assert_eq!(format!("{:03?}", tuple), "(1024, 007)");
673 assert_eq!(format!("{:03?}", list), "[1024, 007]");
674 assert_eq!(format!("{:03?}", map), r#"{"bar": 1024, "baz": 007}"#);
675 assert_eq!(format!("{:03?}", set), "{007, 1024}");
677 format!("{:#03?}", struct_),
687 format!("{:#03?}", tuple),
697 format!("{:#03?}", list),
707 format!("{:#03?}", map),
717 format!("{:#03?}", set),