                          (keys bolt-to-comps))})
        bolts-with-comps))
 
-(defn benchmark [spec & [n]]
-  (let [n (or n 5)]
-    (doall (take n (repeatedly #(time (doall (do-counts (bolts-with-comps spec (medium) 0 6)))))))
-    nil))
-
 (defn benchmark1 []
   (benchmark spec1 5))
 


    (is (not (empty? (babel.generate/lightning-bolts med (get-in good-lb [:head :comp]) 0 0))))
    (is (not (empty? (babel.generate/lightning-bolts med (get-in good-lb [:comp]) 0 0))))))

(deftest nugent-testing
  (let [med (medium)
        spec {:synsem {:cat :verb
                       :sem {:pred :read
                             :subj {:pred :woman}}
                       :subcat '()}}
        bolts-and-comps (bolts-with-comps spec med 0 6)
        ; (def
        bolts-with-phrasal-head (filter #(and (not (nil? (get % [:head :comp])))
                                              (not (empty? (get % [:head :comp])))
                                              (not (empty? (get % [:comp]))))
                                        bolts-and-comps)
                                        ; )

;        (def
        fb (first bolts-with-phrasal-head)
        ; )
        ]
    (is (not (empty? bolts-and-comps)))))

(defn bolts-with-comps-is-slow []
  (let [med (medium)
        spec {:synsem {:cat :verb
                       :sem {:pred :read
                             :subj {:pred :woman}}
                       :subcat '()}}]
    (repeatedly (fn [] (time (type (first (filter #(and (not (empty? (get % [:head :comp])))
                                                        (not (empty? (get % [:comp]))))
                                                  (bolts-with-comps spec med 0 6)))))))))

;; lein test :only babel.test.en/bwc-slow
(deftest bwc-slow
  (is (= 1 (count (take 1 (bolts-with-comps-is-slow))))))

(deftest take-advantage-present
  (let [result (generate {:synsem {:sem {:pred :take-advantage-of

    ;; explicitly set to progressive present:
    (is (= "I am eating" (morph (generate progressive))))))

(deftest benchmark-test []
  (let [med (medium)
        to-run #(time (println (fo (generate
