         end
       end
 
-  By calling `use/2`, a hook called `__using__/1` will be invoked in
-  `ExUnit.Case` which will then do the proper setup.
-
-  Simply put, `use/2` translates to:
+  In this example, `ExUnit.Case.__using__/1` is called with the keyword list
+  `[async: true]` as its argument; `use/2` translates to:
 
       defmodule AssertionTest do
         require ExUnit.Case

      end

  However, do not provide `__using__/1` if all it does is to import,
  alias or require the module itself. For example, do not:

      defmodule MyModule do
        defmacro __using__(opts) do
          quote do
            import MyModule
          end
        end
      end

  In such cases, developers must just import or alias the module
  directly, allowing developers to customize those as they wish,
  without the indirection behind `use/2`.

  Finally, developers should also avoid defining functions inside
  the `__using__/1` callback, unless those functions are the default
  implementation of a previously defined `@callback`. In case you
  want to provide some existing functionality to the user module,
  please define it in a module which will be imported accordingly.
  """
  defmacro use(module, opts \\ []) do
    calls = Enum.map(expand_aliases(module, __CALLER__), fn

        end
      end

  `ExUnit.Case` will then define the `__using__/1` macro:

      defmodule ExUnit.Case do
        defmacro __using__(opts) do
          # do something with opts
          quote do
            # return some code to inject in the caller
          end
        end
      end

  ## Best practices

  `__using__/1` is typically used when there is a need to set some state (via
  module attributes) or callbacks (like `@before_compile`, see the documentation
  for `Module` for more information) into the caller.

  `__using__/1` may also be used to alias, require, or import functionality
  from different modules:

      defmodule MyModule do
