tests.lisp

   1
   2 (defpackage :lalr-parser-generator-tests
   3   (:use :cl :rt :lalr-parser-generator))
   4
   5 (in-package :lalr-parser-generator-tests)
   6
   7
   8 ;;;; LR(0) GRAMMARS
   9
  10 #| (defparameter *lr0-test-grammar*
  11 '(sentence ((open list close)
  12 (variable))
  13 list ((sentence)
  14 (list comma sentence)))) |#
  15
  16 ;; Basic parsing test.
  17 (deftest lr0-grammar.1
  18     (let ((input "open variable comma open open variable close comma variable close close"))
  19       (lalr-parser-generator::test-parser '(sentence ((open list close)
  20                                                       (variable))
  21                                             list ((sentence)
  22                                                   (list comma sentence)))
  23                                           input))
  24   (SENTENCE
  25    (OPEN)
  26    (LIST
  27     (LIST (SENTENCE (VARIABLE)))
  28     (COMMA)
  29     (SENTENCE (OPEN)
  30               (LIST (LIST
  31                      (SENTENCE (OPEN)
  32                                (LIST (SENTENCE (VARIABLE)))
  33                                (CLOSE)))
  34                     (COMMA)
  35                     (SENTENCE (VARIABLE)))
  36               (CLOSE)))
  37    (CLOSE)))
  38
  39 ;; Test for failure: parse errors.
  40 (deftest lr0-grammar.2
  41     (let ((input "open"))
  42       (handler-case
  43           (lalr-parser-generator::test-parser '(sentence ((open list close)
  44                                                           (variable))
  45                                                 list ((sentence)
  46                                                       (list comma sentence)))
  47                                               input)
  48         (simple-error () t)))
  49   t)
  50
  51 (deftest lr0-grammar.3
  52     (let ((input "open variable comma open open variable close comma variable close close open"))
  53       (handler-case
  54           (lalr-parser-generator::test-parser '(sentence ((open list close)
  55                                                           (variable))
  56                                                 list ((sentence)
  57                                                       (list comma sentence)))
  58                                               input)
  59         (simple-error () t)))
  60   t)
  61
  62
  63 #| (defparameter *slr-test-grammar*
  64   '(E ((T + E) (T))
  65     T ((x)))) |#
  66
  67 (deftest slr-grammar.1
  68     (let ((input "x + x + x"))
  69       (lalr-parser-generator::test-parser '(E ((T + E) (T))
  70                                             T ((x)))
  71                                           input))
  72   (E (T (x)) (+) (E (T (x)) (+) (E (T (x))))))
  73
  74 #| (defparameter *simple-nullable-test-grammar*
  75   '(Z ((d)
  76        (X Y Z))
  77     Y (nil
  78        (c))
  79     X ((Y)
  80        (a)))) |#
  81
  82 ;; XXX has shift/reduce conflicts
  83 (deftest nullable-grammar.1
  84     (let ((input "a d"))
  85       (handler-bind ((warning #'muffle-warning))
  86         (lalr-parser-generator::test-parser '(Z ((d) (X Y Z))
  87                                               Y (nil (c))
  88                                               X ((Y) (a)))
  89                                             input)))
  90   (Z (X (A)) (Y) (Z (D))))
  91
  92 #|
  93 (defparameter *simple-lalr-test-grammar*
  94   '(S ((E))
  95     E ((E - T) (T))
  96     T ((n) (OPEN E CLOSE))))
  97  |#
  98
  99 (deftest lalr-grammar.1
 100     (let ((input "open n - open n close - n close - open n close"))
 101       (lalr-parser-generator::test-parser '(S ((E))
 102                                             E ((E - T) (T))
 103                                             T ((n) (OPEN E CLOSE)))
 104                                           input))
 105   (S (E (E
 106          (T (OPEN)
 107             (E (E (E (T (N))) (-) (T (OPEN) (E (T (N))) (CLOSE))) (-) (T (N)))
 108             (CLOSE)))
 109         (-)
 110         (T (OPEN) (E (T (N))) (CLOSE)))))
 111
 112 #|
 113 (defparameter *nicer-looking-test-grammar*
 114 "S = E
 115  E = E - T
 116    | T
 117
 118  T = n
 119    | ( E )")
 120  |#
 121
 122
 123 ;;;; MISC. FAILURE CONDITIONS
 124
 125 ;; Test for failure: bad terminal.
 126 (deftest test-for-failure.1
 127     (let ((input "not-a-terminal"))
 128       (handler-case
 129           (lalr-parser-generator::test-parser '(sentence ((variable))) input)
 130         (simple-error () t)))
 131   t)
 132
 133 ;; Expected shift-reduce conflict.
 134
 135 ;; Expected reduce-reduce conflict.
 136
 137 ;;;; MAKE-PARSER
 138
 139 ;; test make-parser by evaluating its output etc
 140
 141 ;;;; STRESS TESTS
 142
 143 ;; Stress test with random sentence generation.