arc-io-error 0.1.1

A version of std::io::Error implemented on top of Arc instead of Box, making it cloneable.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

extern crate arc_io_error;

use std::error::Error;
use std::fmt;
use std::io;

use arc_io_error::{IoError, IoErrorKind};

#[test]
fn test_os() {
    let err1 = io::Error::from_raw_os_error(42);
    let err2 = IoError::from(io::Error::from_raw_os_error(42));
    let err3 = err2.clone();
    let err4 = io::Error::from(err3.clone());

    assert_eq!(err1.description(), err2.description());
    assert_eq!(err1.description(), err3.description());
    assert_eq!(err1.description(), err4.description());

    assert_eq!(err1.to_string(), err2.to_string());
    assert_eq!(err1.to_string(), err3.to_string());
    assert_eq!(err1.to_string(), err4.to_string());

    assert_eq!(err1.raw_os_error().unwrap(), 42);
    assert_eq!(err2.raw_os_error().unwrap(), 42);
    assert_eq!(err3.raw_os_error().unwrap(), 42);
    assert_eq!(err4.raw_os_error().unwrap(), 42);

    assert_eq!(err1.kind(), err2.kind());
    assert_eq!(err1.kind(), err3.kind());
    assert_eq!(err1.kind(), err4.kind());

    assert!(err1.into_inner().is_none());
    assert!(err2.into_inner().is_none());
    assert!(err3.into_inner().is_none());
    assert!(err4.into_inner().is_none());
}

#[test]
fn test_kind() {
    let err1 = io::Error::from(IoErrorKind::ConnectionReset);
    let err2 = IoError::from(io::Error::from(IoErrorKind::ConnectionReset));
    let err3 = err2.clone();
    let err4 = io::Error::from(err3.clone());

    assert_eq!(err1.description(), err2.description());
    assert_eq!(err1.description(), err3.description());
    assert_eq!(err1.description(), err4.description());

    assert_eq!(err1.to_string(), err2.to_string());
    assert_eq!(err1.to_string(), err3.to_string());
    assert_eq!(err1.to_string(), err4.to_string());

    assert!(err1.raw_os_error().is_none());
    assert!(err2.raw_os_error().is_none());
    assert!(err3.raw_os_error().is_none());
    assert!(err4.raw_os_error().is_none());

    assert_eq!(err1.kind(), IoErrorKind::ConnectionReset);
    assert_eq!(err2.kind(), IoErrorKind::ConnectionReset);
    assert_eq!(err3.kind(), IoErrorKind::ConnectionReset);
    assert_eq!(err4.kind(), IoErrorKind::ConnectionReset);

    assert!(err1.into_inner().is_none());
    assert!(err2.into_inner().is_none());
    assert!(err3.into_inner().is_none());
    assert!(err4.into_inner().is_none());
}

#[test]
fn test_custom() {
    #[derive(Debug)]
    struct MyError(u8);

    impl fmt::Display for MyError {
        fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
            write!(f, "{}: {}", self.description(), self.0)
        }
    }

    impl Error for MyError {
        fn description(&self) -> &str {
            "my error"
        }

        fn cause(&self) -> Option<&Error> {
            None
        }
    }

    let err1 = io::Error::new(IoErrorKind::ConnectionReset, MyError(42));
    let err2 = IoError::from(io::Error::new(IoErrorKind::ConnectionReset, MyError(42)));
    let err3 = err2.clone();
    let err4 = io::Error::from(err3.clone());

    assert_eq!(err1.description(), err2.description());
    assert_eq!(err1.description(), err3.description());
    assert_eq!(err1.description(), err4.description());

    assert_eq!(err1.to_string(), err2.to_string());
    assert_eq!(err1.to_string(), err3.to_string());
    assert_eq!(err1.to_string(), err4.to_string());

    assert!(err1.raw_os_error().is_none());
    assert!(err2.raw_os_error().is_none());
    assert!(err3.raw_os_error().is_none());
    assert!(err4.raw_os_error().is_none());

    assert_eq!(err1.kind(), IoErrorKind::ConnectionReset);
    assert_eq!(err2.kind(), IoErrorKind::ConnectionReset);
    assert_eq!(err3.kind(), IoErrorKind::ConnectionReset);
    assert_eq!(err4.kind(), IoErrorKind::ConnectionReset);

    assert_eq!(err1.into_inner().unwrap().to_string(), "my error: 42");
    assert_eq!(err2.into_inner().unwrap().to_string(), "my error: 42");
    assert_eq!(err3.into_inner().unwrap().to_string(), "my error: 42");
    assert_eq!(err4.into_inner().unwrap().to_string(), "my error: 42");
}