     (list x)
     x))
 
-;; duped from spec to avoid introducing public API
-(defn- ns-matcher
-  [ns-syms]
-  (let [ns-names (into #{} (map str) ns-syms)]
+(defn- sym-matcher
+  "Returns a fn that matches symbols that are either in syms,
+or whose namespace is in syms."
+  [syms]
+  (let [names (into #{} (map str) syms)]
     (fn [s]
-      (contains? ns-names (namespace s)))))
+      (or (contains? names (namespace s))
+          (contains? names (str s))))))
 
 (defn- sym->test-map
   [s]

:no-gen     unable to generate :args
:no-fn      unable to resolve fn to test
"
  ([sym-or-syms] (test sym-or-syms nil))
  ([sym-or-syms opts]
     (validate-opts opts)
     (->> (eduction
           (map sym->test-map)
           (collectionize sym-or-syms))
          (pmap #(test-1 % opts)))))

(defn test-ns
  "Like test, but scoped to specific namespaces, or to
*ns* if no arg specified."
  ([] (test-ns (.name ^clojure.lang.Namespace *ns*)))
  ([ns-or-nses] (test-ns ns-or-nses nil))
  ([ns-or-nses opts]
     (validate-opts opts)
     (let [ns-match? (ns-matcher (collectionize ns-or-nses))]
       (->> (eduction
             (filter symbol?)
             (filter ns-match?)
             (map sym->test-map)
             (keys (s/registry)))
            (pmap #(test-1 % opts))))))

(defn test-all
  "Like test, but tests all vars named by fn-specs in the spec
registry."
  ([] (test-all nil))
  ([opts]
     (validate-opts opts)
     (->> (eduction
           (filter symbol?)
           (map sym->test-map)
           (keys (s/registry)))
          (pmap #(test-1 % opts)))))

(defn abbrev-result
  "Given a test result, returns an abbreviated version

     (test-1 {:f f :spec spec} opts)))

(defn test
  "Checks specs for vars named by syms using test.check.

The opts map includes the following optional keys, where stc
aliases clojure.spec.test.check: 
