   defrecord Config, other: { :a, :b, :c }
 
   test :literal do
-    assert { :a, :b, :c }[1] == :a
-    assert Config.new.other[1] == :a
+    assert_equal :a, { :a, :b, :c }[1]
+    assert_equal :a, Config.new.other[1]
   end
 
   test :positive_integer do
     tuple = { :a, :b, :c }
-    assert tuple[0] == nil
-    assert tuple[1] == :a
-    assert tuple[2] == :b
-    assert tuple[3] == :c
-    assert tuple[4] == nil
+    assert_equal nil, tuple[0]
+    assert_equal :a, tuple[1]
+    assert_equal :b, tuple[2]
+    assert_equal :c, tuple[3]
+    assert_equal nil, tuple[4]
   end
 
   test :negative_integer do
     tuple = { :a, :b, :c }
-    assert tuple[-4] == nil
-    assert tuple[-3] == :a
-    assert tuple[-2] == :b
-    assert tuple[-1] == :c
+    assert_equal nil, tuple[-4]
+    assert_equal :a, tuple[-3]
+    assert_equal :b, tuple[-2]
+    assert_equal :c, tuple[-1]
   end
 
   test :access do
-    assert Tuple.access({ :a, :b, :c }, -1) == :c
+    assert_equal :c, Tuple.access({ :a, :b, :c }, -1)
   end
 end
 


  test :any do
    function = fn(x) -> x == :foo end
    assert function[:foo] == true
    assert function[:bar] == false
  end
end
  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
