xdy 0.13.0

Complex RPG dice expression evaluator with histogram support.
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

//! # Recovery parity with the parser
//!
//! Herein are the differential tests of the parser's recovery mode over the
//! [corpus](super::corpus), which hold it to the ordinary parser.
//!
//! - With a policy that declines every repair, recovery mode must produce
//!   exactly the result of [`Parser::parse`], and must present exactly one
//!   failure for each input that fails to parse, whose error comprises the
//!   leading entries of the parser's error. This holds the detection of
//!   failures and the computation of their errors to the ordinary parse.
//! - With the [canonical](Canonical) policy, which repairs every failure that
//!   it can, the source with the edits of the repairs applied must parse, to
//!   the function that recovery mode produced. This holds the engine's
//!   continuation after each repair to what a parse of the edited source does.

use pretty_assertions::assert_eq;

use crate::{
	Parser,
	parser::{FailureSite, Recovery, Repair, Site},
	tests::{corpus::corpus, recovery::Canonical}
};

////////////////////////////////////////////////////////////////////////////////
//                                  Parity.                                   //
////////////////////////////////////////////////////////////////////////////////

/// A policy that declines every repair, and records the failures that it was
/// asked to repair.
///
/// # Type parameters
/// - `'src`: The lifetime of the source text.
#[derive(Debug, Default)]
struct Decline<'src>
{
	/// The failures.
	sites: Vec<FailureSite<'src>>
}

impl<'src> Recovery<'src> for Decline<'src>
{
	fn repair(&mut self, site: &FailureSite<'src>) -> Repair
	{
		self.sites.push(site.clone());
		Repair::Stop
	}
}

/// Ensure that, when its policy declines every repair, recovery mode matches
/// [`Parser::parse`] on every input in the corpus, and presents exactly one
/// failure for each input that fails, with the leading entries of the error.
#[test]
fn test_declining_recovery_matches_parse()
{
	for input in corpus()
	{
		let expected = Parser::parse(input);
		let mut policy = Decline::default();
		let actual = Parser::parse_recovering(input, &mut policy);
		assert_eq!(actual, expected, "input: {:?}", input);
		match expected
		{
			Ok(_) => assert_eq!(policy.sites, vec![], "input: {:?}", input),
			Err(error) =>
			{
				let position = error.errors[0].0.location_offset();
				let leading = error
					.errors
					.iter()
					.take_while(|(span, _)| span.location_offset() == position)
					.cloned()
					.collect::<Vec<_>>();
				assert_eq!(policy.sites.len(), 1, "input: {:?}", input);
				assert_eq!(
					policy.sites[0].error.errors, leading,
					"input: {:?}",
					input
				);
			}
		}
	}
}

/// Ensure that, for every input in the corpus, the source with the edits of
/// the [canonical](Canonical) policy's repairs applied parses to the function
/// that recovery mode produced. Only an input that begins with a comma, which
/// has no repair, may fail to recover.
#[test]
fn test_canonical_recovery_matches_edited_parse()
{
	for input in corpus()
	{
		let mut policy = Canonical::new(input);
		match Parser::parse_recovering(input, &mut policy)
		{
			Ok(recovered) =>
			{
				let corrected = policy.corrected();
				let parsed = Parser::parse(&corrected).unwrap_or_else(|e| {
					panic!(
						"input {:?} corrected to {:?}, which fails: {}",
						input, corrected, e
					)
				});
				assert_eq!(
					recovered.to_string(),
					parsed.to_string(),
					"input {:?} corrected to {:?}",
					input,
					corrected
				);
			},
			Err(_) => assert!(
				matches!(
					policy.sites.last(),
					Some(FailureSite {
						site: Site::LeadingComma,
						..
					})
				),
				"input {:?} failed to recover at {:?}",
				input,
				policy.sites.last()
			)
		}
	}
}