Oregami
Repositories/oxedyne/fe2o3

oxedyne/fe2o3/fe2o3_core/tests/err_wire.rs

3.4 KiB, 1 run

created by r1870400018:75650, which is this file's identity for as long as the history lasts, whatever it is later renamed to

download · who wrote it · its history

1use oxedyne_fe2o3_core::{
2 prelude::*,
3 error::ErrWire,
4};
5
6use std::str::FromStr;
7
8
9#[test]
10fn every_tag_round_trips_by_name() -> Outcome<()> {
11 assert!(ErrTag::ALL.len() > 70);
12 for (i, tag) in ErrTag::ALL.iter().enumerate() {
13 let name = fmt!("{}", tag);
14 assert_eq!(name, tag.name());
15 let back = res!(ErrTag::from_str(&name));
16 assert_eq!(&back, tag);
17 assert_eq!(ErrTag::from_name(&name), Some(&ErrTag::ALL[i]));
18 }
19 Ok(())
20}
21
22#[test]
23fn an_unknown_tag_name_is_refused_not_a_panic() -> Outcome<()> {
24 assert!(ErrTag::from_str("NoSuchTag").is_err());
25 assert!(ErrTag::from_str("").is_err());
26 assert_eq!(ErrTag::from_name("invalid"), None);
27 Ok(())
28}
29
30fn chained() -> Error<ErrTag> {
31 let inner = err!("the inner fault {}", 7; Input, Missing);
32 let mid = Error::Upstream(std::sync::Arc::new(inner), ErrMsg {
33 msg: "the middle frame".to_string(),
34 tags: &[ErrTag::Decode],
35 });
36 let foreign = std::io::Error::new(std::io::ErrorKind::Other, "a foreign fault");
37 let other = err!(foreign, "wrapping io"; IO);
38 Error::Collection(vec![Box::new(mid), Box::new(other)])
39}
40
41#[test]
42fn an_error_keeps_its_text_and_tags_through_the_wire() -> Outcome<()> {
43 let e = chained();
44 let wire = e.to_wire();
45 let back = wire.to_error();
46 assert_eq!(back.tags(), e.tags());
47 assert_eq!(back.msgs(), e.msgs());
48 assert_eq!(back.plain(), e.plain());
49 // A second trip changes nothing a reader can see.
50 let again = back.to_wire().to_error();
51 assert_eq!(again.tags(), e.tags());
52 assert_eq!(again.msgs(), e.msgs());
53 Ok(())
54}
55
56#[test]
57fn a_frame_with_many_tags_keeps_them_in_order() -> Outcome<()> {
58 let e = err!("three tags"; Wire, Decode, Unknown);
59 let back = e.to_wire().to_error();
60 assert_eq!(back.tags(), vec![ErrTag::Wire, ErrTag::Decode, ErrTag::Unknown]);
61 assert_eq!(back.msgs(), e.msgs());
62 Ok(())
63}
64
65#[test]
66fn an_unknown_tag_on_the_wire_is_kept_as_text() -> Outcome<()> {
67 let wire = ErrWire::Frame {
68 msg: "from a newer peer".to_string(),
69 tags: vec!["Decode".to_string(), "Marmalade".to_string()],
70 cause: None,
71 };
72 let e = wire.to_error();
73 assert_eq!(e.tags(), vec![ErrTag::Decode]);
74 let plain = e.plain();
75 assert!(plain.contains("from a newer peer"), "{}", plain);
76 assert!(plain.contains("Marmalade"), "{}", plain);
77 Ok(())
78}
79
80/// Somebody else's error that wraps one of ours, as its `source()`.
81#[derive(Debug)]
82struct Foreign(Error<ErrTag>);
83
84impl std::fmt::Display for Foreign {
85 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
86 write!(f, "foreign layer")
87 }
88}
89
90impl std::error::Error for Foreign {
91 fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
92 Some(&self.0)
93 }
94}
95
96#[test]
97fn the_words_walk_through_a_foreign_layer_as_the_tags_do() -> Outcome<()> {
98 let ours: Error<ErrTag> = err!("deep words"; Input, Missing);
99 let e: Error<ErrTag> = Error::Upstream(
100 std::sync::Arc::new(Foreign(ours)),
101 ErrMsg { msg: "outer".to_string(), tags: &[ErrTag::Wire] },
102 );
103 assert_eq!(e.msgs(), vec!["outer", "foreign layer", "deep words"]);
104 assert_eq!(e.tags(), vec![ErrTag::Wire, ErrTag::Input, ErrTag::Missing]);
105 let back = e.to_wire().to_error();
106 assert_eq!(back.msgs(), e.msgs());
107 assert_eq!(back.tags(), e.tags());
108 assert_eq!(back.plain(), e.plain());
109 Ok(())
110}