src/vendor/pest/tests/grammar.rs

   1 // pest. Elegant, efficient grammars
   2 // Copyright (C) 2016  Dragoș Tiselice
   3 //
   4 // This Source Code Form is subject to the terms of the Mozilla Public
   5 // License, v. 2.0. If a copy of the MPL was not distributed with this
   6 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7
   8 #[macro_use]
   9 extern crate pest;
  10
  11 use pest::prelude::*;
  12
  13 impl_rdp! {
  14     grammar! {
  15         expr = _{ paren ~ expr? }
  16         paren = { ["("] ~ expr? ~ [")"] }
  17         rep_zero = { ["a"]* ~ eoi }
  18         rep_one = { ["a"]+ }
  19         opt = { ["a"]? }
  20         pres = { &["a"] }
  21         abs = { !(["a"] | ["b"]) ~ any }
  22         digit = { ['0'..'9'] }
  23         number = { ['0'..'9']+ }
  24         plus = { ["+"] }
  25         times = { ["*"] }
  26         power = { ["^"] }
  27
  28         expression = {
  29             { number }
  30             add = _{ plus }
  31             mul = { times }
  32             pow = {< power }
  33         }
  34
  35         whitespace = _{ [" "] }
  36     }
  37 }
  38
  39 #[test]
  40 fn basic() {
  41     let mut parser = Rdp::new(StringInput::new("(())((())())()"));
  42
  43     assert!(parser.expr());
  44     assert!(parser.end());
  45
  46     let queue = vec![
  47         Token::new(Rule::paren, 0, 4),
  48         Token::new(Rule::paren, 1, 3),
  49         Token::new(Rule::paren, 4, 12),
  50         Token::new(Rule::paren, 5, 9),
  51         Token::new(Rule::paren, 6, 8),
  52         Token::new(Rule::paren, 9, 11),
  53         Token::new(Rule::paren, 12, 14)
  54     ];
  55
  56     assert_eq!(parser.queue(), &queue);
  57 }
  58
  59 #[test]
  60 fn fail() {
  61     let mut parser = Rdp::new(StringInput::new("(())((())())("));
  62
  63     assert!(parser.expr());
  64     assert!(!parser.end());
  65
  66     let queue = vec![
  67         Token::new(Rule::paren, 0, 4),
  68         Token::new(Rule::paren, 1, 3),
  69         Token::new(Rule::paren, 4, 12),
  70         Token::new(Rule::paren, 5, 9),
  71         Token::new(Rule::paren, 6, 8),
  72         Token::new(Rule::paren, 9, 11)
  73     ];
  74
  75     assert_eq!(parser.queue(), &queue);
  76
  77     assert_eq!(parser.expected(), (vec![Rule::paren], 13));
  78 }
  79
  80 #[test]
  81 fn rep_zero_empty() {
  82     let mut parser = Rdp::new(StringInput::new(""));
  83
  84     assert!(parser.rep_zero());
  85
  86     let queue = vec![
  87         Token::new(Rule::rep_zero, 0, 0)
  88     ];
  89
  90     assert_eq!(parser.queue(), &queue);
  91 }
  92
  93 #[test]
  94 fn rep_zero_long() {
  95     let mut parser = Rdp::new(StringInput::new("aaaa"));
  96
  97     assert!(parser.rep_zero());
  98
  99     let queue = vec![
 100         Token::new(Rule::rep_zero, 0, 4)
 101     ];
 102
 103     assert_eq!(parser.queue(), &queue);
 104 }
 105
 106 #[test]
 107 fn rep_zero_wrong() {
 108     let mut parser = Rdp::new(StringInput::new("aaaab"));
 109
 110     assert!(!parser.rep_zero());
 111
 112     let queue = vec![];
 113
 114     assert_eq!(parser.queue(), &queue);
 115
 116     assert_eq!(parser.expected(), (vec![Rule::eoi], 4));
 117 }
 118
 119 #[test]
 120 fn rep_one_empty() {
 121     let mut parser = Rdp::new(StringInput::new(""));
 122
 123     assert!(!parser.rep_one());
 124
 125     let queue = vec![];
 126
 127     assert_eq!(parser.queue(), &queue);
 128
 129     assert_eq!(parser.expected(), (vec![Rule::rep_one], 0));
 130 }
 131
 132 #[test]
 133 fn rep_one_long() {
 134     let mut parser = Rdp::new(StringInput::new("aaaa"));
 135
 136     assert!(parser.rep_one());
 137     assert!(parser.end());
 138
 139     let queue = vec![
 140         Token::new(Rule::rep_one, 0, 4)
 141     ];
 142
 143     assert_eq!(parser.queue(), &queue);
 144 }
 145
 146 #[test]
 147 fn rep_one_wrong() {
 148     let mut parser = Rdp::new(StringInput::new("b"));
 149
 150     assert!(!parser.rep_one());
 151     assert!(!parser.end());
 152
 153     let queue = vec![];
 154
 155     assert_eq!(parser.queue(), &queue);
 156
 157     assert_eq!(parser.expected(), (vec![Rule::rep_one], 0));
 158 }
 159
 160 #[test]
 161 fn opt_empty() {
 162     let mut parser = Rdp::new(StringInput::new(""));
 163
 164     assert!(parser.opt());
 165     assert!(parser.end());
 166
 167     let queue = vec![
 168         Token::new(Rule::opt, 0, 0)
 169     ];
 170
 171     assert_eq!(parser.queue(), &queue);
 172 }
 173
 174 #[test]
 175 fn opt_right() {
 176     let mut parser = Rdp::new(StringInput::new("a"));
 177
 178     assert!(parser.opt());
 179     assert!(parser.end());
 180
 181     let queue = vec![
 182         Token::new(Rule::opt, 0, 1)
 183     ];
 184
 185     assert_eq!(parser.queue(), &queue);
 186 }
 187
 188 #[test]
 189 fn opt_wrong() {
 190     let mut parser = Rdp::new(StringInput::new("b"));
 191
 192     assert!(parser.opt());
 193     assert!(!parser.end());
 194
 195     let queue = vec![
 196         Token::new(Rule::opt, 0, 0)
 197     ];
 198
 199     assert_eq!(parser.queue(), &queue);
 200 }
 201
 202 #[test]
 203 fn pres_right() {
 204     let mut parser = Rdp::new(StringInput::new("a"));
 205
 206     assert!(parser.pres());
 207     assert!(!parser.end());
 208
 209     let queue = vec![
 210         Token::new(Rule::pres, 0, 0)
 211     ];
 212
 213     assert_eq!(parser.queue(), &queue);
 214 }
 215
 216 #[test]
 217 fn pres_wrong() {
 218     let mut parser = Rdp::new(StringInput::new("b"));
 219
 220     assert!(!parser.pres());
 221     assert!(!parser.end());
 222
 223     let queue = vec![];
 224
 225     assert_eq!(parser.queue(), &queue);
 226
 227     assert_eq!(parser.expected(), (vec![Rule::pres], 0));
 228 }
 229
 230 #[test]
 231 fn abs_right() {
 232     let mut parser = Rdp::new(StringInput::new("c"));
 233
 234     assert!(parser.abs());
 235     assert!(parser.end());
 236
 237     let queue = vec![
 238         Token::new(Rule::abs, 0, 1)
 239     ];
 240
 241     assert_eq!(parser.queue(), &queue);
 242 }
 243
 244 #[test]
 245 fn abs_wrong() {
 246     let mut parser = Rdp::new(StringInput::new("a"));
 247
 248     assert!(!parser.abs());
 249     assert!(!parser.end());
 250
 251     let queue = vec![];
 252
 253     assert_eq!(parser.queue(), &queue);
 254
 255     assert_eq!(parser.expected(), (vec![Rule::abs], 0));
 256 }
 257
 258 #[test]
 259 fn digit_right() {
 260     let mut parser = Rdp::new(StringInput::new("0"));
 261
 262     assert!(parser.digit());
 263     assert!(parser.end());
 264
 265     let queue = vec![
 266         Token::new(Rule::digit, 0, 1)
 267     ];
 268
 269     assert_eq!(parser.queue(), &queue);
 270 }
 271
 272 #[test]
 273 fn digit_wrong() {
 274     let mut parser = Rdp::new(StringInput::new("a"));
 275
 276     assert!(!parser.digit());
 277     assert!(!parser.end());
 278
 279     let queue = vec![];
 280
 281     assert_eq!(parser.queue(), &queue);
 282
 283     assert_eq!(parser.expected(), (vec![Rule::digit], 0));
 284 }
 285
 286 #[test]
 287 fn expression() {
 288     let mut parser = Rdp::new(StringInput::new("1+2+3*9^2^2+2"));
 289
 290     assert!(parser.expression());
 291     assert!(parser.end());
 292
 293     let queue = vec![
 294         Token::new(Rule::expression, 0, 13),
 295         Token::new(Rule::number, 0, 1),
 296         Token::new(Rule::plus, 1, 2),
 297         Token::new(Rule::number, 2, 3),
 298         Token::new(Rule::plus, 3, 4),
 299         Token::new(Rule::mul, 4, 11),
 300         Token::new(Rule::number, 4, 5),
 301         Token::new(Rule::times, 5, 6),
 302         Token::new(Rule::pow, 6, 11),
 303         Token::new(Rule::number, 6, 7),
 304         Token::new(Rule::power, 7, 8),
 305         Token::new(Rule::pow, 8, 11),
 306         Token::new(Rule::number, 8, 9),
 307         Token::new(Rule::power, 9, 10),
 308         Token::new(Rule::number, 10, 11),
 309         Token::new(Rule::plus, 11, 12),
 310         Token::new(Rule::number, 12, 13)
 311     ];
 312
 313     assert_eq!(parser.queue(), &queue);
 314 }
 315
 316 #[test]
 317 fn expression_spaced() {
 318     let mut parser = Rdp::new(StringInput::new("1 + 2 + 3 * 9^2^2 + 2"));
 319
 320     assert!(parser.expression());
 321     assert!(parser.end());
 322
 323     let queue = vec![
 324         Token::new(Rule::expression, 0, 21),
 325         Token::new(Rule::number, 0, 1),
 326         Token::new(Rule::plus, 2, 3),
 327         Token::new(Rule::number, 4, 5),
 328         Token::new(Rule::plus, 6, 7),
 329         Token::new(Rule::mul, 8, 17),
 330         Token::new(Rule::number, 8, 9),
 331         Token::new(Rule::times, 10, 11),
 332         Token::new(Rule::pow, 12, 17),
 333         Token::new(Rule::number, 12, 13),
 334         Token::new(Rule::power, 13, 14),
 335         Token::new(Rule::pow, 14, 17),
 336         Token::new(Rule::number, 14, 15),
 337         Token::new(Rule::power, 15, 16),
 338         Token::new(Rule::number, 16, 17),
 339         Token::new(Rule::plus, 18, 19),
 340         Token::new(Rule::number, 20, 21)
 341     ];
 342
 343     assert_eq!(parser.queue(), &queue);
 344 }
 345
 346 #[test]
 347 fn expression_space_after() {
 348     let mut parser = Rdp::new(StringInput::new("1 "));
 349
 350     assert!(parser.expression());
 351     assert!(!parser.end());
 352
 353     let queue = vec![
 354         Token::new(Rule::expression, 0, 1),
 355         Token::new(Rule::number, 0, 1)
 356     ];
 357
 358     assert_eq!(parser.queue(), &queue);
 359 }