     test "imports a module only if available" do
       assert "nil" == capture_iex("import_if_available NoSuchModule")
       assert "[1, 2, 3]" == capture_iex("import_if_available Integer; digits 123")
-      assert "[1, 2, 3]" == capture_iex("import_if_available Integer, only: [digits: 1]; digits 123")
+
+      assert "[1, 2, 3]" ==
+               capture_iex("import_if_available Integer, only: [digits: 1]; digits 123")
     end
   end
 
   describe "c" do
     test "compiles a file" do
       assert_raise UndefinedFunctionError, ~r"function Sample\.run/0 is undefined", fn ->
-        Sample.run
+        Sample.run()
       end
 
       filename = "sample.ex"
-      with_file filename, test_module_code(), fn ->
+
+      with_file(filename, test_module_code(), fn ->
         assert c(Path.expand(filename)) == [Sample]
         refute File.exists?("Elixir.Sample.beam")
-        assert Sample.run == :run
-      end
+        assert Sample.run() == :run
+      end)
     after
       cleanup_modules([Sample])
     end
 
     test "handles errors" do
-      ExUnit.CaptureIO.capture_io fn ->
-        with_file "sample.ex", "raise \"oops\"", fn ->
+      ExUnit.CaptureIO.capture_io(fn ->
+        with_file("sample.ex", "raise \"oops\"", fn ->
           assert_raise CompileError, fn -> c("sample.ex") end
-        end
-      end
+        end)
+      end)
     end
 
     test "compiles a file with multiple modules " do
       assert_raise UndefinedFunctionError, ~r"function Sample.run/0 is undefined", fn ->
-        Sample.run
+        Sample.run()
       end
 
       filename = "sample.ex"
-      with_file filename, test_module_code() <> "\n" <> another_test_module(), fn ->
-        assert c(filename) |> Enum.sort == [Sample, Sample2]
-        assert Sample.run == :run
-        assert Sample2.hello == :world
-      end
+
+      with_file(filename, test_module_code() <> "\n" <> another_test_module(), fn ->
+        assert c(filename) |> Enum.sort() == [Sample, Sample2]
+        assert Sample.run() == :run
+        assert Sample2.hello() == :world
+      end)
     after
       cleanup_modules([Sample, Sample2])
     end
 
     test "compiles multiple modules" do
       assert_raise UndefinedFunctionError, ~r"function Sample.run/0 is undefined", fn ->
-        Sample.run
+        Sample.run()
       end
 
       filenames = ["sample1.ex", "sample2.ex"]
-      with_file filenames, [test_module_code(), another_test_module()], fn ->
-        assert c(filenames) |> Enum.sort == [Sample, Sample2]
-        assert Sample.run == :run
-        assert Sample2.hello == :world
-      end
+
+      with_file(filenames, [test_module_code(), another_test_module()], fn ->
+        assert c(filenames) |> Enum.sort() == [Sample, Sample2]
+        assert Sample.run() == :run
+        assert Sample2.hello() == :world
+      end)
     after
       cleanup_modules([Sample, Sample2])
     end
 
     test "compiles Erlang modules" do
       assert_raise UndefinedFunctionError, ~r"function :sample.hello/0 is undefined", fn ->
-        :sample.hello
+        :sample.hello()
       end
 
       filename = "sample.erl"
-      with_file filename, erlang_module_code(), fn ->
+
+      with_file(filename, erlang_module_code(), fn ->
         assert c(filename) == [:sample]
-        assert :sample.hello == :world
+        assert :sample.hello() == :world
         refute File.exists?("sample.beam")
-      end
+      end)
     after
       cleanup_modules([:sample])
     end
 
     test "skips unknown files" do
       assert_raise UndefinedFunctionError, ~r"function :sample.hello/0 is undefined", fn ->
-        :sample.hello
-      end
-
-     filenames = ["sample.erl", "not_found.ex", "sample2.ex"]
-     with_file filenames, [erlang_module_code(), "", another_test_module()], fn ->
-        assert c(filenames) |> Enum.sort == [Sample2, :sample]
-        assert :sample.hello == :world
-        assert Sample2.hello == :world
-      end
+        :sample.hello()
+      end
+
+      filenames = ["sample.erl", "not_found.ex", "sample2.ex"]
+
+      with_file(filenames, [erlang_module_code(), "", another_test_module()], fn ->
+        assert c(filenames) |> Enum.sort() == [Sample2, :sample]
+        assert :sample.hello() == :world
+        assert Sample2.hello() == :world
+      end)
     after
       cleanup_modules([:sample, Sample2])
     end
 
     test "compiles file in path" do
       assert_raise UndefinedFunctionError, ~r"function Sample\.run/0 is undefined", fn ->
-        Sample.run
+        Sample.run()
       end
 
       filename = "sample.ex"
-      with_file filename, test_module_code(), fn ->
+
+      with_file(filename, test_module_code(), fn ->
         assert c(filename, ".") == [Sample]
         assert File.exists?("Elixir.Sample.beam")
-        assert Sample.run == :run
-      end
+        assert Sample.run() == :run
+      end)
     after
       cleanup_modules([Sample])
     end

    test "builds a pid from string" do
      assert inspect(pid("0.32767.3276")) == "#PID<0.32767.3276>"
      assert inspect(pid("0.5.6")) == "#PID<0.5.6>"
      assert_raise ArgumentError, fn ->
        pid("0.6.-6")
      end

  describe "l" do
    test "loads a given module" do
      assert_raise UndefinedFunctionError, ~r"function Sample.run/0 is undefined", fn ->
        Sample.run()
      end

      assert l(:nonexistent_module) == {:error, :nofile}

      filename = "sample.ex"

      with_file(filename, test_module_code(), fn ->
        assert c(filename, ".") == [Sample]
        assert Sample.run() == :run

        File.write!(filename, "defmodule Sample do end")
        elixirc(["sample.ex"])

        assert l(Sample) == {:module, Sample}

        message = "function Sample.run/0 is undefined or private"

        assert_raise UndefinedFunctionError, message, fn ->
          Sample.run()
        end
      end)
    after
      # Clean up the old version left over after l()
      cleanup_modules([Sample])
