error_tools 0.32.0

Basic exceptions handling mechanism
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

//! ## Test Matrix for `ErrWith` Trait Coverage
//!
//! | ID   | Scenario                               | Expected Behavior                               |
//! |------|----------------------------------------|-------------------------------------------------|
//! | T8.1 | `err_with` on `Ok` result              | Returns `Ok` with original value                |
//! | T8.2 | `err_with` on `Err` result             | Returns `Err` with custom report and original error |
//! | T8.3 | `err_with_report` on `Ok` result       | Returns `Ok` with original value                |
//! | T8.4 | `err_with_report` on `Err` result      | Returns `Err` with cloned report and original error |
//! | T8.5 | `ResultWithReport` type alias usage    | Correctly defines a Result with tuple error     |
//!
use super::*;
use error_tools::error::{ErrWith, ResultWithReport};
use std::io;

/// Tests `err_with` on an `Ok` result.
/// Test Combination: T8.1
#[ test ]
fn test_err_with_on_ok() {
  let result: core::result::Result<u32, io::Error> = core::result::Result::Ok(10);
  let processed: core::result::Result<u32, (String, io::Error)> = result.err_with(|| "context".to_string());
  assert!(processed.is_ok());
  assert_eq!(processed.unwrap(), 10);
}

/// Tests `err_with` on an `Err` result.
/// Test Combination: T8.2
#[ test ]
fn test_err_with_on_err() {
  let error = io::Error::new(io::ErrorKind::NotFound, "file not found");
  let result: core::result::Result<u32, io::Error> = core::result::Result::Err(error);
  let processed: core::result::Result<u32, (String, io::Error)> = result.err_with(|| "custom report".to_string());
  assert_eq!(
    processed.map_err(|(r, e): (String, io::Error)| (r, e.kind(), e.to_string())),
    core::result::Result::Err((
      "custom report".to_string(),
      io::ErrorKind::NotFound,
      "file not found".to_string()
    ))
  );
}

/// Tests `err_with_report` on an `Ok` result.
/// Test Combination: T8.3
#[ test ]
fn test_err_with_report_on_ok() {
  let result: core::result::Result<u32, io::Error> = core::result::Result::Ok(20);
  let report = "fixed report".to_string();
  let processed: core::result::Result<u32, (String, io::Error)> = result.err_with_report(&report);
  assert!(processed.is_ok());
  assert_eq!(processed.unwrap(), 20);
}

/// Tests `err_with_report` on an `Err` result.
/// Test Combination: T8.4
#[ test ]
fn test_err_with_report_on_err() {
  let error = io::Error::new(io::ErrorKind::PermissionDenied, "access denied");
  let result: core::result::Result<u32, io::Error> = core::result::Result::Err(error);
  let report = "security issue".to_string();
  let processed: core::result::Result<u32, (String, io::Error)> = result.err_with_report(&report);
  assert_eq!(
    processed.map_err(|(r, e): (String, io::Error)| (r, e.kind(), e.to_string())),
    core::result::Result::Err((
      "security issue".to_string(),
      io::ErrorKind::PermissionDenied,
      "access denied".to_string()
    ))
  );
}

/// Tests `ResultWithReport` type alias usage.
/// Test Combination: T8.5
#[ test ]
fn test_result_with_report_alias() {
  type MyResult = ResultWithReport<String, io::Error>;
  let ok_val: MyResult = core::result::Result::Ok("30".to_string());
  assert!(ok_val.is_ok());
  assert_eq!(ok_val.unwrap(), "30".to_string());

  let err_val: MyResult =
    core::result::Result::Err(("report".to_string(), io::Error::new(io::ErrorKind::BrokenPipe, "pipe broken")));
  assert_eq!(
    err_val.map_err(|(r, e): (String, io::Error)| (r, e.kind(), e.to_string())),
    core::result::Result::Err(("report".to_string(), io::ErrorKind::BrokenPipe, "pipe broken".to_string()))
  );
}