ohno 0.3.4 

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

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

//! Test for derive Error support on tuple structs

#![cfg(feature = "test-util")]

use std::error::Error as StdError;

use ohno::{Error, OhnoCore, assert_error_message};

#[derive(Error)]
struct SimpleTupleError(#[error] OhnoCore);

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

#[derive(Error)]
struct TupleErrorAutoDetect(OhnoCore);

#[derive(Error)]
#[from(std::io::Error, std::fmt::Error)]
struct TupleErrorWithFrom(#[error] OhnoCore);

#[test]
fn test_simple_tuple_error() {
    let error = SimpleTupleError(OhnoCore::from("test error"));
    assert!(error.to_string().contains("test error"));
}

#[test]
fn test_tuple_error_with_fields() {
    let error = TupleErrorWithFields("operation".to_string(), 42, OhnoCore::from("failed"));

    // Access the fields to verify they work
    assert_eq!(error.0, "operation");
    assert_eq!(error.1, 42);
    assert!(error.to_string().contains("failed"));
}

#[test]
fn test_tuple_error_auto_detect() {
    let error = TupleErrorAutoDetect(OhnoCore::from("auto detected"));
    assert!(error.to_string().contains("auto detected"));
}

#[test]
fn test_tuple_error_source() {
    let io_error = std::io::Error::new(std::io::ErrorKind::NotFound, "file not found");
    let error = SimpleTupleError(OhnoCore::from(io_error));

    assert!(error.source().is_some());
}

#[test]
fn test_tuple_error_constructors() {
    // Test new() method
    let error1 = SimpleTupleError::new();
    assert!(error1.to_string().contains("SimpleTupleError"));

    // Test caused_by() method
    let error2 = SimpleTupleError::caused_by("test error");
    assert!(error2.to_string().contains("test error"));
}

#[test]
fn test_tuple_error_with_fields_constructors() {
    // Test new() method with multiple fields
    let error1 = TupleErrorWithFields::new("operation", 42);
    assert!(error1.to_string().contains("TupleErrorWithFields"));

    // Test caused_by() method with multiple fields
    let error2 = TupleErrorWithFields::caused_by("operation", 42, "custom error");
    assert!(error2.to_string().contains("custom error"));
}

#[test]
fn test_tuple_add_enrichment() {
    use ohno::Enrichable;

    let mut error = SimpleTupleError(OhnoCore::from("test"));
    error.add_enrichment(ohno::EnrichmentEntry::new("enrichment message", "test.rs", 80));
    let msg = error.to_string();
    assert!(msg.starts_with("test"), "{msg}");
    assert!(msg.contains("enrichment message (at test.rs:80)"), "{msg}");
}

#[test]
fn test_tuple_error_from_implementations() {
    use std::io;

    // Test From<std::io::Error>
    let io_error = io::Error::new(io::ErrorKind::NotFound, "file not found");
    let error: TupleErrorWithFrom = io_error.into();
    assert_error_message!(error, "file not found");

    // Test From<std::fmt::Error>
    let fmt_error = std::fmt::Error;
    let error: TupleErrorWithFrom = fmt_error.into();
    println!("Error: {error}");
    assert_error_message!(error, "an error occurred when formatting an argument");
}