trivet 3.1.0

The trivet Parser Library
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
123
124
125
126
127
128
129
130

// Trivet
// Copyright (c) 2025 by Stacy Prowell.  All rights reserved.
// https://gitlab.com/binary-tools/trivet

//! Tests of the errors module.

use crate::errors;
use crate::errors::ParseError;
use crate::loc::Loc;
use std::error::Error as StdError;
use std::io::Error;
use std::io::ErrorKind;

#[test]
fn error() {
    // Simple error strings.
    let internal = Loc::Internal;
    let console = Loc::Console {
        line: 17,
        column: 21,
    };
    let file = Loc::File {
        name: "tom".to_string(),
        line: 17,
        column: 21,
    };
    let nfe = Error::from(ErrorKind::NotFound);
    let err = errors::error(internal, nfe);
    assert_eq!(err.to_string(), "(internal): entity not found");
    let nfe = Error::from(ErrorKind::NotFound);
    let err = errors::error(console, nfe);
    assert_eq!(err.to_string(), "17:21: entity not found");
    let nfe = Error::from(ErrorKind::NotFound);
    let err = errors::error(file, nfe);
    assert_eq!(err.to_string(), "tom:17:21: entity not found");

    // Nested error chain.
    let file = Loc::File {
        name: "tom".to_string(),
        line: 17,
        column: 21,
    };
    let nfe = Error::from(ErrorKind::NotFound);
    let err = errors::io_error(file, nfe);
    assert_eq!(err.to_string(), "tom:17:21: I/O Error: entity not found");

    // Checking cause.
    let internal = Loc::Internal;
    let nfe = Error::from(ErrorKind::NotFound);
    let err = errors::io_error(internal, nfe);
    let cause = err.source();
    assert_eq!(cause.unwrap().to_string(), "entity not found");
    let err = errors::unimplemented_error(Loc::Internal, "fire");
    assert!(err.source().is_none());
}

#[test]
fn types() {
    // Test all the error types except I/O error, tested above.
    let file = Loc::File {
        name: "tom".to_string(),
        line: 17,
        column: 21,
    };
    assert_eq!(
        errors::unexpected_eof_error(file.clone()).to_string(),
        "tom:17:21: I/O Error: Unexpected end of file"
    );
    assert_eq!(
        errors::syntax_error(file.clone(), "bad syntax").to_string(),
        "tom:17:21: Syntax Error: bad syntax"
    );
    assert_eq!(
        errors::unexpected_text_error(file.clone(), "a thing", "a different thing").to_string(),
        "tom:17:21: Expected a thing, but found a different thing"
    );
    assert_eq!(
        errors::unexpected_character_error(file.clone(), "ampersand", '&').to_string(),
        "tom:17:21: Expected ampersand, but found '&'"
    );
    assert_eq!(
        errors::internal_error(file.clone(), "hrung collapsed").to_string(),
        "tom:17:21: Internal Error: hrung collapsed"
    );
    assert_eq!(
        errors::not_found_error(file.clone(), "keys").to_string(),
        "tom:17:21: Could not find keys"
    );
    assert_eq!(
        errors::unimplemented_error(file.clone(), "cold fusion").to_string(),
        "tom:17:21: Not Implemented: cold fusion"
    );

    #[allow(invalid_from_utf8)]
    match std::str::from_utf8(b"\xc3\x28") {
        Ok(_) => {}
        Err(err) => {
            let pe = errors::error(file.clone(), err);
            assert_eq!(pe.loc(), &file);
            if let ParseError::Error { loc: _, cause } = pe {
                assert_eq!(
                    cause.to_string(),
                    "invalid utf-8 sequence of 1 bytes from index 0"
                )
            }
        }
    }
    assert_eq!(errors::unexpected_eof_error(file.clone()).loc(), &file);
    assert_eq!(
        errors::syntax_error(file.clone(), "bad syntax").loc(),
        &file
    );
    assert_eq!(
        errors::unexpected_text_error(file.clone(), "a thing", "a different thing").loc(),
        &file
    );
    assert_eq!(
        errors::unexpected_character_error(file.clone(), "ampersand", '&').loc(),
        &file
    );
    assert_eq!(
        errors::internal_error(file.clone(), "hrung collapsed").loc(),
        &file
    );
    assert_eq!(errors::not_found_error(file.clone(), "keys").loc(), &file);
    assert_eq!(
        errors::unimplemented_error(file.clone(), "cold fusion").loc(),
        &file
    );
}