1 use core
::ops
::DerefMut
;
4 fn op1() -> Result
<isize, &'
static str> {
7 fn op2() -> Result
<isize, &'
static str> {
13 assert_eq
!(op1().and(Ok(667)).unwrap(), 667);
14 assert_eq
!(op1().and(Err
::<i32, &'
static str>("bad")).unwrap_err(), "bad");
16 assert_eq
!(op2().and(Ok(667)).unwrap_err(), "sadface");
17 assert_eq
!(op2().and(Err
::<i32, &'
static str>("bad")).unwrap_err(), "sadface");
22 assert_eq
!(op1().and_then(|i
| Ok
::<isize, &'
static str>(i
+ 1)).unwrap(), 667);
23 assert_eq
!(op1().and_then(|_
| Err
::<isize, &'
static str>("bad")).unwrap_err(), "bad");
25 assert_eq
!(op2().and_then(|i
| Ok
::<isize, &'
static str>(i
+ 1)).unwrap_err(), "sadface");
26 assert_eq
!(op2().and_then(|_
| Err
::<isize, &'
static str>("bad")).unwrap_err(), "sadface");
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(), "sadface");
49 assert
!(Ok
::<isize, isize>(1).map(|x
| x
+ 1) == Ok(2));
50 assert
!(Err
::<isize, isize>(1).map(|x
| x
+ 1) == Err(1));
54 fn test_impl_map_err() {
55 assert
!(Ok
::<isize, isize>(1).map_err(|x
| x
+ 1) == Ok(1));
56 assert
!(Err
::<isize, isize>(1).map_err(|x
| x
+ 1) == Err(2));
61 let v
: Result
<Vec
<isize>, ()> = (0..0).map(|_
| Ok
::<isize, ()>(0)).collect();
62 assert
!(v
== Ok(vec
![]));
64 let v
: Result
<Vec
<isize>, ()> = (0..3).map(|x
| Ok
::<isize, ()>(x
)).collect();
65 assert
!(v
== Ok(vec
![0, 1, 2]));
67 let v
: Result
<Vec
<isize>, isize> = (0..3).map(|x
| if x
> 1 { Err(x) }
else { Ok(x) }
).collect();
70 // test that it does not take more elements than it needs
71 let mut functions
: [Box
<dyn Fn() -> Result
<(), isize>>; 3] =
72 [box || Ok(()), box || Err(1), box || panic
!()];
74 let v
: Result
<Vec
<()>, isize> = functions
.iter_mut().map(|f
| (*f
)()).collect();
79 fn test_fmt_default() {
80 let ok
: Result
<isize, &'
static str> = Ok(100);
81 let err
: Result
<isize, &'
static str> = Err("Err");
83 let s
= format
!("{:?}", ok
);
84 assert_eq
!(s
, "Ok(100)");
85 let s
= format
!("{:?}", err
);
86 assert_eq
!(s
, "Err(\"Err\")");
91 let ok
: Result
<isize, &'
static str> = Ok(100);
92 let ok_err
: Result
<isize, &'
static str> = Err("Err");
94 assert_eq
!(ok
.unwrap_or(50), 100);
95 assert_eq
!(ok_err
.unwrap_or(50), 50);
100 let ok
: Result
<isize, isize> = Ok(100);
101 let err
: Result
<isize, isize> = Err(200);
103 assert_eq
!(ok
.into_ok_or_err(), 100);
104 assert_eq
!(err
.into_ok_or_err(), 200);
108 fn test_unwrap_or_else() {
109 fn handler(msg
: &'
static str) -> isize {
110 if msg
== "I got this." { 50 }
else { panic!("BadBad") }
113 let ok
: Result
<isize, &'
static str> = Ok(100);
114 let ok_err
: Result
<isize, &'
static str> = Err("I got this.");
116 assert_eq
!(ok
.unwrap_or_else(handler
), 100);
117 assert_eq
!(ok_err
.unwrap_or_else(handler
), 50);
122 pub fn test_unwrap_or_else_panic() {
123 fn handler(msg
: &'
static str) -> isize {
124 if msg
== "I got this." { 50 }
else { panic!("BadBad") }
127 let bad_err
: Result
<isize, &'
static str> = Err("Unrecoverable mess.");
128 let _
: isize = bad_err
.unwrap_or_else(handler
);
132 fn test_unwrap_unchecked() {
133 let ok
: Result
<isize, &'
static str> = Ok(100);
134 assert_eq
!(unsafe { ok.unwrap_unchecked() }
, 100);
138 fn test_unwrap_err_unchecked() {
139 let ok_err
: Result
<isize, &'
static str> = Err("Err");
140 assert_eq
!(unsafe { ok_err.unwrap_err_unchecked() }
, "Err");
144 pub fn test_expect_ok() {
145 let ok
: Result
<isize, &'
static str> = Ok(100);
146 assert_eq
!(ok
.expect("Unexpected error"), 100);
149 #[should_panic(expected = "Got expected error: \"All good\"")]
150 pub fn test_expect_err() {
151 let err
: Result
<isize, &'
static str> = Err("All good");
152 err
.expect("Got expected error");
156 pub fn test_expect_err_err() {
157 let ok
: Result
<&'
static str, isize> = Err(100);
158 assert_eq
!(ok
.expect_err("Unexpected ok"), 100);
161 #[should_panic(expected = "Got expected ok: \"All good\"")]
162 pub fn test_expect_err_ok() {
163 let err
: Result
<&'
static str, isize> = Ok("All good");
164 err
.expect_err("Got expected ok");
169 let ok
: Result
<isize, &'
static str> = Ok(100);
170 let mut it
= ok
.iter();
171 assert_eq
!(it
.size_hint(), (1, Some(1)));
172 assert_eq
!(it
.next(), Some(&100));
173 assert_eq
!(it
.size_hint(), (0, Some(0)));
174 assert
!(it
.next().is_none());
175 assert_eq
!((&ok
).into_iter().next(), Some(&100));
177 let err
: Result
<isize, &'
static str> = Err("error");
178 assert_eq
!(err
.iter().next(), None
);
182 pub fn test_iter_mut() {
183 let mut ok
: Result
<isize, &'
static str> = Ok(100);
184 for loc
in ok
.iter_mut() {
187 assert_eq
!(ok
, Ok(200));
191 assert_eq
!(ok
, Ok(300));
193 let mut err
: Result
<isize, &'
static str> = Err("error");
194 for loc
in err
.iter_mut() {
197 assert_eq
!(err
, Err("error"));
201 pub fn test_unwrap_or_default() {
202 assert_eq
!(op1().unwrap_or_default(), 666);
203 assert_eq
!(op2().unwrap_or_default(), 0);
207 pub fn test_into_ok() {
208 fn infallible_op() -> Result
<isize, !> {
212 assert_eq
!(infallible_op().into_ok(), 666);
215 impl From
<MyNeverToken
> for ! {
216 fn from(never
: MyNeverToken
) -> ! {
221 fn infallible_op2() -> Result
<isize, MyNeverToken
> {
225 assert_eq
!(infallible_op2().into_ok(), 667);
230 fn try_result_some() -> Option
<u8> {
234 assert_eq
!(try_result_some(), Some(1));
236 fn try_result_none() -> Option
<u8> {
237 let val
= Err(NoneError
)?
;
240 assert_eq
!(try_result_none(), None
);
242 fn try_result_ok() -> Result
<u8, u8> {
243 let result
: Result
<u8, u8> = Ok(1);
247 assert_eq
!(try_result_ok(), Ok(1));
249 fn try_result_err() -> Result
<u8, u8> {
250 let result
: Result
<u8, u8> = Err(1);
254 assert_eq
!(try_result_err(), Err(1));
258 fn test_result_as_deref() {
259 // &Result<T: Deref, E>::Ok(T).as_deref() ->
260 // Result<&T::Deref::Target, &E>::Ok(&*T)
261 let ref_ok
= &Result
::Ok
::<&i32, u8>(&42);
262 let expected_result
= Result
::Ok
::<&i32, &u8>(&42);
263 assert_eq
!(ref_ok
.as_deref(), expected_result
);
265 let ref_ok
= &Result
::Ok
::<String
, u32>(String
::from("a result"));
266 let expected_result
= Result
::Ok
::<&str, &u32>("a result");
267 assert_eq
!(ref_ok
.as_deref(), expected_result
);
269 let ref_ok
= &Result
::Ok
::<Vec
<i32>, u32>(vec
![1, 2, 3, 4, 5]);
270 let expected_result
= Result
::Ok
::<&[i32], &u32>([1, 2, 3, 4, 5].as_slice());
271 assert_eq
!(ref_ok
.as_deref(), expected_result
);
273 // &Result<T: Deref, E>::Err(T).as_deref() ->
274 // Result<&T::Deref::Target, &E>::Err(&*E)
276 let ref_err
= &Result
::Err
::<&u8, i32>(val
);
277 let expected_result
= Result
::Err
::<&u8, &i32>(&val
);
278 assert_eq
!(ref_err
.as_deref(), expected_result
);
280 let s
= String
::from("an error");
281 let ref_err
= &Result
::Err
::<&u32, String
>(s
.clone());
282 let expected_result
= Result
::Err
::<&u32, &String
>(&s
);
283 assert_eq
!(ref_err
.as_deref(), expected_result
);
285 let v
= vec
![5, 4, 3, 2, 1];
286 let ref_err
= &Result
::Err
::<&u32, Vec
<i32>>(v
.clone());
287 let expected_result
= Result
::Err
::<&u32, &Vec
<i32>>(&v
);
288 assert_eq
!(ref_err
.as_deref(), expected_result
);
292 fn test_result_as_deref_mut() {
293 // &mut Result<T: DerefMut, E>::Ok(T).as_deref_mut() ->
294 // Result<&mut T::DerefMut::Target, &mut E>::Ok(&mut *T)
296 let mut expected_val
= 42;
297 let mut_ok
= &mut Result
::Ok
::<&mut i32, u8>(&mut val
);
298 let expected_result
= Result
::Ok
::<&mut i32, &mut u8>(&mut expected_val
);
299 assert_eq
!(mut_ok
.as_deref_mut(), expected_result
);
301 let mut expected_string
= String
::from("a result");
302 let mut_ok
= &mut Result
::Ok
::<String
, u32>(expected_string
.clone());
303 let expected_result
= Result
::Ok
::<&mut str, &mut u32>(expected_string
.deref_mut());
304 assert_eq
!(mut_ok
.as_deref_mut(), expected_result
);
306 let mut expected_vec
= vec
![1, 2, 3, 4, 5];
307 let mut_ok
= &mut Result
::Ok
::<Vec
<i32>, u32>(expected_vec
.clone());
308 let expected_result
= Result
::Ok
::<&mut [i32], &mut u32>(expected_vec
.as_mut_slice());
309 assert_eq
!(mut_ok
.as_deref_mut(), expected_result
);
311 // &mut Result<T: DerefMut, E>::Err(T).as_deref_mut() ->
312 // Result<&mut T, &mut E>::Err(&mut *E)
314 let mut_err
= &mut Result
::Err
::<&mut u8, i32>(val
);
315 let expected_result
= Result
::Err
::<&mut u8, &mut i32>(&mut val
);
316 assert_eq
!(mut_err
.as_deref_mut(), expected_result
);
318 let mut expected_string
= String
::from("an error");
319 let mut_err
= &mut Result
::Err
::<&mut u32, String
>(expected_string
.clone());
320 let expected_result
= Result
::Err
::<&mut u32, &mut String
>(&mut expected_string
);
321 assert_eq
!(mut_err
.as_deref_mut(), expected_result
);
323 let mut expected_vec
= vec
![5, 4, 3, 2, 1];
324 let mut_err
= &mut Result
::Err
::<&mut u32, Vec
<i32>>(expected_vec
.clone());
325 let expected_result
= Result
::Err
::<&mut u32, &mut Vec
<i32>>(&mut expected_vec
);
326 assert_eq
!(mut_err
.as_deref_mut(), expected_result
);
331 // test that the methods of `Result` are usable in a const context
333 const RESULT
: Result
<usize, bool
> = Ok(32);
335 const REF
: Result
<&usize, &bool
> = RESULT
.as_ref();
336 assert_eq
!(REF
, Ok(&32));
338 const IS_OK
: bool
= RESULT
.is_ok();
341 const IS_ERR
: bool
= RESULT
.is_err();
346 fn result_opt_conversions() {
347 #[derive(Copy, Clone, Debug, PartialEq)]
350 fn try_num(x
: i32) -> Result
<i32, BadNumErr
> {
351 if x
<= 5 { Ok(x + 1) }
else { Err(BadNumErr) }
354 type ResOpt
= Result
<Option
<i32>, BadNumErr
>;
355 type OptRes
= Option
<Result
<i32, BadNumErr
>>;
357 let mut x
: ResOpt
= Ok(Some(5));
358 let mut y
: OptRes
= Some(Ok(5));
359 assert_eq
!(x
, y
.transpose());
360 assert_eq
!(x
.transpose(), y
);
364 assert_eq
!(x
, y
.transpose());
365 assert_eq
!(x
.transpose(), y
);
368 y
= Some(Err(BadNumErr
));
369 assert_eq
!(x
, y
.transpose());
370 assert_eq
!(x
.transpose(), y
);
372 let res
: Result
<Vec
<i32>, BadNumErr
> = (0..10)
375 Ok(if y
% 2 == 0 { Some(y - 1) }
else { None }
)
377 .filter_map(Result
::transpose
)
380 assert_eq
!(res
, Err(BadNumErr
))