 (deftest parse-with-boot-stem
   (is (not (empty? (:parses (first (parse "lei esce")))))))
 
-;; roundtrip parser testing
-(defn roundtrip-parsing [n]
-  (take n
-        (repeatedly #(let [generated
-                           (morph (generate {:synsem {:cat :verb
-                                                      :subcat []}}))
-                           parsed (reduce concat (map :parses (parse generated)))]
-                       (log/info (str "generated: " generated))
-                       (log/info (str "semantics: "
-                                      (or
-                                       (strip-refs
-                                        (get-in (first parsed)
-                                                [:synsem :sem]))
-                                       (str "NO PARSE FOUND FOR: " generated))))
-                       {:generated generated
-                        :pred (get-in (first parsed) [:synsem :sem :pred])
-                        :subj (get-in (first parsed) [:synsem :sem :subj :pred])}))))
-
-(defn ps-tree [tree morph]
-  "return just the essentials of a tree: just rule names and surface forms at leaves."
-  (let [rule (get-in tree [:rule])
-        head (get-in tree [:head])
-        comp (get-in tree [:comp])]
-    (if (and head comp rule)
-      (conj {:rule rule}
-            {:head (ps-tree head morph)
-             :comp (ps-tree comp morph)})
-      (morph tree))))
-
 ;; should fail fast: instead seems to run forever.
 (deftest difficult-generate
   (let [synsem

                `[(log/info (str "done with test: " ~test-name))])]
    `(realtest/deftest ~test-name ~@wrapped-arguments)))


;; (repeatedly #(println (morph (time (generate reflexive-passato-is-slow)))))


(deftest casa-parse
  (is (not (empty?
            (reduce concat (map :parses (parse "io sono a casa")))))))

(deftest gestiscono
  (let [result
