dyn_quantity_lexer 0.1.1

Lexer for crate dyn_quantity
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

use dyn_quantity_lexer::*;

#[test]
fn test_parse_degree() {
    {
        let mut lex = Token::lexer("90 deg");

        assert_eq!(lex.next(), Some(Ok(Token::Real(90.0))));

        assert_eq!(
            lex.next(),
            Some(Ok(Token::Degree(Exponents { unit: 1, prefix: 0 })))
        );
    }
    {
        let mut lex = Token::lexer("120 deg^-2");

        assert_eq!(lex.next(), Some(Ok(Token::Real(120.0))));

        assert_eq!(
            lex.next(),
            Some(Ok(Token::Degree(Exponents {
                unit: -2,
                prefix: 0
            })))
        );
    }
    {
        let mut lex = Token::lexer("120 Degree");

        assert_eq!(lex.next(), Some(Ok(Token::Real(120.0))));

        assert_eq!(
            lex.next(),
            Some(Ok(Token::Degree(Exponents { unit: 1, prefix: 0 })))
        );
    }
    {
        let mut lex = Token::lexer("120 degree");

        assert_eq!(lex.next(), Some(Ok(Token::Real(120.0))));

        assert_eq!(
            lex.next(),
            Some(Ok(Token::Degree(Exponents { unit: 1, prefix: 0 })))
        );
    }
    {
        let mut lex = Token::lexer("120 mdegree");

        // Read out the number
        assert_eq!(lex.next(), Some(Ok(Token::Real(120.0))));

        assert_eq!(
            lex.next(),
            Some(Ok(Token::Degree(Exponents {
                unit: 1,
                prefix: -3
            })))
        );
    }
    {
        let mut lex = Token::lexer("PI/2 degree^-3");

        // Read out the number
        assert_eq!(
            lex.next(),
            Some(Ok(Token::Pi(Exponents { unit: 1, prefix: 0 })))
        );
        assert_eq!(lex.next(), Some(Ok(Token::Div)));
        assert_eq!(lex.next(), Some(Ok(Token::Real(2.0))));
        assert_eq!(
            lex.next(),
            Some(Ok(Token::Degree(Exponents {
                unit: -3,
                prefix: 0
            })))
        );
    }
}

#[test]
fn test_parse_rad() {
    {
        let mut lex = Token::lexer("PI/2 rad^2");

        // Read out the number
        assert_eq!(
            lex.next(),
            Some(Ok(Token::Pi(Exponents { unit: 1, prefix: 0 })))
        );
        assert_eq!(lex.next(), Some(Ok(Token::Div)));
        assert_eq!(lex.next(), Some(Ok(Token::Real(2.0))));
        assert_eq!(
            lex.next(),
            Some(Ok(Token::Radians(Exponents { unit: 2, prefix: 0 })))
        );
    }
}