diff --git a/ruby/README.md b/ruby/README.md
index be8d6bc8b1..bc94e1d777 100644
--- a/ruby/README.md
+++ b/ruby/README.md
@@ -43,8 +43,7 @@ mymessage.field3 = SubMessage.new(:foo => 100)
 
 encoded_data = MyTestMessage.encode(mymessage)
 decoded = MyTestMessage.decode(encoded_data)
-assert decoded == mymessage
-
+assert_equal mymessage, decoded
 puts "JSON:"
 puts MyTestMessage.encode_json(mymessage)
 ```
@@ -86,6 +85,14 @@ This gem includes the upb parsing and serialization library as a single-file
 amalgamation. It is up-to-date with upb git commit
 `535bc2fe2f2b467f59347ffc9449e11e47791257`.
 
+Alternatively, you can use Bazel to build and to run tests.
+
+From the project root (rather than the `ruby` directory):
+
+```
+$ bazel test //ruby/tests/...
+```
+
 Version Number Scheme
 ---------------------
 
diff --git a/ruby/compatibility_tests/v3.0.0/tests/basic.rb b/ruby/compatibility_tests/v3.0.0/tests/basic.rb
index d45c19678f..b59193e000 100755
--- a/ruby/compatibility_tests/v3.0.0/tests/basic.rb
+++ b/ruby/compatibility_tests/v3.0.0/tests/basic.rb
@@ -119,42 +119,43 @@ module BasicTest
 
     def test_defaults
       m = TestMessage.new
-      assert m.optional_int32 == 0
-      assert m.optional_int64 == 0
-      assert m.optional_uint32 == 0
-      assert m.optional_uint64 == 0
-      assert m.optional_bool == false
-      assert m.optional_float == 0.0
-      assert m.optional_double == 0.0
-      assert m.optional_string == ""
-      assert m.optional_bytes == ""
-      assert m.optional_msg == nil
-      assert m.optional_enum == :Default
+      assert_equal 0, m.optional_int32
+      assert_equal 0, m.optional_int64
+      assert_equal 0, m.optional_uint32
+      assert_equal 0, m.optional_uint64
+      refute m.optional_bool
+      assert_equal 0.0, m.optional_float
+      assert_equal 0.0, m.optional_double
+      assert_empty m.optional_string
+      assert_empty m.optional_bytes
+      assert_nil m.optional_msg
+      assert_equal :Default, m.optional_enum
     end
 
     def test_setters
       m = TestMessage.new
       m.optional_int32 = -42
-      assert m.optional_int32 == -42
+      assert_equal -42, m.optional_int32
       m.optional_int64 = -0x1_0000_0000
-      assert m.optional_int64 == -0x1_0000_0000
+      assert_equal -0x1_0000_0000, m.optional_int64
       m.optional_uint32 = 0x9000_0000
-      assert m.optional_uint32 == 0x9000_0000
+      assert_equal 0x9000_0000, m.optional_uint32
       m.optional_uint64 = 0x9000_0000_0000_0000
-      assert m.optional_uint64 == 0x9000_0000_0000_0000
+      assert_equal 0x9000_0000_0000_0000, m.optional_uint64
       m.optional_bool = true
-      assert m.optional_bool == true
+      assert m.optional_bool
       m.optional_float = 0.5
-      assert m.optional_float == 0.5
+      assert_equal 0.5, m.optional_float
       m.optional_double = 0.5
+      assert_equal 0.5, m.optional_double
       m.optional_string = "hello"
-      assert m.optional_string == "hello"
+      assert_equal "hello", m.optional_string
       m.optional_bytes = "world".encode!('ASCII-8BIT')
-      assert m.optional_bytes == "world"
+      assert_equal "world", m.optional_bytes
       m.optional_msg = TestMessage2.new(:foo => 42)
-      assert m.optional_msg == TestMessage2.new(:foo => 42)
+      assert_equal m.optional_msg, TestMessage2.new(:foo => 42)
       m.optional_msg = nil
-      assert m.optional_msg == nil
+      assert_nil m.optional_msg
     end
 
     def test_ctor_args
@@ -162,13 +163,13 @@ module BasicTest
                           :optional_msg => TestMessage2.new,
                           :optional_enum => :C,
                           :repeated_string => ["hello", "there", "world"])
-      assert m.optional_int32 == -42
-      assert m.optional_msg.class == TestMessage2
-      assert m.repeated_string.length == 3
-      assert m.optional_enum == :C
-      assert m.repeated_string[0] == "hello"
-      assert m.repeated_string[1] == "there"
-      assert m.repeated_string[2] == "world"
+      assert_equal -42, m.optional_int32
+      assert_instance_of TestMessage2, m.optional_msg
+      assert_equal 3, m.repeated_string.length
+      assert_equal :C, m.optional_enum
+      assert_equal "hello", m.repeated_string[0]
+      assert_equal "there", m.repeated_string[1]
+      assert_equal "world", m.repeated_string[2]
     end
 
     def test_inspect
@@ -183,93 +184,67 @@ module BasicTest
     def test_hash
       m1 = TestMessage.new(:optional_int32 => 42)
       m2 = TestMessage.new(:optional_int32 => 102)
-      assert m1.hash != 0
-      assert m2.hash != 0
+      refute_equal 0, m1.hash
+      refute_equal 0, m2.hash
       # relying on the randomness here -- if hash function changes and we are
       # unlucky enough to get a collision, then change the values above.
-      assert m1.hash != m2.hash
+      refute_equal m1.hash, m2.hash
     end
 
     def test_unknown_field_errors
-      e = assert_raise NoMethodError do
+      e = assert_raises NoMethodError do
         TestMessage.new.hello
       end
       assert_match(/hello/, e.message)
 
-      e = assert_raise NoMethodError do
+      e = assert_raises NoMethodError do
         TestMessage.new.hello = "world"
       end
       assert_match(/hello/, e.message)
     end
 
     def test_initialization_map_errors
-      e = assert_raise ArgumentError do
+      e = assert_raises ArgumentError do
         TestMessage.new(:hello => "world")
       end
       assert_match(/hello/, e.message)
 
-      e = assert_raise ArgumentError do
+      e = assert_raises ArgumentError do
         MapMessage.new(:map_string_int32 => "hello")
       end
-      assert_equal e.message, "Expected Hash object as initializer value for map field 'map_string_int32' (given String)."
-
-      e = assert_raise ArgumentError do
+      assert_equal "Expected Hash object as initializer value for map field 'map_string_int32' (given String).", e.message
+      e = assert_raises ArgumentError do
         TestMessage.new(:repeated_uint32 => "hello")
       end
-      assert_equal e.message, "Expected array as initializer value for repeated field 'repeated_uint32' (given String)."
+      assert_equal "Expected array as initializer value for repeated field 'repeated_uint32' (given String).", e.message
     end
 
     def test_type_errors
       m = TestMessage.new
 
-      # Use rescue to allow subclasses of error
-      success = false
-      begin
+      assert_raises Google::Protobuf::TypeError do
         m.optional_int32 = "hello"
-      rescue TypeError
-        success = true
       end
-      assert(success)
 
-      success = false
-      begin
+      assert_raises Google::Protobuf::TypeError do
         m.optional_string = nil
-      rescue TypeError
-        success = true
       end
-      assert(success)
 
-      success = false
-      begin
+      assert_raises Google::Protobuf::TypeError do
         m.optional_bool = 42
-      rescue TypeError
-        success = true
       end
-      assert(success)
 
-      success = false
-      begin
+      assert_raises Google::Protobuf::TypeError do
         m.optional_msg = TestMessage.new  # expects TestMessage2
-      rescue TypeError
-        success = true
       end
-      assert(success)
 
-      success = false
-      begin
+      assert_raises Google::Protobuf::TypeError do
         m.repeated_int32 = []  # needs RepeatedField
-      rescue TypeError
-        success = true
       end
-      assert(success)
 
-      success = false
-      begin
+      assert_raises Google::Protobuf::TypeError do
         m.repeated_msg.push TestMessage.new
-      rescue TypeError
-        success = true
       end
-      assert(success)
     end
 
     def test_string_encoding
@@ -282,11 +257,11 @@ module BasicTest
       assert_equal Encoding::ASCII_8BIT, m.optional_bytes.encoding
       assert_equal "Test string ASCII", m.optional_bytes
 
-      assert_raise Encoding::UndefinedConversionError do
+      assert_raises Encoding::UndefinedConversionError do
         m.optional_bytes = "Test string UTF-8 \u0100".encode!('UTF-8')
       end
 
-      assert_raise Encoding::UndefinedConversionError do
+      assert_raises Encoding::UndefinedConversionError do
         m.optional_string = ["FFFF"].pack('H*')
       end
 
@@ -296,134 +271,109 @@ module BasicTest
 
       # strings are immutable so we can't do this, but serialize should catch it.
       m.optional_string = "asdf".encode!('UTF-8')
-      assert_raise do
+      assert_raises do
         m.optional_string.encode!('ASCII-8BIT')
       end
     end
 
     def test_rptfield_int32
       l = Google::Protobuf::RepeatedField.new(:int32)
-      assert l.count == 0
+      assert_equal 0, l.count
       l = Google::Protobuf::RepeatedField.new(:int32, [1, 2, 3])
-      assert l.count == 3
+      assert_equal 3, l.count
+      assert_equal [1, 2, 3], l
       assert_equal [1, 2, 3], l
-      assert_equal l, [1, 2, 3]
       l.push 4
-      assert l == [1, 2, 3, 4]
+      assert_equal [1, 2, 3, 4], l
       dst_list = []
       l.each { |val| dst_list.push val }
-      assert dst_list == [1, 2, 3, 4]
-      assert l.to_a == [1, 2, 3, 4]
-      assert l[0] == 1
-      assert l[3] == 4
+      assert_equal [1, 2, 3, 4], dst_list
+      assert_equal [1, 2, 3, 4], l.to_a
+      assert_equal 1, l[0]
+      assert_equal 4, l[3]
       l[0] = 5
-      assert l == [5, 2, 3, 4]
-
+      assert_equal [5, 2, 3, 4], l
       l2 = l.dup
-      assert l == l2
-      assert l.object_id != l2.object_id
+      assert_equal l, l2
+      refute_same l, l2
       l2.push 6
-      assert l.count == 4
-      assert l2.count == 5
-
-      assert l.inspect == '[5, 2, 3, 4]'
-
+      assert_equal 4, l.count
+      assert_equal 5, l2.count
+      assert_equal '[5, 2, 3, 4]', l.inspect
       l.concat([7, 8, 9])
-      assert l == [5, 2, 3, 4, 7, 8, 9]
-      assert l.pop == 9
-      assert l == [5, 2, 3, 4, 7, 8]
-
-      success = false
-      begin
-        m = TestMessage.new
+      assert_equal [5, 2, 3, 4, 7, 8, 9], l
+      assert_equal 9, l.pop
+      assert_equal [5, 2, 3, 4, 7, 8], l
+      m = TestMessage.new
+      assert_raises Google::Protobuf::TypeError do
         l.push m
-      rescue TypeError
-        success = true
       end
-      assert(success)
 
-      m = TestMessage.new
       m.repeated_int32 = l
-      assert m.repeated_int32 == [5, 2, 3, 4, 7, 8]
-      assert m.repeated_int32.object_id == l.object_id
+      assert_equal [5, 2, 3, 4, 7, 8], m.repeated_int32
+      assert_same m.repeated_int32, l
       l.push 42
-      assert m.repeated_int32.pop == 42
-
+      assert_equal 42, m.repeated_int32.pop
       l3 = l + l.dup
-      assert l3.count == l.count * 2
+      assert_equal l.count * 2, l3.count
       l.count.times do |i|
-        assert l3[i] == l[i]
-        assert l3[l.count + i] == l[i]
+        assert_equal l[i], l3[i]
+        assert_equal l[i], l3[l.count + i]
       end
 
       l.clear
-      assert l.count == 0
+      assert_equal 0, l.count
       l += [1, 2, 3, 4]
       l.replace([5, 6, 7, 8])
-      assert l == [5, 6, 7, 8]
-
+      assert_equal [5, 6, 7, 8], l
       l4 = Google::Protobuf::RepeatedField.new(:int32)
       l4[5] = 42
-      assert l4 == [0, 0, 0, 0, 0, 42]
-
+      assert_equal [0, 0, 0, 0, 0, 42], l4
       l4 << 100
-      assert l4 == [0, 0, 0, 0, 0, 42, 100]
+      assert_equal [0, 0, 0, 0, 0, 42, 100], l4
       l4 << 101 << 102
-      assert l4 == [0, 0, 0, 0, 0, 42, 100, 101, 102]
+      assert_equal [0, 0, 0, 0, 0, 42, 100, 101, 102], l4
     end
 
     def test_parent_rptfield
       #make sure we set the RepeatedField and can add to it
       m = TestMessage.new
-      assert m.repeated_string == []
+      assert_empty m.repeated_string
       m.repeated_string << 'ok'
       m.repeated_string.push('ok2')
-      assert m.repeated_string == ['ok', 'ok2']
+      assert_equal ['ok', 'ok2'], m.repeated_string
       m.repeated_string += ['ok3']
-      assert m.repeated_string == ['ok', 'ok2', 'ok3']
+      assert_equal ['ok', 'ok2', 'ok3'], m.repeated_string
     end
 
     def test_rptfield_msg
       l = Google::Protobuf::RepeatedField.new(:message, TestMessage)
       l.push TestMessage.new
-      assert l.count == 1
-
-      success = false
-      begin
+      assert_equal 1, l.count
+      assert_raises Google::Protobuf::TypeError do
         l.push TestMessage2.new
-      rescue TypeError
-        success = true
       end
-      assert(success)
-
-      success = false
-      begin
+      assert_raises Google::Protobuf::TypeError do
         l.push 42
-      rescue TypeError
-        success = true
       end
-      assert(success)
 
       l2 = l.dup
-      assert l2[0] == l[0]
-      assert l2[0].object_id == l[0].object_id
-
+      assert_equal l[0], l2[0]
+      assert_same l2[0], l[0]
       l2 = Google::Protobuf.deep_copy(l)
-      assert l2[0] == l[0]
-      assert l2[0].object_id != l[0].object_id
-
+      assert_equal l[0], l2[0]
+      refute_same l2[0], l[0]
       l3 = l + l2
-      assert l3.count == 2
-      assert l3[0] == l[0]
-      assert l3[1] == l2[0]
+      assert_equal 2, l3.count
+      assert_equal l[0], l3[0]
+      assert_equal l2[0], l3[1]
       l3[0].optional_int32 = 1000
-      assert l[0].optional_int32 == 1000
-
+      assert_equal 1000, l[0].optional_int32
       new_msg = TestMessage.new(:optional_int32 => 200)
       l4 = l + [new_msg]
-      assert l4.count == 2
+      assert_equal 2, l4.count
       new_msg.optional_int32 = 1000
-      assert l4[1].optional_int32 == 1000
+      assert_equal 1000, l4[1].optional_int32
     end
 
     def test_rptfield_enum
@@ -431,27 +381,26 @@ module BasicTest
       l.push :A
       l.push :B
       l.push :C
-      assert l.count == 3
-      assert_raise RangeError do
+      assert_equal 3, l.count
+      assert_raises RangeError do
         l.push :D
       end
-      assert l[0] == :A
-
+      assert_equal :A, l[0]
       l.push 4
-      assert l[3] == 4
+      assert_equal 4, l[3]
     end
 
     def test_rptfield_initialize
-      assert_raise ArgumentError do
+      assert_raises ArgumentError do
         l = Google::Protobuf::RepeatedField.new
       end
-      assert_raise ArgumentError do
+      assert_raises ArgumentError do
         l = Google::Protobuf::RepeatedField.new(:message)
       end
-      assert_raise ArgumentError do
+      assert_raises ArgumentError do
         l = Google::Protobuf::RepeatedField.new([1, 2, 3])
       end
-      assert_raise ArgumentError do
+      assert_raises ArgumentError do
         l = Google::Protobuf::RepeatedField.new(:message, [TestMessage2.new])
       end
     end
@@ -460,32 +409,30 @@ module BasicTest
       l = Google::Protobuf::RepeatedField.new(:int32)
       length_methods = %w(count length size)
       length_methods.each do |lm|
-        assert l.send(lm)  == 0
+        assert_equal 0, l.send(lm)
       end
       # out of bounds returns a nil
-      assert l[0] == nil
-      assert l[1] == nil
-      assert l[-1] == nil
+      assert_nil l[0]
+      assert_nil l[1]
+      assert_nil l[-1]
       l.push 4
       length_methods.each do |lm|
-        assert l.send(lm) == 1
+        assert_equal 1, l.send(lm)
       end
-      assert l[0] == 4
-      assert l[1] == nil
-      assert l[-1] == 4
-      assert l[-2] == nil
-
+      assert_equal 4, l[0]
+      assert_nil l[1]
+      assert_equal 4, l[-1]
+      assert_nil l[-2]
       l.push 2
       length_methods.each do |lm|
-        assert l.send(lm) == 2
-      end
-      assert l[0] == 4
-      assert l[1] == 2
-      assert l[2] == nil
-      assert l[-1] == 2
-      assert l[-2] == 4
-      assert l[-3] == nil
-
+        assert_equal 2, l.send(lm)
+      end
+      assert_equal 4, l[0]
+      assert_equal 2, l[1]
+      assert_nil l[2]
+      assert_equal 2, l[-1]
+      assert_equal 4, l[-2]
+      assert_nil l[-3]
       #adding out of scope will backfill with empty objects
     end
 
@@ -495,48 +442,38 @@ module BasicTest
 
       m = Google::Protobuf::Map.new(:string, :int32)
       m["asdf"] = 1
-      assert m["asdf"] == 1
+      assert_equal 1, m["asdf"]
       m["jkl;"] = 42
-      assert m == { "jkl;" => 42, "asdf" => 1 }
-      assert m.has_key?("asdf")
-      assert !m.has_key?("qwerty")
-      assert m.length == 2
-
+      assert_equal({ "jkl;" => 42, "asdf" => 1 }, m.to_h)
+      assert_includes m.to_h, "asdf"
+      refute_includes m, "qwerty"
+      assert_equal 2, m.length
       m2 = m.dup
-      assert m == m2
-      assert m.hash != 0
-      assert m.hash == m2.hash
-
+      assert_equal m, m2
+      refute_equal 0, m.hash
+      assert_equal m.hash, m2.hash
       collected = {}
       m.each { |k,v| collected[v] = k }
-      assert collected == { 42 => "jkl;", 1 => "asdf" }
-
-      assert m.delete("asdf") == 1
-      assert !m.has_key?("asdf")
-      assert m["asdf"] == nil
-      assert !m.has_key?("asdf")
+      assert_equal({ 42 => "jkl;", 1 => "asdf" }, collected)
+      assert_equal 1, m.delete("asdf")
+      refute_includes m, "asdf"
+      assert_nil m["asdf"]
+      refute_includes m, "asdf"
 
       # We only assert on inspect value when there is one map entry because the
       # order in which elements appear is unspecified (depends on the internal
       # hash function). We don't want a brittle test.
-      assert m.inspect == "{\"jkl;\"=>42}"
-
-      assert m.keys == ["jkl;"]
-      assert m.values == [42]
-
+      assert_equal "{\"jkl;\"=>42}", m.inspect
+      assert_equal ["jkl;"], m.keys
+      assert_equal [42], m.values
       m.clear
-      assert m.length == 0
-      assert m == {}
-
-      success = false
-      begin
+      assert_equal 0, m.length
+      assert_empty m.to_h
+      assert_raises Google::Protobuf::TypeError do
         m[1] = 1
-      rescue TypeError
-        success = true
       end
-      assert(success)
 
-      assert_raise RangeError do
+      assert_raises RangeError do
         m["asdf"] = 0x1_0000_0000
       end
     end
@@ -544,54 +481,46 @@ module BasicTest
     def test_map_ctor
       m = Google::Protobuf::Map.new(:string, :int32,
                                     {"a" => 1, "b" => 2, "c" => 3})
-      assert m == {"a" => 1, "c" => 3, "b" => 2}
+      assert_equal({"a" => 1, "c" => 3, "b" => 2}, m.to_h)
     end
 
     def test_map_keytypes
       m = Google::Protobuf::Map.new(:int32, :int32)
       m[1] = 42
       m[-1] = 42
-      assert_raise RangeError do
+      assert_raises RangeError do
         m[0x8000_0000] = 1
       end
 
-      success = false
-      begin
+      assert_raises Google::Protobuf::TypeError do
         m["asdf"] = 1
-      rescue TypeError
-        success = true
       end
-      assert(success)
 
       m = Google::Protobuf::Map.new(:int64, :int32)
       m[0x1000_0000_0000_0000] = 1
-      assert_raise RangeError do
+      assert_raises RangeError do
         m[0x1_0000_0000_0000_0000] = 1
       end
 
-      success = false
-      begin
+      assert_raises Google::Protobuf::TypeError do
         m["asdf"] = 1
-      rescue TypeError
-        success = true
       end
-      assert(success)
 
       m = Google::Protobuf::Map.new(:uint32, :int32)
       m[0x8000_0000] = 1
-      assert_raise RangeError do
+      assert_raises RangeError do
         m[0x1_0000_0000] = 1
       end
-      assert_raise RangeError do
+      assert_raises RangeError do
         m[-1] = 1
       end
 
       m = Google::Protobuf::Map.new(:uint64, :int32)
       m[0x8000_0000_0000_0000] = 1
-      assert_raise RangeError do
+      assert_raises RangeError do
         m[0x1_0000_0000_0000_0000] = 1
       end
-      assert_raise RangeError do
+      assert_raises RangeError do
         m[-1] = 1
       end
 
@@ -599,33 +528,21 @@ module BasicTest
       m[true] = 1
       m[false] = 2
 
-      success = false
-      begin
+      assert_raises Google::Protobuf::TypeError do
         m[1] = 1
-      rescue TypeError
-        success = true
       end
-      assert(success)
 
-      success = false
-      begin
+      assert_raises Google::Protobuf::TypeError do
         m["asdf"] = 1
-      rescue TypeError
-        success = true
       end
-      assert(success)
 
       m = Google::Protobuf::Map.new(:string, :int32)
       m["asdf"] = 1
-      success = false
-      begin
+      assert_raises Google::Protobuf::TypeError do
         m[1] = 1
-      rescue TypeError
-        success = true
       end
-      assert(success)
-      assert_raise Encoding::UndefinedConversionError do
-        bytestring = ["FFFF"].pack("H*")
+      bytestring = ["FFFF"].pack("H*")
+      assert_raises Encoding::UndefinedConversionError do
         m[bytestring] = 1
       end
 
@@ -634,45 +551,36 @@ module BasicTest
       m[bytestring] = 1
       # Allowed -- we will automatically convert to ASCII-8BIT.
       m["asdf"] = 1
-      success = false
-      begin
+      assert_raises Google::Protobuf::TypeError do
         m[1] = 1
-      rescue TypeError
-        success = true
       end
-      assert(success)
     end
 
     def test_map_msg_enum_valuetypes
       m = Google::Protobuf::Map.new(:string, :message, TestMessage)
       m["asdf"] = TestMessage.new
-      success = false
-      begin
+      assert_raises Google::Protobuf::TypeError do
         m["jkl;"] = TestMessage2.new
-      rescue TypeError
-        success = true
       end
-      assert(success)
 
       m = Google::Protobuf::Map.new(
         :string, :message, TestMessage,
         { "a" => TestMessage.new(:optional_int32 => 42),
           "b" => TestMessage.new(:optional_int32 => 84) })
-      assert m.length == 2
-      assert m.values.map{|msg| msg.optional_int32}.sort == [42, 84]
-
+      assert_equal 2, m.length
+      assert_equal [42, 84], m.values.map{|msg| msg.optional_int32}.sort
       m = Google::Protobuf::Map.new(:string, :enum, TestEnum,
                                     { "x" => :A, "y" => :B, "z" => :C })
-      assert m.length == 3
-      assert m["z"] == :C
+      assert_equal 3, m.length
+      assert_equal :C, m["z"]
       m["z"] = 2
-      assert m["z"] == :B
+      assert_equal :B, m["z"]
       m["z"] = 5
-      assert m["z"] == 5
-      assert_raise RangeError do
+      assert_equal 5, m["z"]
+      assert_raises RangeError do
         m["z"] = :Z
       end
-      assert_raise RangeError do
+      assert_raises RangeError do
         m["z"] = "z"
       end
     end
@@ -684,72 +592,50 @@ module BasicTest
           "b" => TestMessage.new(:optional_int32 => 84) })
 
       m2 = m.dup
-      assert m == m2
-      assert m.object_id != m2.object_id
-      assert m["a"].object_id == m2["a"].object_id
-      assert m["b"].object_id == m2["b"].object_id
-
+      assert_equal m, m2
+      refute_same m, m2
+      assert_same m["a"], m2["a"]
+      assert_same m["b"], m2["b"]
       m2 = Google::Protobuf.deep_copy(m)
-      assert m == m2
-      assert m.object_id != m2.object_id
-      assert m["a"].object_id != m2["a"].object_id
-      assert m["b"].object_id != m2["b"].object_id
+      assert_equal m, m2
+      refute_same m, m2
+      refute_same m["a"], m2["a"]
+      refute_same m["b"], m2["b"]
     end
 
     def test_map_field
       m = MapMessage.new
-      assert m.map_string_int32 == {}
-      assert m.map_string_msg == {}
-
+      assert_empty m.map_string_int32.to_h
+      assert_empty m.map_string_msg.to_h
       m = MapMessage.new(
         :map_string_int32 => {"a" => 1, "b" => 2},
         :map_string_msg => {"a" => TestMessage2.new(:foo => 1),
                             "b" => TestMessage2.new(:foo => 2)})
-      assert m.map_string_int32.keys.sort == ["a", "b"]
-      assert m.map_string_int32["a"] == 1
-      assert m.map_string_msg["b"].foo == 2
-
+      assert_equal ["a", "b"], m.map_string_int32.keys.sort
+      assert_equal 1, m.map_string_int32["a"]
+      assert_equal 2, m.map_string_msg["b"].foo
       m.map_string_int32["c"] = 3
-      assert m.map_string_int32["c"] == 3
+      assert_equal 3, m.map_string_int32["c"]
       m.map_string_msg["c"] = TestMessage2.new(:foo => 3)
-      assert m.map_string_msg["c"] == TestMessage2.new(:foo => 3)
+      assert_equal TestMessage2.new(:foo => 3), m.map_string_msg["c"]
       m.map_string_msg.delete("b")
       m.map_string_msg.delete("c")
-      assert m.map_string_msg == { "a" => TestMessage2.new(:foo => 1) }
-
-      success = false
-      begin
+      assert_equal({ "a" => TestMessage2.new(:foo => 1).to_h }, m.map_string_msg.to_h)
+      assert_raises Google::Protobuf::TypeError do
         m.map_string_msg["e"] = TestMessage.new # wrong value type
-      rescue TypeError
-        success = true
       end
-      assert(success)
       # ensure nothing was added by the above
-      assert m.map_string_msg == { "a" => TestMessage2.new(:foo => 1) }
-
+      assert_equal({ "a" => TestMessage2.new(:foo => 1).to_h }, m.map_string_msg.to_h)
       m.map_string_int32 = Google::Protobuf::Map.new(:string, :int32)
-      success = false
-      begin
+      assert_raises Google::Protobuf::TypeError do
         m.map_string_int32 = Google::Protobuf::Map.new(:string, :int64)
-      rescue TypeError
-        success = true
       end
-      assert(success)
-      success = false
-      begin
+      assert_raises Google::Protobuf::TypeError do
         m.map_string_int32 = {}
-      rescue TypeError
-        success = true
       end
-      assert(success)
-
-      success = false
-      begin
+      assert_raises Google::Protobuf::TypeError do
         m = MapMessage.new(:map_string_int32 => { 1 => "I am not a number" })
-      rescue TypeError
-        success = true
       end
-      assert(success)
     end
 
     def test_map_encode_decode
@@ -758,77 +644,68 @@ module BasicTest
         :map_string_msg => {"a" => TestMessage2.new(:foo => 1),
                             "b" => TestMessage2.new(:foo => 2)})
       m2 = MapMessage.decode(MapMessage.encode(m))
-      assert m == m2
-
+      assert_equal m, m2
       m3 = MapMessageWireEquiv.decode(MapMessage.encode(m))
-      assert m3.map_string_int32.length == 2
-
+      assert_equal 2, m3.map_string_int32.length
       kv = {}
       m3.map_string_int32.map { |msg| kv[msg.key] = msg.value }
-      assert kv == {"a" => 1, "b" => 2}
-
+      assert_equal({"a" => 1, "b" => 2}, kv)
       kv = {}
       m3.map_string_msg.map { |msg| kv[msg.key] = msg.value }
-      assert kv == {"a" => TestMessage2.new(:foo => 1),
-                    "b" => TestMessage2.new(:foo => 2)}
+      assert_equal({"a" => TestMessage2.new(:foo => 1),
+                    "b" => TestMessage2.new(:foo => 2)}, kv)
     end
 
     def test_oneof_descriptors
       d = OneofMessage.descriptor
       o = d.lookup_oneof("my_oneof")
-      assert o != nil
-      assert o.class == Google::Protobuf::OneofDescriptor
-      assert o.name == "my_oneof"
+      refute_nil o
+      assert_instance_of Google::Protobuf::OneofDescriptor, o
+      assert_equal "my_oneof", o.name
       oneof_count = 0
       d.each_oneof{ |oneof|
         oneof_count += 1
-        assert oneof == o
+        assert_equal o, oneof
       }
-      assert oneof_count == 1
-      assert o.count == 4
+      assert_equal 1, oneof_count
+      assert_equal 4, o.count
       field_names = o.map{|f| f.name}.sort
-      assert field_names == ["a", "b", "c", "d"]
+      assert_equal ["a", "b", "c", "d"], field_names
     end
 
     def test_oneof
       d = OneofMessage.new
-      assert d.a == ""
-      assert d.b == 0
-      assert d.c == nil
-      assert d.d == :Default
-      assert d.my_oneof == nil
-
+      assert_empty d.a
+      assert_equal 0, d.b
+      assert_nil d.c
+      assert_equal :Default, d.d
+      assert_nil d.my_oneof
       d.a = "hi"
-      assert d.a == "hi"
-      assert d.b == 0
-      assert d.c == nil
-      assert d.d == :Default
-      assert d.my_oneof == :a
-
+      assert_equal "hi", d.a
+      assert_equal 0, d.b
+      assert_nil d.c
+      assert_equal :Default, d.d
+      assert_equal :a, d.my_oneof
       d.b = 42
-      assert d.a == ""
-      assert d.b == 42
-      assert d.c == nil
-      assert d.d == :Default
-      assert d.my_oneof == :b
-
+      assert_empty d.a
+      assert_equal 42, d.b
+      assert_nil d.c
+      assert_equal :Default, d.d
+      assert_equal :b, d.my_oneof
       d.c = TestMessage2.new(:foo => 100)
-      assert d.a == ""
-      assert d.b == 0
-      assert d.c.foo == 100
-      assert d.d == :Default
-      assert d.my_oneof == :c
-
+      assert_empty d.a
+      assert_equal 0, d.b
+      assert_equal 100, d.c.foo
+      assert_equal :Default, d.d
+      assert_equal :c, d.my_oneof
       d.d = :C
-      assert d.a == ""
-      assert d.b == 0
-      assert d.c == nil
-      assert d.d == :C
-      assert d.my_oneof == :d
-
+      assert_empty d.a
+      assert_equal 0, d.b
+      assert_nil d.c
+      assert_equal :C, d.d
+      assert_equal :d, d.my_oneof
       d2 = OneofMessage.decode(OneofMessage.encode(d))
-      assert d2 == d
-
+      assert_equal d2, d
       encoded_field_a = OneofMessage.encode(OneofMessage.new(:a => "string"))
       encoded_field_b = OneofMessage.encode(OneofMessage.new(:b => 1000))
       encoded_field_c = OneofMessage.encode(
@@ -837,39 +714,37 @@ module BasicTest
 
       d3 = OneofMessage.decode(
         encoded_field_c + encoded_field_a + encoded_field_d)
-      assert d3.a == ""
-      assert d3.b == 0
-      assert d3.c == nil
-      assert d3.d == :B
-
+      assert_empty d3.a
+      assert_equal 0, d3.b
+      assert_nil d3.c
+      assert_equal :B, d3.d
       d4 = OneofMessage.decode(
         encoded_field_c + encoded_field_a + encoded_field_d +
         encoded_field_c)
-      assert d4.a == ""
-      assert d4.b == 0
-      assert d4.c.foo == 1
-      assert d4.d == :Default
-
+      assert_empty d4.a
+      assert_equal 0, d4.b
+      assert_equal 1, d4.c.foo
+      assert_equal :Default, d4.d
       d5 = OneofMessage.new(:a => "hello")
-      assert d5.a == "hello"
+      assert_equal "hello", d5.a
       d5.a = nil
-      assert d5.a == ""
-      assert OneofMessage.encode(d5) == ''
-      assert d5.my_oneof == nil
+      assert_empty d5.a
+      assert_empty OneofMessage.encode(d5)
+      assert_nil d5.my_oneof
     end
 
     def test_enum_field
       m = TestMessage.new
-      assert m.optional_enum == :Default
+      assert_equal :Default, m.optional_enum
       m.optional_enum = :A
-      assert m.optional_enum == :A
-      assert_raise RangeError do
+      assert_equal :A, m.optional_enum
+      assert_raises RangeError do
         m.optional_enum = :ASDF
       end
       m.optional_enum = 1
-      assert m.optional_enum == :A
+      assert_equal :A, m.optional_enum
       m.optional_enum = 100
-      assert m.optional_enum == 100
+      assert_equal 100, m.optional_enum
     end
 
     def test_dup
@@ -879,25 +754,25 @@ module BasicTest
       tm1 = TestMessage2.new(:foo => 100)
       tm2 = TestMessage2.new(:foo => 200)
       m.repeated_msg.push tm1
-      assert m.repeated_msg[-1] == tm1
+      assert_equal m.repeated_msg[-1], tm1
       m.repeated_msg.push tm2
-      assert m.repeated_msg[-1] == tm2
+      assert_equal m.repeated_msg[-1], tm2
       m2 = m.dup
-      assert m == m2
+      assert_equal m, m2
       m.optional_int32 += 1
-      assert m != m2
-      assert m.repeated_msg[0] == m2.repeated_msg[0]
-      assert m.repeated_msg[0].object_id == m2.repeated_msg[0].object_id
+      refute_equal m2, m
+      assert_equal m.repeated_msg[0], m2.repeated_msg[0]
+      assert_same m.repeated_msg[0], m2.repeated_msg[0]
     end
 
     def test_deep_copy
       m = TestMessage.new(:optional_int32 => 42,
                           :repeated_msg => [TestMessage2.new(:foo => 100)])
       m2 = Google::Protobuf.deep_copy(m)
-      assert m == m2
-      assert m.repeated_msg == m2.repeated_msg
-      assert m.repeated_msg.object_id != m2.repeated_msg.object_id
-      assert m.repeated_msg[0].object_id != m2.repeated_msg[0].object_id
+      assert_equal m, m2
+      assert_equal m.repeated_msg, m2.repeated_msg
+      refute_same m.repeated_msg, m2.repeated_msg
+      refute_same m.repeated_msg[0], m2.repeated_msg[0]
     end
 
     def test_eq
@@ -905,21 +780,19 @@ module BasicTest
                           :repeated_int32 => [1, 2, 3])
       m2 = TestMessage.new(:optional_int32 => 43,
                            :repeated_int32 => [1, 2, 3])
-      assert m != m2
+      refute_equal m2, m
     end
 
     def test_enum_lookup
-      assert TestEnum::A == 1
-      assert TestEnum::B == 2
-      assert TestEnum::C == 3
-
-      assert TestEnum::lookup(1) == :A
-      assert TestEnum::lookup(2) == :B
-      assert TestEnum::lookup(3) == :C
-
-      assert TestEnum::resolve(:A) == 1
-      assert TestEnum::resolve(:B) == 2
-      assert TestEnum::resolve(:C) == 3
+      assert_equal 1, TestEnum::A
+      assert_equal 2, TestEnum::B
+      assert_equal 3, TestEnum::C
+      assert_equal :A, TestEnum::lookup(1)
+      assert_equal :B, TestEnum::lookup(2)
+      assert_equal :C, TestEnum::lookup(3)
+      assert_equal 1, TestEnum::resolve(:A)
+      assert_equal 2, TestEnum::resolve(:B)
+      assert_equal 3, TestEnum::resolve(:C)
     end
 
     def test_parse_serialize
@@ -933,11 +806,10 @@ module BasicTest
                                             TestMessage2.new(:foo => 2)])
       data = TestMessage.encode m
       m2 = TestMessage.decode data
-      assert m == m2
-
+      assert_equal m, m2
       data = Google::Protobuf.encode m
       m2 = Google::Protobuf.decode(TestMessage, data)
-      assert m == m2
+      assert_equal m, m2
     end
 
     def test_encode_decode_helpers
@@ -1010,62 +882,51 @@ module BasicTest
 
     def test_def_errors
       s = Google::Protobuf::DescriptorPool.new
-      success = false
-      begin
+      assert_raises Google::Protobuf::TypeError do
         s.build do
           # enum with no default (integer value 0)
           add_enum "MyEnum" do
             value :A, 1
           end
         end
-      rescue TypeError
-        success = true
       end
-      assert(success)
-      success = false
-      begin
+      assert_raises Google::Protobuf::TypeError do
         s.build do
           # message with required field (unsupported in proto3)
           add_message "MyMessage" do
             required :foo, :int32, 1
           end
         end
-      rescue TypeError
-        success = true
       end
-      assert(success)
     end
 
     def test_corecursive
       # just be sure that we can instantiate types with corecursive field-type
       # references.
       m = Recursive1.new(:foo => Recursive2.new(:foo => Recursive1.new))
-      assert Recursive1.descriptor.lookup("foo").subtype ==
-        Recursive2.descriptor
-      assert Recursive2.descriptor.lookup("foo").subtype ==
-        Recursive1.descriptor
-
+      assert_equal Recursive2.descriptor, Recursive1.descriptor.lookup("foo").subtype
+      assert_equal Recursive1.descriptor, Recursive2.descriptor.lookup("foo").subtype
       serialized = Recursive1.encode(m)
       m2 = Recursive1.decode(serialized)
-      assert m == m2
+      assert_equal m, m2
     end
 
     def test_serialize_cycle
       m = Recursive1.new(:foo => Recursive2.new)
       m.foo.foo = m
-      assert_raise RuntimeError do
-        serialized = Recursive1.encode(m)
+      assert_raises RuntimeError do
+        Recursive1.encode(m)
       end
     end
 
     def test_bad_field_names
       m = BadFieldNames.new(:dup => 1, :class => 2)
       m2 = m.dup
-      assert m == m2
-      assert m['dup'] == 1
-      assert m['class'] == 2
+      assert_equal m, m2
+      assert_equal 1, m['dup']
+      assert_equal 2, m['class']
       m['dup'] = 3
-      assert m['dup'] == 3
+      assert_equal 3, m['dup']
     end
 
     def test_int_ranges
@@ -1077,19 +938,19 @@ module BasicTest
       m.optional_int32 = 1.0
       m.optional_int32 = -1.0
       m.optional_int32 = 2e9
-      assert_raise RangeError do
+      assert_raises RangeError do
         m.optional_int32 = -0x8000_0001
       end
-      assert_raise RangeError do
+      assert_raises RangeError do
         m.optional_int32 = +0x8000_0000
       end
-      assert_raise RangeError do
+      assert_raises RangeError do
         m.optional_int32 = +0x1000_0000_0000_0000_0000_0000 # force Bignum
       end
-      assert_raise RangeError do
+      assert_raises RangeError do
         m.optional_int32 = 1e12
       end
-      assert_raise RangeError do
+      assert_raises RangeError do
         m.optional_int32 = 1.5
       end
 
@@ -1097,28 +958,28 @@ module BasicTest
       m.optional_uint32 = +0xffff_ffff
       m.optional_uint32 = 1.0
       m.optional_uint32 = 4e9
-      assert_raise RangeError do
+      assert_raises RangeError do
         m.optional_uint32 = -1
       end
-      assert_raise RangeError do
+      assert_raises RangeError do
         m.optional_uint32 = -1.5
       end
-      assert_raise RangeError do
+      assert_raises RangeError do
         m.optional_uint32 = -1.5e12
       end
-      assert_raise RangeError do
+      assert_raises RangeError do
         m.optional_uint32 = -0x1000_0000_0000_0000
       end
-      assert_raise RangeError do
+      assert_raises RangeError do
         m.optional_uint32 = +0x1_0000_0000
       end
-      assert_raise RangeError do
+      assert_raises RangeError do
         m.optional_uint32 = +0x1000_0000_0000_0000_0000_0000 # force Bignum
       end
-      assert_raise RangeError do
+      assert_raises RangeError do
         m.optional_uint32 = 1e12
       end
-      assert_raise RangeError do
+      assert_raises RangeError do
         m.optional_uint32 = 1.5
       end
 
@@ -1129,19 +990,19 @@ module BasicTest
       m.optional_int64 = -1.0
       m.optional_int64 = 8e18
       m.optional_int64 = -8e18
-      assert_raise RangeError do
+      assert_raises RangeError do
         m.optional_int64 = -0x8000_0000_0000_0001
       end
-      assert_raise RangeError do
+      assert_raises RangeError do
         m.optional_int64 = +0x8000_0000_0000_0000
       end
-      assert_raise RangeError do
+      assert_raises RangeError do
         m.optional_int64 = +0x1000_0000_0000_0000_0000_0000 # force Bignum
       end
-      assert_raise RangeError do
+      assert_raises RangeError do
         m.optional_int64 = 1e50
       end
-      assert_raise RangeError do
+      assert_raises RangeError do
         m.optional_int64 = 1.5
       end
 
@@ -1149,28 +1010,28 @@ module BasicTest
       m.optional_uint64 = +0xffff_ffff_ffff_ffff
       m.optional_uint64 = 1.0
       m.optional_uint64 = 16e18
-      assert_raise RangeError do
+      assert_raises RangeError do
         m.optional_uint64 = -1
       end
-      assert_raise RangeError do
+      assert_raises RangeError do
         m.optional_uint64 = -1.5
       end
-      assert_raise RangeError do
+      assert_raises RangeError do
         m.optional_uint64 = -1.5e12
       end
-      assert_raise RangeError do
+      assert_raises RangeError do
         m.optional_uint64 = -0x1_0000_0000_0000_0000
       end
-      assert_raise RangeError do
+      assert_raises RangeError do
         m.optional_uint64 = +0x1_0000_0000_0000_0000
       end
-      assert_raise RangeError do
+      assert_raises RangeError do
         m.optional_uint64 = +0x1000_0000_0000_0000_0000_0000 # force Bignum
       end
-      assert_raise RangeError do
+      assert_raises RangeError do
         m.optional_uint64 = 1e50
       end
-      assert_raise RangeError do
+      assert_raises RangeError do
         m.optional_uint64 = 1.5
       end
     end
@@ -1189,7 +1050,7 @@ module BasicTest
       10_000.times do
         m = TestMessage.decode(data)
         data_new = TestMessage.encode(m)
-        assert data_new == data
+        assert_equal data, data_new
         data = data_new
       end
     end
@@ -1197,32 +1058,29 @@ module BasicTest
     def test_reflection
       m = TestMessage.new(:optional_int32 => 1234)
       msgdef = m.class.descriptor
-      assert msgdef.class == Google::Protobuf::Descriptor
+      assert_instance_of Google::Protobuf::Descriptor, msgdef
       assert msgdef.any? {|field| field.name == "optional_int32"}
       optional_int32 = msgdef.lookup "optional_int32"
-      assert optional_int32.class == Google::Protobuf::FieldDescriptor
-      assert optional_int32 != nil
-      assert optional_int32.name == "optional_int32"
-      assert optional_int32.type == :int32
+      assert_instance_of Google::Protobuf::FieldDescriptor, optional_int32
+      refute_nil optional_int32
+      assert_equal "optional_int32", optional_int32.name
+      assert_equal :int32, optional_int32.type
       optional_int32.set(m, 5678)
-      assert m.optional_int32 == 5678
+      assert_equal 5678, m.optional_int32
       m.optional_int32 = 1000
-      assert optional_int32.get(m) == 1000
-
+      assert_equal 1000, optional_int32.get(m)
       optional_msg = msgdef.lookup "optional_msg"
-      assert optional_msg.subtype == TestMessage2.descriptor
-
+      assert_equal TestMessage2.descriptor, optional_msg.subtype
       optional_msg.set(m, optional_msg.subtype.msgclass.new)
 
-      assert msgdef.msgclass == TestMessage
-
+      assert_equal TestMessage, msgdef.msgclass
       optional_enum = msgdef.lookup "optional_enum"
-      assert optional_enum.subtype == TestEnum.descriptor
-      assert optional_enum.subtype.class == Google::Protobuf::EnumDescriptor
+      assert_equal TestEnum.descriptor, optional_enum.subtype
+      assert_instance_of Google::Protobuf::EnumDescriptor, optional_enum.subtype
       optional_enum.subtype.each do |k, v|
         # set with integer, check resolution to symbolic name
         optional_enum.set(m, v)
-        assert optional_enum.get(m) == k
+        assert_equal k, optional_enum.get(m)
       end
     end
 
@@ -1247,8 +1105,7 @@ module BasicTest
 
       json_text = TestMessage.encode_json(m)
       m2 = TestMessage.decode_json(json_text)
-      assert m == m2
-
+      assert_equal m, m2
       # Crash case from GitHub issue 283.
       bar = Bar.new(msg: "bar")
       baz1 = Baz.new(msg: "baz")
@@ -1270,7 +1127,7 @@ module BasicTest
       assert_equal expected_preserve, json
 
       m2 = MapMessage.decode_json(MapMessage.encode_json(m))
-      assert m == m2
+      assert_equal m, m2
     end
   end
 end
diff --git a/ruby/compatibility_tests/v3.0.0/tests/repeated_field_test.rb b/ruby/compatibility_tests/v3.0.0/tests/repeated_field_test.rb
index caebde1db7..5fd943b996 100755
--- a/ruby/compatibility_tests/v3.0.0/tests/repeated_field_test.rb
+++ b/ruby/compatibility_tests/v3.0.0/tests/repeated_field_test.rb
@@ -8,7 +8,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
   def test_acts_like_enumerator
     m = TestMessage.new
     (Enumerable.instance_methods - TestMessage.new.repeated_string.methods).each do |method_name|
-      assert m.repeated_string.respond_to?(method_name) == true, "does not respond to #{method_name}"
+      assert_equal "does not respond to #{method_name}", m.repeated_string.respond_to?(method_name), true
     end
   end
 
@@ -23,7 +23,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
     arr_methods -= [:intersection, :deconstruct] # ruby 2.7 methods we can ignore
     arr_methods -= [:intersect?] # ruby 3.1 methods we can ignore
     arr_methods.each do |method_name|
-      assert m.repeated_string.respond_to?(method_name) == true, "does not respond to #{method_name}"
+      assert_respond_to m.repeated_string, method_name
     end
   end
 
@@ -37,7 +37,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
     assert_equal -1_000_000, m.repeated_int64.first
     assert_equal 10, m.repeated_uint32.first
     assert_equal 1_000_000, m.repeated_uint64.first
-    assert_equal true, m.repeated_bool.first
+    assert m.repeated_bool.first
     assert_equal -1.01,  m.repeated_float.first.round(2)
     assert_equal -1.0000000000001, m.repeated_double.first
     assert_equal 'foo', m.repeated_string.first
@@ -57,7 +57,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
     assert_equal -1_000_001, m.repeated_int64.last
     assert_equal 11, m.repeated_uint32.last
     assert_equal 1_000_001, m.repeated_uint64.last
-    assert_equal false, m.repeated_bool.last
+    refute m.repeated_bool.last
     assert_equal -1.02, m.repeated_float.last.round(2)
     assert_equal -1.0000000000002, m.repeated_double.last
     assert_equal 'bar', m.repeated_string.last
@@ -82,8 +82,8 @@ class RepeatedFieldTest < Test::Unit::TestCase
     assert_equal 10, m.repeated_uint32.pop
     assert_equal 1_000_001, m.repeated_uint64.pop
     assert_equal 1_000_000, m.repeated_uint64.pop
-    assert_equal false, m.repeated_bool.pop
-    assert_equal true, m.repeated_bool.pop
+    refute m.repeated_bool.pop
+    assert m.repeated_bool.pop
     assert_equal -1.02,  m.repeated_float.pop.round(2)
     assert_equal -1.01,  m.repeated_float.pop.round(2)
     assert_equal -1.0000000000002, m.repeated_double.pop
@@ -122,11 +122,11 @@ class RepeatedFieldTest < Test::Unit::TestCase
 
   def test_empty?
     m = TestMessage.new
-    assert_equal true, m.repeated_string.empty?
+    assert_empty m.repeated_string
     m.repeated_string << 'foo'
-    assert_equal false, m.repeated_string.empty?
+    refute_empty m.repeated_string
     m.repeated_string << 'bar'
-    assert_equal false, m.repeated_string.empty?
+    refute_empty m.repeated_string
   end
 
   def test_array_accessor
@@ -252,7 +252,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
     m.repeated_string += reference_arr.clone
     assert_equal reference_arr, m.repeated_string
     reference_arr << 'fizz'
-    assert_not_equal reference_arr, m.repeated_string
+    refute_equal reference_arr, m.repeated_string
     m.repeated_string << 'fizz'
     assert_equal reference_arr, m.repeated_string
   end
@@ -266,7 +266,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
     hash = m.repeated_string.hash
     assert_equal hash, m.repeated_string.hash
     m.repeated_string << 'j'
-    assert_not_equal hash, m.repeated_string.hash
+    refute_equal hash, m.repeated_string.hash
   end
 
   def test_plus
@@ -469,7 +469,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
     result = m.repeated_string.shuffle!
     assert_equal m.repeated_string, result
     # NOTE: sometimes it doesn't change the order...
-    # assert_not_equal m.repeated_string.to_a, orig_repeated_string.to_a
+    # refute_equal m.repeated_string.to_a, orig_repeated_string.to_a
   end
 
   def test_slice!
diff --git a/ruby/compatibility_tests/v3.0.0/tests/stress.rb b/ruby/compatibility_tests/v3.0.0/tests/stress.rb
index 082d5e22df..b688e8b0bd 100755
--- a/ruby/compatibility_tests/v3.0.0/tests/stress.rb
+++ b/ruby/compatibility_tests/v3.0.0/tests/stress.rb
@@ -30,8 +30,8 @@ module StressTest
       100_000.times do
         mnew = TestMessage.decode(data)
         mnew = mnew.dup
-        assert_equal mnew.inspect, m.inspect
-        assert TestMessage.encode(mnew) == data
+        assert_equal m.inspect, mnew.inspect
+        assert_equal data, TestMessage.encode(mnew)
       end
     end
   end
diff --git a/ruby/tests/BUILD.bazel b/ruby/tests/BUILD.bazel
index 220e691faf..9ec6634f22 100644
--- a/ruby/tests/BUILD.bazel
+++ b/ruby/tests/BUILD.bazel
@@ -7,121 +7,123 @@ ruby_library(
 )
 
 filegroup(
-  name = "test_protos",
-  srcs = glob(["*.proto"]),
-  visibility = [
-      "//ruby:__subpackages__",
-  ],
+    name = "test_protos",
+    srcs = glob(["*.proto"]),
+    visibility = [
+        "//ruby:__subpackages__",
+    ],
 )
 
 ruby_test(
     name = "basic",
+    srcs = ["basic.rb"],
     deps = [
         ":common_tests",
         "//ruby:protobuf",
         "//ruby:test_ruby_protos",
-        "@protobuf_bundle//:test-unit"
+        "@protobuf_bundle//:test-unit",
     ],
-    srcs = ["basic.rb"],
 )
 
 ruby_test(
     name = "basic_proto2",
+    srcs = ["basic_proto2.rb"],
     deps = [
         ":common_tests",
         "//ruby:protobuf",
         "//ruby:test_ruby_protos",
-        "@protobuf_bundle//:test-unit"
+        "@protobuf_bundle//:test-unit",
     ],
-    srcs = ["basic_proto2.rb"],
 )
 
 ruby_test(
     name = "encode_decode_test",
+    srcs = ["encode_decode_test.rb"],
     deps = [
-        ":common_tests",
         "//ruby:protobuf",
         "//ruby:test_ruby_protos",
-        "@protobuf_bundle//:test-unit"
+        "@protobuf_bundle//:test-unit",
     ],
-    srcs = ["encode_decode_test.rb"],
 )
 
 ruby_test(
     name = "gc_test",
+    srcs = ["gc_test.rb"],
     deps = [
-        ":common_tests",
         "//ruby:protobuf",
         "//ruby:test_ruby_protos",
-        "@protobuf_bundle//:test-unit"
+        "@protobuf_bundle//:test-unit",
     ],
-    srcs = ["gc_test.rb"],
 )
 
 ruby_test(
     name = "generated_code_test",
+    srcs = ["generated_code_test.rb"],
     deps = [
-        ":common_tests",
         "//ruby:protobuf",
         "//ruby:test_ruby_protos",
-        "@protobuf_bundle//:test-unit"
+        "@protobuf_bundle//:test-unit",
     ],
-    srcs = ["generated_code_test.rb"],
 )
 
 ruby_test(
     name = "multi_level_nesting_test",
+    srcs = ["multi_level_nesting_test.rb"],
     deps = [
-        ":common_tests",
         "//ruby:protobuf",
         "//ruby:test_ruby_protos",
-        "@protobuf_bundle//:test-unit"
+        "@protobuf_bundle//:test-unit",
     ],
-    srcs = ["multi_level_nesting_test.rb"],
 )
 
 ruby_test(
     name = "repeated_field_test",
+    srcs = ["repeated_field_test.rb"],
     deps = [
-        ":common_tests",
         "//ruby:protobuf",
         "//ruby:test_ruby_protos",
-        "@protobuf_bundle//:test-unit"
+        "@protobuf_bundle//:test-unit",
     ],
-    srcs = ["repeated_field_test.rb"],
 )
 
 ruby_test(
     name = "ruby_version",
+    srcs = ["ruby_version.rb"],
     deps = [
-        ":common_tests",
         "//ruby:protobuf",
         "//ruby:test_ruby_protos",
-        "@protobuf_bundle//:test-unit"
+        "@protobuf_bundle//:test-unit",
     ],
-    srcs = ["ruby_version.rb"],
 )
 
 ruby_test(
     name = "stress",
+    srcs = ["stress.rb"],
     deps = [
-        ":common_tests",
         "//ruby:protobuf",
         "//ruby:test_ruby_protos",
-        "@protobuf_bundle//:test-unit"
+        "@protobuf_bundle//:test-unit",
     ],
-    srcs = ["stress.rb"],
 )
 
 ruby_test(
     name = "type_errors",
+    srcs = ["type_errors.rb"],
     deps = [
-        ":common_tests",
         "//ruby:protobuf",
         "//ruby:test_ruby_protos",
-        "@protobuf_bundle//:test-unit"
+        "@protobuf_bundle//:test-unit",
+    ],
+)
+
+ruby_test(
+    name = "well_known_types_test",
+    srcs = ["well_known_types_test.rb"],
+    deps = [
+        "//ruby:protobuf",
+        "//ruby:test_ruby_protos",
+        "@protobuf_bundle//:test-unit",
     ],
-    srcs = ["type_errors.rb"],
 )
 
 pkg_files(
@@ -135,4 +137,3 @@ pkg_files(
     strip_prefix = strip_prefix.from_root(""),
     visibility = ["//ruby:__pkg__"],
 )
-
diff --git a/ruby/tests/basic.rb b/ruby/tests/basic.rb
index 7351b9cd33..2da06df76a 100755
--- a/ruby/tests/basic.rb
+++ b/ruby/tests/basic.rb
@@ -56,7 +56,7 @@ module BasicTest
           inners: []
       )['inners'].to_s
 
-      assert_raise Google::Protobuf::TypeError do
+      assert_raises Google::Protobuf::TypeError do
         outer.new(
             inners: [nil]
         ).to_s
@@ -112,46 +112,46 @@ module BasicTest
 
     def test_has_field
       m = TestSingularFields.new
-      assert !m.has_singular_msg?
+      refute m.has_singular_msg?
       m.singular_msg = TestMessage2.new
       assert m.has_singular_msg?
       assert TestSingularFields.descriptor.lookup('singular_msg').has?(m)
 
       m = OneofMessage.new
-      assert !m.has_my_oneof?
-      assert !m.has_a?
+      refute m.has_my_oneof?
+      refute m.has_a?
       m.a = "foo"
       assert m.has_my_oneof?
       assert m.has_a?
       assert_true OneofMessage.descriptor.lookup('a').has?(m)
 
       m = TestSingularFields.new
-      assert_raise NoMethodError do
+      assert_raises NoMethodError do
         m.has_singular_int32?
       end
-      assert_raise ArgumentError do
+      assert_raises ArgumentError do
         TestSingularFields.descriptor.lookup('singular_int32').has?(m)
       end
 
-      assert_raise NoMethodError do
+      assert_raises NoMethodError do
         m.has_singular_string?
       end
-      assert_raise ArgumentError do
+      assert_raises ArgumentError do
         TestSingularFields.descriptor.lookup('singular_string').has?(m)
       end
 
-      assert_raise NoMethodError do
+      assert_raises NoMethodError do
         m.has_singular_bool?
       end
-      assert_raise ArgumentError do
+      assert_raises ArgumentError do
         TestSingularFields.descriptor.lookup('singular_bool').has?(m)
       end
 
       m = TestMessage.new
-      assert_raise NoMethodError do
+      assert_raises NoMethodError do
         m.has_repeated_msg?
       end
-      assert_raise ArgumentError do
+      assert_raises ArgumentError do
         TestMessage.descriptor.lookup('repeated_msg').has?(m)
       end
     end
@@ -161,14 +161,12 @@ module BasicTest
 
       # Explicitly setting to zero does not cause anything to be serialized.
       m.singular_int32 = 0
-      assert_equal "", TestSingularFields.encode(m)
-
+      assert_empty TestSingularFields.encode(m)
       # Explicitly setting to a non-zero value *does* cause serialization.
       m.singular_int32 = 1
-      assert_not_equal "", TestSingularFields.encode(m)
-
+      refute_empty TestSingularFields.encode(m)
       m.singular_int32 = 0
-      assert_equal "", TestSingularFields.encode(m)
+      assert_empty TestSingularFields.encode(m)
     end
 
     def test_set_clear_defaults
@@ -187,35 +185,33 @@ module BasicTest
       m.singular_string = "foo bar"
       assert_equal "foo bar", m.singular_string
       m.clear_singular_string
-      assert_equal "", m.singular_string
-
+      assert_empty m.singular_string
       m.singular_string = "foo"
       assert_equal "foo", m.singular_string
       TestSingularFields.descriptor.lookup('singular_string').clear(m)
-      assert_equal "", m.singular_string
-
+      assert_empty m.singular_string
       m.singular_msg = TestMessage2.new(:foo => 42)
       assert_equal TestMessage2.new(:foo => 42), m.singular_msg
       assert m.has_singular_msg?
       m.clear_singular_msg
-      assert_equal nil, m.singular_msg
-      assert !m.has_singular_msg?
+      assert_nil m.singular_msg
+      refute m.has_singular_msg?
 
       m.singular_msg = TestMessage2.new(:foo => 42)
       assert_equal TestMessage2.new(:foo => 42), m.singular_msg
       TestSingularFields.descriptor.lookup('singular_msg').clear(m)
-      assert_equal nil, m.singular_msg
+      assert_nil m.singular_msg
     end
 
     def test_import_proto2
       m = TestMessage.new
-      assert !m.has_optional_proto2_submessage?
+      refute m.has_optional_proto2_submessage?
       m.optional_proto2_submessage = ::FooBar::Proto2::TestImportedMessage.new
       assert m.has_optional_proto2_submessage?
       assert TestMessage.descriptor.lookup('optional_proto2_submessage').has?(m)
 
       m.clear_optional_proto2_submessage
-      assert !m.has_optional_proto2_submessage?
+      refute m.has_optional_proto2_submessage?
     end
 
     def test_clear_repeated_fields
@@ -224,96 +220,90 @@ module BasicTest
       m.repeated_int32.push(1)
       assert_equal [1], m.repeated_int32
       m.clear_repeated_int32
-      assert_equal [], m.repeated_int32
-
+      assert_empty m.repeated_int32
       m.repeated_int32.push(1)
       assert_equal [1], m.repeated_int32
       TestMessage.descriptor.lookup('repeated_int32').clear(m)
-      assert_equal [], m.repeated_int32
-
+      assert_empty m.repeated_int32
       m = OneofMessage.new
       m.a = "foo"
       assert_equal "foo", m.a
       assert m.has_my_oneof?
       assert_equal :a, m.my_oneof
       m.clear_a
-      assert !m.has_my_oneof?
+      refute m.has_my_oneof?
 
       m.a = "foobar"
       assert m.has_my_oneof?
       m.clear_my_oneof
-      assert !m.has_my_oneof?
+      refute m.has_my_oneof?
 
       m.a = "bar"
       assert_equal "bar", m.a
       assert m.has_my_oneof?
       OneofMessage.descriptor.lookup('a').clear(m)
-      assert !m.has_my_oneof?
+      refute m.has_my_oneof?
     end
 
     def test_initialization_map_errors
-      e = assert_raise ArgumentError do
+      e = assert_raises ArgumentError do
         TestMessage.new(:hello => "world")
       end
       assert_match(/hello/, e.message)
 
-      e = assert_raise ArgumentError do
+      e = assert_raises ArgumentError do
         MapMessage.new(:map_string_int32 => "hello")
       end
-      assert_equal e.message, "Expected Hash object as initializer value for map field 'map_string_int32' (given String)."
-
-      e = assert_raise ArgumentError do
+      assert_equal "Expected Hash object as initializer value for map field 'map_string_int32' (given String).", e.message
+      e = assert_raises ArgumentError do
         TestMessage.new(:repeated_uint32 => "hello")
       end
-      assert_equal e.message, "Expected array as initializer value for repeated field 'repeated_uint32' (given String)."
+      assert_equal "Expected array as initializer value for repeated field 'repeated_uint32' (given String).", e.message
     end
 
     def test_map_field
       m = MapMessage.new
-      assert m.map_string_int32 == {}
-      assert m.map_string_msg == {}
+      assert_empty m.map_string_int32.to_h
+      assert_empty m.map_string_msg.to_h
 
       m = MapMessage.new(
         :map_string_int32 => {"a" => 1, "b" => 2},
         :map_string_msg => {"a" => TestMessage2.new(:foo => 1),
                             "b" => TestMessage2.new(:foo => 2)},
         :map_string_enum => {"a" => :A, "b" => :B})
-      assert m.map_string_int32.keys.sort == ["a", "b"]
-      assert m.map_string_int32["a"] == 1
-      assert m.map_string_msg["b"].foo == 2
-      assert m.map_string_enum["a"] == :A
-
+      assert_equal ["a", "b"], m.map_string_int32.keys.sort
+      assert_equal 1, m.map_string_int32["a"]
+      assert_equal 2, m.map_string_msg["b"].foo
+      assert_equal :A, m.map_string_enum["a"]
       m.map_string_int32["c"] = 3
-      assert m.map_string_int32["c"] == 3
+      assert_equal 3, m.map_string_int32["c"]
       m.map_string_msg["c"] = TestMessage2.new(:foo => 3)
-      assert m.map_string_msg["c"] == TestMessage2.new(:foo => 3)
+      assert_equal TestMessage2.new(:foo => 3), m.map_string_msg["c"]
       m.map_string_msg.delete("b")
       m.map_string_msg.delete("c")
-      assert m.map_string_msg == { "a" => TestMessage2.new(:foo => 1) }
-
-      assert_raise Google::Protobuf::TypeError do
+      assert_equal({ "a" => TestMessage2.new(:foo => 1).to_h }, m.map_string_msg.to_h)
+      assert_raises Google::Protobuf::TypeError do
         m.map_string_msg["e"] = TestMessage.new # wrong value type
       end
       # ensure nothing was added by the above
-      assert m.map_string_msg == { "a" => TestMessage2.new(:foo => 1) }
-
+      assert_equal({ "a" => TestMessage2.new(:foo => 1).to_h }, m.map_string_msg.to_h)
       m.map_string_int32 = Google::Protobuf::Map.new(:string, :int32)
-      assert_raise Google::Protobuf::TypeError do
+      assert_raises Google::Protobuf::TypeError do
         m.map_string_int32 = Google::Protobuf::Map.new(:string, :int64)
       end
-      assert_raise Google::Protobuf::TypeError do
+      assert_raises Google::Protobuf::TypeError do
         m.map_string_int32 = {}
       end
 
-      assert_raise Google::Protobuf::TypeError do
+      assert_raises Google::Protobuf::TypeError do
         m = MapMessage.new(:map_string_int32 => { 1 => "I am not a number" })
       end
     end
 
     def test_map_field_with_symbol
       m = MapMessage.new
-      assert m.map_string_int32 == {}
-      assert m.map_string_msg == {}
+      assert_empty m.map_string_int32.to_h
+      assert_empty m.map_string_msg.to_h
 
       m = MapMessage.new(
         :map_string_int32 => {a: 1, "b" => 2},
@@ -335,7 +325,7 @@ module BasicTest
       expected_a = "<BasicTest::MapMessage: map_string_int32: {\"b\"=>2, \"a\"=>1}, map_string_msg: {\"b\"=><BasicTest::TestMessage2: foo: 2>, \"a\"=><BasicTest::TestMessage2: foo: 1>}, map_string_enum: {\"b\"=>:B, \"a\"=>:A}>"
       expected_b = "<BasicTest::MapMessage: map_string_int32: {\"a\"=>1, \"b\"=>2}, map_string_msg: {\"a\"=><BasicTest::TestMessage2: foo: 1>, \"b\"=><BasicTest::TestMessage2: foo: 2>}, map_string_enum: {\"a\"=>:A, \"b\"=>:B}>"
       inspect_result = m.inspect
-      assert expected_a == inspect_result || expected_b == inspect_result, "Incorrect inspect result: #{inspect_result}"
+      assert_includes [expected_a, expected_b], inspect_result
     end
 
     def test_map_corruption
@@ -353,7 +343,7 @@ module BasicTest
         assert_equal 4, m.map_int64[0].value
         assert_equal 5, m.map_uint32[0].value
         assert_equal 6, m.map_uint64[0].value
-        assert_equal true, m.map_bool[0].value
+        assert m.map_bool[0].value
         assert_equal 'str', m.map_string[0].value
         assert_equal 'fun', m.map_bytes[0].value
       }
@@ -395,9 +385,9 @@ module BasicTest
         assert_equal 0, m.map_int64[0].value
         assert_equal 0, m.map_uint32[0].value
         assert_equal 0, m.map_uint64[0].value
-        assert_equal false, m.map_bool[0].value
-        assert_equal '', m.map_string[0].value
-        assert_equal '', m.map_bytes[0].value
+        refute m.map_bool[0].value
+        assert_empty m.map_string[0].value
+        assert_empty m.map_bytes[0].value
       }
 
       m = proto_module::Wrapper.new(
@@ -437,9 +427,9 @@ module BasicTest
         assert_equal 0, m.map_int64[0].value
         assert_equal 0, m.map_uint32[0].value
         assert_equal 0, m.map_uint64[0].value
-        assert_equal false, m.map_bool[0].value
-        assert_equal '', m.map_string[0].value
-        assert_equal '', m.map_bytes[0].value
+        refute m.map_bool[0].value
+        assert_empty m.map_string[0].value
+        assert_empty m.map_bytes[0].value
       }
 
       m = proto_module::Wrapper.new(
@@ -489,19 +479,16 @@ module BasicTest
                             "b" => TestMessage2.new(:foo => 2)},
         :map_string_enum => {"a" => :A, "b" => :B})
       m2 = MapMessage.decode(MapMessage.encode(m))
-      assert m == m2
-
+      assert_equal m, m2
       m3 = MapMessageWireEquiv.decode(MapMessage.encode(m))
-      assert m3.map_string_int32.length == 2
-
+      assert_equal 2, m3.map_string_int32.length
       kv = {}
       m3.map_string_int32.map { |msg| kv[msg.key] = msg.value }
-      assert kv == {"a" => 1, "b" => 2}
-
+      assert_equal({"a" => 1, "b" => 2}, kv)
       kv = {}
       m3.map_string_msg.map { |msg| kv[msg.key] = msg.value }
-      assert kv == {"a" => TestMessage2.new(:foo => 1),
-                    "b" => TestMessage2.new(:foo => 2)}
+      assert_equal({"a" => TestMessage2.new(:foo => 1),
+                    "b" => TestMessage2.new(:foo => 2)}, kv)
     end
 
     def test_protobuf_decode_json_ignore_unknown_fields
@@ -510,8 +497,8 @@ module BasicTest
         not_in_message: "some_value"
       }.to_json, { ignore_unknown_fields: true })
 
-      assert_equal m.optional_string, "foo"
-      e = assert_raise Google::Protobuf::ParseError do
+      assert_equal "foo", m.optional_string
+      e = assert_raises Google::Protobuf::ParseError do
         TestMessage.decode_json({ not_in_message: "some_value" }.to_json)
       end
       assert_match(/No such field: not_in_message/, e.message)
@@ -573,10 +560,10 @@ module BasicTest
       m = MapMessage.new(:map_string_int32 => {"a" => 1})
       expected = {mapStringInt32: {a: 1}, mapStringMsg: {}, mapStringEnum: {}}
       expected_preserve = {map_string_int32: {a: 1}, map_string_msg: {}, map_string_enum: {}}
-      assert_equal JSON.parse(MapMessage.encode_json(m, :emit_defaults=>true), :symbolize_names => true), expected
+      assert_equal expected, JSON.parse(MapMessage.encode_json(m, :emit_defaults=>true), :symbolize_names => true)
 
       json = MapMessage.encode_json(m, :preserve_proto_fieldnames => true, :emit_defaults=>true)
-      assert_equal JSON.parse(json, :symbolize_names => true), expected_preserve
+      assert_equal expected_preserve, JSON.parse(json, :symbolize_names => true)
 
       m2 = MapMessage.decode_json(MapMessage.encode_json(m))
       assert_equal m, m2
@@ -588,7 +575,7 @@ module BasicTest
 
       actual = MapMessage.encode_json(m, :emit_defaults => true)
 
-      assert_equal JSON.parse(actual, :symbolize_names => true), expected
+      assert_equal expected, JSON.parse(actual, :symbolize_names => true)
     end
 
     def test_json_emit_defaults_submsg
@@ -615,18 +602,18 @@ module BasicTest
 
     def test_respond_to
       msg = MapMessage.new
-      assert msg.respond_to?(:map_string_int32)
-      assert !msg.respond_to?(:bacon)
+      assert_respond_to msg, :map_string_int32
+      refute_respond_to msg, :bacon
     end
 
     def test_file_descriptor
       file_descriptor = TestMessage.descriptor.file_descriptor
-      assert nil != file_descriptor
+      refute_nil file_descriptor
       assert_equal "tests/basic_test.proto", file_descriptor.name
       assert_equal :proto3, file_descriptor.syntax
 
       file_descriptor = TestEnum.descriptor.file_descriptor
-      assert nil != file_descriptor
+      refute_nil file_descriptor
       assert_equal "tests/basic_test.proto", file_descriptor.name
       assert_equal :proto3, file_descriptor.syntax
     end
@@ -645,10 +632,10 @@ module BasicTest
       assert m.map_string_int32.frozen?
       assert m.map_string_msg.frozen?
 
-      assert_raise(FrozenErrorType) { m.map_string_int32['foo'] = 1 }
-      assert_raise(FrozenErrorType) { m.map_string_msg['bar'] = proto_module::TestMessage2.new }
-      assert_raise(FrozenErrorType) { m.map_string_int32.delete('a') }
-      assert_raise(FrozenErrorType) { m.map_string_int32.clear }
+      assert_raises(FrozenErrorType) { m.map_string_int32['foo'] = 1 }
+      assert_raises(FrozenErrorType) { m.map_string_msg['bar'] = proto_module::TestMessage2.new }
+      assert_raises(FrozenErrorType) { m.map_string_int32.delete('a') }
+      assert_raises(FrozenErrorType) { m.map_string_int32.clear }
     end
 
     def test_map_length
@@ -691,23 +678,23 @@ module BasicTest
 
     def test_map_fields_respond_to? # regression test for issue 9202
       msg = proto_module::MapMessage.new
-      assert msg.respond_to?(:map_string_int32=)
+      assert_respond_to msg, :map_string_int32=
       msg.map_string_int32 = Google::Protobuf::Map.new(:string, :int32)
-      assert msg.respond_to?(:map_string_int32)
+      assert_respond_to msg, :map_string_int32
       assert_equal( Google::Protobuf::Map.new(:string, :int32), msg.map_string_int32 )
-      assert msg.respond_to?(:clear_map_string_int32)
+      assert_respond_to msg, :clear_map_string_int32
       msg.clear_map_string_int32
 
-      assert !msg.respond_to?(:has_map_string_int32?)
-      assert_raise NoMethodError do
+      refute_respond_to msg, :has_map_string_int32?
+      assert_raises NoMethodError do
         msg.has_map_string_int32?
       end
-      assert !msg.respond_to?(:map_string_int32_as_value)
-      assert_raise NoMethodError do
+      refute_respond_to msg, :map_string_int32_as_value
+      assert_raises NoMethodError do
         msg.map_string_int32_as_value
       end
-      assert !msg.respond_to?(:map_string_int32_as_value=)
-      assert_raise NoMethodError do
+      refute_respond_to msg, :map_string_int32_as_value=
+      assert_raises NoMethodError do
         msg.map_string_int32_as_value = :boom
       end
     end
@@ -718,13 +705,13 @@ module BasicTest
     # `has_` prefix + "?" suffix actions should work for oneofs fields and members.
     assert msg.has_my_oneof?
     assert msg.respond_to? :has_my_oneof?
-    assert msg.respond_to?( :has_a? )
-    assert !msg.has_a?
-    assert msg.respond_to?( :has_b? )
-    assert !msg.has_b?
-    assert msg.respond_to?( :has_c? )
-    assert !msg.has_c?
-    assert msg.respond_to?( :has_d? )
-    assert !msg.has_d?
+    assert_respond_to msg, :has_a?
+    refute msg.has_a?
+    assert_respond_to msg, :has_b?
+    refute msg.has_b?
+    assert_respond_to msg, :has_c?
+    refute msg.has_c?
+    assert_respond_to msg, :has_d?
+    refute msg.has_d?
   end
 end
diff --git a/ruby/tests/basic_proto2.rb b/ruby/tests/basic_proto2.rb
index 5391c302ee..e9e99e5459 100755
--- a/ruby/tests/basic_proto2.rb
+++ b/ruby/tests/basic_proto2.rb
@@ -35,34 +35,34 @@ module BasicTestProto2
 
     def test_has_field
       m = TestMessage.new
-      assert !m.has_optional_int32?
-      assert !TestMessage.descriptor.lookup('optional_int32').has?(m)
-      assert !m.has_optional_int64?
-      assert !TestMessage.descriptor.lookup('optional_int64').has?(m)
-      assert !m.has_optional_uint32?
-      assert !TestMessage.descriptor.lookup('optional_uint32').has?(m)
-      assert !m.has_optional_uint64?
-      assert !TestMessage.descriptor.lookup('optional_uint64').has?(m)
-      assert !m.has_optional_bool?
-      assert !TestMessage.descriptor.lookup('optional_bool').has?(m)
-      assert !m.has_optional_float?
-      assert !TestMessage.descriptor.lookup('optional_float').has?(m)
-      assert !m.has_optional_double?
-      assert !TestMessage.descriptor.lookup('optional_double').has?(m)
-      assert !m.has_optional_string?
-      assert !TestMessage.descriptor.lookup('optional_string').has?(m)
-      assert !m.has_optional_bytes?
-      assert !TestMessage.descriptor.lookup('optional_bytes').has?(m)
-      assert !m.has_optional_enum?
-      assert !TestMessage.descriptor.lookup('optional_enum').has?(m)
+      refute m.has_optional_int32?
+      refute TestMessage.descriptor.lookup('optional_int32').has?(m)
+      refute m.has_optional_int64?
+      refute TestMessage.descriptor.lookup('optional_int64').has?(m)
+      refute m.has_optional_uint32?
+      refute TestMessage.descriptor.lookup('optional_uint32').has?(m)
+      refute m.has_optional_uint64?
+      refute TestMessage.descriptor.lookup('optional_uint64').has?(m)
+      refute m.has_optional_bool?
+      refute TestMessage.descriptor.lookup('optional_bool').has?(m)
+      refute m.has_optional_float?
+      refute TestMessage.descriptor.lookup('optional_float').has?(m)
+      refute m.has_optional_double?
+      refute TestMessage.descriptor.lookup('optional_double').has?(m)
+      refute m.has_optional_string?
+      refute TestMessage.descriptor.lookup('optional_string').has?(m)
+      refute m.has_optional_bytes?
+      refute TestMessage.descriptor.lookup('optional_bytes').has?(m)
+      refute m.has_optional_enum?
+      refute TestMessage.descriptor.lookup('optional_enum').has?(m)
 
       m = TestMessage.new(:optional_int32 => nil)
-      assert !m.has_optional_int32?
+      refute m.has_optional_int32?
 
-      assert_raise NoMethodError do
+      assert_raises NoMethodError do
         m.has_repeated_msg?
       end
-      assert_raise ArgumentError do
+      assert_raises ArgumentError do
         TestMessage.descriptor.lookup('repeated_msg').has?(m)
       end
 
@@ -71,46 +71,46 @@ module BasicTestProto2
       assert TestMessage.descriptor.lookup('optional_msg').has?(m)
 
       m = OneofMessage.new
-      assert !m.has_my_oneof?
+      refute m.has_my_oneof?
       m.a = "foo"
       assert m.has_my_oneof?
       assert_equal :a, m.my_oneof
       assert m.has_a?
       assert OneofMessage.descriptor.lookup('a').has?(m)
       assert_equal "foo", m.a
-      assert !m.has_b?
-      assert !OneofMessage.descriptor.lookup('b').has?(m)
-      assert !m.has_c?
-      assert !OneofMessage.descriptor.lookup('c').has?(m)
-      assert !m.has_d?
-      assert !OneofMessage.descriptor.lookup('d').has?(m)
+      refute m.has_b?
+      refute OneofMessage.descriptor.lookup('b').has?(m)
+      refute m.has_c?
+      refute OneofMessage.descriptor.lookup('c').has?(m)
+      refute m.has_d?
+      refute OneofMessage.descriptor.lookup('d').has?(m)
 
       m = OneofMessage.new
       m.b = 100
       assert m.has_b?
       assert_equal 100, m.b
       assert m.has_my_oneof?
-      assert !m.has_a?
-      assert !m.has_c?
-      assert !m.has_d?
+      refute m.has_a?
+      refute m.has_c?
+      refute m.has_d?
 
       m = OneofMessage.new
       m.c = TestMessage2.new
       assert m.has_c?
       assert_equal TestMessage2.new, m.c
       assert m.has_my_oneof?
-      assert !m.has_a?
-      assert !m.has_b?
-      assert !m.has_d?
+      refute m.has_a?
+      refute m.has_b?
+      refute m.has_d?
 
       m = OneofMessage.new
       m.d = :A
       assert m.has_d?
       assert_equal :A, m.d
       assert m.has_my_oneof?
-      assert !m.has_a?
-      assert !m.has_b?
-      assert !m.has_c?
+      refute m.has_a?
+      refute m.has_b?
+      refute m.has_c?
     end
 
     def test_defined_defaults
@@ -119,23 +119,23 @@ module BasicTestProto2
       assert_equal 2, m.optional_int64
       assert_equal 3, m.optional_uint32
       assert_equal 4, m.optional_uint64
-      assert_equal true, m.optional_bool
+      assert m.optional_bool
       assert_equal 6.0, m.optional_float
       assert_equal 7.0, m.optional_double
       assert_equal "Default Str", m.optional_string
       assert_equal "\xCF\xA5s\xBD\xBA\xE6fubar".force_encoding("ASCII-8BIT"), m.optional_bytes
       assert_equal :B2, m.optional_enum
 
-      assert !m.has_optional_int32?
-      assert !m.has_optional_int64?
-      assert !m.has_optional_uint32?
-      assert !m.has_optional_uint64?
-      assert !m.has_optional_bool?
-      assert !m.has_optional_float?
-      assert !m.has_optional_double?
-      assert !m.has_optional_string?
-      assert !m.has_optional_bytes?
-      assert !m.has_optional_enum?
+      refute m.has_optional_int32?
+      refute m.has_optional_int64?
+      refute m.has_optional_uint32?
+      refute m.has_optional_uint64?
+      refute m.has_optional_bool?
+      refute m.has_optional_float?
+      refute m.has_optional_double?
+      refute m.has_optional_string?
+      refute m.has_optional_bytes?
+      refute m.has_optional_enum?
     end
 
     def test_set_clear_defaults
@@ -146,56 +146,55 @@ module BasicTestProto2
       assert m.has_optional_int32?
       m.clear_optional_int32
       assert_equal 1, m.optional_int32
-      assert !m.has_optional_int32?
+      refute m.has_optional_int32?
 
       m.optional_string = "foo bar"
       assert_equal "foo bar", m.optional_string
       assert m.has_optional_string?
       m.clear_optional_string
       assert_equal "Default Str", m.optional_string
-      assert !m.has_optional_string?
+      refute m.has_optional_string?
 
       m.optional_msg = TestMessage2.new(:foo => 42)
       assert_equal TestMessage2.new(:foo => 42), m.optional_msg
       assert m.has_optional_msg?
 
       m.clear_optional_msg
-      assert_equal nil, m.optional_msg
-      assert !m.has_optional_msg?
+      assert_nil m.optional_msg
+      refute m.has_optional_msg?
 
       m.optional_msg = TestMessage2.new(:foo => 42)
       assert_equal TestMessage2.new(:foo => 42), m.optional_msg
       assert TestMessageDefaults.descriptor.lookup('optional_msg').has?(m)
 
       TestMessageDefaults.descriptor.lookup('optional_msg').clear(m)
-      assert_equal nil, m.optional_msg
-      assert !TestMessageDefaults.descriptor.lookup('optional_msg').has?(m)
+      assert_nil m.optional_msg
+      refute TestMessageDefaults.descriptor.lookup('optional_msg').has?(m)
 
       m = TestMessage.new
       m.repeated_int32.push(1)
       assert_equal [1], m.repeated_int32
       m.clear_repeated_int32
-      assert_equal [], m.repeated_int32
-
+      assert_empty m.repeated_int32
       m = OneofMessage.new
       m.a = "foo"
       assert_equal "foo", m.a
       assert m.has_a?
       m.clear_a
-      assert !m.has_a?
+      refute m.has_a?
 
       m = OneofMessage.new
       m.a = "foobar"
       assert m.has_my_oneof?
       m.clear_my_oneof
-      assert !m.has_my_oneof?
+      refute m.has_my_oneof?
 
       m = OneofMessage.new
       m.a = "bar"
       assert_equal "bar", m.a
       assert m.has_my_oneof?
       OneofMessage.descriptor.lookup('a').clear(m)
-      assert !m.has_my_oneof?
+      refute m.has_my_oneof?
     end
 
     def test_assign_nil
@@ -205,20 +204,20 @@ module BasicTestProto2
       assert_equal TestMessage2.new(:foo => 42), m.optional_msg
       assert m.has_optional_msg?
       m.optional_msg = nil
-      assert_equal nil, m.optional_msg
-      assert !m.has_optional_msg?
+      assert_nil m.optional_msg
+      refute m.has_optional_msg?
     end
 
     def test_initialization_map_errors
-      e = assert_raise ArgumentError do
+      e = assert_raises ArgumentError do
         TestMessage.new(:hello => "world")
       end
       assert_match(/hello/, e.message)
 
-      e = assert_raise ArgumentError do
+      e = assert_raises ArgumentError do
         TestMessage.new(:repeated_uint32 => "hello")
       end
-      assert_equal e.message, "Expected array as initializer value for repeated field 'repeated_uint32' (given String)."
+      assert_equal "Expected array as initializer value for repeated field 'repeated_uint32' (given String).", e.message
     end
 
 
@@ -241,17 +240,17 @@ module BasicTestProto2
       # This test fails with JRuby 1.7.23, likely because of an old JRuby bug.
       return if RUBY_PLATFORM == "java"
       msg = TestMessage.new
-      assert !msg.respond_to?(:bacon)
+      refute_respond_to msg, :bacon
     end
 
     def test_file_descriptor
       file_descriptor = TestMessage.descriptor.file_descriptor
-      assert nil != file_descriptor
+      refute_nil file_descriptor
       assert_equal "tests/basic_test_proto2.proto", file_descriptor.name
       assert_equal :proto2, file_descriptor.syntax
 
       file_descriptor = TestEnum.descriptor.file_descriptor
-      assert nil != file_descriptor
+      refute_nil file_descriptor
       assert_equal "tests/basic_test_proto2.proto", file_descriptor.name
       assert_equal :proto2, file_descriptor.syntax
     end
@@ -264,11 +263,11 @@ module BasicTestProto2
       assert msg.respond_to? :has_a?
       assert msg.has_a?
       assert msg.respond_to? :has_b?
-      assert !msg.has_b?
+      refute msg.has_b?
       assert msg.respond_to? :has_c?
-      assert !msg.has_c?
+      refute msg.has_c?
       assert msg.respond_to? :has_d?
-      assert !msg.has_d?
+      refute msg.has_d?
     end
   end
 end
diff --git a/ruby/tests/common_tests.rb b/ruby/tests/common_tests.rb
index 28494f9c08..afa3da59d1 100644
--- a/ruby/tests/common_tests.rb
+++ b/ruby/tests/common_tests.rb
@@ -14,49 +14,49 @@ module CommonTests
 
   def test_defaults
     m = proto_module::TestMessage.new
-    assert m.optional_int32 == 0
-    assert m.optional_int64 == 0
-    assert m.optional_uint32 == 0
-    assert m.optional_uint64 == 0
-    assert m.optional_bool == false
-    assert m.optional_float == 0.0
-    assert m.optional_double == 0.0
-    assert m.optional_string == ""
-    assert m.optional_bytes == ""
-    assert m.optional_msg == nil
-    assert m.optional_enum == :Default
+    assert_equal 0, m.optional_int32
+    assert_equal 0, m.optional_int64
+    assert_equal 0, m.optional_uint32
+    assert_equal 0, m.optional_uint64
+    refute m.optional_bool
+    assert_equal 0.0, m.optional_float
+    assert_equal 0.0, m.optional_double
+    assert_empty m.optional_string
+    assert_empty m.optional_bytes
+    assert_nil m.optional_msg
+    assert_equal :Default, m.optional_enum
   end
 
   def test_setters
     m = proto_module::TestMessage.new
     m.optional_int32 = -42
-    assert m.optional_int32 == -42
+    assert_equal -42, m.optional_int32
     m.optional_int64 = -0x1_0000_0000
-    assert m.optional_int64 == -0x1_0000_0000
+    assert_equal -0x1_0000_0000, m.optional_int64
     m.optional_uint32 = 0x9000_0000
-    assert m.optional_uint32 == 0x9000_0000
+    assert_equal 0x9000_0000, m.optional_uint32
     m.optional_uint64 = 0x9000_0000_0000_0000
-    assert m.optional_uint64 == 0x9000_0000_0000_0000
+    assert_equal 0x9000_0000_0000_0000, m.optional_uint64
     m.optional_bool = true
-    assert m.optional_bool == true
+    assert_equal m.optional_bool, true
     m.optional_float = 0.5
-    assert m.optional_float == 0.5
+    assert_equal 0.5, m.optional_float
     m.optional_double = 0.5
-    assert m.optional_double == 0.5
+    assert_equal 0.5, m.optional_double
     m.optional_string = "hello"
-    assert m.optional_string == "hello"
+    assert_equal "hello", m.optional_string
     m.optional_string = :hello
-    assert m.optional_string == "hello"
+    assert_equal "hello", m.optional_string
     m.optional_bytes = "world".encode!('ASCII-8BIT')
-    assert m.optional_bytes == "world"
+    assert_equal "world", m.optional_bytes
     m.optional_msg = proto_module::TestMessage2.new(:foo => 42)
-    assert m.optional_msg == proto_module::TestMessage2.new(:foo => 42)
+    assert_equal proto_module::TestMessage2.new(:foo => 42), m.optional_msg
     m.optional_msg = nil
-    assert m.optional_msg == nil
+    assert_nil m.optional_msg
     m.optional_enum = :C
-    assert m.optional_enum == :C
+    assert_equal :C, m.optional_enum
     m.optional_enum = 'C'
-    assert m.optional_enum == :C
+    assert_equal :C, m.optional_enum
   end
 
   def test_ctor_args
@@ -64,20 +64,19 @@ module CommonTests
                                       :optional_msg => proto_module::TestMessage2.new,
                                       :optional_enum => :C,
                                       :repeated_string => ["hello", "there", "world"])
-    assert m.optional_int32 == -42
-    assert m.optional_msg.class == proto_module::TestMessage2
-    assert m.repeated_string.length == 3
-    assert m.optional_enum == :C
-    assert m.repeated_string[0] == "hello"
-    assert m.repeated_string[1] == "there"
-    assert m.repeated_string[2] == "world"
+    assert_equal -42, m.optional_int32
+    assert_instance_of proto_module::TestMessage2, m.optional_msg
+    assert_equal 3, m.repeated_string.length
+    assert_equal :C, m.optional_enum
+    assert_equal "hello", m.repeated_string[0]
+    assert_equal "there", m.repeated_string[1]
+    assert_equal "world", m.repeated_string[2]
   end
 
   def test_ctor_string_symbol_args
     m = proto_module::TestMessage.new(:optional_enum => 'C', :repeated_enum => ['A', 'B'])
     assert_equal :C, m.optional_enum
     assert_equal [:A, :B], m.repeated_enum
-
     m = proto_module::TestMessage.new(:optional_string => :foo, :repeated_string => [:foo, :bar])
     assert_equal 'foo', m.optional_string
     assert_equal ['foo', 'bar'], m.repeated_string
@@ -88,7 +87,7 @@ module CommonTests
 
     assert_equal :Default, m.optional_enum
     assert_equal 0, m.optional_int32
-    assert_equal "", m.optional_string
+    assert_empty m.optional_string
     assert_nil m.optional_msg
   end
 
@@ -102,11 +101,10 @@ module CommonTests
     assert_equal 2, m.number
     assert_equal [10, 20, 30], m.repeated_number
 
-    assert_not_nil m.child_msg
-    assert_not_nil m.child_msg.sub_child
-    assert_equal m.child_msg.sub_child.optional_int32, 1
-
-    assert_not_nil m.repeated_msg
+    refute_nil m.child_msg
+    refute_nil m.child_msg.sub_child
+    assert_equal 1, m.child_msg.sub_child.optional_int32
+    refute_nil m.repeated_msg
     assert_equal 1, m.repeated_msg.length
     assert_equal 3, m.repeated_msg.first.sub_child.optional_int32
   end
@@ -131,22 +129,22 @@ module CommonTests
     m1 = proto_module::TestMessage.new(:optional_int32 => 42)
     m2 = proto_module::TestMessage.new(:optional_int32 => 102, repeated_string: ['please', 'work', 'ok?'])
     m3 = proto_module::TestMessage.new(:optional_int32 => 102, repeated_string: ['please', 'work', 'ok?'])
-    assert m1.hash != 0
-    assert m2.hash != 0
-    assert m3.hash != 0
+    refute_equal 0, m1.hash
+    refute_equal 0, m2.hash
+    refute_equal 0, m3.hash
     # relying on the randomness here -- if hash function changes and we are
     # unlucky enough to get a collision, then change the values above.
-    assert m1.hash != m2.hash
+    refute_equal m1.hash, m2.hash
     assert_equal m2.hash, m3.hash
   end
 
   def test_unknown_field_errors
-    e = assert_raise NoMethodError do
+    e = assert_raises NoMethodError do
       proto_module::TestMessage.new.hello
     end
     assert_match(/hello/, e.message)
 
-    e = assert_raise NoMethodError do
+    e = assert_raises NoMethodError do
       proto_module::TestMessage.new.hello = "world"
     end
     assert_match(/hello/, e.message)
@@ -154,7 +152,7 @@ module CommonTests
 
   def test_type_errors
     m = proto_module::TestMessage.new
-    e = assert_raise Google::Protobuf::TypeError do
+    e = assert_raises Google::Protobuf::TypeError do
       m.optional_int32 = "hello"
     end
 
@@ -162,28 +160,28 @@ module CommonTests
     # TODO: This can be removed when we can safely migrate to Google::Protobuf::TypeError
     assert e.is_a?(::TypeError)
 
-    assert_raise Google::Protobuf::TypeError do
+    assert_raises Google::Protobuf::TypeError do
       m.optional_string = 42
     end
-    assert_raise Google::Protobuf::TypeError do
+    assert_raises Google::Protobuf::TypeError do
       m.optional_string = nil
     end
-    assert_raise Google::Protobuf::TypeError do
+    assert_raises Google::Protobuf::TypeError do
       m.optional_bool = 42
     end
-    assert_raise Google::Protobuf::TypeError do
+    assert_raises Google::Protobuf::TypeError do
       m.optional_msg = proto_module::TestMessage.new  # expects TestMessage2
     end
 
-    assert_raise Google::Protobuf::TypeError do
+    assert_raises Google::Protobuf::TypeError do
       m.repeated_int32 = []  # needs RepeatedField
     end
 
-    assert_raise Google::Protobuf::TypeError do
+    assert_raises Google::Protobuf::TypeError do
       m.repeated_int32.push "hello"
     end
 
-    assert_raise Google::Protobuf::TypeError do
+    assert_raises Google::Protobuf::TypeError do
       m.repeated_msg.push proto_module::TestMessage.new
     end
   end
@@ -198,11 +196,11 @@ module CommonTests
     assert_equal Encoding::ASCII_8BIT, m.optional_bytes.encoding
     assert_equal "Test string ASCII", m.optional_bytes
 
-    assert_raise Encoding::UndefinedConversionError do
+    assert_raises Encoding::UndefinedConversionError do
       m.optional_bytes = "Test string UTF-8 \u0100".encode!('UTF-8')
     end
 
-    assert_raise Encoding::UndefinedConversionError do
+    assert_raises Encoding::UndefinedConversionError do
       m.optional_string = ["FFFF"].pack('H*')
     end
 
@@ -212,118 +210,108 @@ module CommonTests
 
     # strings are immutable so we can't do this, but serialize should catch it.
     m.optional_string = "asdf".encode!('UTF-8')
-    assert_raise(FrozenErrorType) { m.optional_string.encode!('ASCII-8BIT') }
+    assert_raises(FrozenErrorType) { m.optional_string.encode!('ASCII-8BIT') }
   end
 
   def test_rptfield_int32
     l = Google::Protobuf::RepeatedField.new(:int32)
-    assert l.count == 0
+    assert_equal 0, l.count
     l = Google::Protobuf::RepeatedField.new(:int32, [1, 2, 3])
-    assert l.count == 3
+    assert_equal 3, l.count
     assert_equal [1, 2, 3], l
     assert_equal l, [1, 2, 3]
     l.push 4
-    assert l == [1, 2, 3, 4]
+    assert_equal [1, 2, 3, 4], l
     dst_list = []
     l.each { |val| dst_list.push val }
-    assert dst_list == [1, 2, 3, 4]
-    assert l.to_a == [1, 2, 3, 4]
-    assert l[0] == 1
-    assert l[3] == 4
+    assert_equal [1, 2, 3, 4], dst_list
+    assert_equal [1, 2, 3, 4], l.to_a
+    assert_equal 1, l[0]
+    assert_equal 4, l[3]
     l[0] = 5
-    assert l == [5, 2, 3, 4]
-
+    assert_equal [5, 2, 3, 4], l
     l2 = l.dup
-    assert l == l2
-    assert l.object_id != l2.object_id
+    assert_equal l, l2
+    refute_same l, l2
     l2.push 6
-    assert l.count == 4
-    assert l2.count == 5
-
-    assert l.inspect == '[5, 2, 3, 4]'
-
+    assert_equal 4, l.count
+    assert_equal 5, l2.count
+    assert_equal '[5, 2, 3, 4]', l.inspect
     l.concat([7, 8, 9])
-    assert l == [5, 2, 3, 4, 7, 8, 9]
-    assert l.pop == 9
-    assert l == [5, 2, 3, 4, 7, 8]
-
-    assert_raise Google::Protobuf::TypeError do
+    assert_equal [5, 2, 3, 4, 7, 8, 9], l
+    assert_equal 9, l.pop
+    assert_equal [5, 2, 3, 4, 7, 8], l
+    assert_raises Google::Protobuf::TypeError do
       m = proto_module::TestMessage.new
       l.push m
     end
 
     m = proto_module::TestMessage.new
     m.repeated_int32 = l
-    assert m.repeated_int32 == [5, 2, 3, 4, 7, 8]
-    assert m.repeated_int32.object_id == l.object_id
+    assert_equal [5, 2, 3, 4, 7, 8], m.repeated_int32
+    assert_equal m.repeated_int32.object_id, l.object_id
     l.push 42
-    assert m.repeated_int32.pop == 42
-
+    assert_equal 42, m.repeated_int32.pop
     l3 = l + l.dup
-    assert l3.count == l.count * 2
+    assert_equal l3.count, l.count * 2
     l.count.times do |i|
-      assert l3[i] == l[i]
-      assert l3[l.count + i] == l[i]
+      assert_equal l[i], l3[i] 
+      assert_equal l[i], l3[l.count + i]
     end
 
     l.clear
-    assert l.count == 0
+    assert_equal 0, l.count
     l += [1, 2, 3, 4]
     l.replace([5, 6, 7, 8])
-    assert l == [5, 6, 7, 8]
-
+    assert_equal [5, 6, 7, 8], l
     l4 = Google::Protobuf::RepeatedField.new(:int32)
     l4[5] = 42
-    assert l4 == [0, 0, 0, 0, 0, 42]
-
+    assert_equal [0, 0, 0, 0, 0, 42], l4
     l4 << 100
-    assert l4 == [0, 0, 0, 0, 0, 42, 100]
+    assert_equal [0, 0, 0, 0, 0, 42, 100], l4
     l4 << 101 << 102
-    assert l4 == [0, 0, 0, 0, 0, 42, 100, 101, 102]
+    assert_equal [0, 0, 0, 0, 0, 42, 100, 101, 102], l4
   end
 
   def test_parent_rptfield
     #make sure we set the RepeatedField and can add to it
     m = proto_module::TestMessage.new
-    assert m.repeated_string == []
+    assert_empty m.repeated_string
     m.repeated_string << 'ok'
     m.repeated_string.push('ok2')
-    assert m.repeated_string == ['ok', 'ok2']
+    assert_equal ['ok', 'ok2'], m.repeated_string
     m.repeated_string += ['ok3']
-    assert m.repeated_string == ['ok', 'ok2', 'ok3']
+    assert_equal ['ok', 'ok2', 'ok3'], m.repeated_string
   end
 
   def test_rptfield_msg
     l = Google::Protobuf::RepeatedField.new(:message, proto_module::TestMessage)
     l.push proto_module::TestMessage.new
-    assert l.count == 1
-    assert_raise Google::Protobuf::TypeError do
+    assert_equal 1, l.count
+    assert_raises Google::Protobuf::TypeError do
       l.push proto_module::TestMessage2.new
     end
-    assert_raise Google::Protobuf::TypeError do
+    assert_raises Google::Protobuf::TypeError do
       l.push 42
     end
 
     l2 = l.dup
-    assert l2[0] == l[0]
-    assert l2[0].object_id == l[0].object_id
-
+    assert_equal l[0], l2[0]
+    assert_same l2[0], l[0]
     l2 = Google::Protobuf.deep_copy(l)
-    assert l2[0] == l[0]
-    assert l2[0].object_id != l[0].object_id
-
+    assert_equal l[0], l2[0]
+    refute_same l2[0], l[0]
     l3 = l + l2
-    assert l3.count == 2
-    assert l3[0] == l[0]
-    assert l3[1] == l2[0]
+    assert_equal 2, l3.count
+    assert_equal l[0], l3[0]
+    assert_equal l2[0], l3[1]
     l3[0].optional_int32 = 1000
-    assert l[0].optional_int32 == 1000
-
+    assert_equal 1000, l[0].optional_int32
     new_msg = proto_module::TestMessage.new(:optional_int32 => 200)
     l4 = l + [new_msg]
-    assert l4.count == 2
+    assert_equal 2, l4.count
     new_msg.optional_int32 = 1000
-    assert l4[1].optional_int32 == 1000
+    assert_equal 1000, l4[1].optional_int32
   end
 
   def test_rptfield_enum
@@ -332,28 +320,27 @@ module CommonTests
     l.push :B
     l.push :C
     l.push :v0
-    assert l.count == 4
-    assert_raise RangeError do
+    assert_equal 4, l.count
+    assert_raises RangeError do
       l.push :D
     end
-    assert l[0] == :A
-    assert l[3] == :v0
-
+    assert_equal :A, l[0]
+    assert_equal :v0, l[3]
     l.push 5
-    assert l[4] == 5
+    assert_equal 5, l[4]
   end
 
   def test_rptfield_initialize
-    assert_raise ArgumentError do
+    assert_raises ArgumentError do
       Google::Protobuf::RepeatedField.new
     end
-    assert_raise ArgumentError do
+    assert_raises ArgumentError do
       Google::Protobuf::RepeatedField.new(:message)
     end
-    assert_raise ArgumentError do
+    assert_raises ArgumentError do
       Google::Protobuf::RepeatedField.new([1, 2, 3])
     end
-    assert_raise ArgumentError do
+    assert_raises ArgumentError do
       Google::Protobuf::RepeatedField.new(:message, [proto_module::TestMessage2.new])
     end
   end
@@ -362,32 +349,30 @@ module CommonTests
     l = Google::Protobuf::RepeatedField.new(:int32)
     length_methods = %w(count length size)
     length_methods.each do |lm|
-      assert l.send(lm)  == 0
+      assert_equal 0, l.send(lm)
     end
     # out of bounds returns a nil
-    assert l[0] == nil
-    assert l[1] == nil
-    assert l[-1] == nil
+    assert_nil l[0]
+    assert_nil l[1]
+    assert_nil l[-1]
     l.push 4
     length_methods.each do |lm|
-      assert l.send(lm) == 1
+      assert_equal 1, l.send(lm)
     end
-    assert l[0] == 4
-    assert l[1] == nil
-    assert l[-1] == 4
-    assert l[-2] == nil
-
+    assert_equal 4, l[0]
+    assert_nil l[1]
+    assert_equal 4, l[-1]
+    assert_nil l[-2]
     l.push 2
     length_methods.each do |lm|
-      assert l.send(lm) == 2
-    end
-    assert l[0] == 4
-    assert l[1] == 2
-    assert l[2] == nil
-    assert l[-1] == 2
-    assert l[-2] == 4
-    assert l[-3] == nil
-
+      assert_equal 2, l.send(lm)
+    end
+    assert_equal 4, l[0]
+    assert_equal 2, l[1]
+    assert_nil l[2]
+    assert_equal 2, l[-1]
+    assert_equal 4, l[-2]
+    assert_nil l[-3]
     #adding out of scope will backfill with empty objects
   end
 
@@ -397,43 +382,39 @@ module CommonTests
 
     m = Google::Protobuf::Map.new(:string, :int32)
     m["asdf"] = 1
-    assert m["asdf"] == 1
+    assert_equal 1, m["asdf"]
     m["jkl;"] = 42
-    assert m == { "jkl;" => 42, "asdf" => 1 }
+    assert_equal({ "jkl;" => 42, "asdf" => 1 }, m.to_h)
     assert m.has_key?("asdf")
-    assert !m.has_key?("qwerty")
-    assert m.length == 2
-
+    refute m.has_key?("qwerty")
+    assert_equal 2, m.length
     m2 = m.dup
     assert_equal m, m2
-    assert m.hash != 0
+    refute_equal 0, m.hash
     assert_equal m.hash, m2.hash
 
     collected = {}
     m.each { |k,v| collected[v] = k }
-    assert collected == { 42 => "jkl;", 1 => "asdf" }
-
-    assert m.delete("asdf") == 1
-    assert !m.has_key?("asdf")
-    assert m["asdf"] == nil
-    assert !m.has_key?("asdf")
+    assert_equal({ 42 => "jkl;", 1 => "asdf" }, collected)
+    assert_equal 1, m.delete("asdf")
+    refute m.has_key?("asdf")
+    assert_nil m["asdf"]
+    refute m.has_key?("asdf")
 
     # We only assert on inspect value when there is one map entry because the
     # order in which elements appear is unspecified (depends on the internal
     # hash function). We don't want a brittle test.
-    assert m.inspect == "{\"jkl;\"=>42}"
-
-    assert m.keys == ["jkl;"]
-    assert m.values == [42]
-
+    assert_equal "{\"jkl;\"=>42}", m.inspect
+    assert_equal ["jkl;"], m.keys
+    assert_equal [42], m.values
     m.clear
-    assert m.length == 0
-    assert m == {}
+    assert_equal 0, m.length
+    assert_empty m.to_h
 
-    assert_raise Google::Protobuf::TypeError do
+    assert_raises Google::Protobuf::TypeError do
       m[1] = 1
     end
-    assert_raise RangeError do
+    assert_raises RangeError do
       m["asdf"] = 0x1_0000_0000
     end
   end
@@ -447,69 +428,69 @@ module CommonTests
     m1["counter"] = "a"
     m2["counter"] = "aa"
 
-    assert_not_equal m1, m2
+    refute_equal m1, m2
   end
 
   def test_map_ctor
     m = Google::Protobuf::Map.new(:string, :int32,
                                   {"a" => 1, "b" => 2, "c" => 3})
-    assert m == {"a" => 1, "c" => 3, "b" => 2}
+    assert_equal({"a" => 1, "c" => 3, "b" => 2}, m.to_h)
   end
 
   def test_map_keytypes
     m = Google::Protobuf::Map.new(:int32, :int32)
     m[1] = 42
     m[-1] = 42
-    assert_raise RangeError do
+    assert_raises RangeError do
       m[0x8000_0000] = 1
     end
-    assert_raise Google::Protobuf::TypeError do
+    assert_raises Google::Protobuf::TypeError do
       m["asdf"] = 1
     end
 
     m = Google::Protobuf::Map.new(:int64, :int32)
     m[0x1000_0000_0000_0000] = 1
-    assert_raise RangeError do
+    assert_raises RangeError do
       m[0x1_0000_0000_0000_0000] = 1
     end
-    assert_raise Google::Protobuf::TypeError do
+    assert_raises Google::Protobuf::TypeError do
       m["asdf"] = 1
     end
 
     m = Google::Protobuf::Map.new(:uint32, :int32)
     m[0x8000_0000] = 1
-    assert_raise RangeError do
+    assert_raises RangeError do
       m[0x1_0000_0000] = 1
     end
-    assert_raise RangeError do
+    assert_raises RangeError do
       m[-1] = 1
     end
 
     m = Google::Protobuf::Map.new(:uint64, :int32)
     m[0x8000_0000_0000_0000] = 1
-    assert_raise RangeError do
+    assert_raises RangeError do
       m[0x1_0000_0000_0000_0000] = 1
     end
-    assert_raise RangeError do
+    assert_raises RangeError do
       m[-1] = 1
     end
 
     m = Google::Protobuf::Map.new(:bool, :int32)
     m[true] = 1
     m[false] = 2
-    assert_raise Google::Protobuf::TypeError do
+    assert_raises Google::Protobuf::TypeError do
       m[1] = 1
     end
-    assert_raise Google::Protobuf::TypeError do
+    assert_raises Google::Protobuf::TypeError do
       m["asdf"] = 1
     end
 
     m = Google::Protobuf::Map.new(:string, :int32)
     m["asdf"] = 1
-    assert_raise Google::Protobuf::TypeError do
+    assert_raises Google::Protobuf::TypeError do
       m[1] = 1
     end
-    assert_raise Encoding::UndefinedConversionError do
+    assert_raises Encoding::UndefinedConversionError do
       bytestring = ["FFFF"].pack("H*")
       m[bytestring] = 1
     end
@@ -519,7 +500,7 @@ module CommonTests
     m[bytestring] = 1
     # Allowed -- we will automatically convert to ASCII-8BIT.
     m["asdf"] = 1
-    assert_raise Google::Protobuf::TypeError do
+    assert_raises Google::Protobuf::TypeError do
       m[1] = 1
     end
   end
@@ -527,7 +508,7 @@ module CommonTests
   def test_map_msg_enum_valuetypes
     m = Google::Protobuf::Map.new(:string, :message, proto_module::TestMessage)
     m["asdf"] = proto_module::TestMessage.new
-    assert_raise Google::Protobuf::TypeError do
+    assert_raises Google::Protobuf::TypeError do
       m["jkl;"] = proto_module::TestMessage2.new
     end
 
@@ -535,21 +516,20 @@ module CommonTests
       :string, :message, proto_module::TestMessage,
       { "a" => proto_module::TestMessage.new(:optional_int32 => 42),
         "b" => proto_module::TestMessage.new(:optional_int32 => 84) })
-    assert m.length == 2
-    assert m.values.map{|msg| msg.optional_int32}.sort == [42, 84]
-
+    assert_equal 2, m.length
+    assert_equal [42, 84], m.values.map{|msg| msg.optional_int32}.sort
     m = Google::Protobuf::Map.new(:string, :enum, proto_module::TestEnum,
                                   { "x" => :A, "y" => :B, "z" => :C })
-    assert m.length == 3
-    assert m["z"] == :C
+    assert_equal 3, m.length
+    assert_equal :C, m["z"]
     m["z"] = 2
-    assert m["z"] == :B
+    assert_equal :B, m["z"]
     m["z"] = 5
-    assert m["z"] == 5
-    assert_raise RangeError do
+    assert_equal 5, m["z"]
+    assert_raises RangeError do
       m["z"] = :Z
     end
-    assert_raise RangeError do
+    assert_raises RangeError do
       m["z"] = "z"
     end
   end
@@ -561,75 +541,68 @@ module CommonTests
         "b" => proto_module::TestMessage.new(:optional_int32 => 84) })
 
     m2 = m.dup
-    assert m.to_h == m2.to_h
-    assert m == m2
-    assert m.object_id != m2.object_id
-    assert m["a"].object_id == m2["a"].object_id
-    assert m["b"].object_id == m2["b"].object_id
-
+    assert_equal m.to_h, m2.to_h
+    assert_equal m, m2
+    refute_same m, m2
+    assert_same m["a"], m2["a"]
+    assert_same m["b"], m2["b"]
     m2 = Google::Protobuf.deep_copy(m)
-    assert m == m2
-    assert m.object_id != m2.object_id
-    assert m["a"].object_id != m2["a"].object_id
-    assert m["b"].object_id != m2["b"].object_id
+    assert_equal m, m2
+    refute_same m, m2
+    refute_same m["a"], m2["a"]
+    refute_same m["b"], m2["b"]
   end
 
   def test_oneof_descriptors
     d = proto_module::OneofMessage.descriptor
     o = d.lookup_oneof("my_oneof")
-    assert o != nil
-    assert o.class == Google::Protobuf::OneofDescriptor
-    assert o.name == "my_oneof"
+    refute_nil o
+    assert_instance_of Google::Protobuf::OneofDescriptor, o
+    assert_equal "my_oneof", o.name
     oneof_count = 0
     d.each_oneof{ |oneof|
       oneof_count += 1
-      assert oneof == o
+      assert_equal o, oneof
     }
-    assert oneof_count == 1
-    assert o.count == 4
+    assert_equal 1, oneof_count
+    assert_equal 4, o.count
     field_names = o.map{|f| f.name}.sort
-    assert field_names == ["a", "b", "c", "d"]
+    assert_equal ["a", "b", "c", "d"], field_names
   end
 
   def test_oneof
     d = proto_module::OneofMessage.new
-    assert d.a == ""
-    assert d.b == 0
-    assert d.c == nil
-    assert d.d == :Default
-    assert d.my_oneof == nil
-
+    assert_empty d.a
+    assert_equal 0, d.b
+    assert_nil d.c
+    assert_equal :Default, d.d
+    assert_nil d.my_oneof
     d.a = "hi"
-    assert d.a == "hi"
-    assert d.b == 0
-    assert d.c == nil
-    assert d.d == :Default
-    assert d.my_oneof == :a
-
+    assert_equal "hi", d.a
+    assert_equal 0, d.b
+    assert_nil d.c
+    assert_equal :Default, d.d
+    assert_equal :a, d.my_oneof
     d.b = 42
-    assert d.a == ""
-    assert d.b == 42
-    assert d.c == nil
-    assert d.d == :Default
-    assert d.my_oneof == :b
-
+    assert_empty d.a
+    assert_equal 42, d.b
+    assert_nil d.c
+    assert_equal :Default, d.d
+    assert_equal :b, d.my_oneof
     d.c = proto_module::TestMessage2.new(:foo => 100)
-    assert d.a == ""
-    assert d.b == 0
-    assert d.c.foo == 100
-    assert d.d == :Default
-    assert d.my_oneof == :c
-
+    assert_empty d.a
+    assert_equal 0, d.b
+    assert_equal 100, d.c.foo
+    assert_equal :Default, d.d
+    assert_equal :c, d.my_oneof
     d.d = :C
-    assert d.a == ""
-    assert d.b == 0
-    assert d.c == nil
-    assert d.d == :C
-    assert d.my_oneof == :d
-
+    assert_empty d.a
+    assert_equal 0, d.b
+    assert_nil d.c
+    assert_equal :C, d.d
+    assert_equal :d, d.my_oneof
     d2 = proto_module::OneofMessage.decode(proto_module::OneofMessage.encode(d))
-    assert d2 == d
-
+    assert_equal d, d2
     encoded_field_a = proto_module::OneofMessage.encode(proto_module::OneofMessage.new(:a => "string"))
     encoded_field_b = proto_module::OneofMessage.encode(proto_module::OneofMessage.new(:b => 1000))
     encoded_field_c = proto_module::OneofMessage.encode(
@@ -638,39 +611,37 @@ module CommonTests
 
     d3 = proto_module::OneofMessage.decode(
       encoded_field_c + encoded_field_a + encoded_field_b + encoded_field_d)
-    assert d3.a == ""
-    assert d3.b == 0
-    assert d3.c == nil
-    assert d3.d == :B
-
+    assert_empty d3.a
+    assert_equal 0, d3.b
+    assert_nil d3.c
+    assert_equal :B, d3.d
     d4 = proto_module::OneofMessage.decode(
       encoded_field_c + encoded_field_a + encoded_field_b + encoded_field_d +
       encoded_field_c)
-    assert d4.a == ""
-    assert d4.b == 0
-    assert d4.c.foo == 1
-    assert d4.d == :Default
-
+    assert_empty d4.a
+    assert_equal 0, d4.b
+    assert_equal 1, d4.c.foo
+    assert_equal :Default, d4.d
     d5 = proto_module::OneofMessage.new(:a => "hello")
-    assert d5.a == "hello"
+    assert_equal "hello", d5.a
     d5.a = nil
-    assert d5.a == ""
-    assert proto_module::OneofMessage.encode(d5) == ''
-    assert d5.my_oneof == nil
+    assert_empty d5.a
+    assert_empty proto_module::OneofMessage.encode(d5)
+    assert_nil d5.my_oneof
   end
 
   def test_enum_field
     m = proto_module::TestMessage.new
-    assert m.optional_enum == :Default
+    assert_equal :Default, m.optional_enum
     m.optional_enum = :A
-    assert m.optional_enum == :A
-    assert_raise RangeError do
+    assert_equal :A, m.optional_enum
+    assert_raises RangeError do
       m.optional_enum = :ASDF
     end
     m.optional_enum = 1
-    assert m.optional_enum == :A
+    assert_equal :A, m.optional_enum
     m.optional_enum = 100
-    assert m.optional_enum == 100
+    assert_equal 100, m.optional_enum
   end
 
   def test_dup
@@ -680,34 +651,34 @@ module CommonTests
     tm1 = proto_module::TestMessage2.new(:foo => 100)
     tm2 = proto_module::TestMessage2.new(:foo => 200)
     m.repeated_msg.push tm1
-    assert m.repeated_msg[-1] == tm1
+    assert_equal m.repeated_msg[-1], tm1
     m.repeated_msg.push tm2
-    assert m.repeated_msg[-1] == tm2
+    assert_equal m.repeated_msg[-1], tm2
     m2 = m.dup
-    assert m == m2
+    assert_equal m, m2
     m.optional_int32 += 1
-    assert m != m2
-    assert m.repeated_msg[0] == m2.repeated_msg[0]
-    assert m.repeated_msg[0].object_id == m2.repeated_msg[0].object_id
+    refute_equal m, m2
+    assert_equal m.repeated_msg[0], m2.repeated_msg[0]
+    assert_equal m.repeated_msg[0].object_id, m2.repeated_msg[0].object_id
   end
 
   def test_deep_copy
     m = proto_module::TestMessage.new(:optional_int32 => 42,
                                       :repeated_msg => [proto_module::TestMessage2.new(:foo => 100)])
     m2 = Google::Protobuf.deep_copy(m)
-    assert m == m2
-    assert m.repeated_msg == m2.repeated_msg
-    assert m.repeated_msg.object_id != m2.repeated_msg.object_id
-    assert m.repeated_msg[0].object_id != m2.repeated_msg[0].object_id
+    assert_equal m, m2
+    assert_equal m.repeated_msg, m2.repeated_msg
+    refute_same m.repeated_msg, m2.repeated_msg
+    refute_same m.repeated_msg[0], m2.repeated_msg[0]
   end
 
   def test_sub_message_deep_copy # regression test for issue 12505
     m = proto_module::Foo.new(bar: proto_module::Bar.new(msg: "Hello World"))
     m2 = Google::Protobuf.deep_copy(m)
-    assert_equal(m, m2)
-    assert_not_equal(m.object_id, m2.object_id)
-    assert_equal(m.bar, m2.bar)
-    assert_not_equal(m.bar.object_id, m2.bar.object_id)
+    assert_equal m, m2
+    refute_same m, m2
+    assert_equal m.bar, m2.bar
+    refute_same m.bar, m2.bar
   end
 
   def test_message_eq
@@ -715,25 +686,23 @@ module CommonTests
                                       :repeated_int32 => [1, 2, 3])
     m2 = proto_module::TestMessage.new(:optional_int32 => 43,
                                        :repeated_int32 => [1, 2, 3])
-    assert m != m2
-    assert_not_equal proto_module::TestMessage.new, proto_module::TestMessage2.new
+    refute_equal m, m2
+    refute_equal proto_module::TestMessage.new, proto_module::TestMessage2.new
   end
 
   def test_enum_lookup
-    assert proto_module::TestEnum::A == 1
-    assert proto_module::TestEnum::B == 2
-    assert proto_module::TestEnum::C == 3
-    assert proto_module::TestEnum::V0 == 4
-
-    assert proto_module::TestEnum::lookup(1) == :A
-    assert proto_module::TestEnum::lookup(2) == :B
-    assert proto_module::TestEnum::lookup(3) == :C
-    assert proto_module::TestEnum::lookup(4) == :v0
-
-    assert proto_module::TestEnum::resolve(:A) == 1
-    assert proto_module::TestEnum::resolve(:B) == 2
-    assert proto_module::TestEnum::resolve(:C) == 3
-    assert proto_module::TestEnum::resolve(:v0) == 4
+    assert_equal 1, proto_module::TestEnum::A
+    assert_equal 2, proto_module::TestEnum::B
+    assert_equal 3, proto_module::TestEnum::C
+    assert_equal 4, proto_module::TestEnum::V0
+    assert_equal :A, proto_module::TestEnum::lookup(1)
+    assert_equal :B, proto_module::TestEnum::lookup(2)
+    assert_equal :C, proto_module::TestEnum::lookup(3)
+    assert_equal :v0, proto_module::TestEnum::lookup(4)
+    assert_equal 1, proto_module::TestEnum::resolve(:A)
+    assert_equal 2, proto_module::TestEnum::resolve(:B)
+    assert_equal 3, proto_module::TestEnum::resolve(:C)
+    assert_equal 4, proto_module::TestEnum::resolve(:v0)
   end
 
   def test_enum_const_get_helpers
@@ -755,23 +724,23 @@ module CommonTests
 
     m = proto_module::TestMessage2.new({foo: 2})
     assert_equal 2, m.foo
-    assert_raise(NoMethodError) { m.foo_ }
-    assert_raise(NoMethodError) { m.foo_X }
-    assert_raise(NoMethodError) { m.foo_XX }
-    assert_raise(NoMethodError) { m.foo_XXX }
-    assert_raise(NoMethodError) { m.foo_XXXX }
-    assert_raise(NoMethodError) { m.foo_XXXXX }
-    assert_raise(NoMethodError) { m.foo_XXXXXX }
+    assert_raises(NoMethodError) { m.foo_ }
+    assert_raises(NoMethodError) { m.foo_X }
+    assert_raises(NoMethodError) { m.foo_XX }
+    assert_raises(NoMethodError) { m.foo_XXX }
+    assert_raises(NoMethodError) { m.foo_XXXX }
+    assert_raises(NoMethodError) { m.foo_XXXXX }
+    assert_raises(NoMethodError) { m.foo_XXXXXX }
 
     m = proto_module::Enumer.new({optional_enum: :B})
     assert_equal :B, m.optional_enum
-    assert_raise(NoMethodError) { m.optional_enum_ }
-    assert_raise(NoMethodError) { m.optional_enum_X }
-    assert_raise(NoMethodError) { m.optional_enum_XX }
-    assert_raise(NoMethodError) { m.optional_enum_XXX }
-    assert_raise(NoMethodError) { m.optional_enum_XXXX }
-    assert_raise(NoMethodError) { m.optional_enum_XXXXX }
-    assert_raise(NoMethodError) { m.optional_enum_XXXXXX }
+    assert_raises(NoMethodError) { m.optional_enum_ }
+    assert_raises(NoMethodError) { m.optional_enum_X }
+    assert_raises(NoMethodError) { m.optional_enum_XX }
+    assert_raises(NoMethodError) { m.optional_enum_XXX }
+    assert_raises(NoMethodError) { m.optional_enum_XXXX }
+    assert_raises(NoMethodError) { m.optional_enum_XXXXX }
+    assert_raises(NoMethodError) { m.optional_enum_XXXXXX }
   end
 
   def test_enum_getter
@@ -799,8 +768,8 @@ module CommonTests
     assert_equal 'thing', m.a_const
     assert_equal :B, m.optional_enum
 
-    assert_raise(NoMethodError) { m.a }
-    assert_raise(NoMethodError) { m.a_const_const }
+    assert_raises(NoMethodError) { m.a }
+    assert_raises(NoMethodError) { m.a_const_const }
   end
 
   def test_repeated_push
@@ -845,7 +814,7 @@ module CommonTests
 
     data = Google::Protobuf.encode m
     m2 = Google::Protobuf.decode(proto_module::TestMessage, data)
-    assert m == m2
+    assert_equal m, m2
   end
 
   def test_encode_decode_helpers
@@ -891,7 +860,7 @@ module CommonTests
 
   def test_def_errors
     s = Google::Protobuf::DescriptorPool.new
-    assert_raise Google::Protobuf::TypeError do
+    assert_raises Google::Protobuf::TypeError do
       s.build do
         # enum with no default (integer value 0)
         add_enum "MyEnum" do
@@ -899,7 +868,7 @@ module CommonTests
         end
       end
     end
-    assert_raise Google::Protobuf::TypeError do
+    assert_raises Google::Protobuf::TypeError do
       s.build do
         # message with required field (unsupported in proto3)
         add_message "MyMessage" do
@@ -913,20 +882,17 @@ module CommonTests
     # just be sure that we can instantiate types with corecursive field-type
     # references.
     m = proto_module::Recursive1.new(:foo => proto_module::Recursive2.new(:foo => proto_module::Recursive1.new))
-    assert proto_module::Recursive1.descriptor.lookup("foo").subtype ==
-           proto_module::Recursive2.descriptor
-    assert proto_module::Recursive2.descriptor.lookup("foo").subtype ==
-           proto_module::Recursive1.descriptor
-
+    assert_equal proto_module::Recursive2.descriptor, proto_module::Recursive1.descriptor.lookup("foo").subtype
+    assert_equal proto_module::Recursive1.descriptor, proto_module::Recursive2.descriptor.lookup("foo").subtype
     serialized = proto_module::Recursive1.encode(m)
     m2 = proto_module::Recursive1.decode(serialized)
-    assert m == m2
+    assert_equal m, m2
   end
 
   def test_serialize_cycle
     m = proto_module::Recursive1.new(:foo => proto_module::Recursive2.new)
     m.foo.foo = m
-    assert_raise RuntimeError do
+    assert_raises RuntimeError do
       proto_module::Recursive1.encode(m)
     end
   end
@@ -934,11 +900,11 @@ module CommonTests
   def test_bad_field_names
     m = proto_module::BadFieldNames.new(:dup => 1, :class => 2)
     m2 = m.dup
-    assert m == m2
-    assert m['dup'] == 1
-    assert m['class'] == 2
+    assert_equal m, m2
+    assert_equal 1, m['dup']
+    assert_equal 2, m['class']
     m['dup'] = 3
-    assert m['dup'] == 3
+    assert_equal 3, m['dup']
   end
 
   def test_int_ranges
@@ -950,19 +916,19 @@ module CommonTests
     m.optional_int32 = 1.0
     m.optional_int32 = -1.0
     m.optional_int32 = 2e9
-    assert_raise RangeError do
+    assert_raises RangeError do
       m.optional_int32 = -0x8000_0001
     end
-    assert_raise RangeError do
+    assert_raises RangeError do
       m.optional_int32 = +0x8000_0000
     end
-    assert_raise RangeError do
+    assert_raises RangeError do
       m.optional_int32 = +0x1000_0000_0000_0000_0000_0000 # force Bignum
     end
-    assert_raise RangeError do
+    assert_raises RangeError do
       m.optional_int32 = 1e12
     end
-    assert_raise RangeError do
+    assert_raises RangeError do
       m.optional_int32 = 1.5
     end
 
@@ -970,28 +936,28 @@ module CommonTests
     m.optional_uint32 = +0xffff_ffff
     m.optional_uint32 = 1.0
     m.optional_uint32 = 4e9
-    assert_raise RangeError do
+    assert_raises RangeError do
       m.optional_uint32 = -1
     end
-    assert_raise RangeError do
+    assert_raises RangeError do
       m.optional_uint32 = -1.5
     end
-    assert_raise RangeError do
+    assert_raises RangeError do
       m.optional_uint32 = -1.5e12
     end
-    assert_raise RangeError do
+    assert_raises RangeError do
       m.optional_uint32 = -0x1000_0000_0000_0000
     end
-    assert_raise RangeError do
+    assert_raises RangeError do
       m.optional_uint32 = +0x1_0000_0000
     end
-    assert_raise RangeError do
+    assert_raises RangeError do
       m.optional_uint32 = +0x1000_0000_0000_0000_0000_0000 # force Bignum
     end
-    assert_raise RangeError do
+    assert_raises RangeError do
       m.optional_uint32 = 1e12
     end
-    assert_raise RangeError do
+    assert_raises RangeError do
       m.optional_uint32 = 1.5
     end
 
@@ -1002,19 +968,19 @@ module CommonTests
     m.optional_int64 = -1.0
     m.optional_int64 = 8e18
     m.optional_int64 = -8e18
-    assert_raise RangeError do
+    assert_raises RangeError do
       m.optional_int64 = -0x8000_0000_0000_0001
     end
-    assert_raise RangeError do
+    assert_raises RangeError do
       m.optional_int64 = +0x8000_0000_0000_0000
     end
-    assert_raise RangeError do
+    assert_raises RangeError do
       m.optional_int64 = +0x1000_0000_0000_0000_0000_0000 # force Bignum
     end
-    assert_raise RangeError do
+    assert_raises RangeError do
       m.optional_int64 = 1e50
     end
-    assert_raise RangeError do
+    assert_raises RangeError do
       m.optional_int64 = 1.5
     end
 
@@ -1022,28 +988,28 @@ module CommonTests
     m.optional_uint64 = +0xffff_ffff_ffff_ffff
     m.optional_uint64 = 1.0
     m.optional_uint64 = 16e18
-    assert_raise RangeError do
+    assert_raises RangeError do
       m.optional_uint64 = -1
     end
-    assert_raise RangeError do
+    assert_raises RangeError do
       m.optional_uint64 = -1.5
     end
-    assert_raise RangeError do
+    assert_raises RangeError do
       m.optional_uint64 = -1.5e12
     end
-    assert_raise RangeError do
+    assert_raises RangeError do
       m.optional_uint64 = -0x1_0000_0000_0000_0000
     end
-    assert_raise RangeError do
+    assert_raises RangeError do
       m.optional_uint64 = +0x1_0000_0000_0000_0000
     end
-    assert_raise RangeError do
+    assert_raises RangeError do
       m.optional_uint64 = +0x1000_0000_0000_0000_0000_0000 # force Bignum
     end
-    assert_raise RangeError do
+    assert_raises RangeError do
       m.optional_uint64 = 1e50
     end
-    assert_raise RangeError do
+    assert_raises RangeError do
       m.optional_uint64 = 1.5
     end
   end
@@ -1061,7 +1027,7 @@ module CommonTests
     10_000.times do
       m = proto_module::TestMessage.decode(data)
       data_new = proto_module::TestMessage.encode(m)
-      assert data_new == data
+      assert_equal data, data_new
       data = data_new
     end
   end
@@ -1069,32 +1035,29 @@ module CommonTests
   def test_reflection
     m = proto_module::TestMessage.new(:optional_int32 => 1234)
     msgdef = m.class.descriptor
-    assert msgdef.class == Google::Protobuf::Descriptor
+    assert_instance_of Google::Protobuf::Descriptor, msgdef
     assert msgdef.any? {|field| field.name == "optional_int32"}
     optional_int32 = msgdef.lookup "optional_int32"
-    assert optional_int32.class == Google::Protobuf::FieldDescriptor
-    assert optional_int32 != nil
-    assert optional_int32.name == "optional_int32"
-    assert optional_int32.type == :int32
+    assert_instance_of Google::Protobuf::FieldDescriptor, optional_int32
+    refute_nil optional_int32
+    assert_equal "optional_int32", optional_int32.name
+    assert_equal :int32, optional_int32.type
     optional_int32.set(m, 5678)
-    assert m.optional_int32 == 5678
+    assert_equal 5678, m.optional_int32
     m.optional_int32 = 1000
-    assert optional_int32.get(m) == 1000
-
+    assert_equal 1000, optional_int32.get(m)
     optional_msg = msgdef.lookup "optional_msg"
-    assert optional_msg.subtype == proto_module::TestMessage2.descriptor
-
+    assert_equal proto_module::TestMessage2.descriptor, optional_msg.subtype
     optional_msg.set(m, optional_msg.subtype.msgclass.new)
 
-    assert msgdef.msgclass == proto_module::TestMessage
-
+    assert_equal proto_module::TestMessage, msgdef.msgclass
     optional_enum = msgdef.lookup "optional_enum"
-    assert optional_enum.subtype == proto_module::TestEnum.descriptor
-    assert optional_enum.subtype.class == Google::Protobuf::EnumDescriptor
+    assert_equal proto_module::TestEnum.descriptor, optional_enum.subtype
+    assert_instance_of Google::Protobuf::EnumDescriptor, optional_enum.subtype
     optional_enum.subtype.each do |k, v|
       # set with integer, check resolution to symbolic name
       optional_enum.set(m, v)
-      assert optional_enum.get(m) == k
+      assert_equal optional_enum.get(m), k
     end
   end
 
@@ -1129,7 +1092,7 @@ module CommonTests
   end
 
   def test_json_empty
-    assert proto_module::TestMessage.encode_json(proto_module::TestMessage.new) == '{}'
+    assert_equal '{}', proto_module::TestMessage.encode_json(proto_module::TestMessage.new)
   end
 
   def test_json_emit_defaults
@@ -1260,7 +1223,7 @@ module CommonTests
     struct = struct_from_ruby(JSON.parse(json))
     assert_equal json, struct.to_json
 
-    assert_raise(RuntimeError, "Recursion limit exceeded during encoding") do
+    assert_raises(RuntimeError, "Recursion limit exceeded during encoding") do
       struct = Google::Protobuf::Struct.new
       struct.fields["foobar"] = Google::Protobuf::Value.new(struct_value: struct)
       Google::Protobuf::Struct.encode(struct)
@@ -1268,7 +1231,7 @@ module CommonTests
   end
 
   def test_comparison_with_arbitrary_object
-    assert proto_module::TestMessage.new != nil
+    refute_nil proto_module::TestMessage.new
   end
 
   def test_wrappers_set_to_default
@@ -1279,9 +1242,9 @@ module CommonTests
       assert_equal 0, m.int64.value
       assert_equal 0, m.uint32.value
       assert_equal 0, m.uint64.value
-      assert_equal false, m.bool.value
-      assert_equal '', m.string.value
-      assert_equal '', m.bytes.value
+      refute m.bool.value
+      assert_empty m.string.value
+      assert_empty m.bytes.value
     }
 
     m = proto_module::Wrapper.new(
@@ -1329,10 +1292,9 @@ module CommonTests
       assert_equal 6, m.uint64.value
       assert_equal 6, m.uint64_as_value
 
-      assert_equal true, m.bool_as_value
-      assert_equal true, m.bool.value
-      assert_equal true, m.bool_as_value
-
+      assert m.bool_as_value
+      assert m.bool.value
+      assert m.bool_as_value
       assert_equal "st\nr", m.string_as_value
       assert_equal "st\nr", m.string.value
       assert_equal "st\nr", m.string_as_value
@@ -1384,7 +1346,7 @@ module CommonTests
       assert_equal 4, m.repeated_int64[0].value
       assert_equal 5, m.repeated_uint32[0].value
       assert_equal 6, m.repeated_uint64[0].value
-      assert_equal true, m.repeated_bool[0].value
+      assert m.repeated_bool[0].value
       assert_equal 'str', m.repeated_string[0].value
       assert_equal 'fun', m.repeated_bytes[0].value
     }
@@ -1479,7 +1441,7 @@ module CommonTests
 
       # This is nonsensical to do and does not work.  There is no good reason
       # to parse a wrapper type directly.
-      assert_raise(RuntimeError) { klass::decode_json(serialized_json) }
+      assert_raises(RuntimeError) { klass::decode_json(serialized_json) }
     }
 
     run_test.call(Google::Protobuf::DoubleValue, 2.0)
@@ -1514,7 +1476,7 @@ module CommonTests
       assert_equal 500, m.uint64_as_value
       assert_equal Google::Protobuf::UInt64Value.new(value: 500), m.uint64
       m.bool_as_value = false
-      assert_equal false, m.bool_as_value
+      refute m.bool_as_value
       assert_equal Google::Protobuf::BoolValue.new(value: false), m.bool
       m.string_as_value = 'xy'
       assert_equal 'xy', m.string_as_value
@@ -1593,7 +1555,7 @@ module CommonTests
       assert_equal 500, m.uint64_as_value
       assert_equal Google::Protobuf::UInt64Value.new(value: 500), m.uint64
       m.bool = Google::Protobuf::BoolValue.new(value: false)
-      assert_equal false, m.bool_as_value
+      refute m.bool_as_value
       assert_equal Google::Protobuf::BoolValue.new(value: false), m.bool
       m.string = Google::Protobuf::StringValue.new(value: 'xy')
       assert_equal 'xy', m.string_as_value
@@ -1657,26 +1619,26 @@ module CommonTests
   def test_wrappers_only
     m = proto_module::Wrapper.new(real_string: 'hi', string_in_oneof: 'there')
 
-    assert_raise(NoMethodError) { m.real_string_as_value }
-    assert_raise(NoMethodError) { m.as_value }
-    assert_raise(NoMethodError) { m._as_value }
-    assert_raise(NoMethodError) { m.string_in_oneof_as_value }
+    assert_raises(NoMethodError) { m.real_string_as_value }
+    assert_raises(NoMethodError) { m.as_value }
+    assert_raises(NoMethodError) { m._as_value }
+    assert_raises(NoMethodError) { m.string_in_oneof_as_value }
 
     m = proto_module::Wrapper.new
     m.string_as_value = 'you'
     assert_equal 'you', m.string.value
     assert_equal 'you', m.string_as_value
-    assert_raise(NoMethodError) { m.string_ }
-    assert_raise(NoMethodError) { m.string_X }
-    assert_raise(NoMethodError) { m.string_XX }
-    assert_raise(NoMethodError) { m.string_XXX }
-    assert_raise(NoMethodError) { m.string_XXXX }
-    assert_raise(NoMethodError) { m.string_XXXXX }
-    assert_raise(NoMethodError) { m.string_XXXXXX }
-    assert_raise(NoMethodError) { m.string_XXXXXXX }
-    assert_raise(NoMethodError) { m.string_XXXXXXXX }
-    assert_raise(NoMethodError) { m.string_XXXXXXXXX }
-    assert_raise(NoMethodError) { m.string_XXXXXXXXXX }
+    assert_raises(NoMethodError) { m.string_ }
+    assert_raises(NoMethodError) { m.string_X }
+    assert_raises(NoMethodError) { m.string_XX }
+    assert_raises(NoMethodError) { m.string_XXX }
+    assert_raises(NoMethodError) { m.string_XXXX }
+    assert_raises(NoMethodError) { m.string_XXXXX }
+    assert_raises(NoMethodError) { m.string_XXXXXX }
+    assert_raises(NoMethodError) { m.string_XXXXXXX }
+    assert_raises(NoMethodError) { m.string_XXXXXXXX }
+    assert_raises(NoMethodError) { m.string_XXXXXXXXX }
+    assert_raises(NoMethodError) { m.string_XXXXXXXXXX }
   end
 
   def test_converts_time
@@ -1693,10 +1655,10 @@ module CommonTests
     m = proto_module::TimeMessage.new(timestamp: Time.at(1))
     assert_equal Google::Protobuf::Timestamp.new(seconds: 1, nanos: 0), m.timestamp
 
-    assert_raise(Google::Protobuf::TypeError) { m.timestamp = 2 }
-    assert_raise(Google::Protobuf::TypeError) { m.timestamp = 2.4 }
-    assert_raise(Google::Protobuf::TypeError) { m.timestamp = '4' }
-    assert_raise(Google::Protobuf::TypeError) { m.timestamp = proto_module::TimeMessage.new }
+    assert_raises(Google::Protobuf::TypeError) { m.timestamp = 2 }
+    assert_raises(Google::Protobuf::TypeError) { m.timestamp = 2.4 }
+    assert_raises(Google::Protobuf::TypeError) { m.timestamp = '4' }
+    assert_raises(Google::Protobuf::TypeError) { m.timestamp = proto_module::TimeMessage.new }
 
     def test_time(year, month, day)
       str = ("\"%04d-%02d-%02dT00:00:00.000+00:00\"" % [year, month, day])
@@ -1740,8 +1702,8 @@ module CommonTests
     m = proto_module::TimeMessage.new(duration: -123.321)
     assert_equal Google::Protobuf::Duration.new(seconds: -123, nanos: -321_000_000), m.duration
 
-    assert_raise(Google::Protobuf::TypeError) { m.duration = '2' }
-    assert_raise(Google::Protobuf::TypeError) { m.duration = proto_module::TimeMessage.new }
+    assert_raises(Google::Protobuf::TypeError) { m.duration = '2' }
+    assert_raises(Google::Protobuf::TypeError) { m.duration = proto_module::TimeMessage.new }
   end
 
   def test_freeze
@@ -1749,32 +1711,31 @@ module CommonTests
     m.optional_int32 = 10
     m.freeze
 
-    frozen_error = assert_raise(FrozenErrorType) { m.optional_int32 = 20 }
+    frozen_error = assert_raises(FrozenErrorType) { m.optional_int32 = 20 }
     assert_match "can't modify frozen #{proto_module}::TestMessage", frozen_error.message
     assert_equal 10, m.optional_int32
-    assert_equal true, m.frozen?
-
-    assert_raise(FrozenErrorType) { m.optional_int64 = 2 }
-    assert_raise(FrozenErrorType) { m.optional_uint32 = 3 }
-    assert_raise(FrozenErrorType) { m.optional_uint64 = 4 }
-    assert_raise(FrozenErrorType) { m.optional_bool = true }
-    assert_raise(FrozenErrorType) { m.optional_float = 6.0 }
-    assert_raise(FrozenErrorType) { m.optional_double = 7.0 }
-    assert_raise(FrozenErrorType) { m.optional_string = '8' }
-    assert_raise(FrozenErrorType) { m.optional_bytes = nil }
-    assert_raise(FrozenErrorType) { m.optional_msg = proto_module::TestMessage2.new }
-    assert_raise(FrozenErrorType) { m.optional_enum = :A }
-    assert_raise(FrozenErrorType) { m.repeated_int32 = 1 }
-    assert_raise(FrozenErrorType) { m.repeated_int64 = 2 }
-    assert_raise(FrozenErrorType) { m.repeated_uint32 = 3 }
-    assert_raise(FrozenErrorType) { m.repeated_uint64 = 4 }
-    assert_raise(FrozenErrorType) { m.repeated_bool = true }
-    assert_raise(FrozenErrorType) { m.repeated_float = 6.0 }
-    assert_raise(FrozenErrorType) { m.repeated_double = 7.0 }
-    assert_raise(FrozenErrorType) { m.repeated_string = '8' }
-    assert_raise(FrozenErrorType) { m.repeated_bytes = nil }
-    assert_raise(FrozenErrorType) { m.repeated_msg = proto_module::TestMessage2.new }
-    assert_raise(FrozenErrorType) { m.repeated_enum = :A }
+    assert m.frozen?
+    assert_raises(FrozenErrorType) { m.optional_int64 = 2 }
+    assert_raises(FrozenErrorType) { m.optional_uint32 = 3 }
+    assert_raises(FrozenErrorType) { m.optional_uint64 = 4 }
+    assert_raises(FrozenErrorType) { m.optional_bool = true }
+    assert_raises(FrozenErrorType) { m.optional_float = 6.0 }
+    assert_raises(FrozenErrorType) { m.optional_double = 7.0 }
+    assert_raises(FrozenErrorType) { m.optional_string = '8' }
+    assert_raises(FrozenErrorType) { m.optional_bytes = nil }
+    assert_raises(FrozenErrorType) { m.optional_msg = proto_module::TestMessage2.new }
+    assert_raises(FrozenErrorType) { m.optional_enum = :A }
+    assert_raises(FrozenErrorType) { m.repeated_int32 = 1 }
+    assert_raises(FrozenErrorType) { m.repeated_int64 = 2 }
+    assert_raises(FrozenErrorType) { m.repeated_uint32 = 3 }
+    assert_raises(FrozenErrorType) { m.repeated_uint64 = 4 }
+    assert_raises(FrozenErrorType) { m.repeated_bool = true }
+    assert_raises(FrozenErrorType) { m.repeated_float = 6.0 }
+    assert_raises(FrozenErrorType) { m.repeated_double = 7.0 }
+    assert_raises(FrozenErrorType) { m.repeated_string = '8' }
+    assert_raises(FrozenErrorType) { m.repeated_bytes = nil }
+    assert_raises(FrozenErrorType) { m.repeated_msg = proto_module::TestMessage2.new }
+    assert_raises(FrozenErrorType) { m.repeated_enum = :A }
   end
 
   def test_eq
@@ -1784,17 +1745,16 @@ module CommonTests
     h = {}
     h[m1] = :yes
 
-    assert m1 == m2
+    assert_equal m1, m2
     assert m1.eql?(m2)
-    assert m1.hash == m2.hash
-    assert h[m1] == :yes
-    assert h[m2] == :yes
-
+    assert_equal m1.hash, m2.hash
+    assert_equal :yes, h[m1]
+    assert_equal :yes, h[m2]
     m1.optional_int32 = 2
 
-    assert m1 != m2
-    assert !m1.eql?(m2)
-    assert m1.hash != m2.hash
+    refute_equal m1, m2
+    refute m1.eql?(m2)
+    refute_equal m1.hash, m2.hash
     assert_nil h[m2]
   end
 
@@ -1842,33 +1802,33 @@ module CommonTests
     assert_equal 0, msg.optional_int32
 
     assert msg.respond_to? :has_optional_int32?
-    assert !msg.has_optional_int32?
+    refute msg.has_optional_int32?
 
-    assert !msg.respond_to?( :optional_int32_as_value= )
-    assert_raise NoMethodError do
+    refute_respond_to msg, :optional_int32_as_value=
+    assert_raises NoMethodError do
       msg.optional_int32_as_value = 42
     end
 
-    assert !msg.respond_to?( :optional_int32_as_value )
-    assert_raise NoMethodError do
+    refute_respond_to msg, :optional_int32_as_value
+    assert_raises NoMethodError do
       msg.optional_int32_as_value
     end
 
     assert msg.respond_to? :optional_enum_const
     assert_equal 0, msg.optional_enum_const
 
-    assert !msg.respond_to?( :foo )
-    assert_raise NoMethodError do
+    refute_respond_to msg, :foo
+    assert_raises NoMethodError do
       msg.foo
     end
 
-    assert !msg.respond_to?( :foo_const )
-    assert_raise NoMethodError do
+    refute_respond_to msg, :foo_const
+    assert_raises NoMethodError do
       msg.foo_const
     end
 
-    assert !msg.respond_to?( :optional_int32_const )
-    assert_raise NoMethodError do
+    refute_respond_to msg, :optional_int32_const
+    assert_raises NoMethodError do
       msg.optional_int32_const
     end
   end
@@ -1880,7 +1840,7 @@ module CommonTests
     assert msg.respond_to? :my_oneof
     assert_nil msg.my_oneof
     assert msg.respond_to? :a
-    assert_equal "", msg.a
+    assert_empty msg.a
     assert msg.respond_to? :b
     assert_equal 0, msg.b
     assert msg.respond_to? :c
@@ -1903,8 +1863,8 @@ module CommonTests
     msg.clear_d
 
     # `=` suffix actions should work on elements of a oneof but not the oneof itself.
-    assert !msg.respond_to?( :my_oneof= )
-    error = assert_raise RuntimeError do
+    refute_respond_to msg, :my_oneof=
+    error = assert_raises RuntimeError do
       msg.my_oneof = nil
     end
     assert_equal "Oneof accessors are read-only.", error.message
@@ -1922,64 +1882,64 @@ module CommonTests
     assert msg.has_my_oneof?
 
     # `_as_value` suffix actions should only work for wrapped fields.
-    assert !msg.respond_to?( :my_oneof_as_value )
-    assert_raise NoMethodError do
+    refute_respond_to msg, :my_oneof_as_value
+    assert_raises NoMethodError do
       msg.my_oneof_as_value
     end
-    assert !msg.respond_to?( :a_as_value )
-    assert_raise NoMethodError do
+    refute_respond_to msg, :a_as_value
+    assert_raises NoMethodError do
       msg.a_as_value
     end
-    assert !msg.respond_to?( :b_as_value )
-    assert_raise NoMethodError do
+    refute_respond_to msg, :b_as_value
+    assert_raises NoMethodError do
       msg.b_as_value
     end
-    assert !msg.respond_to?( :c_as_value )
-    assert_raise NoMethodError do
+    refute_respond_to msg, :c_as_value
+    assert_raises NoMethodError do
       msg.c_as_value
     end
-    assert !msg.respond_to?( :d_as_value )
-    assert_raise NoMethodError do
+    refute_respond_to msg, :d_as_value
+    assert_raises NoMethodError do
       msg.d_as_value
     end
 
     # `_as_value=` suffix actions should only work for wrapped fields.
-    assert !msg.respond_to?( :my_oneof_as_value= )
-    assert_raise NoMethodError do
+    refute_respond_to msg, :my_oneof_as_value=
+    assert_raises NoMethodError do
       msg.my_oneof_as_value = :boom
     end
-    assert !msg.respond_to?( :a_as_value= )
-    assert_raise NoMethodError do
+    refute_respond_to msg, :a_as_value=
+    assert_raises NoMethodError do
       msg.a_as_value = ""
     end
-    assert !msg.respond_to?( :b_as_value= )
-    assert_raise NoMethodError do
+    refute_respond_to msg, :b_as_value=
+    assert_raises NoMethodError do
       msg.b_as_value = 42
     end
-    assert !msg.respond_to?( :c_as_value= )
-    assert_raise NoMethodError do
+    refute_respond_to msg, :c_as_value=
+    assert_raises NoMethodError do
       msg.c_as_value = proto_module::TestMessage2.new
     end
-    assert !msg.respond_to?( :d_as_value= )
-    assert_raise NoMethodError do
+    refute_respond_to msg, :d_as_value=
+    assert_raises NoMethodError do
       msg.d_as_value = :Default
     end
 
     # `_const` suffix actions should only work for enum fields.
-    assert !msg.respond_to?( :my_oneof_const )
-    assert_raise NoMethodError do
+    refute_respond_to msg, :my_oneof_const
+    assert_raises NoMethodError do
       msg.my_oneof_const
     end
-    assert !msg.respond_to?( :a_const )
-    assert_raise NoMethodError do
+    refute_respond_to msg, :a_const
+    assert_raises NoMethodError do
       msg.a_const
     end
-    assert !msg.respond_to?( :b_const )
-    assert_raise NoMethodError do
+    refute_respond_to msg, :b_const
+    assert_raises NoMethodError do
       msg.b_const
     end
-    assert !msg.respond_to?( :c_const )
-    assert_raise NoMethodError do
+    refute_respond_to msg, :c_const
+    assert_raises NoMethodError do
       msg.c_const
     end
     assert msg.respond_to? :d_const
@@ -1988,9 +1948,9 @@ module CommonTests
 
   def test_wrapped_fields_respond_to? # regression test for issue 9202
     msg = proto_module::Wrapper.new
-    assert msg.respond_to?( :double_as_value= )
+    assert_respond_to msg, :double_as_value=
     msg.double_as_value = 42
-    assert msg.respond_to?( :double_as_value )
+    assert_respond_to msg, :double_as_value
     assert_equal 42, msg.double_as_value
     assert_equal Google::Protobuf::DoubleValue.new(value: 42), msg.double
   end
diff --git a/ruby/tests/encode_decode_test.rb b/ruby/tests/encode_decode_test.rb
index 710e754990..0a2e9d4ddc 100755
--- a/ruby/tests/encode_decode_test.rb
+++ b/ruby/tests/encode_decode_test.rb
@@ -19,8 +19,7 @@ class EncodeDecodeTest < Test::Unit::TestCase
     m = A::B::C::TestMessage.decode(from)
     Google::Protobuf.discard_unknown(m)
     to = A::B::C::TestMessage.encode(m)
-    assert_equal '', to
-
+    assert_empty to
     # Test discard unknown for singular message field.
     unknown_msg = A::B::C::TestUnknown.new(
             :optional_unknown =>
@@ -29,8 +28,7 @@ class EncodeDecodeTest < Test::Unit::TestCase
     m = A::B::C::TestMessage.decode(from)
     Google::Protobuf.discard_unknown(m)
     to = A::B::C::TestMessage.encode(m.optional_msg)
-    assert_equal '', to
-
+    assert_empty to
     # Test discard unknown for repeated message field.
     unknown_msg = A::B::C::TestUnknown.new(
             :repeated_unknown =>
@@ -39,8 +37,7 @@ class EncodeDecodeTest < Test::Unit::TestCase
     m = A::B::C::TestMessage.decode(from)
     Google::Protobuf.discard_unknown(m)
     to = A::B::C::TestMessage.encode(m.repeated_msg[0])
-    assert_equal '', to
-
+    assert_empty to
     # Test discard unknown for map value message field.
     unknown_msg = A::B::C::TestUnknown.new(
             :map_unknown =>
@@ -49,8 +46,7 @@ class EncodeDecodeTest < Test::Unit::TestCase
     m = A::B::C::TestMessage.decode(from)
     Google::Protobuf.discard_unknown(m)
     to = A::B::C::TestMessage.encode(m.map_string_msg[''])
-    assert_equal '', to
-
+    assert_empty to
     # Test discard unknown for oneof message field.
     unknown_msg = A::B::C::TestUnknown.new(
             :oneof_unknown =>
@@ -59,7 +55,7 @@ class EncodeDecodeTest < Test::Unit::TestCase
     m = A::B::C::TestMessage.decode(from)
     Google::Protobuf.discard_unknown(m)
     to = A::B::C::TestMessage.encode(m.oneof_msg)
-    assert_equal '', to
+    assert_empty to
   end
 
   def test_encode_json
@@ -67,8 +63,7 @@ class EncodeDecodeTest < Test::Unit::TestCase
     json = msg.to_json
 
     to = A::B::C::TestMessage.decode_json(json)
-    assert_equal to.optional_int32, 22
-
+    assert_equal 22, to.optional_int32
     msg = A::B::C::TestMessage.new({ optional_int32: 22 })
     json = msg.to_json({ preserve_proto_fieldnames: true })
 
@@ -115,7 +110,7 @@ class EncodeDecodeTest < Test::Unit::TestCase
   end
 
   def test_encode_wrong_msg
-    assert_raise ::ArgumentError do
+    assert_raises ::ArgumentError do
       m = A::B::C::TestMessage.new(
           :optional_int32 => 1,
       )
@@ -146,7 +141,7 @@ class EncodeDecodeTest < Test::Unit::TestCase
     msg_out = A::B::C::TestMessage.decode(msg_encoded)
     assert_match msg.to_json, msg_out.to_json
 
-    assert_raise Google::Protobuf::ParseError do
+    assert_raises Google::Protobuf::ParseError do
       A::B::C::TestMessage.decode(msg_encoded, { recursion_limit: 4 })
     end
 
@@ -171,7 +166,7 @@ class EncodeDecodeTest < Test::Unit::TestCase
     msg_out = A::B::C::TestMessage.decode(msg_encoded)
     assert_match msg.to_json, msg_out.to_json
 
-    assert_raise RuntimeError do
+    assert_raises RuntimeError do
       A::B::C::TestMessage.encode(msg, { recursion_limit: 5 })
     end
 
diff --git a/ruby/tests/repeated_field_test.rb b/ruby/tests/repeated_field_test.rb
index de96869960..45909d374b 100755
--- a/ruby/tests/repeated_field_test.rb
+++ b/ruby/tests/repeated_field_test.rb
@@ -8,7 +8,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
   def test_acts_like_enumerator
     m = TestMessage.new
     (Enumerable.instance_methods - TestMessage.new.repeated_string.methods).each do |method_name|
-      assert m.repeated_string.respond_to?(method_name) == true, "does not respond to #{method_name}"
+      assert_respond_to m.repeated_string, method_name
     end
   end
 
@@ -23,7 +23,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
     arr_methods -= [:intersection, :deconstruct] # ruby 2.7 methods we can ignore
     arr_methods -= [:intersect?] # ruby 3.1 methods we can ignore
     arr_methods.each do |method_name|
-      assert m.repeated_string.respond_to?(method_name) == true, "does not respond to #{method_name}"
+      assert_respond_to m.repeated_string, method_name
     end
   end
 
@@ -31,8 +31,8 @@ class RepeatedFieldTest < Test::Unit::TestCase
     m = TestMessage.new
     repeated_field_names(TestMessage).each do |field_name|
       assert_nil m.send(field_name).first
-      assert_equal [], m.send(field_name).first(0)
-      assert_equal [], m.send(field_name).first(1)
+      assert_empty m.send(field_name).first(0)
+      assert_empty m.send(field_name).first(1)
     end
 
     fill_test_msg(m)
@@ -40,7 +40,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
     assert_equal( -1_000_000, m.repeated_int64.first )
     assert_equal 10, m.repeated_uint32.first
     assert_equal 1_000_000, m.repeated_uint64.first
-    assert_equal true, m.repeated_bool.first
+    assert m.repeated_bool.first
     assert_equal( -1.01,  m.repeated_float.first.round(2) )
     assert_equal( -1.0000000000001, m.repeated_double.first )
     assert_equal 'foo', m.repeated_string.first
@@ -52,7 +52,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
       m.repeated_int32.first(-1)
     end
     assert_equal "negative array size", err.message
-    assert_equal [], m.repeated_int32.first(0)
+    assert_empty m.repeated_int32.first(0)
     assert_equal [-10], m.repeated_int32.first(1)
     assert_equal [-10, -11], m.repeated_int32.first(2)
     assert_equal [-10, -11], m.repeated_int32.first(3)
@@ -69,7 +69,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
     assert_equal( -1_000_001, m.repeated_int64.last )
     assert_equal 11, m.repeated_uint32.last
     assert_equal 1_000_001, m.repeated_uint64.last
-    assert_equal false, m.repeated_bool.last
+    refute m.repeated_bool.last
     assert_equal( -1.02, m.repeated_float.last.round(2) )
     assert_equal( -1.0000000000002, m.repeated_double.last )
     assert_equal 'bar', m.repeated_string.last
@@ -81,7 +81,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
       m.repeated_int32.last(-1)
     end
     assert_equal "negative array size", err.message
-    assert_equal [], m.repeated_int32.last(0)
+    assert_empty m.repeated_int32.last(0)
     assert_equal [-11], m.repeated_int32.last(1)
     assert_equal [-10, -11], m.repeated_int32.last(2)
     assert_equal [-10, -11], m.repeated_int32.last(3)
@@ -103,8 +103,8 @@ class RepeatedFieldTest < Test::Unit::TestCase
     assert_equal 10, m.repeated_uint32.pop
     assert_equal 1_000_001, m.repeated_uint64.pop
     assert_equal 1_000_000, m.repeated_uint64.pop
-    assert_equal false, m.repeated_bool.pop
-    assert_equal true, m.repeated_bool.pop
+    refute m.repeated_bool.pop
+    assert m.repeated_bool.pop
     assert_equal( -1.02,  m.repeated_float.pop.round(2) )
     assert_equal( -1.01,  m.repeated_float.pop.round(2) )
     assert_equal( -1.0000000000002, m.repeated_double.pop )
@@ -143,17 +143,17 @@ class RepeatedFieldTest < Test::Unit::TestCase
 
   def test_empty?
     m = TestMessage.new
-    assert_equal true, m.repeated_string.empty?
+    assert_empty m.repeated_string
     m.repeated_string << 'foo'
-    assert_equal false, m.repeated_string.empty?
+    refute_empty m.repeated_string
     m.repeated_string << 'bar'
-    assert_equal false, m.repeated_string.empty?
+    refute_empty m.repeated_string
   end
 
   def test_reassign
     m = TestMessage.new
     m.repeated_msg = Google::Protobuf::RepeatedField.new(:message, TestMessage2, [TestMessage2.new(:foo => 1)])
-    assert_equal m.repeated_msg.first, TestMessage2.new(:foo => 1)
+    assert_equal TestMessage2.new(:foo => 1), m.repeated_msg.first
   end
 
   def test_array_accessor
@@ -323,7 +323,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
     m.repeated_string += reference_arr.clone
     assert_equal reference_arr, m.repeated_string
     reference_arr << 'fizz'
-    assert_not_equal reference_arr, m.repeated_string
+    refute_equal reference_arr, m.repeated_string
     m.repeated_string << 'fizz'
     assert_equal reference_arr, m.repeated_string
   end
@@ -337,7 +337,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
     hash = m.repeated_string.hash
     assert_equal hash, m.repeated_string.hash
     m.repeated_string << 'j'
-    assert_not_equal hash, m.repeated_string.hash
+    refute_equal hash, m.repeated_string.hash
   end
 
   def test_plus
diff --git a/ruby/tests/stress.rb b/ruby/tests/stress.rb
index 6a3f51d8a5..b688e8b0bd 100755
--- a/ruby/tests/stress.rb
+++ b/ruby/tests/stress.rb
@@ -31,7 +31,7 @@ module StressTest
         mnew = TestMessage.decode(data)
         mnew = mnew.dup
         assert_equal m.inspect, mnew.inspect
-        assert TestMessage.encode(mnew) == data
+        assert_equal data, TestMessage.encode(mnew)
       end
     end
   end
diff --git a/ruby/tests/well_known_types_test.rb b/ruby/tests/well_known_types_test.rb
index fbdee38a29..3ab8a7cd0f 100755
--- a/ruby/tests/well_known_types_test.rb
+++ b/ruby/tests/well_known_types_test.rb
@@ -65,18 +65,17 @@ class TestWellKnownTypes < Test::Unit::TestCase
     struct["sublist"] = sublist
 
     assert_equal 12345, struct["number"]
-    assert_equal true, struct["boolean-true"]
-    assert_equal false, struct["boolean-false"]
-    assert_equal nil, struct["null"]
+    assert struct["boolean-true"]
+    refute struct["boolean-false"]
+    assert_nil struct["null"]
     assert_equal "abcdef", struct["string"]
     assert_equal(Google::Protobuf::Struct.from_hash(substruct),
                  struct["substruct"])
     assert_equal(Google::Protobuf::ListValue.from_a(sublist),
                  struct["sublist"])
 
-    assert_equal true, struct.has_key?("null")
-    assert_equal false, struct.has_key?("missing_key")
-
+    assert struct.has_key? "null"
+    refute struct.has_key? "missing_key"
     should_equal = {
       "number" => 12345,
       "boolean-true" => true,
@@ -91,48 +90,48 @@ class TestWellKnownTypes < Test::Unit::TestCase
     }
 
     list = struct["sublist"]
-    list.is_a?(Google::Protobuf::ListValue)
+    assert_instance_of Google::Protobuf::ListValue, list
     assert_equal "abc", list[0]
     assert_equal 123, list[1]
     assert_equal({"deepkey" => "deepval"}, list[2].to_h)
 
     # to_h returns a fully-flattened Ruby structure (Hash and Array).
-    assert_equal(should_equal, struct.to_h)
+    assert_equal should_equal, struct.to_h
 
     # Test that we can safely access a missing key
-    assert_equal(nil, struct["missing_key"])
+    assert_nil struct["missing_key"]
 
     # Test that we can assign Struct and ListValue directly.
     struct["substruct"] = Google::Protobuf::Struct.from_hash(substruct)
     struct["sublist"] = Google::Protobuf::ListValue.from_a(sublist)
 
-    assert_equal(should_equal, struct.to_h)
+    assert_equal should_equal, struct.to_h
 
     struct["sublist"] << nil
     should_equal["sublist"] << nil
 
-    assert_equal(should_equal, struct.to_h)
-    assert_equal(should_equal["sublist"].length, struct["sublist"].length)
+    assert_equal should_equal, struct.to_h
+    assert_equal should_equal["sublist"].length, struct["sublist"].length
 
-    assert_raise Google::Protobuf::UnexpectedStructType do
+    assert_raises Google::Protobuf::UnexpectedStructType do
       struct[123] = 5
     end
 
-    assert_raise Google::Protobuf::UnexpectedStructType do
+    assert_raises Google::Protobuf::UnexpectedStructType do
       struct[5] = Time.new
     end
 
-    assert_raise Google::Protobuf::UnexpectedStructType do
+    assert_raises Google::Protobuf::UnexpectedStructType do
       struct[5] = [Time.new]
     end
 
-    assert_raise Google::Protobuf::UnexpectedStructType do
+    assert_raises Google::Protobuf::UnexpectedStructType do
       struct[5] = {123 => 456}
     end
 
-    assert_raise Google::Protobuf::UnexpectedStructType do
-      struct = Google::Protobuf::Struct.new
-      struct.fields["foo"] = Google::Protobuf::Value.new
+    struct = Google::Protobuf::Struct.new
+    struct.fields["foo"] = Google::Protobuf::Value.new
+    assert_raises Google::Protobuf::UnexpectedStructType do
       # Tries to return a Ruby value for a Value class whose type
       # hasn't been filled in.
       struct["foo"]
@@ -184,10 +183,10 @@ class TestWellKnownTypes < Test::Unit::TestCase
     assert_equal expected_b_x, s[:b][:x].values
     assert_equal expected_b_x, s['b'][:x].values
     assert_equal expected_b_x, s[:b]['x'].values
-    assert_equal true, s['b']['y']
-    assert_equal true, s[:b][:y]
-    assert_equal true, s[:b]['y']
-    assert_equal true, s['b'][:y]
+    assert s['b']['y']
+    assert s[:b][:y]
+    assert s[:b]['y']
+    assert s['b'][:y]
     assert_equal Google::Protobuf::Struct.new, s['c']
     assert_equal Google::Protobuf::Struct.new, s[:c]
 
@@ -202,10 +201,10 @@ class TestWellKnownTypes < Test::Unit::TestCase
     )
     assert_equal 'Eh', s['a']
     assert_equal 'Eh', s[:a]
-    assert_equal false, s['b']['y']
-    assert_equal false, s[:b][:y]
-    assert_equal false, s['b'][:y]
-    assert_equal false, s[:b]['y']
+    refute s['b']['y']
+    refute s[:b][:y]
+    refute s['b'][:y]
+    refute s[:b]['y']
   end
 
   def test_b8325
@@ -218,30 +217,26 @@ class TestWellKnownTypes < Test::Unit::TestCase
 
   def test_from_ruby
     pb = Google::Protobuf::Value.from_ruby(nil)
-    assert_equal pb.null_value, :NULL_VALUE
-
+    assert_equal :NULL_VALUE, pb.null_value
     pb = Google::Protobuf::Value.from_ruby(1.23)
-    assert_equal pb.number_value, 1.23
-
+    assert_equal 1.23, pb.number_value
     pb = Google::Protobuf::Value.from_ruby('1.23')
-    assert_equal pb.string_value, '1.23'
-
+    assert_equal '1.23', pb.string_value
     pb = Google::Protobuf::Value.from_ruby(true)
-    assert_equal pb.bool_value, true
+    assert pb.bool_value
 
     pb = Google::Protobuf::Value.from_ruby(false)
-    assert_equal pb.bool_value, false
-
+    refute pb.bool_value
     pb = Google::Protobuf::Value.from_ruby(Google::Protobuf::Struct.from_hash({ 'a' => 1, 'b' => '2', 'c' => [1, 2, 3], 'd' => nil, 'e' => true }))
-    assert_equal pb.struct_value, Google::Protobuf::Struct.from_hash({ 'a' => 1, 'b' => '2', 'c' => [1, 2, 3], 'd' => nil, 'e' => true })
+    assert_equal Google::Protobuf::Struct.from_hash({ 'a' => 1, 'b' => '2', 'c' => [1, 2, 3], 'd' => nil, 'e' => true }), pb.struct_value
 
     pb = Google::Protobuf::Value.from_ruby({ 'a' => 1, 'b' => '2', 'c' => [1, 2, 3], 'd' => nil, 'e' => true })
-    assert_equal pb.struct_value, Google::Protobuf::Struct.from_hash({ 'a' => 1, 'b' => '2', 'c' => [1, 2, 3], 'd' => nil, 'e' => true })
+    assert_equal Google::Protobuf::Struct.from_hash({ 'a' => 1, 'b' => '2', 'c' => [1, 2, 3], 'd' => nil, 'e' => true }), pb.struct_value
 
     pb = Google::Protobuf::Value.from_ruby(Google::Protobuf::ListValue.from_a([1, 2, 3]))
-    assert_equal pb.list_value, Google::Protobuf::ListValue.from_a([1, 2, 3])
+    assert_equal Google::Protobuf::ListValue.from_a([1, 2, 3]), pb.list_value
 
     pb = Google::Protobuf::Value.from_ruby([1, 2, 3])
-    assert_equal pb.list_value, Google::Protobuf::ListValue.from_a([1, 2, 3])
+    assert_equal Google::Protobuf::ListValue.from_a([1, 2, 3]), pb.list_value
   end
 end