4152080470

Build # 4152080470

Build Type

push

github

Committed by GitHub

Commit Message

Traversal Trees (#120)

Run Details

349 of 349 new or added lines in 11 files covered. (100.0%)

1824 of 2003 relevant lines covered (91.06%)

510166.89 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

82.93

/src/error.rs

use std::error;
use std::fmt;
use std::str;

use nom::{
    error::{VerboseError, VerboseErrorKind},
    Err,
};

#[derive(PartialEq, Eq, Debug, Clone)]
pub enum Error {
    ParseError(String),
    GenerateError(String),
    RecursionLimit(String),
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            Error::ParseError(ref s)
            | Error::GenerateError(ref s)
            | Error::RecursionLimit(ref s) => write!(f, "{s}"),
        }
    }
}

impl error::Error for Error {
    fn description(&self) -> &str {
        "BNF error"
    }
}

impl<'a> From<VerboseError<(&'a str, VerboseErrorKind)>> for Error {
    fn from(err: VerboseError<(&str, VerboseErrorKind)>) -> Self {
        Error::ParseError(format!("Parsing error: {err:?}"))
    }
}

impl From<Err<VerboseError<&str>>> for Error {
    fn from(err: Err<VerboseError<&str>>) -> Self {
        Error::ParseError(format!("Parsing error: {err:?}"))
    }
}

impl<'a> From<(&'a str, VerboseErrorKind)> for Error {
    fn from(err: (&str, VerboseErrorKind)) -> Self {
        let string = format!("Parsing error: {:?}\n {:?}", err.1, err.0);
        Error::ParseError(string)
    }
}

#[cfg(test)]
mod tests {
    use crate::error::Error;
    use nom::{bytes::complete::tag, error::VerboseError, Err, IResult};

    fn give_error_kind(input: &str) -> IResult<&str, &str, VerboseError<&str>> {
        let (input, _) = tag("1234")(input)?;
        let (input, res) = tag("5678")(input)?;
        Ok((input, res))
    }

    #[test]
    fn gets_error_error() {
        let nom_result = give_error_kind("12340");
        let nom_error;
        match nom_result {
            Result::Err(e) => match e {
                Err::Error(_) => nom_error = e,
                _ => panic!("gets_error_error should result in IResult::Err(Err::Error(e))"),
            },
            _ => panic!("gets_error_error should result in IResult::Err"),
        }

        let bnf_error: Result<String, Error> = Err(Error::from(nom_error));

        assert!(
            bnf_error.is_err(),
            "production result should be error {bnf_error:?}"
        );

        match bnf_error.unwrap_err() {
            Error::ParseError(_) => (),
            e => panic!("production error should be error parsing: {e:?}"),
        }
    }

    #[test]
    fn gets_error_on_incomplete() {
        let nom_result = give_error_kind("");
        let nom_error = match nom_result {
            Result::Err(e) => e,
            _ => panic!("gets_error_error should result in IResult::Err"),
        };

        let bnf_error: Result<String, Error> = Err(Error::from(nom_error));

        assert!(
            bnf_error.is_err(),
            "production result should be error {bnf_error:?}"
        );
        match bnf_error.unwrap_err() {
            Error::ParseError(_) => (),
            e => panic!("production error should be parse error: {e:?}"),
        }
    }

    #[test]
    fn uses_error_recursion_limit() {
        let bnf_error = Error::RecursionLimit(String::from("reucrsion limit reached!"));
        match bnf_error {
            Error::RecursionLimit(_) => (),
            e => panic!("should match on reursion limit: {e:?}"),
        }
    }

    #[test]
    fn uses_error_generate() {
        let bnf_error = Error::GenerateError(String::from("error generating!"));
        match bnf_error {
            Error::GenerateError(_) => (),
            e => panic!("should match on generate error: {e:?}"),
        }
    }

    #[test]
    fn test_error_display() {
        let parse_error = Error::ParseError(String::from("parsing error!"));
        let generate_error = Error::GenerateError(String::from("error generating!"));
        let recursion_error = Error::RecursionLimit(String::from("recursion limit reached!"));

        assert_eq!(parse_error.to_string(), String::from("parsing error!"));
        assert_eq!(
            generate_error.to_string(),
            String::from("error generating!")
        );
        assert_eq!(
            recursion_error.to_string(),
            String::from("recursion limit reached!")
        );
    }

    #[test]
    fn from_nom_verbose_error() {
        let error = nom::error::VerboseError { errors: vec![] };
        let _ = Error::from(error);
    }

    #[test]
    fn from_str_and_nom_verbose_error_kind() {
        let description = "anything";
        let verbose_kind = nom::error::VerboseErrorKind::Char('z');
        let _ = Error::from((description, verbose_kind));
    }
}

