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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

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

mod common;

use core::{any::TypeId, iter::zip, panic::Location};

use common::*;

#[test]
fn opaque_attachment() {
    let mut report = create_report()
        .attach_opaque(AttachmentA(10))
        .attach_opaque(AttachmentB(20));

    let frame = report.frames_mut().next().expect("No frame found");
    let source = frame
        .sources_mut()
        .first_mut()
        .expect("No source frame found");
    let attachment = source
        .downcast_mut::<AttachmentA>()
        .expect("Wrong source frame");
    attachment.0 += 10;

    assert_eq!(frame.sources().len(), 1);
    let source = frame.sources().first().expect("No source frame found");
    let attachment = source
        .downcast_ref::<AttachmentA>()
        .expect("Wrong source frame");
    assert_eq!(attachment.0, 20);
}

#[test]
fn sources() {
    let mut report_a = create_report().attach_opaque(AttachmentA(10)).expand();
    let report_b = create_report().attach_opaque(AttachmentA(20));
    report_a.push(report_b);
    let mut report = report_a.attach_opaque(AttachmentB(30));

    let frame = report.frames_mut().next().expect("No frames");
    assert_eq!(frame.sources().len(), 2);

    for source in frame.sources_mut() {
        let attachment = source
            .downcast_mut::<AttachmentA>()
            .expect("Wrong source frame");
        attachment.0 += 5;
    }

    for (source, expect) in zip(frame.sources(), [15, 25]) {
        let attachment = source
            .downcast_ref::<AttachmentA>()
            .expect("Wrong source frame");
        assert_eq!(attachment.0, expect);
    }
}

#[test]
fn printable_attachment() {
    let mut report = create_report()
        .attach(PrintableA(10))
        .attach(PrintableB(20));

    let frame = report.frames_mut().next().expect("No frame found");
    let source = frame
        .sources_mut()
        .first_mut()
        .expect("No source frame found");
    let attachment = source
        .downcast_mut::<PrintableA>()
        .expect("Wrong source frame");
    attachment.0 += 10;

    assert_eq!(frame.sources().len(), 1);
    let source = frame.sources().first().expect("No source frame found");
    let attachment = source
        .downcast_ref::<PrintableA>()
        .expect("Wrong source frame");
    assert_eq!(attachment.0, 20);
}

#[test]
fn context() {
    let mut report = create_report().change_context(ContextA(10));

    let mut frames = report.frames_mut();

    let frame = frames.next().expect("No location frame found");
    assert_eq!(frame.sources().len(), 1);
    assert!(frame.is::<Location>(), "not a location frame");

    let source = frame
        .sources_mut()
        .first_mut()
        .expect("no source frame found");

    let context = source
        .downcast_mut::<ContextA>()
        .expect("not a context frame");
    context.0 += 10;

    assert_eq!(frame.sources().len(), 1);
    let source = frame.sources().first().expect("no source frame found");
    let context = source
        .downcast_ref::<ContextA>()
        .expect("not a context frame");
    assert_eq!(context.0, 20);
}

#[test]
fn type_id() {
    let report = create_report().attach_opaque(2_u32);
    let current = report.current_frame();

    assert_eq!(current.type_id(), TypeId::of::<u32>());

    let context = report
        .frames()
        .last()
        .expect("should have at least a single frame");
    assert_eq!(context.type_id(), TypeId::of::<RootError>());
}