     end
 
     test "guards can be used in other funs in the same module" do
-      require Guards.In.Funs
-      assert Guards.In.Funs.is_foo(:foo)
-      refute Guards.In.Funs.is_foo(:bar)
+      require GuardsInFuns
+      assert GuardsInFuns.is_foo(:foo)
+      refute GuardsInFuns.is_foo(:bar)
     end
 
     test "guards do not change code evaluation semantics" do
-      require Guards.In.Funs
+      require GuardsInFuns
       x = 1
-      assert Guards.In.Funs.is_equal(x = 2, x) == false
+      assert GuardsInFuns.is_equal(x = 2, x) == false
       assert x == 2
     end
 
-    defmodule Macros.In.Guards do
+    defmodule MacrosInGuards do
       defmacro is_foo(atom) do
         quote do
           unquote(atom) == :foo

    end

    test "macros can be used in other guards in the same module" do
      require Macros.In.Guards
      assert Macros.In.Guards.is_foobar(:foo)
      assert Macros.In.Guards.is_foobar(:bar)
      refute Macros.In.Guards.is_foobar(:baz)
    end

    defmodule Guards.In.Guards do
      defguard is_foo(atom) when atom == :foo
      defguard is_foobar(atom) when is_foo(atom) or atom == :bar
    end

    test "guards can be used in other guards in the same module" do
      require Guards.In.Guards
      assert Guards.In.Guards.is_foobar(:foo)
      assert Guards.In.Guards.is_foobar(:bar)
      refute Guards.In.Guards.is_foobar(:baz)
    end

    defmodule Default.Args do
      defguard is_divisible(value, remainder \\ 2)
               when is_integer(value) and rem(value, remainder) == 0
    end

    test "permits default values in args" do
      require Default.Args
      assert Default.Args.is_divisible(2)
      refute Default.Args.is_divisible(1)
      assert Default.Args.is_divisible(3, 3)
      refute Default.Args.is_divisible(3, 4)
    end

    test "doesn't allow matching in args" do

    end

    test "guards can be used in other macros in the same module" do
      require GuardsInMacros
      assert GuardsInMacros.is_foo(:foo)
      refute GuardsInMacros.is_foo(:baz)
      assert GuardsInMacros.is_compile_time_foo(:foo)
    end

    defmodule GuardsInFuns do
      defguard is_foo(atom) when atom == :foo
      defguard is_equal(foo, bar) when foo == bar

