   use ExUnit.Case
 
   test :literal do
-    assert 'abc'[%r(a)] == 'a'
+    assert_equal 'a', 'abc'[%r(a)]
   end
 
   test :regex do
     list = 'abc'
-    assert list[%r(b)] == 'b'
-    assert list[%r(d)] == nil
+    assert_equal 'b', list[%r(b)]
+    assert_equal nil, list[%r(d)]
   end
 
   test :atom do
     list = [foo: "bar"]
-    assert list[:foo] == "bar"
-    assert list[:bar] == nil
+    assert_equal "bar", list[:foo]
+    assert_equal nil, list[:bar]
   end
 
   test :access do
-    assert List.access([foo: :bar ], :foo) == :bar
+    assert_equal :bar, List.access([foo: :bar ], :foo)
   end
 end
 

  end

  defp is_zero(Config[integer: 0]), do: true
  defp is_zero(Config[integer: _]),  do: false

  defp is_config(Config[]), do: true
  defp is_config(_), do: false

  defrecord Config, integer: 0

  test :keywords do
    assert_equal { Config, 0 }, Config[]
    assert_equal { Config, 1 }, Config[integer: 1]
  end

  test :in_guard_with_variable do
    assert_equal 0, get_var(Config.new)
    assert_equal 1, get_var(Config.new(integer: 1))
  end

  test :in_guard_with_record_match do
    assert_equal true, is_config(Config.new)
    assert_equal false, is_config({ Access.AtomTest, 1 })
    assert_equal false, is_config({ Config, 1, 2 })
  end

  test :in_guard_with_field_match do
    assert_equal true, is_zero(Config.new)
    assert_equal false, is_zero(Config.new(integer: 1))
  end

  test :match do
