parser-test 0.3.3

Declarative tester for parsers
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

use std::fmt::Debug;

pub mod highlighter;

/// Parser output tokens should implement this trait
pub trait Token {
    type Rule;

    fn start(&self) -> usize;
    fn end(&self) -> usize;
    fn rule(&self) -> Self::Rule;
}

pub struct TestToken<R> {
    pub start: usize,
    pub end: usize,
    pub rule: R,
}

impl<R: Copy> Token for TestToken<R> {
    type Rule = R;

    fn start(&self) -> usize {
        self.start
    }
    fn end(&self) -> usize {
        self.end
    }
    fn rule(&self) -> Self::Rule {
        self.rule
    }
}

pub fn test<O, E, R>(output: O, expected: E, spans: &str) -> bool
    where O: IntoIterator,
          <O as IntoIterator>::Item: Token<Rule = R>,
          E: IntoIterator<Item = R>,
          R: Eq + Sized + Debug,
{
    let mut expected_spans = highlighter::Highlighter::new(spans);
    let mut expected = expected.into_iter();
    for actual_output in output {
        let expected_span = expected_spans.next().expect("Not enough spans defined");
        let expected_output = expected.next().expect("More output than expected");
        if actual_output.rule() != expected_output {
            panic!("Expected rule: {:?} got: {:?} at pos:{}",
                   expected_output,
                   actual_output.rule(),
                   actual_output.start()
            );
        }
        if actual_output.start() != expected_span.0 || actual_output.end() != expected_span.1 {
            panic!("Spans do not match on rule: {:?}: [{}, {}] vs [{}, {}]",
                   actual_output.rule(),
                   actual_output.start(),
                   actual_output.end(),
                   expected_span.0,
                   expected_span.1
            );
        }
    }
    assert!(expected.next().is_none(), "Expected more output");
    assert!(expected_spans.next().is_none(), "Defined more spans than expected rules");

    true
}