3 fn op1() -> Result<isize, &'static str> { Ok(666) }
4 fn op2() -> Result<isize, &'static str> { Err("sadface") }
8 assert_eq!(op1().and(Ok(667)).unwrap(), 667);
9 assert_eq!(op1().and(Err::<i32, &'static str>("bad")).unwrap_err(),
12 assert_eq!(op2().and(Ok(667)).unwrap_err(), "sadface");
13 assert_eq!(op2().and(Err::<i32,&'static str>("bad")).unwrap_err(),
19 assert_eq!(op1().and_then(|i| Ok::<isize, &'static str>(i + 1)).unwrap(), 667);
20 assert_eq!(op1().and_then(|_| Err::<isize, &'static str>("bad")).unwrap_err(),
23 assert_eq!(op2().and_then(|i| Ok::<isize, &'static str>(i + 1)).unwrap_err(),
25 assert_eq!(op2().and_then(|_| Err::<isize, &'static str>("bad")).unwrap_err(),
31 assert_eq!(op1().or(Ok::<_, &'static str>(667)).unwrap(), 666);
32 assert_eq!(op1().or(Err("bad")).unwrap(), 666);
34 assert_eq!(op2().or(Ok::<_, &'static str>(667)).unwrap(), 667);
35 assert_eq!(op2().or(Err("bad")).unwrap_err(), "bad");
40 assert_eq!(op1().or_else(|_| Ok::<isize, &'static str>(667)).unwrap(), 666);
41 assert_eq!(op1().or_else(|e| Err::<isize, &'static str>(e)).unwrap(), 666);
43 assert_eq!(op2().or_else(|_| Ok::<isize, &'static str>(667)).unwrap(), 667);
44 assert_eq!(op2().or_else(|e| Err::<isize, &'static str>(e)).unwrap_err(),
50 assert!(Ok::<isize, isize>(1).map(|x| x + 1) == Ok(2));
51 assert!(Err::<isize, isize>(1).map(|x| x + 1) == Err(1));
55 fn test_impl_map_err() {
56 assert!(Ok::<isize, isize>(1).map_err(|x| x + 1) == Ok(1));
57 assert!(Err::<isize, isize>(1).map_err(|x| x + 1) == Err(2));
62 let v: Result<Vec<isize>, ()> = (0..0).map(|_| Ok::<isize, ()>(0)).collect();
63 assert!(v == Ok(vec![]));
65 let v: Result<Vec<isize>, ()> = (0..3).map(|x| Ok::<isize, ()>(x)).collect();
66 assert!(v == Ok(vec![0, 1, 2]));
68 let v: Result<Vec<isize>, isize> = (0..3).map(|x| {
69 if x > 1 { Err(x) } else { Ok(x) }
73 // test that it does not take more elements than it needs
74 let mut functions: [Box<dyn Fn() -> Result<(), isize>>; 3] =
75 [box || Ok(()), box || Err(1), box || panic!()];
77 let v: Result<Vec<()>, isize> = functions.iter_mut().map(|f| (*f)()).collect();
82 fn test_fmt_default() {
83 let ok: Result<isize, &'static str> = Ok(100);
84 let err: Result<isize, &'static str> = Err("Err");
86 let s = format!("{:?}", ok);
87 assert_eq!(s, "Ok(100)");
88 let s = format!("{:?}", err);
89 assert_eq!(s, "Err(\"Err\")");
94 let ok: Result<isize, &'static str> = Ok(100);
95 let ok_err: Result<isize, &'static str> = Err("Err");
97 assert_eq!(ok.unwrap_or(50), 100);
98 assert_eq!(ok_err.unwrap_or(50), 50);
102 fn test_unwrap_or_else() {
103 fn handler(msg: &'static str) -> isize {
104 if msg == "I got this." {
111 let ok: Result<isize, &'static str> = Ok(100);
112 let ok_err: Result<isize, &'static str> = Err("I got this.");
114 assert_eq!(ok.unwrap_or_else(handler), 100);
115 assert_eq!(ok_err.unwrap_or_else(handler), 50);
120 pub fn test_unwrap_or_else_panic() {
121 fn handler(msg: &'static str) -> isize {
122 if msg == "I got this." {
129 let bad_err: Result<isize, &'static str> = Err("Unrecoverable mess.");
130 let _ : isize = bad_err.unwrap_or_else(handler);
135 pub fn test_expect_ok() {
136 let ok: Result<isize, &'static str> = Ok(100);
137 assert_eq!(ok.expect("Unexpected error"), 100);
140 #[should_panic(expected="Got expected error: \"All good\"")]
141 pub fn test_expect_err() {
142 let err: Result<isize, &'static str> = Err("All good");
143 err.expect("Got expected error");
148 pub fn test_expect_err_err() {
149 let ok: Result<&'static str, isize> = Err(100);
150 assert_eq!(ok.expect_err("Unexpected ok"), 100);
153 #[should_panic(expected="Got expected ok: \"All good\"")]
154 pub fn test_expect_err_ok() {
155 let err: Result<&'static str, isize> = Ok("All good");
156 err.expect_err("Got expected ok");
161 let ok: Result<isize, &'static str> = Ok(100);
162 let mut it = ok.iter();
163 assert_eq!(it.size_hint(), (1, Some(1)));
164 assert_eq!(it.next(), Some(&100));
165 assert_eq!(it.size_hint(), (0, Some(0)));
166 assert!(it.next().is_none());
167 assert_eq!((&ok).into_iter().next(), Some(&100));
169 let err: Result<isize, &'static str> = Err("error");
170 assert_eq!(err.iter().next(), None);
174 pub fn test_iter_mut() {
175 let mut ok: Result<isize, &'static str> = Ok(100);
176 for loc in ok.iter_mut() {
179 assert_eq!(ok, Ok(200));
183 assert_eq!(ok, Ok(300));
185 let mut err: Result<isize, &'static str> = Err("error");
186 for loc in err.iter_mut() {
189 assert_eq!(err, Err("error"));
193 pub fn test_unwrap_or_default() {
194 assert_eq!(op1().unwrap_or_default(), 666);
195 assert_eq!(op2().unwrap_or_default(), 0);
200 fn try_result_some() -> Option<u8> {
204 assert_eq!(try_result_some(), Some(1));
206 fn try_result_none() -> Option<u8> {
207 let val = Err(NoneError)?;
210 assert_eq!(try_result_none(), None);
212 fn try_result_ok() -> Result<u8, u8> {
213 let result: Result<u8, u8> = Ok(1);
217 assert_eq!(try_result_ok(), Ok(1));
219 fn try_result_err() -> Result<u8, u8> {
220 let result: Result<u8, u8> = Err(1);
224 assert_eq!(try_result_err(), Err(1));
228 fn test_result_deref() {
229 // &Result<T: Deref, E>::Ok(T).deref_ok() ->
230 // Result<&T::Deref::Target, &E>::Ok(&*T)
231 let ref_ok = &Result::Ok::<&i32, u8>(&42);
232 let expected_result = Result::Ok::<&i32, &u8>(&42);
233 assert_eq!(ref_ok.deref_ok(), expected_result);
235 let ref_ok = &Result::Ok::<String, u32>(String::from("a result"));
236 let expected_result = Result::Ok::<&str, &u32>("a result");
237 assert_eq!(ref_ok.deref_ok(), expected_result);
239 let ref_ok = &Result::Ok::<Vec<i32>, u32>(vec![1, 2, 3, 4, 5]);
240 let expected_result = Result::Ok::<&[i32], &u32>(&[1, 2, 3, 4, 5][..]);
241 assert_eq!(ref_ok.deref_ok(), expected_result);
243 // &Result<T: Deref, E: Deref>::Ok(T).deref() ->
244 // Result<&T::Deref::Target, &E::Deref::Target>::Ok(&*T)
245 let ref_ok = &Result::Ok::<&i32, &u8>(&42);
246 let expected_result = Result::Ok::<&i32, &u8>(&42);
247 assert_eq!(ref_ok.deref(), expected_result);
249 let ref_ok = &Result::Ok::<String, &u32>(String::from("a result"));
250 let expected_result = Result::Ok::<&str, &u32>("a result");
251 assert_eq!(ref_ok.deref(), expected_result);
253 let ref_ok = &Result::Ok::<Vec<i32>, &u32>(vec![1, 2, 3, 4, 5]);
254 let expected_result = Result::Ok::<&[i32], &u32>(&[1, 2, 3, 4, 5][..]);
255 assert_eq!(ref_ok.deref(), expected_result);
257 // &Result<T, E: Deref>::Err(T).deref_err() ->
258 // Result<&T, &E::Deref::Target>::Err(&*E)
259 let ref_err = &Result::Err::<u8, &i32>(&41);
260 let expected_result = Result::Err::<&u8, &i32>(&41);
261 assert_eq!(ref_err.deref_err(), expected_result);
263 let ref_err = &Result::Err::<u32, String>(String::from("an error"));
264 let expected_result = Result::Err::<&u32, &str>("an error");
265 assert_eq!(ref_err.deref_err(), expected_result);
267 let ref_err = &Result::Err::<u32, Vec<i32>>(vec![5, 4, 3, 2, 1]);
268 let expected_result = Result::Err::<&u32, &[i32]>(&[5, 4, 3, 2, 1][..]);
269 assert_eq!(ref_err.deref_err(), expected_result);
271 // &Result<T: Deref, E: Deref>::Err(T).deref_err() ->
272 // Result<&T, &E::Deref::Target>::Err(&*E)
273 let ref_err = &Result::Err::<&u8, &i32>(&41);
274 let expected_result = Result::Err::<&u8, &i32>(&41);
275 assert_eq!(ref_err.deref(), expected_result);
277 let ref_err = &Result::Err::<&u32, String>(String::from("an error"));
278 let expected_result = Result::Err::<&u32, &str>("an error");
279 assert_eq!(ref_err.deref(), expected_result);
281 let ref_err = &Result::Err::<&u32, Vec<i32>>(vec![5, 4, 3, 2, 1]);
282 let expected_result = Result::Err::<&u32, &[i32]>(&[5, 4, 3, 2, 1][..]);
283 assert_eq!(ref_err.deref(), expected_result);
285 // The following cases test calling deref_* with the wrong variant (i.e.
286 // `deref_ok()` with a `Result::Err()`, or `deref_err()` with a `Result::Ok()`.
287 // While unusual, these cases are supported to ensure that an `inner_deref`
288 // call can still be made even when one of the Result types does not implement
289 // `Deref` (for example, std::io::Error).
291 // &Result<T, E: Deref>::Ok(T).deref_err() ->
292 // Result<&T, &E::Deref::Target>::Ok(&T)
293 let ref_ok = &Result::Ok::<i32, &u8>(42);
294 let expected_result = Result::Ok::<&i32, &u8>(&42);
295 assert_eq!(ref_ok.deref_err(), expected_result);
297 let ref_ok = &Result::Ok::<&str, &u32>("a result");
298 let expected_result = Result::Ok::<&&str, &u32>(&"a result");
299 assert_eq!(ref_ok.deref_err(), expected_result);
301 let ref_ok = &Result::Ok::<[i32; 5], &u32>([1, 2, 3, 4, 5]);
302 let expected_result = Result::Ok::<&[i32; 5], &u32>(&[1, 2, 3, 4, 5]);
303 assert_eq!(ref_ok.deref_err(), expected_result);
305 // &Result<T: Deref, E>::Err(E).deref_ok() ->
306 // Result<&T::Deref::Target, &E>::Err(&E)
307 let ref_err = &Result::Err::<&u8, i32>(41);
308 let expected_result = Result::Err::<&u8, &i32>(&41);
309 assert_eq!(ref_err.deref_ok(), expected_result);
311 let ref_err = &Result::Err::<&u32, &str>("an error");
312 let expected_result = Result::Err::<&u32, &&str>(&"an error");
313 assert_eq!(ref_err.deref_ok(), expected_result);
315 let ref_err = &Result::Err::<&u32, [i32; 5]>([5, 4, 3, 2, 1]);
316 let expected_result = Result::Err::<&u32, &[i32; 5]>(&[5, 4, 3, 2, 1]);
317 assert_eq!(ref_err.deref_ok(), expected_result);