         (assert (integer? (:line m)))
         (assert (nil? (:name m)))
         (assert (= '[x y] (:locals m)))))))
+
+(let [g (description :given [x 1 y 2]
+                     (= 1 x)
+                     "foo" (= y 2)
+                     (description (= y 2)))]
+  (assert (group? g))
+  (assert (= 2 (count (:contexts g))))
+  (let [exs (:examples g)]
+    (assert (vector? exs))
+    (assert (= 2 (count exs)))
+    (assert (every? fn? exs))
+    (let [[ex1 ex2] exs]
+      (assert (true? (ex1 1 2)))
+      (assert (true? (ex2 1 2)))
+      (let [m (meta ex1)]
+        (assert (nil? (:doc m)))
+        (assert (= *ns* (:ns m)))
+        (assert (string? (:file m)))
+        (assert (integer? (:line m)))
+        (assert (nil? (:name m)))
+        (assert (= '[x y] (:locals m))))
+      (let [m (meta ex2)]
+        (assert (= "foo" (:doc m)))
+        (assert (= *ns* (:ns m)))
+        (assert (string? (:file m)))
+        (assert (integer? (:line m)))
+        (assert (nil? (:name m)))
+        (assert (= '[x y] (:locals m))))))
+  (let [sgs (:subgroups g)]
+    (assert (= 1 (count sgs)))
+    (let [sg (first sgs)]
+      (assert (group? sg))
+      (assert (= 1 (count (:examples sg))))
+      (assert (= 2 (count (:contexts sg)))))))

            (every? group? subgroups)
            (or-nil map? metadata)]
      :post [(group? %)]}
     (Group. contexts examples nil metadata)))

(defmacro example
  "Creates an example function, using current context locals for

  Option :given is followed by a vector of symbol-expression pairs.
  All examples in the group will run with the symbol bound to the
  state returned by that expression."
  {::subgroup true}
  [& body]
  (let [[docstring body] (get-arg string? body)
        [opts body] (get-options body)
        givens (interleave (firsts (:given opts))
