; This file contains a test function and test cases
;   for CS 152, Fall 2006, Assignment 4.


            
; This function converts rules to strings,
;   while leaving other types of arguments 
;   unchanged (so in particular, strings
;   remain strings).

(define (maybe-rule->string r)
  (if (rule? r) (rule->string r) r))


; A test function for Assignment 4, CS 152, Fall 2006

(define (test)
  (for-each (lambda (x) (print(eval x)) (newline) (newline))
            test-cases))


; Test cases for Assignment 4, CS 152, Fall 2006

(define test-cases
  '((maybe-rule->string (build-rule 'S '(NP VP)))
    (maybe-rule->string (build-rule 'NP '(Det N)))
    (maybe-rule->string (build-rule 'NP '("kim")))
    (maybe-rule->string (build-rule 'VP '(V NP)))
    (maybe-rule->string (build-rule 'Det '(a)))
    (maybe-rule->string (build-rule 'Det '()))
    (maybe-rule->string (build-rule 'N '(boy)))
    (maybe-rule->string (build-rule 'N 'girl))
    (maybe-rule->string (build-rule 'V '(likes)))
    (maybe-rule->string (build-rule "V" '(saw)))

    (build-grammar 'S 'x)
    (build-grammar 
     "S"
     (list 
      (build-rule 'S '(x))
      (build-rule 'S '(x S S))))
    
    (find-first #t)      
    
    (define g0 
      (build-grammar 'S
       (list
        (build-rule 'S '(NP VP))
        (build-rule 'NP '(Det N))
        (build-rule 'NP '("kim"))
        (build-rule 'VP '(V NP))
        (build-rule 'Det '(a))
        (build-rule 'Det '())
        (build-rule 'N '(boy))
        (build-rule 'N 'girl)
        (build-rule 'V '(likes))
        (build-rule "V" '(saw)))))
    (find-first g0)
                                       
    
    (define g1 
      (build-grammar 'E
       (list                                     
        (build-rule 'E '())                    
        (build-rule 'E '(Opd))                    
        (build-rule 'E '(~ E))                    
        (build-rule 'E '( < E Op E >))                    
        (build-rule 'Op '(^))            
        (build-rule 'Op '(v))                   
        (build-rule 'Opd '(T))                    
        (build-rule 'Opd '(F))                 
        (build-rule 'Opd '(true))                   
        (build-rule 'Opd '(false))
        (build-rule 'Opd '(T)))))                    
    (find-first g1)                  
                                        
    
    (define g2 (build-grammar 'E
      (list                        
       (build-rule 'Op '(+))                    
       (build-rule 'Op '(-))                    
       (build-rule 'Opd '(x))                    
       (build-rule 'Opd '(y))   
       (build-rule 'E '(E Op E))                    
       (build-rule 'E '(Opd )))))
    (find-first g2)                 
                                        
    
    
    (define g3 (build-grammar 'S  
      (list
       (build-rule 'S '(x = y))
       (build-rule 'S '(if T then S))                    
       (build-rule 'S '(if T then S else S))                    
       (build-rule 'T '(x < y)))))
    (find-first g3)                  
                                         
    
    (define g4 (build-grammar 'S 
      (list
       (build-rule 'S '(a S a))
       (build-rule 'S '(b S b))
       (build-rule 'S '(a))                    
       (build-rule 'S '(b)))))                    
    (find-first g4)             
    
    
  (define g5 (build-grammar 'S  
    (list
      (build-rule 'S '(a S a))
      (build-rule 'S '(b S b))                    
      (build-rule 'S '(a a))                    
      (build-rule 'S '(b b))                    
      (build-rule 'S '(a))                    
      (build-rule 'S '(b)))))                    
  (find-first g5)                 
                                       
   
  (define g6 (build-grammar 'S
    (list
      (build-rule 'V '(like))
      (build-rule 'V '(flies))
      (build-rule 'P '(like))
      (build-rule 'Det '(an))
      (build-rule 'N '(time))                  
      (build-rule 'N '(flies))                   
      (build-rule 'N '(arrow))
      (build-rule 'S '(NP VP))
      (build-rule 'NP '(Det N))
      (build-rule 'NP '(N N))                   
      (build-rule 'NP '(N))
      (build-rule 'VP '(V NP))
      (build-rule 'VP '(V PP))
      (build-rule 'PP '(P NP)))))
   (find-first g6)     
   

 (define g7 (build-grammar 'S
     (list
       (build-rule 'S '(NP VP))
       (build-rule 'NP '(Det N))
       (build-rule 'VP '(VI)) 
       (build-rule 'VP '(VT NP))
       (build-rule 'Det '(the))
       (build-rule 'N '(boy))                    
       (build-rule 'N '(girl))                    
       (build-rule 'VI '(arrived))
       (build-rule 'VT '(liked)) 
       (build-rule 'VI '(sneezed)) 
       (build-rule 'VT '(saw)))))
  (find-first g7)                 
  

  (define g8 (build-grammar 'S
    (list             
      (build-rule 'S '(NP VP))
      (build-rule 'NP '(Det N))
      (build-rule 'VP '(VI))
      (build-rule 'VP '(VT NP))
      (build-rule 'Det '(the))
      (build-rule 'N '(boy))
      (build-rule 'N '(girl))                    
      (build-rule 'VI '(arrived))
      (build-rule 'VI '(arrived))
      (build-rule 'VT '(liked))
      (build-rule 'VI '(sneezed)) 
      (build-rule 'VT '(saw))))) 
  (find-first g8)                  
  

  (define g9 (build-grammar 'S
    (list                       
      (build-rule 'S '(NP VP))
      (build-rule 'NP '(Det N))
      (build-rule 'VP '(VI))
      (build-rule 'VP '(VT NP))
      (build-rule 'Det '(the))
      (build-rule 'N '(boy))
      (build-rule 'N '(girl))                    
      (build-rule 'VI '(arrived))
      (build-rule 'VT '(liked)) 
      (build-rule 'VI '(smelled)) 
      (build-rule 'VT '(smelled)))))
  (find-first g9)
    
  
  (define g10 (build-grammar 'S
    (list
      (build-rule 'S '(x))
      (build-rule 'S '(x S S)))))
  (find-first g10)
                      
      
  (define g11 (build-grammar 'Statement
    (list                        
      (build-rule 'Statement '(AssignmentStatement))
      (build-rule 'Statement '(ForStatement))
      (build-rule 'Statement '(Declaration))
      (build-rule 'AssignmentStatement '(Variable := Expression))
      (build-rule 'ForStatement '(for Variable in Range))
      (build-rule 'Declaration '(TypeName Variable))
      (build-rule 'Variable '(identifier))
      (build-rule 'TypeName '(identifier)))))
  (find-first g11) 
                     
  (define g13 (build-grammar 'S 
    (list
      (build-rule 'S '(NP VP))
      (build-rule 'VP '(V NP))
      (build-rule 'NP '(Det N))
      (build-rule 'Det '(the))
      (build-rule 'Det '(NP \'s))
      (build-rule 'N '(professor))
      (build-rule 'N '(student))
      (build-rule 'N '(dog))               
      (build-rule 'V '(liked))
      (build-rule 'V '(saw)))))
  (find-first g13)
    
  (define g14 (build-grammar 'A  
    (list                         
      (build-rule 'A '(B))
      (build-rule 'E '(e))
      (build-rule 'B '(C))
      (build-rule 'F '(f))
      (build-rule 'C '(D E))
      (build-rule 'D '(A F)))))
  (find-first g14)
))