micropdf 0.17.0

A pure Rust PDF library - A pure Rust PDF library with fz_/pdf_ API compatibility
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

//! Error handling — compatibility shim.
//!
//! `Error` is a re-export of `MpError`; all logic lives in `crate::micropdf::error`.

pub use crate::micropdf::error::MpError as Error;
pub use crate::micropdf::error::MpResult as Result;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_error_generic() {
        let e = Error::generic("test error");
        assert!(matches!(e, Error::Generic(_)));
        assert_eq!(format!("{}", e), "test error");
    }

    #[test]
    fn test_error_argument() {
        let e = Error::argument("bad argument");
        assert!(matches!(e, Error::Argument(_)));
        assert!(format!("{}", e).contains("bad argument"));
    }

    #[test]
    fn test_error_limit() {
        let e = Error::limit("size exceeded");
        assert!(matches!(e, Error::Limit(_)));
        assert!(format!("{}", e).contains("size exceeded"));
    }

    #[test]
    fn test_error_unsupported() {
        let e = Error::unsupported("feature not supported");
        assert!(matches!(e, Error::Unsupported(_)));
        assert!(format!("{}", e).contains("feature not supported"));
    }

    #[test]
    fn test_error_format() {
        let e = Error::format("invalid format");
        assert!(matches!(e, Error::Format(_)));
        assert!(format!("{}", e).contains("invalid format"));
    }

    #[test]
    fn test_error_syntax() {
        let e = Error::syntax("syntax error at line 5");
        assert!(matches!(e, Error::Syntax(_)));
        assert!(format!("{}", e).contains("syntax error"));
    }

    #[test]
    fn test_error_pdf() {
        let e = Error::pdf("invalid PDF structure");
        assert!(matches!(e, Error::Pdf(_)));
        assert!(format!("{}", e).contains("invalid PDF"));
    }

    #[test]
    fn test_error_encryption() {
        let e = Error::encryption("wrong password");
        assert!(matches!(e, Error::Encryption(_)));
        assert!(format!("{}", e).contains("wrong password"));
    }

    #[test]
    fn test_error_font() {
        let e = Error::font("font not found");
        assert!(matches!(e, Error::Font(_)));
        assert!(format!("{}", e).contains("font not found"));
    }

    #[test]
    fn test_error_image() {
        let e = Error::image("corrupted image");
        assert!(matches!(e, Error::Image(_)));
        assert!(format!("{}", e).contains("corrupted image"));
    }

    #[test]
    fn test_error_eof() {
        let e = Error::Eof;
        assert!(matches!(e, Error::Eof));
        assert!(format!("{}", e).contains("end of file"));
    }

    #[test]
    fn test_error_abort() {
        let e = Error::Abort;
        assert!(matches!(e, Error::Abort));
        assert!(format!("{}", e).contains("aborted"));
    }

    #[test]
    fn test_error_from_io_error() {
        let io_err = std::io::Error::new(std::io::ErrorKind::NotFound, "file not found");
        let e: Error = io_err.into();
        assert!(matches!(e, Error::System(_)));
        assert!(format!("{}", e).contains("file not found"));
    }

    #[test]
    fn test_error_debug() {
        let e = Error::generic("test");
        let debug = format!("{:?}", e);
        assert!(debug.contains("Generic"));
    }

    #[test]
    fn test_result_type() {
        fn returns_ok() -> Result<i32> {
            Ok(42)
        }

        fn returns_err() -> Result<i32> {
            Err(Error::generic("error"))
        }

        assert_eq!(returns_ok().unwrap(), 42);
        assert!(returns_err().is_err());
    }

    #[test]
    fn test_error_constructors_with_string() {
        assert!(matches!(
            Error::generic(String::from("g")),
            Error::Generic(_)
        ));
        assert!(matches!(
            Error::argument(String::from("a")),
            Error::Argument(_)
        ));
        assert!(matches!(Error::limit(String::from("l")), Error::Limit(_)));
        assert!(matches!(
            Error::unsupported(String::from("u")),
            Error::Unsupported(_)
        ));
        assert!(matches!(Error::format(String::from("f")), Error::Format(_)));
        assert!(matches!(Error::syntax(String::from("s")), Error::Syntax(_)));
        assert!(matches!(Error::pdf(String::from("p")), Error::Pdf(_)));
        assert!(matches!(
            Error::encryption(String::from("e")),
            Error::Encryption(_)
        ));
        assert!(matches!(Error::font(String::from("fo")), Error::Font(_)));
        assert!(matches!(Error::image(String::from("i")), Error::Image(_)));
    }
}