 
       defmacro optional_macro_callback(arg1, arg2), do: {arg1, arg2}
 
-      assert Module.overridable? __MODULE__, {:required_callback, 0}
-      assert Module.overridable? __MODULE__, {:optional_callback, 0}
-      assert Module.overridable? __MODULE__, {:required_macro_callback, 1}
-      refute Module.overridable? __MODULE__, {:optional_macro_callback, 1}
-      refute Module.overridable? __MODULE__, {:not_a_behaviour_callback, 1}
+      assert Module.overridable?(__MODULE__, {:required_callback, 0})
+      assert Module.overridable?(__MODULE__, {:optional_callback, 0})
+      assert Module.overridable?(__MODULE__, {:required_macro_callback, 1})
+      refute Module.overridable?(__MODULE__, {:optional_macro_callback, 1})
+      refute Module.overridable?(__MODULE__, {:not_a_behaviour_callback, 1})
     end
   end
 
   test "undefined module can't be passed as argument to defoverridable" do
-    message = "cannot pass module Kernel.OverridableTest.Bar as argument to defoverridable/1 because it was not defined"
-    assert_raise ArgumentError, message, fn ->
-      Code.eval_string """
+    message =
+      "cannot pass module Kernel.OverridableTest.Bar as argument to defoverridable/1 because it was not defined"
+
+    assert_raise ArgumentError, message, fn ->
+      Code.eval_string("""
       defmodule Kernel.OverridableTest.Foo do
         defoverridable Kernel.OverridableTest.Bar
       end
-      """
-    end
-    purge Kernel.OverridableTest.Foo
+      """)
+    end
+
+    purge(Kernel.OverridableTest.Foo)
   end
 
   test "module without @behaviour can't be passed as argument to defoverridable" do
-    message = "cannot pass module Kernel.OverridableExampleBehaviour as argument to defoverridable/1" <>
-              " because its corresponding behaviour is missing. Did you forget to add " <>
-              "@behaviour Kernel.OverridableExampleBehaviour?"
-    assert_raise ArgumentError, message, fn ->
-      Code.eval_string """
+    message =
+      "cannot pass module Kernel.OverridableExampleBehaviour as argument to defoverridable/1" <>
+        " because its corresponding behaviour is missing. Did you forget to add " <>
+        "@behaviour Kernel.OverridableExampleBehaviour?"
+
+    assert_raise ArgumentError, message, fn ->
+      Code.eval_string("""
       defmodule Kernel.OverridableTest.Foo do
         defoverridable Kernel.OverridableExampleBehaviour
       end
-      """
-    end
-    purge Kernel.OverridableTest.Foo
+      """)
+    end
+
+    purge(Kernel.OverridableTest.Foo)
   end
 
   test "module with no callbacks can't be passed as argument to defoverridable" do
-    message = "cannot pass module Kernel.OverridableTest.Bar as argument to defoverridable/1 because it does not define any callbacks"
-    assert_raise ArgumentError, message, fn ->
-      Code.eval_string """
+    message =
+      "cannot pass module Kernel.OverridableTest.Bar as argument to defoverridable/1 because it does not define any callbacks"
+
+    assert_raise ArgumentError, message, fn ->
+      Code.eval_string("""
       defmodule Kernel.OverridableTest.Bar do
       end
       defmodule Kernel.OverridableTest.Foo do
         @behaviour Kernel.OverridableTest.Bar
         defoverridable Kernel.OverridableTest.Bar
       end
-      """
-    end
-    purge Kernel.OverridableTest.Bar
-    purge Kernel.OverridableTest.Foo
+      """)
+    end
+
+    purge(Kernel.OverridableTest.Bar)
+    purge(Kernel.OverridableTest.Foo)
   end
 
   test "atom which is not a module can't be passed as argument to defoverridable" do
     message = "cannot pass module :abc as argument to defoverridable/1 because it was not defined"
-    assert_raise ArgumentError, message, fn ->
-      Code.eval_string """
+
+    assert_raise ArgumentError, message, fn ->
+      Code.eval_string("""
       defmodule Kernel.OverridableTest.Foo do
         defoverridable :abc
       end
-      """
-    end
-    purge Kernel.OverridableTest.Foo
+      """)
+    end
+
+    purge(Kernel.OverridableTest.Foo)
   end
 end

    13
  end

  defoverridable [sample: 0, with_super: 0, without_super: 0,
                  super_with_multiple_args: 2, many_clauses: 1]

  true = Module.overridable? __MODULE__, {:without_super, 0}
  true = Module.overridable? __MODULE__, {:with_super, 0}

  def without_super do
    :without_super

defmodule Kernel.OverridableExampleBehaviour do
  @callback required_callback :: any
  @callback optional_callback :: any
  @macrocallback required_macro_callback(arg :: any) :: Macro.t()
  @macrocallback optional_macro_callback(arg :: any, arg2 :: any) :: Macro.t()
  @optional_callbacks optional_callback: 0, optional_macro_callback: 1
end

