                                        :mod {:pred :difficile}
                                        :number :sing
                                        :pred :donna}}}
-                       :model (np-grammar))]
+                       :model np-grammar)]
     (is (or (= (morph expr) "la donna difficile")
             (= (morph expr) "la difficile donna")))
     (is (not (empty? (reduce concat (map
-                                     :parses (parse (morph expr) (np-grammar)))))))))
+                                     :parses (parse (morph expr) np-grammar))))))))
 
 (deftest forbid-mispelling
- (is (empty? (:parses (parse (morph "la donna difficila") (np-grammar))))))
+ (is (empty? (:parses (parse (morph "la donna difficila") np-grammar)))))
 
 (deftest generate-and-parse-noun-phrase-with-specifier
   ;; create a noun phrase where the determiner is "ventotto", but the head of the noun phrase
   ;; might be anything.
   (let [result (generate {:synsem {:sem {:spec {:def :twentyeight}}}}
-                         :model (np-grammar))]
+                         :model np-grammar)]
     (is (not (= "" (morph result))))
     (is (= :twentyeight (get-in result [:synsem :sem :spec :def])))
     (is (not (empty? (parse (morph result)))))))

                                        ;; generic spec to something more specific
                                        ;; if this test fails and you want to investigate
                                        ;; why.
                                        :model (np-grammar))))]
    (is (= do-this-many
           (count (map-fn (fn [expr] 
                            (let [surface (morph expr)
                                  parsed (reduce concat (map :parses
                                                             (parse surface (np-grammar))))]
                              (if (not (empty? parsed))
                                (log/info (str "parse OK:" surface))
                                (log/error (str "parse failed: " surface)))

                           #(generate {:synsem {:cat :verb
                                                :sem {:tense :future}
                                                :subcat '()}}
                                      :model small)))]
    (is (= do-this-many
           (count (map-fn (fn [expr]
                          (let [surface (morph expr)
