error-stack 0.7.0

A context-aware error-handling library that supports arbitrary attached user data
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

#![cfg_attr(nightly, feature(error_generic_member_access))]

mod common;
use core::{
    error::Error,
    fmt::{Display, Formatter},
};

use common::*;
use error_stack::{IntoReport as _, Report};

#[derive(Debug)]
struct MyError;

impl Display for MyError {
    fn fmt(&self, fmt: &mut Formatter<'_>) -> core::fmt::Result {
        fmt.write_str("Error")
    }
}

impl Error for MyError {}

#[test]
fn push_append() {
    let mut err1 = MyError.into_report().attach("Not Supported").expand();
    let err2 = MyError.into_report().attach("Not Supported");
    let mut err3 = MyError.into_report().attach("Not Supported").expand();

    let count = expect_count(2) * 3;

    err1.push(err2);
    err3.append(err1);

    assert_eq!(err3.current_frames().len(), 3);
    assert_eq!(err3.frames().count(), count);
}

#[test]
fn push() {
    let mut err1 = MyError.into_report().attach("Not Supported").expand();
    let err2 = MyError.into_report().attach("Not Supported");
    let err3 = MyError.into_report().attach("Not Supported");

    let count = expect_count(2) * 3;

    err1.push(err2);
    err1.push(err3);

    assert_eq!(err1.current_frames().len(), 3);
    assert_eq!(err1.frames().count(), count);
}

#[test]
fn extend() {
    let mut err1 = MyError.into_report().attach("Not Supported").expand();
    let err2 = MyError.into_report().attach("Not Supported");
    let err3 = MyError.into_report().attach("Not Supported");

    err1.extend([err2, err3]);
    assert_eq!(err1.current_frames().len(), 3);
    assert_eq!(err1.frames().count(), expect_count(2) * 3);
}

#[test]
fn collect_single() {
    let report: Option<Report<[MyError]>> = vec![
        MyError.into_report(),
        MyError.into_report(),
        MyError.into_report(),
    ]
    .into_iter()
    .collect();

    let report = report.expect("should be some");
    assert_eq!(report.current_frames().len(), 3);
    assert_eq!(report.frames().count(), expect_count(1) * 3);
}

#[test]
fn collect_multiple() {
    let report: Option<Report<[MyError]>> = vec![
        MyError.into_report().expand(),
        MyError.into_report().expand(),
        MyError.into_report().expand(),
    ]
    .into_iter()
    .collect();

    let report = report.expect("should be some");
    assert_eq!(report.current_frames().len(), 3);
    assert_eq!(report.frames().count(), expect_count(1) * 3);
}

#[test]
fn collect_none() {
    let report: Option<Report<[MyError]>> = ([] as [Report<MyError>; 0]).into_iter().collect();

    assert!(report.is_none());
}