   This is useful when there are a set of setup callbacks or a set
   of functions that should be shared between test modules.
 
-  Once a case template is used, the regular functionality in
-  `ExUnit.Case` plus the functionality defined in the template
-  will become available.
+  Let's imagine that you create a `MyCase` module that calls `use
+  ExUnit.CaseTemplate`. When a test case module calls `use MyCase`, the
+  following things hold true:
+
+    * All the functionality that `MyCase` would have had available from
+      `use ExUnit.Case` is available (same as if `MyCase` called `use
+      ExUnit.Case` directly)
+
+    * All the functions and macros defined in `MyCase` are imported into
+      the test case
+
+    * The `setup` and `setup_all` callbacks that you define in `MyCase`
+      get used in the test case module
+
+  The options that you pass to `use MyCase` get also passed to `use
+  ExUnit.Case` under the hood. This means you can do things like `use
+  MyCase, async: true`. You can also access this options in `using/2`.
 
   ## Example
 


        test "truth" do
          assert true
        end
      end


  end

  @doc false
  # We inject this code in the module that calls "use MyTemplate".
  def __proxy__(module, opts) do
    quote do
      use ExUnit.Case, unquote(opts)