1	use std::error;
2	use std::fmt;
3	use std::str;
4
5	use nom::{
6	error::{VerboseError, VerboseErrorKind},
7	Err,
8	};
9
10	#[derive(PartialEq, Eq, Debug, Clone)]	×
11	pub enum Error {
12	ParseError(String),	×
13	GenerateError(String),	×
14	RecursionLimit(String),	×
15	}
16
17	impl fmt::Display for Error {
18	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {	4✔
19	match *self {	4✔
20	Error::ParseError(ref s)	2✔
21	\| Error::GenerateError(ref s)	1✔
22	\| Error::RecursionLimit(ref s) => write!(f, "{s}"),	4✔
23	}
24	}	4✔
25	}
26
27	impl error::Error for Error {
28	fn description(&self) -> &str {	×
29	"BNF error"
30	}	×
31	}
32
33	impl<'a> From<VerboseError<(&'a str, VerboseErrorKind)>> for Error {
34	fn from(err: VerboseError<(&str, VerboseErrorKind)>) -> Self {	1✔
35	Error::ParseError(format!("Parsing error: {err:?}"))	1✔
36	}	1✔
37	}
38
39	impl From<Err<VerboseError<&str>>> for Error {
40	fn from(err: Err<VerboseError<&str>>) -> Self {	13✔
41	Error::ParseError(format!("Parsing error: {err:?}"))	13✔
42	}	13✔
43	}
44
45	impl<'a> From<(&'a str, VerboseErrorKind)> for Error {
46	fn from(err: (&str, VerboseErrorKind)) -> Self {	1✔
47	let string = format!("Parsing error: {:?}\n {:?}", err.1, err.0);	1✔
48	Error::ParseError(string)	1✔
49	}	1✔
50	}
51
52	#[cfg(test)]
53	mod tests {
54	use crate::error::Error;
55	use nom::{bytes::complete::tag, error::VerboseError, Err, IResult};
56
57	fn give_error_kind(input: &str) -> IResult<&str, &str, VerboseError<&str>> {	2✔
58	let (input, _) = tag("1234")(input)?;	2✔
59	let (input, res) = tag("5678")(input)?;	1✔
60	Ok((input, res))	×
61	}	2✔
62
63	#[test]
64	fn gets_error_error() {	2✔
65	let nom_result = give_error_kind("12340");	1✔
66	let nom_error;
67	match nom_result {	1✔
68	Result::Err(e) => match e {	1✔
69	Err::Error(_) => nom_error = e,	1✔
70	_ => panic!("gets_error_error should result in IResult::Err(Err::Error(e))"),	×
71	},
72	_ => panic!("gets_error_error should result in IResult::Err"),	×
73	}
74
75	let bnf_error: Result<String, Error> = Err(Error::from(nom_error));	1✔
76
77	assert!(	1✔
78	bnf_error.is_err(),	1✔
79	"production result should be error {bnf_error:?}"
80	);
81
82	match bnf_error.unwrap_err() {	1✔
83	Error::ParseError(_) => (),
84	e => panic!("production error should be error parsing: {e:?}"),	×
85	}
86	}	2✔
87
88	#[test]
89	fn gets_error_on_incomplete() {	2✔
90	let nom_result = give_error_kind("");	1✔
91	let nom_error = match nom_result {	1✔
92	Result::Err(e) => e,	1✔
93	_ => panic!("gets_error_error should result in IResult::Err"),	×
94	};
95
96	let bnf_error: Result<String, Error> = Err(Error::from(nom_error));	1✔
97
98	assert!(	1✔
99	bnf_error.is_err(),	1✔
100	"production result should be error {bnf_error:?}"
101	);
102	match bnf_error.unwrap_err() {	1✔
103	Error::ParseError(_) => (),
104	e => panic!("production error should be parse error: {e:?}"),	×
105	}
106	}	2✔
107
108	#[test]
109	fn uses_error_recursion_limit() {	2✔
110	let bnf_error = Error::RecursionLimit(String::from("reucrsion limit reached!"));	1✔
111	match bnf_error {	1✔
112	Error::RecursionLimit(_) => (),
113	e => panic!("should match on reursion limit: {e:?}"),	×
114	}
115	}	2✔
116
117	#[test]
118	fn uses_error_generate() {	2✔
119	let bnf_error = Error::GenerateError(String::from("error generating!"));	1✔
120	match bnf_error {	1✔
121	Error::GenerateError(_) => (),
122	e => panic!("should match on generate error: {e:?}"),	×
123	}
124	}	2✔
125
126	#[test]
127	fn test_error_display() {	2✔
128	let parse_error = Error::ParseError(String::from("parsing error!"));	1✔
129	let generate_error = Error::GenerateError(String::from("error generating!"));	1✔
130	let recursion_error = Error::RecursionLimit(String::from("recursion limit reached!"));	1✔
131
132	assert_eq!(parse_error.to_string(), String::from("parsing error!"));	1✔
133	assert_eq!(	1✔
134	generate_error.to_string(),	1✔
135	String::from("error generating!")	1✔
136	);
137	assert_eq!(	1✔
138	recursion_error.to_string(),	1✔
139	String::from("recursion limit reached!")	1✔
140	);
141	}	2✔
142
143	#[test]
144	fn from_nom_verbose_error() {	2✔
145	let error = nom::error::VerboseError { errors: vec![] };	1✔
146	let _ = Error::from(error);	1✔
147	}	2✔
148
149	#[test]
150	fn from_str_and_nom_verbose_error_kind() {	2✔
151	let description = "anything";	1✔
152	let verbose_kind = nom::error::VerboseErrorKind::Char('z');	1✔
153	let _ = Error::from((description, verbose_kind));	1✔
154	}	2✔
155	}

shnewto / bnf / 4152080470

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous