4568677051

Build Type

push

github

Committed by Jeffrey Crocker

Commit Message

LLVM coverage reporting

Run Details

2125 of 2200 relevant lines covered (96.59%)

53550.13 hits per line

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

84.88

/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),
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            Error::ParseError(ref s) | Error::GenerateError(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_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!"));

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

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

shnewto / bnf / 4568677051

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