   (is-not (p/public? fail))
   (is-not (p/public? private-defn)))
 
+
 (deftest private?-tests
   (is (p/private? private-defn))
   (is (p/private? private-def))
   (is-not (p/private? foo))
   (is-not (p/private? bar)))
 
+
 (def dynamic-defn
   (ast
    (defn ^:dynamic fred [x]
      (rand-int (mod x 4)))))
 
+
 (def dynamic-def
   (ast
    (def ^:dynamic *foo* nil)))
+
 
 (deftest dynamic?-test
   (is (p/dynamic? dynamic-defn))

   (defn foo [x]
     (inc x))))

(def bar
  (ast
   (def bar
     (fn [x] (dec x)))))

(def fail
  (ast
   (fn [] 1)))

(deftest def?-tests
  (is (p/def? foo))
  (is (p/def? bar))
  (is-not (p/def? fail)))

(deftest def->symbol-tests
  (is (= 'foo (p/def->symbol foo)))
  (is (= 'bar (p/def->symbol bar)))
  (is (nil? (p/def->symbol fail))))

(def private-defn
  (ast
   (defn ^:private baz [x]
     (* x x))))

(def private-def
  (ast
   (def ^:private quxx
     (fn [x] (mod x 2)))))

(deftest public?-tests
  (is (p/public? foo))

  (is-not (p/dynamic? bar))
  (is-not (p/dynamic? fail)))


(def const-defn
  (ast
   (defn ^:const corge [x]
     (/ x x))))


(def const-def
  (ast
   (def ^:const grault
     (fn [x] (- x 2)))))


(deftest const?-tests
  (is (p/const? const-defn))
