ohno 0.3.5

High-quality Rust error handling.
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

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

#![expect(missing_docs, reason = "Test code")]

/// Test that our automatic Debug implementation produces identical output to standard #[derive(Debug)]
use ohno::{Error, OhnoCore};

#[test]
fn test_named_struct_debug_structure() {
    #[derive(Debug)]
    pub struct RefNamedStruct {
        pub inner: OhnoCore,
        pub code: i32,
        pub message: String,
    }

    #[derive(Error)]
    pub struct TestNamedStruct {
        #[error]
        pub inner: OhnoCore,
        pub code: i32,
        pub message: String,
    }

    let ref_struct = RefNamedStruct {
        inner: OhnoCore::from("test_error"),
        code: 404,
        message: "Not found".to_string(),
    };
    let ref_debug = format!("{ref_struct:?}").replace("RefNamedStruct", "TestNamedStruct");

    let test_struct = TestNamedStruct {
        inner: ref_struct.inner,
        code: ref_struct.code,
        message: ref_struct.message,
    };

    let test_debug = format!("{test_struct:?}");
    assert_eq!(ref_debug, test_debug);
}

#[test]
fn test_tuple_struct_debug_structure() {
    #[derive(Debug)]
    pub struct RefTupleStruct(pub OhnoCore, pub String, pub i32);

    #[derive(Error)]
    pub struct TestTupleStruct(#[error] pub OhnoCore, pub String, pub i32);

    let ref_struct = RefTupleStruct(OhnoCore::from("error_content"), "additional_info".to_string(), 42);

    let ref_debug = format!("{ref_struct:?}").replace("RefTupleStruct", "TestTupleStruct");

    let test_struct = TestTupleStruct(ref_struct.0, ref_struct.1, ref_struct.2);

    let test_debug = format!("{test_struct:?}");
    assert_eq!(ref_debug, test_debug);
}

#[test]
fn test_single_field_struct_debug_structure() {
    #[derive(Debug)]
    pub struct RefSingleField {
        pub value: OhnoCore,
    }

    #[derive(Error)]
    pub struct TestSingleField {
        #[error]
        pub value: OhnoCore,
    }

    let ref_struct = RefSingleField {
        value: OhnoCore::from("single_value"),
    };

    let ref_debug = format!("{ref_struct:?}").replace("RefSingleField", "TestSingleField");

    let test_struct = TestSingleField { value: ref_struct.value };

    let test_debug = format!("{test_struct:?}");
    assert_eq!(ref_debug, test_debug);
}

#[test]
fn test_struct_with_enum_field_debug_structure() {
    #[derive(Debug)]
    #[expect(dead_code, reason = "Test")]
    enum TestStatus {
        Ok,
        NotFound,
        Error(String),
    }

    #[derive(Debug)]
    struct RefEnumFieldStruct {
        error: OhnoCore,
        status: TestStatus,
    }

    #[derive(Error)]
    struct TestEnumFieldStruct {
        #[error]
        error: OhnoCore,
        status: TestStatus,
    }

    let ref_struct = RefEnumFieldStruct {
        error: OhnoCore::from("enum_error"),
        status: TestStatus::Error("fail".to_string()),
    };
    let ref_debug = format!("{ref_struct:?}").replace("RefEnumFieldStruct", "TestEnumFieldStruct");

    let test_struct = TestEnumFieldStruct {
        error: ref_struct.error,
        status: ref_struct.status,
    };
    let test_debug = format!("{test_struct:?}");
    assert_eq!(ref_debug, test_debug);
}