   defrecord Config, integer: 0
 
   test :keywords do
-    assert Config[] == { Config, 0 }
-    assert Config[integer: 1] == { Config, 1 }
+    assert_equal { Config, 0 }, Config[]
+    assert_equal { Config, 1 }, Config[integer: 1]
   end
 
   test :in_guard_with_variable do
-    assert get_var(Config.new) == 0
-    assert get_var(Config.new(integer: 1)) == 1
+    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 is_config(Config.new) == true
-    assert is_config({ Access.AtomTest, 1 }) == false
-    assert is_config({ Config, 1, 2 }) == false
+    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 is_zero(Config.new) == true
-    assert is_zero(Config.new(integer: 1)) == false
+    assert_equal true, is_zero(Config.new)
+    assert_equal false, is_zero(Config.new(integer: 1))
   end
 
   test :match do

  use ExUnit.Case

  test :literal do
    assert 'abc'[%r(a)] == 'a'
  end

  test :regex do
    list = 'abc'
    assert list[%r(b)] == 'b'
    assert list[%r(d)] == nil
  end

  test :atom do
    list = [foo: "bar"]
    assert list[:foo] == "bar"
    assert list[:bar] == nil
  end

  test :access do
    assert List.access([foo: :bar ], :foo) == :bar
  end
end


  use ExUnit.Case

  test :literal do
    assert_equal "a", "abc"[%r(a)]
  end

  test :regex do
    binary = "abc"
    assert_equal "b", binary[%r(b)]
    assert_equal nil, binary[%r(d)]
  end

  test :access do
    assert_equal "a", Binary.access("abc", %r"a")
  end
end

