   describe "require" do
     test "raises for non-compile-time module" do
       assert_raise CompileError, ~r"invalid argument for require, .*, got: {:a, :tuple}", fn ->
-        expand(quote do: (require {:a, :tuple}))
+        expand(quote(do: require({:a, :tuple})))
       end
     end
 
     test "invalid options" do
       assert_raise CompileError, ~r"unsupported option :ops given to require", fn ->
-        expand(quote do: (require Foo, ops: 1))
+        expand(quote(do: require(Foo, ops: 1)))
       end
     end
   end
 
   describe "=" do
     test "sets context to match" do
-      assert expand(quote do: __ENV__.context = :match) == quote do: :match = :match
+      assert expand(quote(do: __ENV__.context = :match)) == quote(do: :match = :match)
     end
 
     test "defines vars" do


  describe "__block__" do
    test "expands to nil when empty" do
      assert expand(quote do: unquote(:__block__)()) == nil
    end

    test "expands to argument when arity is 1" do
      assert expand(quote do: unquote(:__block__)(1)) == 1
    end

    test "is recursive to argument when arity is 1" do
      assert expand(quote do: unquote(:__block__)(_ = 1, unquote(:__block__)(2))) == quote do: __block__(_ = 1, 2)
    end

    test "accumulates vars" do
      assert expand(quote(do: (a = 1; a))) == quote do: (a = 1; a)
    end
  end



  describe "import" do
    test "raises on invalid macro" do
      message = ~r"cannot import Kernel.invalid/1 because it is undefined or private"

      assert_raise CompileError, message, fn ->
        expand(quote(do: import(Kernel, only: [invalid: 1])))
      end
    end

    test "raises on invalid options" do
      message = ~r"invalid :only option for import, expected a keyword list with integer values"

      assert_raise CompileError, message, fn ->
        expand(quote(do: import(Kernel, only: [invalid: nil])))
      end

      message = ~r"invalid :except option for import, expected a keyword list with integer values"

      assert_raise CompileError, message, fn ->
        expand(quote(do: import(Kernel, except: [invalid: nil])))
      end

      message = ~r/invalid options for import, expected a keyword list, got: "invalid_options"/

      assert_raise CompileError, message, fn ->
        expand(quote(do: import(Kernel, "invalid_options")))
      end
    end

    test "raises on conflicting options" do
      message =
        ~r":only and :except can only be given together to import when :only is either :functions or :macros"

      assert_raise CompileError, message, fn ->
        expand(quote(do: import(Kernel, only: [], except: [])))
      end
    end

    test "invalid import option" do
      assert_raise CompileError, ~r"unsupported option :ops given to import", fn ->
        expand(quote(do: import(:lists, ops: 1)))
      end
    end

    test "raises for non-compile-time module" do
      assert_raise CompileError, ~r"invalid argument for import, .*, got: {:a, :tuple}", fn ->
        expand(quote(do: import({:a, :tuple})))
      end
    end
  end
