Merge pull request #31786 from composerinteralia/respond-to-tests

Use respond_to test helpers

101 files changed, 1237 insertions, 1237 deletions

diff --git a/activerecord/test/cases/adapter_test.rb b/activerecord/test/cases/adapter_test.rb
index 9aaa2852d0..0092146e09 100644
--- a/activerecord/test/cases/adapter_test.rb
+++ b/activerecord/test/cases/adapter_test.rb
@@ -78,7 +78,7 @@ module ActiveRecord
       idx_name = "accounts_idx"
 
       indexes = @connection.indexes("accounts")
-      assert indexes.empty?
+      assert_empty indexes
 
       @connection.add_index :accounts, :firm_id, name: idx_name
       indexes = @connection.indexes("accounts")
@@ -368,16 +368,16 @@ module ActiveRecord
     unless in_memory_db?
       test "transaction state is reset after a reconnect" do
         @connection.begin_transaction
-        assert @connection.transaction_open?
+        assert_predicate @connection, :transaction_open?
         @connection.reconnect!
-        assert !@connection.transaction_open?
+        assert_not_predicate @connection, :transaction_open?
       end
 
       test "transaction state is reset after a disconnect" do
         @connection.begin_transaction
-        assert @connection.transaction_open?
+        assert_predicate @connection, :transaction_open?
         @connection.disconnect!
-        assert !@connection.transaction_open?
+        assert_not_predicate @connection, :transaction_open?
       end
     end
 
diff --git a/activerecord/test/cases/adapters/mysql2/case_sensitivity_test.rb b/activerecord/test/cases/adapters/mysql2/case_sensitivity_test.rb
index fd5f712f1a..aa870349be 100644
--- a/activerecord/test/cases/adapters/mysql2/case_sensitivity_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/case_sensitivity_test.rb
@@ -14,8 +14,8 @@ class Mysql2CaseSensitivityTest < ActiveRecord::Mysql2TestCase
   end
 
   def test_case_sensitive
-    assert !CollationTest.columns_hash["string_ci_column"].case_sensitive?
-    assert CollationTest.columns_hash["string_cs_column"].case_sensitive?
+    assert_not_predicate CollationTest.columns_hash["string_ci_column"], :case_sensitive?
+    assert_predicate CollationTest.columns_hash["string_cs_column"], :case_sensitive?
   end
 
   def test_case_insensitive_comparison_for_ci_column
diff --git a/activerecord/test/cases/adapters/mysql2/connection_test.rb b/activerecord/test/cases/adapters/mysql2/connection_test.rb
index 13b4096671..726f58d58e 100644
--- a/activerecord/test/cases/adapters/mysql2/connection_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/connection_test.rb
@@ -40,29 +40,29 @@ class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
   end
 
   def test_no_automatic_reconnection_after_timeout
-    assert @connection.active?
+    assert_predicate @connection, :active?
     @connection.update("set @@wait_timeout=1")
     sleep 2
-    assert !@connection.active?
+    assert_not_predicate @connection, :active?
   ensure
     # Repair all fixture connections so other tests won't break.
     @fixture_connections.each(&:verify!)
   end
 
   def test_successful_reconnection_after_timeout_with_manual_reconnect
-    assert @connection.active?
+    assert_predicate @connection, :active?
     @connection.update("set @@wait_timeout=1")
     sleep 2
     @connection.reconnect!
-    assert @connection.active?
+    assert_predicate @connection, :active?
   end
 
   def test_successful_reconnection_after_timeout_with_verify
-    assert @connection.active?
+    assert_predicate @connection, :active?
     @connection.update("set @@wait_timeout=1")
     sleep 2
     @connection.verify!
-    assert @connection.active?
+    assert_predicate @connection, :active?
   end
 
   def test_execute_after_disconnect
diff --git a/activerecord/test/cases/adapters/mysql2/enum_test.rb b/activerecord/test/cases/adapters/mysql2/enum_test.rb
index 108bec832c..832f5d61d1 100644
--- a/activerecord/test/cases/adapters/mysql2/enum_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/enum_test.rb
@@ -13,11 +13,11 @@ class Mysql2EnumTest < ActiveRecord::Mysql2TestCase
 
   def test_should_not_be_unsigned
     column = EnumTest.columns_hash["enum_column"]
-    assert_not column.unsigned?
+    assert_not_predicate column, :unsigned?
   end
 
   def test_should_not_be_bigint
     column = EnumTest.columns_hash["enum_column"]
-    assert_not column.bigint?
+    assert_not_predicate column, :bigint?
   end
 end
diff --git a/activerecord/test/cases/adapters/mysql2/unsigned_type_test.rb b/activerecord/test/cases/adapters/mysql2/unsigned_type_test.rb
index b01f5d7f5a..97da96003d 100644
--- a/activerecord/test/cases/adapters/mysql2/unsigned_type_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/unsigned_type_test.rb
@@ -54,7 +54,7 @@ class Mysql2UnsignedTypeTest < ActiveRecord::Mysql2TestCase
     end
 
     @connection.columns("unsigned_types").select { |c| /^unsigned_/.match?(c.name) }.each do |column|
-      assert column.unsigned?
+      assert_predicate column, :unsigned?
     end
   end
 
diff --git a/activerecord/test/cases/adapters/postgresql/array_test.rb b/activerecord/test/cases/adapters/postgresql/array_test.rb
index 7eecd5bc35..58fa7532a2 100644
--- a/activerecord/test/cases/adapters/postgresql/array_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/array_test.rb
@@ -39,12 +39,12 @@ class PostgresqlArrayTest < ActiveRecord::PostgreSQLTestCase
   def test_column
     assert_equal :string, @column.type
     assert_equal "character varying(255)", @column.sql_type
-    assert @column.array?
-    assert_not @type.binary?
+    assert_predicate @column, :array?
+    assert_not_predicate @type, :binary?
 
     ratings_column = PgArray.columns_hash["ratings"]
     assert_equal :integer, ratings_column.type
-    assert ratings_column.array?
+    assert_predicate ratings_column, :array?
   end
 
   def test_not_compatible_with_serialize_array
@@ -109,7 +109,7 @@ class PostgresqlArrayTest < ActiveRecord::PostgreSQLTestCase
 
     assert_equal :text, column.type
     assert_equal [], PgArray.column_defaults["snippets"]
-    assert column.array?
+    assert_predicate column, :array?
   end
 
   def test_change_column_cant_make_non_array_column_to_array
@@ -257,7 +257,7 @@ class PostgresqlArrayTest < ActiveRecord::PostgreSQLTestCase
     x = PgArray.create!(tags: tags)
     x.reload
 
-    refute x.changed?
+    assert_not_predicate x, :changed?
   end
 
   def test_quoting_non_standard_delimiters
@@ -279,7 +279,7 @@ class PostgresqlArrayTest < ActiveRecord::PostgreSQLTestCase
     x.reload
 
     assert_equal %w(one two three), x.tags
-    assert_not x.changed?
+    assert_not_predicate x, :changed?
   end
 
   def test_mutate_value_in_array
@@ -290,7 +290,7 @@ class PostgresqlArrayTest < ActiveRecord::PostgreSQLTestCase
     x.reload
 
     assert_equal [{ "a" => "c" }, { "b" => "b" }], x.hstores
-    assert_not x.changed?
+    assert_not_predicate x, :changed?
   end
 
   def test_datetime_with_timezone_awareness
diff --git a/activerecord/test/cases/adapters/postgresql/bit_string_test.rb b/activerecord/test/cases/adapters/postgresql/bit_string_test.rb
index df04299569..c8e728bbb6 100644
--- a/activerecord/test/cases/adapters/postgresql/bit_string_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/bit_string_test.rb
@@ -29,20 +29,20 @@ class PostgresqlBitStringTest < ActiveRecord::PostgreSQLTestCase
     column = PostgresqlBitString.columns_hash["a_bit"]
     assert_equal :bit, column.type
     assert_equal "bit(8)", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlBitString.type_for_attribute("a_bit")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_bit_string_varying_column
     column = PostgresqlBitString.columns_hash["a_bit_varying"]
     assert_equal :bit_varying, column.type
     assert_equal "bit varying(4)", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlBitString.type_for_attribute("a_bit_varying")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_default
diff --git a/activerecord/test/cases/adapters/postgresql/bytea_test.rb b/activerecord/test/cases/adapters/postgresql/bytea_test.rb
index a6bee113ff..64bb6906cd 100644
--- a/activerecord/test/cases/adapters/postgresql/bytea_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/bytea_test.rb
@@ -75,7 +75,7 @@ class PostgresqlByteaTest < ActiveRecord::PostgreSQLTestCase
   def test_write_value
     data = "\u001F"
     record = ByteaDataType.create(payload: data)
-    assert_not record.new_record?
+    assert_not_predicate record, :new_record?
     assert_equal(data, record.payload)
   end
 
@@ -101,14 +101,14 @@ class PostgresqlByteaTest < ActiveRecord::PostgreSQLTestCase
     data = File.read(File.join(__dir__, "..", "..", "..", "assets", "example.log"))
     assert(data.size > 1)
     record = ByteaDataType.create(payload: data)
-    assert_not record.new_record?
+    assert_not_predicate record, :new_record?
     assert_equal(data, record.payload)
     assert_equal(data, ByteaDataType.where(id: record.id).first.payload)
   end
 
   def test_write_nil
     record = ByteaDataType.create(payload: nil)
-    assert_not record.new_record?
+    assert_not_predicate record, :new_record?
     assert_nil(record.payload)
     assert_nil(ByteaDataType.where(id: record.id).first.payload)
   end
diff --git a/activerecord/test/cases/adapters/postgresql/change_schema_test.rb b/activerecord/test/cases/adapters/postgresql/change_schema_test.rb
index adf461a9cc..6dba4f3e14 100644
--- a/activerecord/test/cases/adapters/postgresql/change_schema_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/change_schema_test.rb
@@ -33,7 +33,7 @@ module ActiveRecord
         connection.change_column :strings, :somedate, :timestamp, array: true, cast_as: :timestamp
         column = connection.columns(:strings).find { |c| c.name == "somedate" }
         assert_equal :datetime, column.type
-        assert column.array?
+        assert_predicate column, :array?
       end
     end
   end
diff --git a/activerecord/test/cases/adapters/postgresql/citext_test.rb b/activerecord/test/cases/adapters/postgresql/citext_test.rb
index a25f102bad..9eb0b7d99c 100644
--- a/activerecord/test/cases/adapters/postgresql/citext_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/citext_test.rb
@@ -32,10 +32,10 @@ class PostgresqlCitextTest < ActiveRecord::PostgreSQLTestCase
     column = Citext.columns_hash["cival"]
     assert_equal :citext, column.type
     assert_equal "citext", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = Citext.type_for_attribute("cival")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_change_table_supports_json
diff --git a/activerecord/test/cases/adapters/postgresql/composite_test.rb b/activerecord/test/cases/adapters/postgresql/composite_test.rb
index 5da95f7e2c..b0ce2694a3 100644
--- a/activerecord/test/cases/adapters/postgresql/composite_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/composite_test.rb
@@ -51,10 +51,10 @@ class PostgresqlCompositeTest < ActiveRecord::PostgreSQLTestCase
     column = PostgresqlComposite.columns_hash["address"]
     assert_nil column.type
     assert_equal "full_address", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlComposite.type_for_attribute("address")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_composite_mapping
@@ -113,10 +113,10 @@ class PostgresqlCompositeWithCustomOIDTest < ActiveRecord::PostgreSQLTestCase
     column = PostgresqlComposite.columns_hash["address"]
     assert_equal :full_address, column.type
     assert_equal "full_address", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlComposite.type_for_attribute("address")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_composite_mapping
diff --git a/activerecord/test/cases/adapters/postgresql/connection_test.rb b/activerecord/test/cases/adapters/postgresql/connection_test.rb
index 81358b8fc4..d1b3c434e1 100644
--- a/activerecord/test/cases/adapters/postgresql/connection_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/connection_test.rb
@@ -157,7 +157,7 @@ module ActiveRecord
       original_connection_pid = @connection.query("select pg_backend_pid()")
 
       # Sanity check.
-      assert @connection.active?
+      assert_predicate @connection, :active?
 
       if @connection.send(:postgresql_version) >= 90200
         secondary_connection = ActiveRecord::Base.connection_pool.checkout
@@ -176,7 +176,7 @@ module ActiveRecord
 
       @connection.verify!
 
-      assert @connection.active?
+      assert_predicate @connection, :active?
 
       # If we get no exception here, then either we re-connected successfully, or
       # we never actually got disconnected.
diff --git a/activerecord/test/cases/adapters/postgresql/domain_test.rb b/activerecord/test/cases/adapters/postgresql/domain_test.rb
index dafbc0a3db..eeaad94c27 100644
--- a/activerecord/test/cases/adapters/postgresql/domain_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/domain_test.rb
@@ -30,10 +30,10 @@ class PostgresqlDomainTest < ActiveRecord::PostgreSQLTestCase
     column = PostgresqlDomain.columns_hash["price"]
     assert_equal :decimal, column.type
     assert_equal "custom_money", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlDomain.type_for_attribute("price")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_domain_acts_like_basetype
diff --git a/activerecord/test/cases/adapters/postgresql/enum_test.rb b/activerecord/test/cases/adapters/postgresql/enum_test.rb
index 3d3cbe11a3..6789ff63e7 100644
--- a/activerecord/test/cases/adapters/postgresql/enum_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/enum_test.rb
@@ -32,10 +32,10 @@ class PostgresqlEnumTest < ActiveRecord::PostgreSQLTestCase
     column = PostgresqlEnum.columns_hash["current_mood"]
     assert_equal :enum, column.type
     assert_equal "mood", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlEnum.type_for_attribute("current_mood")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_enum_defaults
@@ -73,7 +73,7 @@ class PostgresqlEnumTest < ActiveRecord::PostgreSQLTestCase
     @connection.execute "INSERT INTO postgresql_enums VALUES (1, 'sad');"
     stderr_output = capture(:stderr) { PostgresqlEnum.first }
 
-    assert stderr_output.blank?
+    assert_predicate stderr_output, :blank?
   end
 
   def test_enum_type_cast
diff --git a/activerecord/test/cases/adapters/postgresql/full_text_test.rb b/activerecord/test/cases/adapters/postgresql/full_text_test.rb
index c6f1e1727f..95dee3bf44 100644
--- a/activerecord/test/cases/adapters/postgresql/full_text_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/full_text_test.rb
@@ -22,10 +22,10 @@ class PostgresqlFullTextTest < ActiveRecord::PostgreSQLTestCase
     column = Tsvector.columns_hash["text_vector"]
     assert_equal :tsvector, column.type
     assert_equal "tsvector", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = Tsvector.type_for_attribute("text_vector")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_update_tsvector
diff --git a/activerecord/test/cases/adapters/postgresql/geometric_test.rb b/activerecord/test/cases/adapters/postgresql/geometric_test.rb
index e1ba00e07b..8c6f046553 100644
--- a/activerecord/test/cases/adapters/postgresql/geometric_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/geometric_test.rb
@@ -39,10 +39,10 @@ class PostgresqlPointTest < ActiveRecord::PostgreSQLTestCase
     column = PostgresqlPoint.columns_hash["x"]
     assert_equal :point, column.type
     assert_equal "point", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlPoint.type_for_attribute("x")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_default
@@ -79,7 +79,7 @@ class PostgresqlPointTest < ActiveRecord::PostgreSQLTestCase
     p.reload
 
     assert_equal ActiveRecord::Point.new(10.0, 25.0), p.x
-    assert_not p.changed?
+    assert_not_predicate p, :changed?
   end
 
   def test_array_assignment
@@ -117,10 +117,10 @@ class PostgresqlPointTest < ActiveRecord::PostgreSQLTestCase
     column = PostgresqlPoint.columns_hash["legacy_x"]
     assert_equal :point, column.type
     assert_equal "point", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlPoint.type_for_attribute("legacy_x")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_legacy_default
@@ -157,7 +157,7 @@ class PostgresqlPointTest < ActiveRecord::PostgreSQLTestCase
     p.reload
 
     assert_equal [10.0, 25.0], p.legacy_x
-    assert_not p.changed?
+    assert_not_predicate p, :changed?
   end
 end
 
diff --git a/activerecord/test/cases/adapters/postgresql/hstore_test.rb b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
index f09e34b5f2..4b061a9375 100644
--- a/activerecord/test/cases/adapters/postgresql/hstore_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
@@ -40,7 +40,7 @@ class PostgresqlHstoreTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_hstore_included_in_extensions
-    assert @connection.respond_to?(:extensions), "connection should have a list of extensions"
+    assert_respond_to @connection, :extensions
     assert_includes @connection.extensions, "hstore", "extension list should include hstore"
   end
 
@@ -58,9 +58,9 @@ class PostgresqlHstoreTest < ActiveRecord::PostgreSQLTestCase
   def test_column
     assert_equal :hstore, @column.type
     assert_equal "hstore", @column.sql_type
-    assert_not @column.array?
+    assert_not_predicate @column, :array?
 
-    assert_not @type.binary?
+    assert_not_predicate @type, :binary?
   end
 
   def test_default
@@ -165,7 +165,7 @@ class PostgresqlHstoreTest < ActiveRecord::PostgreSQLTestCase
     hstore.reload
 
     assert_equal "four", hstore.settings["three"]
-    assert_not hstore.changed?
+    assert_not_predicate hstore, :changed?
   end
 
   def test_dirty_from_user_equal
@@ -174,7 +174,7 @@ class PostgresqlHstoreTest < ActiveRecord::PostgreSQLTestCase
 
     hstore.settings = { "key" => "value", "alongkey" => "anything" }
     assert_equal settings, hstore.settings
-    refute hstore.changed?
+    assert_not_predicate hstore, :changed?
   end
 
   def test_hstore_dirty_from_database_equal
@@ -184,7 +184,7 @@ class PostgresqlHstoreTest < ActiveRecord::PostgreSQLTestCase
 
     assert_equal settings, hstore.settings
     hstore.settings = settings
-    refute hstore.changed?
+    assert_not_predicate hstore, :changed?
   end
 
   def test_gen1
diff --git a/activerecord/test/cases/adapters/postgresql/ltree_test.rb b/activerecord/test/cases/adapters/postgresql/ltree_test.rb
index eca29f2892..8349ee6ee2 100644
--- a/activerecord/test/cases/adapters/postgresql/ltree_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/ltree_test.rb
@@ -31,10 +31,10 @@ class PostgresqlLtreeTest < ActiveRecord::PostgreSQLTestCase
     column = Ltree.columns_hash["path"]
     assert_equal :ltree, column.type
     assert_equal "ltree", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = Ltree.type_for_attribute("path")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_write
diff --git a/activerecord/test/cases/adapters/postgresql/money_test.rb b/activerecord/test/cases/adapters/postgresql/money_test.rb
index cc10890fa8..be3590e8dd 100644
--- a/activerecord/test/cases/adapters/postgresql/money_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/money_test.rb
@@ -26,10 +26,10 @@ class PostgresqlMoneyTest < ActiveRecord::PostgreSQLTestCase
     assert_equal :money, column.type
     assert_equal "money", column.sql_type
     assert_equal 2, column.scale
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlMoney.type_for_attribute("wealth")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_default
diff --git a/activerecord/test/cases/adapters/postgresql/network_test.rb b/activerecord/test/cases/adapters/postgresql/network_test.rb
index f461544a85..736570451b 100644
--- a/activerecord/test/cases/adapters/postgresql/network_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/network_test.rb
@@ -24,30 +24,30 @@ class PostgresqlNetworkTest < ActiveRecord::PostgreSQLTestCase
     column = PostgresqlNetworkAddress.columns_hash["cidr_address"]
     assert_equal :cidr, column.type
     assert_equal "cidr", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlNetworkAddress.type_for_attribute("cidr_address")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_inet_column
     column = PostgresqlNetworkAddress.columns_hash["inet_address"]
     assert_equal :inet, column.type
     assert_equal "inet", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlNetworkAddress.type_for_attribute("inet_address")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_macaddr_column
     column = PostgresqlNetworkAddress.columns_hash["mac_address"]
     assert_equal :macaddr, column.type
     assert_equal "macaddr", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = PostgresqlNetworkAddress.type_for_attribute("mac_address")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_network_types
diff --git a/activerecord/test/cases/adapters/postgresql/serial_test.rb b/activerecord/test/cases/adapters/postgresql/serial_test.rb
index 6a99323be5..83ea86be6d 100644
--- a/activerecord/test/cases/adapters/postgresql/serial_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/serial_test.rb
@@ -24,14 +24,14 @@ class PostgresqlSerialTest < ActiveRecord::PostgreSQLTestCase
     column = PostgresqlSerial.columns_hash["seq"]
     assert_equal :integer, column.type
     assert_equal "integer", column.sql_type
-    assert column.serial?
+    assert_predicate column, :serial?
   end
 
   def test_not_serial_column
     column = PostgresqlSerial.columns_hash["serials_id"]
     assert_equal :integer, column.type
     assert_equal "integer", column.sql_type
-    assert_not column.serial?
+    assert_not_predicate column, :serial?
   end
 
   def test_schema_dump_with_shorthand
@@ -66,14 +66,14 @@ class PostgresqlBigSerialTest < ActiveRecord::PostgreSQLTestCase
     column = PostgresqlBigSerial.columns_hash["seq"]
     assert_equal :integer, column.type
     assert_equal "bigint", column.sql_type
-    assert column.serial?
+    assert_predicate column, :serial?
   end
 
   def test_not_bigserial_column
     column = PostgresqlBigSerial.columns_hash["serials_id"]
     assert_equal :integer, column.type
     assert_equal "bigint", column.sql_type
-    assert_not column.serial?
+    assert_not_predicate column, :serial?
   end
 
   def test_schema_dump_with_shorthand
@@ -111,7 +111,7 @@ module SequenceNameDetectionTestCases
       columns = @connection.columns(:foo)
       columns.each do |column|
         assert_equal :integer, column.type
-        assert column.serial?
+        assert_predicate column, :serial?
       end
     end
 
@@ -142,7 +142,7 @@ module SequenceNameDetectionTestCases
       columns = @connection.columns(@table_name)
       columns.each do |column|
         assert_equal :integer, column.type
-        assert column.serial?
+        assert_predicate column, :serial?
       end
     end
 
diff --git a/activerecord/test/cases/adapters/postgresql/uuid_test.rb b/activerecord/test/cases/adapters/postgresql/uuid_test.rb
index c24e0cb330..71d07e2f4c 100644
--- a/activerecord/test/cases/adapters/postgresql/uuid_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/uuid_test.rb
@@ -82,7 +82,7 @@ class PostgresqlUUIDTest < ActiveRecord::PostgreSQLTestCase
     UUIDType.reset_column_information
     column = UUIDType.columns_hash["thingy"]
 
-    assert column.array?
+    assert_predicate column, :array?
     assert_equal "{}", column.default
 
     schema = dump_table_schema "uuid_data_type"
@@ -93,10 +93,10 @@ class PostgresqlUUIDTest < ActiveRecord::PostgreSQLTestCase
     column = UUIDType.columns_hash["guid"]
     assert_equal :uuid, column.type
     assert_equal "uuid", column.sql_type
-    assert_not column.array?
+    assert_not_predicate column, :array?
 
     type = UUIDType.type_for_attribute("guid")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_treat_blank_uuid_as_nil
@@ -178,7 +178,7 @@ class PostgresqlUUIDTest < ActiveRecord::PostgreSQLTestCase
     duplicate = klass.new(guid: record.guid)
 
     assert record.guid.present? # Ensure we actually are testing a UUID
-    assert_not duplicate.valid?
+    assert_not_predicate duplicate, :valid?
   end
 end
 
diff --git a/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
index 20579c6476..7e0ce3a28e 100644
--- a/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
@@ -475,11 +475,11 @@ module ActiveRecord
       end
 
       def test_respond_to_enable_extension
-        assert @conn.respond_to?(:enable_extension)
+        assert_respond_to @conn, :enable_extension
       end
 
       def test_respond_to_disable_extension
-        assert @conn.respond_to?(:disable_extension)
+        assert_respond_to @conn, :disable_extension
       end
 
       def test_statement_closed
diff --git a/activerecord/test/cases/associations/belongs_to_associations_test.rb b/activerecord/test/cases/associations/belongs_to_associations_test.rb
index 0f7a249bf3..9e6d94191b 100644
--- a/activerecord/test/cases/associations/belongs_to_associations_test.rb
+++ b/activerecord/test/cases/associations/belongs_to_associations_test.rb
@@ -79,7 +79,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     end
 
     account = model.new
-    assert account.valid?
+    assert_predicate account, :valid?
   ensure
     ActiveRecord::Base.belongs_to_required_by_default = original_value
   end
@@ -95,7 +95,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     end
 
     account = model.new
-    assert_not account.valid?
+    assert_not_predicate account, :valid?
     assert_equal [{ error: :blank }], account.errors.details[:company]
   ensure
     ActiveRecord::Base.belongs_to_required_by_default = original_value
@@ -112,7 +112,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     end
 
     account = model.new
-    assert_not account.valid?
+    assert_not_predicate account, :valid?
     assert_equal [{ error: :blank }], account.errors.details[:company]
   ensure
     ActiveRecord::Base.belongs_to_required_by_default = original_value
@@ -246,14 +246,14 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     Firm.create("name" => "Apple")
     Client.create("name" => "Citibank", :firm_name => "Apple")
     citibank_result = Client.all.merge!(where: { name: "Citibank" }, includes: :firm_with_primary_key).first
-    assert citibank_result.association(:firm_with_primary_key).loaded?
+    assert_predicate citibank_result.association(:firm_with_primary_key), :loaded?
   end
 
   def test_eager_loading_with_primary_key_as_symbol
     Firm.create("name" => "Apple")
     Client.create("name" => "Citibank", :firm_name => "Apple")
     citibank_result = Client.all.merge!(where: { name: "Citibank" }, includes: :firm_with_primary_key_symbols).first
-    assert citibank_result.association(:firm_with_primary_key_symbols).loaded?
+    assert_predicate citibank_result.association(:firm_with_primary_key_symbols), :loaded?
   end
 
   def test_creating_the_belonging_object
@@ -320,7 +320,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     client  = Client.create!(name: "Jimmy")
     account = client.create_account!(credit_limit: 10)
     assert_equal account, client.account
-    assert account.persisted?
+    assert_predicate account, :persisted?
     client.save
     client.reload
     assert_equal account, client.account
@@ -330,7 +330,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     client = Client.create!(name: "Jimmy")
     assert_raise(ActiveRecord::RecordInvalid) { client.create_account! }
     assert_not_nil client.account
-    assert client.account.new_record?
+    assert_predicate client.account, :new_record?
   end
 
   def test_reloading_the_belonging_object
@@ -627,10 +627,10 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     final_cut = Client.new("name" => "Final Cut")
     firm = Firm.find(1)
     final_cut.firm = firm
-    assert !final_cut.persisted?
+    assert_not_predicate final_cut, :persisted?
     assert final_cut.save
-    assert final_cut.persisted?
-    assert firm.persisted?
+    assert_predicate final_cut, :persisted?
+    assert_predicate firm, :persisted?
     assert_equal firm, final_cut.firm
     final_cut.association(:firm).reload
     assert_equal firm, final_cut.firm
@@ -640,10 +640,10 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     final_cut = Client.new("name" => "Final Cut")
     firm = Firm.find(1)
     final_cut.firm_with_primary_key = firm
-    assert !final_cut.persisted?
+    assert_not_predicate final_cut, :persisted?
     assert final_cut.save
-    assert final_cut.persisted?
-    assert firm.persisted?
+    assert_predicate final_cut, :persisted?
+    assert_predicate firm, :persisted?
     assert_equal firm, final_cut.firm_with_primary_key
     final_cut.association(:firm_with_primary_key).reload
     assert_equal firm, final_cut.firm_with_primary_key
@@ -790,7 +790,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
 
   def test_cant_save_readonly_association
     assert_raise(ActiveRecord::ReadOnlyRecord) { companies(:first_client).readonly_firm.save! }
-    assert companies(:first_client).readonly_firm.readonly?
+    assert_predicate companies(:first_client).readonly_firm, :readonly?
   end
 
   def test_polymorphic_assignment_foreign_key_type_string
@@ -949,15 +949,15 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     firm_proxy                = client.send(:association_instance_get, :firm)
     firm_with_condition_proxy = client.send(:association_instance_get, :firm_with_condition)
 
-    assert !firm_proxy.stale_target?
-    assert !firm_with_condition_proxy.stale_target?
+    assert_not_predicate firm_proxy, :stale_target?
+    assert_not_predicate firm_with_condition_proxy, :stale_target?
     assert_equal companies(:first_firm), client.firm
     assert_equal companies(:first_firm), client.firm_with_condition
 
     client.client_of = companies(:another_firm).id
 
-    assert firm_proxy.stale_target?
-    assert firm_with_condition_proxy.stale_target?
+    assert_predicate firm_proxy, :stale_target?
+    assert_predicate firm_with_condition_proxy, :stale_target?
     assert_equal companies(:another_firm), client.firm
     assert_equal companies(:another_firm), client.firm_with_condition
   end
@@ -968,12 +968,12 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     sponsor.sponsorable
     proxy = sponsor.send(:association_instance_get, :sponsorable)
 
-    assert !proxy.stale_target?
+    assert_not_predicate proxy, :stale_target?
     assert_equal members(:groucho), sponsor.sponsorable
 
     sponsor.sponsorable_id = members(:some_other_guy).id
 
-    assert proxy.stale_target?
+    assert_predicate proxy, :stale_target?
     assert_equal members(:some_other_guy), sponsor.sponsorable
   end
 
@@ -983,12 +983,12 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     sponsor.sponsorable
     proxy = sponsor.send(:association_instance_get, :sponsorable)
 
-    assert !proxy.stale_target?
+    assert_not_predicate proxy, :stale_target?
     assert_equal members(:groucho), sponsor.sponsorable
 
     sponsor.sponsorable_type = "Firm"
 
-    assert proxy.stale_target?
+    assert_predicate proxy, :stale_target?
     assert_equal companies(:first_firm), sponsor.sponsorable
   end
 
@@ -1122,7 +1122,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     comment.post_id = 9223372036854775808 # out of range in the bigint
 
     assert_nil comment.post
-    assert_not comment.valid?
+    assert_not_predicate comment, :valid?
     assert_equal [{ error: :blank }], comment.errors.details[:post]
   end
 
@@ -1142,7 +1142,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
 
     citibank.firm_id = apple.id.to_s
 
-    assert !citibank.association(:firm).stale_target?
+    assert_not_predicate citibank.association(:firm), :stale_target?
   end
 
   def test_reflect_the_most_recent_change
diff --git a/activerecord/test/cases/associations/callbacks_test.rb b/activerecord/test/cases/associations/callbacks_test.rb
index e096cd4a0b..25d55dc4c9 100644
--- a/activerecord/test/cases/associations/callbacks_test.rb
+++ b/activerecord/test/cases/associations/callbacks_test.rb
@@ -15,7 +15,7 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
     @david = authors(:david)
     @thinking = posts(:thinking)
     @authorless = posts(:authorless)
-    assert @david.post_log.empty?
+    assert_empty @david.post_log
   end
 
   def test_adding_macro_callbacks
@@ -96,7 +96,7 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
   def test_has_and_belongs_to_many_add_callback
     david = developers(:david)
     ar = projects(:active_record)
-    assert ar.developers_log.empty?
+    assert_empty ar.developers_log
     ar.developers_with_callbacks << david
     assert_equal ["before_adding#{david.id}", "after_adding#{david.id}"], ar.developers_log
     ar.developers_with_callbacks << david
@@ -122,12 +122,12 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
     assert_equal alice, dev
     assert_not_nil new_dev
     assert new_dev, "record should not have been saved"
-    assert_not alice.new_record?
+    assert_not_predicate alice, :new_record?
   end
 
   def test_has_and_belongs_to_many_after_add_called_after_save
     ar = projects(:active_record)
-    assert ar.developers_log.empty?
+    assert_empty ar.developers_log
     alice = Developer.new(name: "alice")
     ar.developers_with_callbacks << alice
     assert_equal "after_adding#{alice.id}", ar.developers_log.last
@@ -143,7 +143,7 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
     david = developers(:david)
     jamis = developers(:jamis)
     activerecord = projects(:active_record)
-    assert activerecord.developers_log.empty?
+    assert_empty activerecord.developers_log
     activerecord.developers_with_callbacks.delete(david)
     assert_equal ["before_removing#{david.id}", "after_removing#{david.id}"], activerecord.developers_log
 
@@ -154,7 +154,7 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
 
   def test_has_and_belongs_to_many_does_not_fire_callbacks_on_clear
     activerecord = projects(:active_record)
-    assert activerecord.developers_log.empty?
+    assert_empty activerecord.developers_log
     if activerecord.developers_with_callbacks.size == 0
       activerecord.developers << developers(:david)
       activerecord.developers << developers(:jamis)
@@ -163,7 +163,7 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
     end
     activerecord.developers_with_callbacks.flat_map { |d| ["before_removing#{d.id}", "after_removing#{d.id}"] }.sort
     assert activerecord.developers_with_callbacks.clear
-    assert_predicate activerecord.developers_log, :empty?
+    assert_empty activerecord.developers_log
   end
 
   def test_has_many_and_belongs_to_many_callbacks_for_save_on_parent
@@ -183,7 +183,7 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
       @david.unchangeable_posts << @authorless
     rescue Exception
     end
-    assert @david.post_log.empty?
+    assert_empty @david.post_log
     assert_not_includes @david.unchangeable_posts, @authorless
     @david.reload
     assert_not_includes @david.unchangeable_posts, @authorless
diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index 9830917bc3..cb07ca5cd3 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -284,7 +284,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_loading_from_an_association_that_has_a_hash_of_conditions
-    assert !Author.all.merge!(includes: :hello_posts_with_hash_conditions).find(authors(:david).id).hello_posts.empty?
+    assert_not_empty Author.all.merge!(includes: :hello_posts_with_hash_conditions).find(authors(:david).id).hello_posts
   end
 
   def test_loading_with_no_associations
@@ -1444,51 +1444,51 @@ class EagerAssociationTest < ActiveRecord::TestCase
   test "preloading readonly association" do
     # has-one
     firm = Firm.where(id: "1").preload(:readonly_account).first!
-    assert firm.readonly_account.readonly?
+    assert_predicate firm.readonly_account, :readonly?
 
     # has_and_belongs_to_many
     project = Project.where(id: "2").preload(:readonly_developers).first!
-    assert project.readonly_developers.first.readonly?
+    assert_predicate project.readonly_developers.first, :readonly?
 
     # has-many :through
     david = Author.where(id: "1").preload(:readonly_comments).first!
-    assert david.readonly_comments.first.readonly?
+    assert_predicate david.readonly_comments.first, :readonly?
   end
 
   test "eager-loading non-readonly association" do
     # has_one
     firm = Firm.where(id: "1").eager_load(:account).first!
-    assert_not firm.account.readonly?
+    assert_not_predicate firm.account, :readonly?
 
     # has_and_belongs_to_many
     project = Project.where(id: "2").eager_load(:developers).first!
-    assert_not project.developers.first.readonly?
+    assert_not_predicate project.developers.first, :readonly?
 
     # has_many :through
     david = Author.where(id: "1").eager_load(:comments).first!
-    assert_not david.comments.first.readonly?
+    assert_not_predicate david.comments.first, :readonly?
 
     # belongs_to
     post = Post.where(id: "1").eager_load(:author).first!
-    assert_not post.author.readonly?
+    assert_not_predicate post.author, :readonly?
   end
 
   test "eager-loading readonly association" do
     # has-one
     firm = Firm.where(id: "1").eager_load(:readonly_account).first!
-    assert firm.readonly_account.readonly?
+    assert_predicate firm.readonly_account, :readonly?
 
     # has_and_belongs_to_many
     project = Project.where(id: "2").eager_load(:readonly_developers).first!
-    assert project.readonly_developers.first.readonly?
+    assert_predicate project.readonly_developers.first, :readonly?
 
     # has-many :through
     david = Author.where(id: "1").eager_load(:readonly_comments).first!
-    assert david.readonly_comments.first.readonly?
+    assert_predicate david.readonly_comments.first, :readonly?
 
     # belongs_to
     post = Post.where(id: "1").eager_load(:readonly_author).first!
-    assert post.readonly_author.readonly?
+    assert_predicate post.readonly_author, :readonly?
   end
 
   test "preloading a polymorphic association with references to the associated table" do
diff --git a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
index c817d7267b..d9e05cf7e2 100644
--- a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
@@ -180,11 +180,11 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   def test_has_and_belongs_to_many
     david = Developer.find(1)
 
-    assert !david.projects.empty?
+    assert_not_empty david.projects
     assert_equal 2, david.projects.size
 
     active_record = Project.find(1)
-    assert !active_record.developers.empty?
+    assert_not_empty active_record.developers
     assert_equal 3, active_record.developers.size
     assert_includes active_record.developers, david
   end
@@ -262,10 +262,10 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     no_of_projects = Project.count
     aredridel = Developer.new("name" => "Aredridel")
     aredridel.projects.concat([Project.find(1), p = Project.new("name" => "Projekt")])
-    assert !aredridel.persisted?
-    assert !p.persisted?
+    assert_not_predicate aredridel, :persisted?
+    assert_not_predicate p, :persisted?
     assert aredridel.save
-    assert aredridel.persisted?
+    assert_predicate aredridel, :persisted?
     assert_equal no_of_devels + 1, Developer.count
     assert_equal no_of_projects + 1, Project.count
     assert_equal 2, aredridel.projects.size
@@ -311,14 +311,14 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   def test_build
     devel = Developer.find(1)
     proj = assert_no_queries(ignore_none: false) { devel.projects.build("name" => "Projekt") }
-    assert !devel.projects.loaded?
+    assert_not_predicate devel.projects, :loaded?
 
     assert_equal devel.projects.last, proj
-    assert devel.projects.loaded?
+    assert_predicate devel.projects, :loaded?
 
-    assert !proj.persisted?
+    assert_not_predicate proj, :persisted?
     devel.save
-    assert proj.persisted?
+    assert_predicate proj, :persisted?
     assert_equal devel.projects.last, proj
     assert_equal Developer.find(1).projects.sort_by(&:id).last, proj  # prove join table is updated
   end
@@ -326,14 +326,14 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   def test_new_aliased_to_build
     devel = Developer.find(1)
     proj = assert_no_queries(ignore_none: false) { devel.projects.new("name" => "Projekt") }
-    assert !devel.projects.loaded?
+    assert_not_predicate devel.projects, :loaded?
 
     assert_equal devel.projects.last, proj
-    assert devel.projects.loaded?
+    assert_predicate devel.projects, :loaded?
 
-    assert !proj.persisted?
+    assert_not_predicate proj, :persisted?
     devel.save
-    assert proj.persisted?
+    assert_predicate proj, :persisted?
     assert_equal devel.projects.last, proj
     assert_equal Developer.find(1).projects.sort_by(&:id).last, proj  # prove join table is updated
   end
@@ -343,10 +343,10 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     devel.projects.build(name: "Make bed")
     proj2 = devel.projects.build(name: "Lie in it")
     assert_equal devel.projects.last, proj2
-    assert !proj2.persisted?
+    assert_not_predicate proj2, :persisted?
     devel.save
-    assert devel.persisted?
-    assert proj2.persisted?
+    assert_predicate devel, :persisted?
+    assert_predicate proj2, :persisted?
     assert_equal devel.projects.last, proj2
     assert_equal Developer.find_by_name("Marcel").projects.last, proj2  # prove join table is updated
   end
@@ -354,12 +354,12 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   def test_create
     devel = Developer.find(1)
     proj = devel.projects.create("name" => "Projekt")
-    assert !devel.projects.loaded?
+    assert_not_predicate devel.projects, :loaded?
 
     assert_equal devel.projects.last, proj
-    assert !devel.projects.loaded?
+    assert_not_predicate devel.projects, :loaded?
 
-    assert proj.persisted?
+    assert_predicate proj, :persisted?
     assert_equal Developer.find(1).projects.sort_by(&:id).last, proj  # prove join table is updated
   end
 
@@ -367,14 +367,14 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     # in Oracle '' is saved as null therefore need to save ' ' in not null column
     post = categories(:general).post_with_conditions.build(body: " ")
 
-    assert        post.save
-    assert_equal  "Yet Another Testing Title", post.title
+    assert post.save
+    assert_equal "Yet Another Testing Title", post.title
 
     # in Oracle '' is saved as null therefore need to save ' ' in not null column
     another_post = categories(:general).post_with_conditions.create(body: " ")
 
-    assert        another_post.persisted?
-    assert_equal  "Yet Another Testing Title", another_post.title
+    assert_predicate another_post, :persisted?
+    assert_equal "Yet Another Testing Title", another_post.title
   end
 
   def test_distinct_after_the_fact
@@ -441,10 +441,10 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
 
   def test_removing_associations_on_destroy
     david = DeveloperWithBeforeDestroyRaise.find(1)
-    assert !david.projects.empty?
+    assert_not_empty david.projects
     david.destroy
-    assert david.projects.empty?
-    assert DeveloperWithBeforeDestroyRaise.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = 1").empty?
+    assert_empty david.projects
+    assert_empty DeveloperWithBeforeDestroyRaise.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = 1")
   end
 
   def test_destroying
@@ -459,7 +459,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     end
 
     join_records = Developer.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = #{david.id} AND project_id = #{project.id}")
-    assert join_records.empty?
+    assert_empty join_records
 
     assert_equal 1, david.reload.projects.size
     assert_equal 1, david.projects.reload.size
@@ -475,7 +475,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     end
 
     join_records = Developer.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = #{david.id}")
-    assert join_records.empty?
+    assert_empty join_records
 
     assert_equal 0, david.reload.projects.size
     assert_equal 0, david.projects.reload.size
@@ -484,23 +484,23 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   def test_destroy_all
     david = Developer.find(1)
     david.projects.reload
-    assert !david.projects.empty?
+    assert_not_empty david.projects
 
     assert_no_difference "Project.count" do
       david.projects.destroy_all
     end
 
     join_records = Developer.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = #{david.id}")
-    assert join_records.empty?
+    assert_empty join_records
 
-    assert david.projects.empty?
-    assert david.projects.reload.empty?
+    assert_empty david.projects
+    assert_empty david.projects.reload
   end
 
   def test_destroy_associations_destroys_multiple_associations
     george = parrots(:george)
-    assert !george.pirates.empty?
-    assert !george.treasures.empty?
+    assert_not_empty george.pirates
+    assert_not_empty george.treasures
 
     assert_no_difference "Pirate.count" do
       assert_no_difference "Treasure.count" do
@@ -509,12 +509,12 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     end
 
     join_records = Parrot.connection.select_all("SELECT * FROM parrots_pirates WHERE parrot_id = #{george.id}")
-    assert join_records.empty?
-    assert george.pirates.reload.empty?
+    assert_empty join_records
+    assert_empty george.pirates.reload
 
     join_records = Parrot.connection.select_all("SELECT * FROM parrots_treasures WHERE parrot_id = #{george.id}")
-    assert join_records.empty?
-    assert george.treasures.reload.empty?
+    assert_empty join_records
+    assert_empty george.treasures.reload
   end
 
   def test_associations_with_conditions
@@ -547,7 +547,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     developer = project.developers.first
 
     assert_no_queries(ignore_none: false) do
-      assert project.developers.loaded?
+      assert_predicate project.developers, :loaded?
       assert_includes project.developers, developer
     end
   end
@@ -557,18 +557,18 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     developer = project.developers.first
 
     project.reload
-    assert ! project.developers.loaded?
+    assert_not_predicate project.developers, :loaded?
     assert_queries(1) do
       assert_includes project.developers, developer
     end
-    assert ! project.developers.loaded?
+    assert_not_predicate project.developers, :loaded?
   end
 
   def test_include_returns_false_for_non_matching_record_to_verify_scoping
     project = projects(:active_record)
     developer = Developer.create name: "Bryan", salary: 50_000
 
-    assert ! project.developers.loaded?
+    assert_not_predicate project.developers, :loaded?
     assert ! project.developers.include?(developer)
   end
 
@@ -763,9 +763,9 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
 
   def test_get_ids_for_unloaded_associations_does_not_load_them
     developer = developers(:david)
-    assert !developer.projects.loaded?
+    assert_not_predicate developer.projects, :loaded?
     assert_equal projects(:active_record, :action_controller).map(&:id).sort, developer.project_ids.sort
-    assert !developer.projects.loaded?
+    assert_not_predicate developer.projects, :loaded?
   end
 
   def test_assign_ids
diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index 18548f8516..9ee42cef0f 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -57,7 +57,7 @@ class HasManyAssociationsTestPrimaryKeys < ActiveRecord::TestCase
 
   def test_custom_primary_key_on_new_record_should_fetch_with_query
     subscriber = Subscriber.new(nick: "webster132")
-    assert !subscriber.subscriptions.loaded?
+    assert_not_predicate subscriber.subscriptions, :loaded?
 
     assert_queries 1 do
       assert_equal 2, subscriber.subscriptions.size
@@ -68,7 +68,7 @@ class HasManyAssociationsTestPrimaryKeys < ActiveRecord::TestCase
 
   def test_association_primary_key_on_new_record_should_fetch_with_query
     author = Author.new(name: "David")
-    assert !author.essays.loaded?
+    assert_not_predicate author.essays, :loaded?
 
     assert_queries 1 do
       assert_equal 1, author.essays.size
@@ -103,7 +103,7 @@ class HasManyAssociationsTestPrimaryKeys < ActiveRecord::TestCase
 
   def test_blank_custom_primary_key_on_new_record_should_not_run_queries
     author = Author.new
-    assert !author.essays.loaded?
+    assert_not_predicate author.essays, :loaded?
 
     assert_queries 0 do
       assert_equal 0, author.essays.size
@@ -201,7 +201,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     part.reload
 
     assert_nil part.ship
-    assert !part.updated_at_changed?
+    assert_not_predicate part, :updated_at_changed?
   end
 
   def test_create_from_association_should_respect_default_scope
@@ -444,7 +444,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
       new_clients << company.clients_of_firm.build(name: "Another Client III")
     end
 
-    assert_not company.clients_of_firm.loaded?
+    assert_not_predicate company.clients_of_firm, :loaded?
     assert_queries(1) do
       assert_same new_clients[0], company.clients_of_firm.third
       assert_same new_clients[1], company.clients_of_firm.fourth
@@ -464,7 +464,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
       new_clients << company.clients_of_firm.build(name: "Another Client III")
     end
 
-    assert_not company.clients_of_firm.loaded?
+    assert_not_predicate company.clients_of_firm, :loaded?
     assert_queries(1) do
       assert_same new_clients[0], company.clients_of_firm.third!
       assert_same new_clients[1], company.clients_of_firm.fourth!
@@ -587,14 +587,14 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     # taking from unloaded Relation
     bob = klass.find(authors(:bob).id)
     new_post = bob.posts.build
-    assert_not bob.posts.loaded?
+    assert_not_predicate bob.posts, :loaded?
     assert_equal [posts(:misc_by_bob)], bob.posts.take(1)
     assert_equal [posts(:misc_by_bob), posts(:other_by_bob)], bob.posts.take(2)
     assert_equal [posts(:misc_by_bob), posts(:other_by_bob), new_post], bob.posts.take(3)
 
     # taking from loaded Relation
     bob.posts.load
-    assert bob.posts.loaded?
+    assert_predicate bob.posts, :loaded?
     assert_equal [posts(:misc_by_bob)], bob.posts.take(1)
     assert_equal [posts(:misc_by_bob), posts(:other_by_bob)], bob.posts.take(2)
     assert_equal [posts(:misc_by_bob), posts(:other_by_bob), new_post], bob.posts.take(3)
@@ -713,13 +713,13 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_find_each
     firm = companies(:first_firm)
 
-    assert ! firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
 
     assert_queries(4) do
       firm.clients.find_each(batch_size: 1) { |c| assert_equal firm.id, c.firm_id }
     end
 
-    assert ! firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_find_each_with_conditions
@@ -732,13 +732,13 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
       end
     end
 
-    assert ! firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_find_in_batches
     firm = companies(:first_firm)
 
-    assert ! firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
 
     assert_queries(2) do
       firm.clients.find_in_batches(batch_size: 2) do |clients|
@@ -746,7 +746,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
       end
     end
 
-    assert ! firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_find_all_sanitized
@@ -955,20 +955,20 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_new_aliased_to_build
     company = companies(:first_firm)
     new_client = assert_no_queries(ignore_none: false) { company.clients_of_firm.new("name" => "Another Client") }
-    assert !company.clients_of_firm.loaded?
+    assert_not_predicate company.clients_of_firm, :loaded?
 
     assert_equal "Another Client", new_client.name
-    assert !new_client.persisted?
+    assert_not_predicate new_client, :persisted?
     assert_equal new_client, company.clients_of_firm.last
   end
 
   def test_build
     company = companies(:first_firm)
     new_client = assert_no_queries(ignore_none: false) { company.clients_of_firm.build("name" => "Another Client") }
-    assert !company.clients_of_firm.loaded?
+    assert_not_predicate company.clients_of_firm, :loaded?
 
     assert_equal "Another Client", new_client.name
-    assert !new_client.persisted?
+    assert_not_predicate new_client, :persisted?
     assert_equal new_client, company.clients_of_firm.last
   end
 
@@ -982,9 +982,9 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_collection_not_empty_after_building
     company = companies(:first_firm)
-    assert_predicate company.contracts, :empty?
+    assert_empty company.contracts
     company.contracts.build
-    assert_not_predicate company.contracts, :empty?
+    assert_not_empty company.contracts
   end
 
   def test_collection_size_twice_for_regressions
@@ -1008,7 +1008,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_build_followed_by_save_does_not_load_target
     companies(:first_firm).clients_of_firm.build("name" => "Another Client")
     assert companies(:first_firm).save
-    assert !companies(:first_firm).clients_of_firm.loaded?
+    assert_not_predicate companies(:first_firm).clients_of_firm, :loaded?
   end
 
   def test_build_without_loading_association
@@ -1028,10 +1028,10 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_build_via_block
     company = companies(:first_firm)
     new_client = assert_no_queries(ignore_none: false) { company.clients_of_firm.build { |client| client.name = "Another Client" } }
-    assert !company.clients_of_firm.loaded?
+    assert_not_predicate company.clients_of_firm, :loaded?
 
     assert_equal "Another Client", new_client.name
-    assert !new_client.persisted?
+    assert_not_predicate new_client, :persisted?
     assert_equal new_client, company.clients_of_firm.last
   end
 
@@ -1069,7 +1069,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_predicate companies(:first_firm).clients_of_firm, :loaded?
 
     new_client = companies(:first_firm).clients_of_firm.create("name" => "Another Client")
-    assert new_client.persisted?
+    assert_predicate new_client, :persisted?
     assert_equal new_client, companies(:first_firm).clients_of_firm.last
     assert_equal new_client, companies(:first_firm).clients_of_firm.reload.last
   end
@@ -1082,7 +1082,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_create_followed_by_save_does_not_load_target
     companies(:first_firm).clients_of_firm.create("name" => "Another Client")
     assert companies(:first_firm).save
-    assert !companies(:first_firm).clients_of_firm.loaded?
+    assert_not_predicate companies(:first_firm).clients_of_firm, :loaded?
   end
 
   def test_deleting
@@ -1108,7 +1108,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     # option is not given on the association.
     ship = Ship.create(name: "Countless", treasures_count: 10)
 
-    assert_not Ship.reflect_on_association(:treasures).has_cached_counter?
+    assert_not_predicate Ship.reflect_on_association(:treasures), :has_cached_counter?
 
     # Count should come from sql count() of treasures rather than treasures_count attribute
     assert_equal ship.treasures.size, 0
@@ -1199,7 +1199,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_calling_empty_with_counter_cache
     post = posts(:welcome)
     assert_queries(0) do
-      assert_not post.comments.empty?
+      assert_not_empty post.comments
     end
   end
 
@@ -1441,13 +1441,13 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_creation_respects_hash_condition
     ms_client = companies(:first_firm).clients_like_ms_with_hash_conditions.build
 
-    assert        ms_client.save
-    assert_equal  "Microsoft", ms_client.name
+    assert ms_client.save
+    assert_equal "Microsoft", ms_client.name
 
     another_ms_client = companies(:first_firm).clients_like_ms_with_hash_conditions.create
 
-    assert        another_ms_client.persisted?
-    assert_equal  "Microsoft", another_ms_client.name
+    assert_predicate another_ms_client, :persisted?
+    assert_equal "Microsoft", another_ms_client.name
   end
 
   def test_clearing_without_initial_access
@@ -1570,7 +1570,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     firm = companies(:first_firm)
     assert_equal 3, firm.clients.size
     firm.destroy
-    assert Client.all.merge!(where: "firm_id=#{firm.id}").to_a.empty?
+    assert_empty Client.all.merge!(where: "firm_id=#{firm.id}").to_a
   end
 
   def test_dependence_for_associations_with_hash_condition
@@ -1633,7 +1633,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     firm = RestrictedWithExceptionFirm.create!(name: "restrict")
     firm.companies.create(name: "child")
 
-    assert !firm.companies.empty?
+    assert_not_empty firm.companies
     assert_raise(ActiveRecord::DeleteRestrictionError) { firm.destroy }
     assert RestrictedWithExceptionFirm.exists?(name: "restrict")
     assert firm.companies.exists?(name: "child")
@@ -1643,11 +1643,11 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     firm = RestrictedWithErrorFirm.create!(name: "restrict")
     firm.companies.create(name: "child")
 
-    assert !firm.companies.empty?
+    assert_not_empty firm.companies
 
     firm.destroy
 
-    assert !firm.errors.empty?
+    assert_not_empty firm.errors
 
     assert_equal "Cannot delete record because dependent companies exist", firm.errors[:base].first
     assert RestrictedWithErrorFirm.exists?(name: "restrict")
@@ -1660,11 +1660,11 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     firm = RestrictedWithErrorFirm.create!(name: "restrict")
     firm.companies.create(name: "child")
 
-    assert !firm.companies.empty?
+    assert_not_empty firm.companies
 
     firm.destroy
 
-    assert !firm.errors.empty?
+    assert_not_empty firm.errors
 
     assert_equal "Cannot delete record because dependent client companies exist", firm.errors[:base].first
     assert RestrictedWithErrorFirm.exists?(name: "restrict")
@@ -1716,8 +1716,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     account = Account.new
     orig_accounts = firm.accounts.to_a
 
-    assert !account.valid?
-    assert !orig_accounts.empty?
+    assert_not_predicate account, :valid?
+    assert_not_empty orig_accounts
     error = assert_raise ActiveRecord::RecordNotSaved do
       firm.accounts = [account]
     end
@@ -1775,9 +1775,9 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_get_ids_for_unloaded_associations_does_not_load_them
     company = companies(:first_firm)
-    assert !company.clients.loaded?
+    assert_not_predicate company.clients, :loaded?
     assert_equal [companies(:first_client).id, companies(:second_client).id, companies(:another_first_firm_client).id], company.client_ids
-    assert !company.clients.loaded?
+    assert_not_predicate company.clients, :loaded?
   end
 
   def test_counter_cache_on_unloaded_association
@@ -1859,7 +1859,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     client = firm.clients.first
 
     assert_no_queries do
-      assert firm.clients.loaded?
+      assert_predicate firm.clients, :loaded?
       assert_equal true, firm.clients.include?(client)
     end
   end
@@ -1869,18 +1869,18 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     client = firm.clients.first
 
     firm.reload
-    assert ! firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
     assert_queries(1) do
       assert_equal true, firm.clients.include?(client)
     end
-    assert ! firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_include_returns_false_for_non_matching_record_to_verify_scoping
     firm = companies(:first_firm)
     client = Client.create!(name: "Not Associated")
 
-    assert ! firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
     assert_equal false, firm.clients.include?(client)
   end
 
@@ -1889,13 +1889,13 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     firm.clients.first
     firm.clients.second
     firm.clients.last
-    assert !firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_calling_first_or_last_on_loaded_association_should_not_fetch_with_query
     firm = companies(:first_firm)
     firm.clients.load_target
-    assert firm.clients.loaded?
+    assert_predicate firm.clients, :loaded?
 
     assert_no_queries(ignore_none: false) do
       firm.clients.first
@@ -1908,7 +1908,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_calling_first_or_last_on_existing_record_with_build_should_load_association
     firm = companies(:first_firm)
     firm.clients.build(name: "Foo")
-    assert !firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
 
     assert_queries 1 do
       firm.clients.first
@@ -1916,13 +1916,13 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
       firm.clients.last
     end
 
-    assert firm.clients.loaded?
+    assert_predicate firm.clients, :loaded?
   end
 
   def test_calling_first_nth_or_last_on_existing_record_with_create_should_not_load_association
     firm = companies(:first_firm)
     firm.clients.create(name: "Foo")
-    assert !firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
 
     assert_queries 3 do
       firm.clients.first
@@ -1930,7 +1930,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
       firm.clients.last
     end
 
-    assert !firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_calling_first_nth_or_last_on_new_record_should_not_run_queries
@@ -1946,14 +1946,14 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_calling_first_or_last_with_integer_on_association_should_not_load_association
     firm = companies(:first_firm)
     firm.clients.create(name: "Foo")
-    assert !firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
 
     assert_queries 2 do
       firm.clients.first(2)
       firm.clients.last(2)
     end
 
-    assert !firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_calling_many_should_count_instead_of_loading_association
@@ -1961,7 +1961,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_queries(1) do
       firm.clients.many?  # use count query
     end
-    assert !firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_calling_many_on_loaded_association_should_not_use_query
@@ -1976,22 +1976,22 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
       firm.clients.expects(:size).never
       firm.clients.many? { true }
     end
-    assert firm.clients.loaded?
+    assert_predicate firm.clients, :loaded?
   end
 
   def test_calling_many_should_return_false_if_none_or_one
     firm = companies(:another_firm)
-    assert !firm.clients_like_ms.many?
+    assert_not_predicate firm.clients_like_ms, :many?
     assert_equal 0, firm.clients_like_ms.size
 
     firm = companies(:first_firm)
-    assert !firm.limited_clients.many?
+    assert_not_predicate firm.limited_clients, :many?
     assert_equal 1, firm.limited_clients.size
   end
 
   def test_calling_many_should_return_true_if_more_than_one
     firm = companies(:first_firm)
-    assert firm.clients.many?
+    assert_predicate firm.clients, :many?
     assert_equal 3, firm.clients.size
   end
 
@@ -2000,7 +2000,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_queries(1) do
       firm.clients.none?  # use count query
     end
-    assert !firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_calling_none_on_loaded_association_should_not_use_query
@@ -2015,18 +2015,18 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
       firm.clients.expects(:size).never
       firm.clients.none? { true }
     end
-    assert firm.clients.loaded?
+    assert_predicate firm.clients, :loaded?
   end
 
   def test_calling_none_should_return_true_if_none
     firm = companies(:another_firm)
-    assert firm.clients_like_ms.none?
+    assert_predicate firm.clients_like_ms, :none?
     assert_equal 0, firm.clients_like_ms.size
   end
 
   def test_calling_none_should_return_false_if_any
     firm = companies(:first_firm)
-    assert !firm.limited_clients.none?
+    assert_not_predicate firm.limited_clients, :none?
     assert_equal 1, firm.limited_clients.size
   end
 
@@ -2035,7 +2035,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_queries(1) do
       firm.clients.one?  # use count query
     end
-    assert !firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_calling_one_on_loaded_association_should_not_use_query
@@ -2050,24 +2050,24 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
       firm.clients.expects(:size).never
       firm.clients.one? { true }
     end
-    assert firm.clients.loaded?
+    assert_predicate firm.clients, :loaded?
   end
 
   def test_calling_one_should_return_false_if_zero
     firm = companies(:another_firm)
-    assert ! firm.clients_like_ms.one?
+    assert_not_predicate firm.clients_like_ms, :one?
     assert_equal 0, firm.clients_like_ms.size
   end
 
   def test_calling_one_should_return_true_if_one
     firm = companies(:first_firm)
-    assert firm.limited_clients.one?
+    assert_predicate firm.limited_clients, :one?
     assert_equal 1, firm.limited_clients.size
   end
 
   def test_calling_one_should_return_false_if_more_than_one
     firm = companies(:first_firm)
-    assert ! firm.clients.one?
+    assert_not_predicate firm.clients, :one?
     assert_equal 3, firm.clients.size
   end
 
@@ -2287,7 +2287,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     post = posts(:welcome)
 
     assert post.taggings_with_delete_all.count > 0
-    assert !post.taggings_with_delete_all.loaded?
+    assert_not_predicate post.taggings_with_delete_all, :loaded?
 
     # 2 queries: one DELETE and another to update the counter cache
     assert_queries(2) do
@@ -2309,7 +2309,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   test "collection proxy respects default scope" do
     author = authors(:mary)
-    assert !author.first_posts.exists?
+    assert_not_predicate author.first_posts, :exists?
   end
 
   test "association with extend option" do
@@ -2428,7 +2428,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     pirate = FamousPirate.new
     pirate.famous_ships << ship = FamousShip.new
 
-    assert pirate.valid?
+    assert_predicate pirate, :valid?
     assert_not pirate.valid?(:conference)
     assert_equal "can't be blank", ship.errors[:name].first
   end
diff --git a/activerecord/test/cases/associations/has_many_through_associations_test.rb b/activerecord/test/cases/associations/has_many_through_associations_test.rb
index dabeeff1be..25118b26f5 100644
--- a/activerecord/test/cases/associations/has_many_through_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_through_associations_test.rb
@@ -353,10 +353,10 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     end
 
     assert_queries(1) do
-      assert posts(:welcome).people.empty?
+      assert_empty posts(:welcome).people
     end
 
-    assert posts(:welcome).reload.people.reload.empty?
+    assert_empty posts(:welcome).reload.people.reload
   end
 
   def test_destroy_association
@@ -366,8 +366,8 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
       end
     end
 
-    assert posts(:welcome).reload.people.empty?
-    assert posts(:welcome).people.reload.empty?
+    assert_empty posts(:welcome).reload.people
+    assert_empty posts(:welcome).people.reload
   end
 
   def test_destroy_all
@@ -377,8 +377,8 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
       end
     end
 
-    assert posts(:welcome).reload.people.empty?
-    assert posts(:welcome).people.reload.empty?
+    assert_empty posts(:welcome).reload.people
+    assert_empty posts(:welcome).people.reload
   end
 
   def test_should_raise_exception_for_destroying_mismatching_records
@@ -685,10 +685,10 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     end
 
     assert_queries(0) do
-      assert posts(:welcome).people.empty?
+      assert_empty posts(:welcome).people
     end
 
-    assert posts(:welcome).reload.people.reload.empty?
+    assert_empty posts(:welcome).reload.people.reload
   end
 
   def test_association_callback_ordering
@@ -770,9 +770,9 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_get_ids_for_unloaded_associations_does_not_load_them
     person = people(:michael)
-    assert !person.posts.loaded?
+    assert_not_predicate person.posts, :loaded?
     assert_equal [posts(:welcome).id, posts(:authorless).id].sort, person.post_ids.sort
-    assert !person.posts.loaded?
+    assert_not_predicate person.posts, :loaded?
   end
 
   def test_association_proxy_transaction_method_starts_transaction_in_association_class
@@ -862,7 +862,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     category = author.named_categories.create(name: "Primary")
     author.named_categories.delete(category)
     assert !Categorization.exists?(author_id: author.id, named_category_name: category.name)
-    assert author.named_categories.reload.empty?
+    assert_empty author.named_categories.reload
   end
 
   def test_collection_singular_ids_getter_with_string_primary_keys
@@ -944,8 +944,8 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_through_association_readonly_should_be_false
-    assert !people(:michael).posts.first.readonly?
-    assert !people(:michael).posts.to_a.first.readonly?
+    assert_not_predicate people(:michael).posts.first, :readonly?
+    assert_not_predicate people(:michael).posts.to_a.first, :readonly?
   end
 
   def test_can_update_through_association
@@ -1034,12 +1034,12 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     post.author_categorizations
     proxy = post.send(:association_instance_get, :author_categorizations)
 
-    assert !proxy.stale_target?
+    assert_not_predicate proxy, :stale_target?
     assert_equal authors(:mary).categorizations.sort_by(&:id), post.author_categorizations.sort_by(&:id)
 
     post.author_id = authors(:david).id
 
-    assert proxy.stale_target?
+    assert_predicate proxy, :stale_target?
     assert_equal authors(:david).categorizations.sort_by(&:id), post.author_categorizations.sort_by(&:id)
   end
 
@@ -1056,7 +1056,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
 
     assert_includes post.author_addresses, address
     post.author_addresses.delete(address)
-    assert post[:author_count].nil?
+    assert_predicate post[:author_count], :nil?
   end
 
   def test_primary_key_option_on_source
diff --git a/activerecord/test/cases/associations/has_one_associations_test.rb b/activerecord/test/cases/associations/has_one_associations_test.rb
index ec5d95080b..1a213ef7e4 100644
--- a/activerecord/test/cases/associations/has_one_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_associations_test.rb
@@ -114,8 +114,8 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
     developer = Developer.create!(name: "Someone")
     ship = Ship.create!(name: "Planet Caravan", developer: developer)
     ship.destroy
-    assert !ship.persisted?
-    assert !developer.persisted?
+    assert_not_predicate ship, :persisted?
+    assert_not_predicate developer, :persisted?
   end
 
   def test_natural_assignment_to_nil_after_destroy
@@ -186,7 +186,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
 
     assert_raise(ActiveRecord::DeleteRestrictionError) { firm.destroy }
     assert RestrictedWithExceptionFirm.exists?(name: "restrict")
-    assert firm.account.present?
+    assert_predicate firm.account, :present?
   end
 
   def test_restrict_with_error
@@ -197,10 +197,10 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
 
     firm.destroy
 
-    assert !firm.errors.empty?
+    assert_not_empty firm.errors
     assert_equal "Cannot delete record because a dependent account exists", firm.errors[:base].first
     assert RestrictedWithErrorFirm.exists?(name: "restrict")
-    assert firm.account.present?
+    assert_predicate firm.account, :present?
   end
 
   def test_restrict_with_error_with_locale
@@ -213,10 +213,10 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
 
     firm.destroy
 
-    assert !firm.errors.empty?
+    assert_not_empty firm.errors
     assert_equal "Cannot delete record because a dependent firm account exists", firm.errors[:base].first
     assert RestrictedWithErrorFirm.exists?(name: "restrict")
-    assert firm.account.present?
+    assert_predicate firm.account, :present?
   ensure
     I18n.backend.reload!
   end
@@ -377,7 +377,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
   def test_assignment_before_child_saved
     firm = Firm.find(1)
     firm.account = a = Account.new("credit_limit" => 1000)
-    assert a.persisted?
+    assert_predicate a, :persisted?
     assert_equal a, firm.account
     assert_equal a, firm.account
     firm.association(:account).reload
@@ -395,7 +395,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
 
   def test_cant_save_readonly_association
     assert_raise(ActiveRecord::ReadOnlyRecord) { companies(:first_firm).readonly_account.save!  }
-    assert companies(:first_firm).readonly_account.readonly?
+    assert_predicate companies(:first_firm).readonly_account, :readonly?
   end
 
   def test_has_one_proxy_should_not_respond_to_private_methods
@@ -433,7 +433,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
 
   def test_create_respects_hash_condition
     account = companies(:first_firm).create_account_limit_500_with_hash_conditions
-    assert       account.persisted?
+    assert_predicate account, :persisted?
     assert_equal 500, account.credit_limit
   end
 
@@ -450,7 +450,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
     new_ship = pirate.create_ship
     assert_not_equal ships(:black_pearl), new_ship
     assert_equal new_ship, pirate.ship
-    assert new_ship.new_record?
+    assert_predicate new_ship, :new_record?
     assert_nil orig_ship.pirate_id
     assert !orig_ship.changed? # check it was saved
   end
@@ -460,8 +460,8 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
     orig_ship = pirate.dependent_ship
 
     new_ship = pirate.create_dependent_ship
-    assert new_ship.new_record?
-    assert orig_ship.destroyed?
+    assert_predicate new_ship, :new_record?
+    assert_predicate orig_ship, :destroyed?
   end
 
   def test_creation_failure_due_to_new_record_should_raise_error
@@ -481,7 +481,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
     pirate = pirates(:blackbeard)
     pirate.ship.name = nil
 
-    assert !pirate.ship.valid?
+    assert_not_predicate pirate.ship, :valid?
     error = assert_raise(ActiveRecord::RecordNotSaved) do
       pirate.ship = ships(:interceptor)
     end
@@ -588,7 +588,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
     ship.save!
 
     ship.name = "new name"
-    assert ship.changed?
+    assert_predicate ship, :changed?
     assert_queries(1) do
       # One query for updating name, not triggering query for updating pirate_id
       pirate.ship = ship
diff --git a/activerecord/test/cases/associations/has_one_through_associations_test.rb b/activerecord/test/cases/associations/has_one_through_associations_test.rb
index 8bbd4134fa..9964f084ac 100644
--- a/activerecord/test/cases/associations/has_one_through_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_through_associations_test.rb
@@ -47,11 +47,11 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
     new_club = new_member.association(:club).build
     assert new_member.current_membership
     assert_equal new_club, new_member.club
-    assert new_club.new_record?
-    assert new_member.current_membership.new_record?
+    assert_predicate new_club, :new_record?
+    assert_predicate new_member.current_membership, :new_record?
     assert new_member.save
-    assert new_club.persisted?
-    assert new_member.current_membership.persisted?
+    assert_predicate new_club, :persisted?
+    assert_predicate new_member.current_membership, :persisted?
   end
 
   def test_creating_association_builds_through_record_for_new
@@ -241,7 +241,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
       MemberDetail.all.merge!(includes: :member_type).to_a
     end
     @new_detail = @member_details[0]
-    assert @new_detail.send(:association, :member_type).loaded?
+    assert_predicate @new_detail.send(:association, :member_type), :loaded?
     assert_no_queries { @new_detail.member_type }
   end
 
@@ -329,12 +329,12 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
     minivan.dashboard
     proxy = minivan.send(:association_instance_get, :dashboard)
 
-    assert !proxy.stale_target?
+    assert_not_predicate proxy, :stale_target?
     assert_equal dashboards(:cool_first), minivan.dashboard
 
     minivan.speedometer_id = speedometers(:second).id
 
-    assert proxy.stale_target?
+    assert_predicate proxy, :stale_target?
     assert_equal dashboards(:second), minivan.dashboard
   end
 
@@ -346,7 +346,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
 
     minivan.speedometer_id = speedometers(:second).id
 
-    assert proxy.stale_target?
+    assert_predicate proxy, :stale_target?
     assert_equal dashboards(:second), minivan.dashboard
   end
 
diff --git a/activerecord/test/cases/associations/inner_join_association_test.rb b/activerecord/test/cases/associations/inner_join_association_test.rb
index 7be875fec6..ca0620dc3b 100644
--- a/activerecord/test/cases/associations/inner_join_association_test.rb
+++ b/activerecord/test/cases/associations/inner_join_association_test.rb
@@ -115,19 +115,19 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
     scope = Post.joins(:special_comments).where(id: posts(:sti_comments).id)
 
     # The join should match SpecialComment and its subclasses only
-    assert scope.where("comments.type" => "Comment").empty?
-    assert !scope.where("comments.type" => "SpecialComment").empty?
-    assert !scope.where("comments.type" => "SubSpecialComment").empty?
+    assert_empty scope.where("comments.type" => "Comment")
+    assert_not_empty scope.where("comments.type" => "SpecialComment")
+    assert_not_empty scope.where("comments.type" => "SubSpecialComment")
   end
 
   def test_find_with_conditions_on_reflection
-    assert !posts(:welcome).comments.empty?
+    assert_not_empty posts(:welcome).comments
     assert Post.joins(:nonexistent_comments).where(id: posts(:welcome).id).empty? # [sic!]
   end
 
   def test_find_with_conditions_on_through_reflection
-    assert !posts(:welcome).tags.empty?
-    assert Post.joins(:misc_tags).where(id: posts(:welcome).id).empty?
+    assert_not_empty posts(:welcome).tags
+    assert_empty Post.joins(:misc_tags).where(id: posts(:welcome).id)
   end
 
   test "the default scope of the target is applied when joining associations" do
diff --git a/activerecord/test/cases/associations/inverse_associations_test.rb b/activerecord/test/cases/associations/inverse_associations_test.rb
index c0d328ca8a..bad1bcdb67 100644
--- a/activerecord/test/cases/associations/inverse_associations_test.rb
+++ b/activerecord/test/cases/associations/inverse_associations_test.rb
@@ -129,7 +129,7 @@ class AutomaticInverseFindingTests < ActiveRecord::TestCase
   def test_polymorphic_has_one_should_find_inverse_automatically
     man_reflection = Man.reflect_on_association(:polymorphic_face_without_inverse)
 
-    assert man_reflection.has_inverse?
+    assert_predicate man_reflection, :has_inverse?
   end
 end
 
@@ -150,22 +150,22 @@ class InverseAssociationTests < ActiveRecord::TestCase
 
   def test_should_be_able_to_ask_a_reflection_if_it_has_an_inverse
     has_one_with_inverse_ref = Man.reflect_on_association(:face)
-    assert has_one_with_inverse_ref.has_inverse?
+    assert_predicate has_one_with_inverse_ref, :has_inverse?
 
     has_many_with_inverse_ref = Man.reflect_on_association(:interests)
-    assert has_many_with_inverse_ref.has_inverse?
+    assert_predicate has_many_with_inverse_ref, :has_inverse?
 
     belongs_to_with_inverse_ref = Face.reflect_on_association(:man)
-    assert belongs_to_with_inverse_ref.has_inverse?
+    assert_predicate belongs_to_with_inverse_ref, :has_inverse?
 
     has_one_without_inverse_ref = Club.reflect_on_association(:sponsor)
-    assert !has_one_without_inverse_ref.has_inverse?
+    assert_not_predicate has_one_without_inverse_ref, :has_inverse?
 
     has_many_without_inverse_ref = Club.reflect_on_association(:memberships)
-    assert !has_many_without_inverse_ref.has_inverse?
+    assert_not_predicate has_many_without_inverse_ref, :has_inverse?
 
     belongs_to_without_inverse_ref = Sponsor.reflect_on_association(:sponsor_club)
-    assert !belongs_to_without_inverse_ref.has_inverse?
+    assert_not_predicate belongs_to_without_inverse_ref, :has_inverse?
   end
 
   def test_inverse_of_method_should_supply_the_actual_reflection_instance_it_is_the_inverse_of
@@ -464,7 +464,7 @@ class InverseHasManyTests < ActiveRecord::TestCase
     interest = Interest.create!(man: man)
 
     man.interests.find(interest.id)
-    assert_not man.interests.loaded?
+    assert_not_predicate man.interests, :loaded?
   end
 
   def test_raise_record_not_found_error_when_invalid_ids_are_passed
@@ -504,16 +504,16 @@ class InverseHasManyTests < ActiveRecord::TestCase
     i.man.name = "Charles"
     assert_equal i.man.name, man.name
 
-    assert !man.persisted?
+    assert_not_predicate man, :persisted?
   end
 
   def test_inverse_instance_should_be_set_before_find_callbacks_are_run
     reset_callbacks(Interest, :find) do
       Interest.after_find { raise unless association(:man).loaded? && man.present? }
 
-      assert Man.first.interests.reload.any?
-      assert Man.includes(:interests).first.interests.any?
-      assert Man.joins(:interests).includes(:interests).first.interests.any?
+      assert_predicate Man.first.interests.reload, :any?
+      assert_predicate Man.includes(:interests).first.interests, :any?
+      assert_predicate Man.joins(:interests).includes(:interests).first.interests, :any?
     end
   end
 
@@ -521,9 +521,9 @@ class InverseHasManyTests < ActiveRecord::TestCase
     reset_callbacks(Interest, :initialize) do
       Interest.after_initialize { raise unless association(:man).loaded? && man.present? }
 
-      assert Man.first.interests.reload.any?
-      assert Man.includes(:interests).first.interests.any?
-      assert Man.joins(:interests).includes(:interests).first.interests.any?
+      assert_predicate Man.first.interests.reload, :any?
+      assert_predicate Man.includes(:interests).first.interests, :any?
+      assert_predicate Man.joins(:interests).includes(:interests).first.interests, :any?
     end
   end
 
diff --git a/activerecord/test/cases/associations/join_model_test.rb b/activerecord/test/cases/associations/join_model_test.rb
index 5d83c9435b..f19a9f5f7a 100644
--- a/activerecord/test/cases/associations/join_model_test.rb
+++ b/activerecord/test/cases/associations/join_model_test.rb
@@ -44,11 +44,11 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_has_many_distinct_through_count
     author = authors(:mary)
-    assert !authors(:mary).unique_categorized_posts.loaded?
+    assert_not_predicate authors(:mary).unique_categorized_posts, :loaded?
     assert_queries(1) { assert_equal 1, author.unique_categorized_posts.count }
     assert_queries(1) { assert_equal 1, author.unique_categorized_posts.count(:title) }
     assert_queries(1) { assert_equal 0, author.unique_categorized_posts.where(title: nil).count(:title) }
-    assert !authors(:mary).unique_categorized_posts.loaded?
+    assert_not_predicate authors(:mary).unique_categorized_posts, :loaded?
   end
 
   def test_has_many_distinct_through_find
@@ -454,8 +454,8 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_has_many_through_uses_conditions_specified_on_the_has_many_association
     author = Author.first
-    assert author.comments.present?
-    assert author.nonexistent_comments.blank?
+    assert_predicate author.comments, :present?
+    assert_predicate author.nonexistent_comments, :blank?
   end
 
   def test_has_many_through_uses_correct_attributes
@@ -468,26 +468,26 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
     saved_post.tags << new_tag
     assert new_tag.persisted? # consistent with habtm!
-    assert saved_post.persisted?
+    assert_predicate saved_post, :persisted?
     assert_includes saved_post.tags, new_tag
 
-    assert new_tag.persisted?
+    assert_predicate new_tag, :persisted?
     assert_includes saved_post.reload.tags.reload, new_tag
 
     new_post = Post.new(title: "Association replacement works!", body: "You best believe it.")
     saved_tag = tags(:general)
 
     new_post.tags << saved_tag
-    assert !new_post.persisted?
-    assert saved_tag.persisted?
+    assert_not_predicate new_post, :persisted?
+    assert_predicate saved_tag, :persisted?
     assert_includes new_post.tags, saved_tag
 
     new_post.save!
-    assert new_post.persisted?
+    assert_predicate new_post, :persisted?
     assert_includes new_post.reload.tags.reload, saved_tag
 
-    assert !posts(:thinking).tags.build.persisted?
-    assert !posts(:thinking).tags.new.persisted?
+    assert_not_predicate posts(:thinking).tags.build, :persisted?
+    assert_not_predicate posts(:thinking).tags.new, :persisted?
   end
 
   def test_create_associate_when_adding_to_has_many_through
@@ -529,14 +529,14 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   def test_has_many_through_collection_size_doesnt_load_target_if_not_loaded
     author = authors(:david)
     assert_equal 10, author.comments.size
-    assert !author.comments.loaded?
+    assert_not_predicate author.comments, :loaded?
   end
 
   def test_has_many_through_collection_size_uses_counter_cache_if_it_exists
     c = categories(:general)
     c.categorizations_count = 100
     assert_equal 100, c.categorizations.size
-    assert !c.categorizations.loaded?
+    assert_not_predicate c.categorizations, :loaded?
   end
 
   def test_adding_junk_to_has_many_through_should_raise_type_mismatch
@@ -710,7 +710,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     category = david.categories.first
 
     assert_no_queries do
-      assert david.categories.loaded?
+      assert_predicate david.categories, :loaded?
       assert_includes david.categories, category
     end
   end
@@ -720,18 +720,18 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     category = david.categories.first
 
     david.reload
-    assert ! david.categories.loaded?
+    assert_not_predicate david.categories, :loaded?
     assert_queries(1) do
       assert_includes david.categories, category
     end
-    assert ! david.categories.loaded?
+    assert_not_predicate david.categories, :loaded?
   end
 
   def test_has_many_through_include_returns_false_for_non_matching_record_to_verify_scoping
     david = authors(:david)
     category = Category.create!(name: "Not Associated")
 
-    assert ! david.categories.loaded?
+    assert_not_predicate david.categories, :loaded?
     assert ! david.categories.include?(category)
   end
 
diff --git a/activerecord/test/cases/associations/left_outer_join_association_test.rb b/activerecord/test/cases/associations/left_outer_join_association_test.rb
index c95d0425cd..7b5c394177 100644
--- a/activerecord/test/cases/associations/left_outer_join_association_test.rb
+++ b/activerecord/test/cases/associations/left_outer_join_association_test.rb
@@ -69,15 +69,15 @@ class LeftOuterJoinAssociationTest < ActiveRecord::TestCase
     scope = Post.left_outer_joins(:special_comments).where(id: posts(:sti_comments).id)
 
     # The join should match SpecialComment and its subclasses only
-    assert scope.where("comments.type" => "Comment").empty?
-    assert !scope.where("comments.type" => "SpecialComment").empty?
-    assert !scope.where("comments.type" => "SubSpecialComment").empty?
+    assert_empty scope.where("comments.type" => "Comment")
+    assert_not_empty scope.where("comments.type" => "SpecialComment")
+    assert_not_empty scope.where("comments.type" => "SubSpecialComment")
   end
 
   def test_does_not_override_select
     authors = Author.select("authors.name, #{%{(authors.author_address_id || ' ' || authors.author_address_extra_id) as addr_id}}").left_outer_joins(:posts)
-    assert authors.any?
-    assert authors.first.respond_to?(:addr_id)
+    assert_predicate authors, :any?
+    assert_respond_to authors.first, :addr_id
   end
 
   test "the default scope of the target is applied when joining associations" do
diff --git a/activerecord/test/cases/associations/nested_through_associations_test.rb b/activerecord/test/cases/associations/nested_through_associations_test.rb
index 65d30d011b..03ed1c1d47 100644
--- a/activerecord/test/cases/associations/nested_through_associations_test.rb
+++ b/activerecord/test/cases/associations/nested_through_associations_test.rb
@@ -78,7 +78,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
 
     # This ensures that the polymorphism of taggings is being observed correctly
     authors = Author.joins(:tags).where("taggings.taggable_type" => "FakeModel")
-    assert authors.empty?
+    assert_empty authors
   end
 
   # has_many through
@@ -177,7 +177,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
 
     members = Member.joins(:organization_member_details).
                      where("member_details.id" => 9)
-    assert members.empty?
+    assert_empty members
   end
 
   # has_many through
@@ -209,7 +209,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
 
     members = Member.joins(:organization_member_details_2).
                      where("member_details.id" => 9)
-    assert members.empty?
+    assert_empty members
   end
 
   # has_many through
@@ -425,9 +425,9 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
 
     # Check the polymorphism of taggings is being observed correctly (in both joins)
     authors = Author.joins(:similar_posts).where("taggings.taggable_type" => "FakeModel")
-    assert authors.empty?
+    assert_empty authors
     authors = Author.joins(:similar_posts).where("taggings_authors_join.taggable_type" => "FakeModel")
-    assert authors.empty?
+    assert_empty authors
   end
 
   def test_nested_has_many_through_with_scope_on_polymorphic_reflection
@@ -456,9 +456,9 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
 
     # Ensure STI is respected in the join
     scope = Post.joins(:special_comments_ratings).where(id: posts(:sti_comments).id)
-    assert scope.where("comments.type" => "Comment").empty?
-    assert !scope.where("comments.type" => "SpecialComment").empty?
-    assert !scope.where("comments.type" => "SubSpecialComment").empty?
+    assert_empty scope.where("comments.type" => "Comment")
+    assert_not_empty scope.where("comments.type" => "SpecialComment")
+    assert_not_empty scope.where("comments.type" => "SubSpecialComment")
   end
 
   def test_has_many_through_with_sti_on_nested_through_reflection
@@ -466,8 +466,8 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
     assert_equal [taggings(:special_comment_rating)], taggings
 
     scope = Post.joins(:special_comments_ratings_taggings).where(id: posts(:sti_comments).id)
-    assert scope.where("comments.type" => "Comment").empty?
-    assert !scope.where("comments.type" => "SpecialComment").empty?
+    assert_empty scope.where("comments.type" => "Comment")
+    assert_not_empty scope.where("comments.type" => "SpecialComment")
   end
 
   def test_nested_has_many_through_writers_should_raise_error
@@ -517,7 +517,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_nested_has_many_through_with_conditions_on_through_associations_preload
-    assert Author.where("tags.id" => 100).joins(:misc_post_first_blue_tags).empty?
+    assert_empty Author.where("tags.id" => 100).joins(:misc_post_first_blue_tags)
 
     authors = assert_queries(3) { Author.includes(:misc_post_first_blue_tags).to_a.sort_by(&:id) }
     blue = tags(:blue)
@@ -574,9 +574,9 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
     c = Categorization.new
     c.author = authors(:david)
     c.post_taggings.to_a
-    assert !c.post_taggings.empty?
+    assert_not_empty c.post_taggings
     c.save
-    assert !c.post_taggings.empty?
+    assert_not_empty c.post_taggings
   end
 
   def test_polymorphic_has_many_through_when_through_association_has_not_loaded
diff --git a/activerecord/test/cases/associations_test.rb b/activerecord/test/cases/associations_test.rb
index de04221ea6..fce2a7eed1 100644
--- a/activerecord/test/cases/associations_test.rb
+++ b/activerecord/test/cases/associations_test.rb
@@ -47,7 +47,7 @@ class AssociationsTest < ActiveRecord::TestCase
     ship = Ship.create!(name: "The good ship Dollypop")
     part = ship.parts.create!(name: "Mast")
     part.mark_for_destruction
-    assert ship.parts[0].marked_for_destruction?
+    assert_predicate ship.parts[0], :marked_for_destruction?
   end
 
   def test_loading_the_association_target_should_load_most_recent_attributes_for_child_records_marked_for_destruction
@@ -119,7 +119,7 @@ class AssociationProxyTest < ActiveRecord::TestCase
     david = authors(:david)
 
     david.posts << (post = Post.new(title: "New on Edge", body: "More cool stuff!"))
-    assert !david.posts.loaded?
+    assert_not_predicate david.posts, :loaded?
     assert_includes david.posts, post
   end
 
@@ -127,7 +127,7 @@ class AssociationProxyTest < ActiveRecord::TestCase
     david = authors(:david)
 
     david.categories << categories(:technology)
-    assert !david.categories.loaded?
+    assert_not_predicate david.categories, :loaded?
     assert_includes david.categories, categories(:technology)
   end
 
@@ -135,23 +135,23 @@ class AssociationProxyTest < ActiveRecord::TestCase
     david = authors(:david)
 
     david.posts << (post = Post.new(title: "New on Edge", body: "More cool stuff!"))
-    assert !david.posts.loaded?
+    assert_not_predicate david.posts, :loaded?
     david.save
-    assert !david.posts.loaded?
+    assert_not_predicate david.posts, :loaded?
     assert_includes david.posts, post
   end
 
   def test_push_does_not_lose_additions_to_new_record
     josh = Author.new(name: "Josh")
     josh.posts << Post.new(title: "New on Edge", body: "More cool stuff!")
-    assert josh.posts.loaded?
+    assert_predicate josh.posts, :loaded?
     assert_equal 1, josh.posts.size
   end
 
   def test_append_behaves_like_push
     josh = Author.new(name: "Josh")
     josh.posts.append Post.new(title: "New on Edge", body: "More cool stuff!")
-    assert josh.posts.loaded?
+    assert_predicate josh.posts, :loaded?
     assert_equal 1, josh.posts.size
   end
 
@@ -163,22 +163,22 @@ class AssociationProxyTest < ActiveRecord::TestCase
   def test_save_on_parent_does_not_load_target
     david = developers(:david)
 
-    assert !david.projects.loaded?
+    assert_not_predicate david.projects, :loaded?
     david.update_columns(created_at: Time.now)
-    assert !david.projects.loaded?
+    assert_not_predicate david.projects, :loaded?
   end
 
   def test_load_does_load_target
     david = developers(:david)
 
-    assert !david.projects.loaded?
+    assert_not_predicate david.projects, :loaded?
     david.projects.load
-    assert david.projects.loaded?
+    assert_predicate david.projects, :loaded?
   end
 
   def test_inspect_does_not_reload_a_not_yet_loaded_target
     andreas = Developer.new name: "Andreas", log: "new developer added"
-    assert !andreas.audit_logs.loaded?
+    assert_not_predicate andreas.audit_logs, :loaded?
     assert_match(/message: "new developer added"/, andreas.audit_logs.inspect)
   end
 
@@ -248,14 +248,14 @@ class AssociationProxyTest < ActiveRecord::TestCase
   test "first! works on loaded associations" do
     david = authors(:david)
     assert_equal david.first_posts.first, david.first_posts.reload.first!
-    assert david.first_posts.loaded?
+    assert_predicate david.first_posts, :loaded?
     assert_no_queries { david.first_posts.first! }
   end
 
   def test_pluck_uses_loaded_target
     david = authors(:david)
     assert_equal david.first_posts.pluck(:title), david.first_posts.load.pluck(:title)
-    assert david.first_posts.loaded?
+    assert_predicate david.first_posts, :loaded?
     assert_no_queries { david.first_posts.pluck(:title) }
   end
 
@@ -263,9 +263,9 @@ class AssociationProxyTest < ActiveRecord::TestCase
     david = authors(:david)
     david.posts.reload
 
-    assert david.posts.loaded?
+    assert_predicate david.posts, :loaded?
     david.posts.reset
-    assert !david.posts.loaded?
+    assert_not_predicate david.posts, :loaded?
   end
 end
 
diff --git a/activerecord/test/cases/attribute_methods_test.rb b/activerecord/test/cases/attribute_methods_test.rb
index c48f7d3518..dc6638d45d 100644
--- a/activerecord/test/cases/attribute_methods_test.rb
+++ b/activerecord/test/cases/attribute_methods_test.rb
@@ -99,8 +99,8 @@ class AttributeMethodsTest < ActiveRecord::TestCase
   end
 
   test "boolean attributes" do
-    assert !Topic.find(1).approved?
-    assert Topic.find(2).approved?
+    assert_not_predicate Topic.find(1), :approved?
+    assert_predicate Topic.find(2), :approved?
   end
 
   test "set attributes" do
@@ -142,16 +142,16 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_respond_to topic, :title=
     assert_respond_to topic, "author_name"
     assert_respond_to topic, "attribute_names"
-    assert !topic.respond_to?("nothingness")
-    assert !topic.respond_to?(:nothingness)
+    assert_not_respond_to topic, "nothingness"
+    assert_not_respond_to topic, :nothingness
   end
 
   test "respond_to? with a custom primary key" do
     keyboard = Keyboard.create
     assert_not_nil keyboard.key_number
     assert_equal keyboard.key_number, keyboard.id
-    assert keyboard.respond_to?("key_number")
-    assert keyboard.respond_to?("id")
+    assert_respond_to keyboard, "key_number"
+    assert_respond_to keyboard, "id"
   end
 
   test "id_before_type_cast with a custom primary key" do
@@ -170,8 +170,8 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
 
     topic = klass.allocate
-    assert !topic.respond_to?("nothingness")
-    assert !topic.respond_to?(:nothingness)
+    assert_not_respond_to topic, "nothingness"
+    assert_not_respond_to topic, :nothingness
     assert_respond_to topic, "title"
     assert_respond_to topic, :title
   end
@@ -457,30 +457,30 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     SQL
 
     assert_equal "Firm", object.string_value
-    assert object.string_value?
+    assert_predicate object, :string_value?
 
     object.string_value = "  "
-    assert !object.string_value?
+    assert_not_predicate object, :string_value?
 
     assert_equal 1, object.int_value.to_i
-    assert object.int_value?
+    assert_predicate object, :int_value?
 
     object.int_value = "0"
-    assert !object.int_value?
+    assert_not_predicate object, :int_value?
   end
 
   test "non-attribute read and write" do
     topic = Topic.new
-    assert !topic.respond_to?("mumbo")
+    assert_not_respond_to topic, "mumbo"
     assert_raise(NoMethodError) { topic.mumbo }
     assert_raise(NoMethodError) { topic.mumbo = 5 }
   end
 
   test "undeclared attribute method does not affect respond_to? and method_missing" do
     topic = @target.new(title: "Budget")
-    assert topic.respond_to?("title")
+    assert_respond_to topic, "title"
     assert_equal "Budget", topic.title
-    assert !topic.respond_to?("title_hello_world")
+    assert_not_respond_to topic, "title_hello_world"
     assert_raise(NoMethodError) { topic.title_hello_world }
   end
 
@@ -491,7 +491,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
       @target.attribute_method_prefix prefix
 
       meth = "#{prefix}title"
-      assert topic.respond_to?(meth)
+      assert_respond_to topic, meth
       assert_equal ["title"], topic.send(meth)
       assert_equal ["title", "a"], topic.send(meth, "a")
       assert_equal ["title", 1, 2, 3], topic.send(meth, 1, 2, 3)
@@ -505,7 +505,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
       topic = @target.new(title: "Budget")
 
       meth = "title#{suffix}"
-      assert topic.respond_to?(meth)
+      assert_respond_to topic, meth
       assert_equal ["title"], topic.send(meth)
       assert_equal ["title", "a"], topic.send(meth, "a")
       assert_equal ["title", 1, 2, 3], topic.send(meth, 1, 2, 3)
@@ -519,7 +519,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
       topic = @target.new(title: "Budget")
 
       meth = "#{prefix}title#{suffix}"
-      assert topic.respond_to?(meth)
+      assert_respond_to topic, meth
       assert_equal ["title"], topic.send(meth)
       assert_equal ["title", "a"], topic.send(meth, "a")
       assert_equal ["title", 1, 2, 3], topic.send(meth, 1, 2, 3)
@@ -541,7 +541,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     else
       topic = Topic.all.merge!(select: "topics.*, 1=2 as is_test").first
     end
-    assert !topic.is_test?
+    assert_not_predicate topic, :is_test?
   end
 
   test "typecast attribute from select to true" do
@@ -552,7 +552,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     else
       topic = Topic.all.merge!(select: "topics.*, 2=2 as is_test").first
     end
-    assert topic.is_test?
+    assert_predicate topic, :is_test?
   end
 
   test "raises ActiveRecord::DangerousAttributeError when defining an AR method in a model" do
@@ -743,7 +743,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
         expected_time = Time.utc(2000, 01, 01, 10)
 
         assert_equal expected_time, record.bonus_time
-        assert record.bonus_time.utc?
+        assert_predicate record.bonus_time, :utc?
       end
     end
   end
@@ -767,7 +767,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     privatize("title")
 
     topic = @target.new(title: "The pros and cons of programming naked.")
-    assert !topic.respond_to?(:title)
+    assert_not_respond_to topic, :title
     exception = assert_raise(NoMethodError) { topic.title }
     assert_includes exception.message, "private method"
     assert_equal "I'm private", topic.send(:title)
@@ -777,7 +777,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     privatize("title=(value)")
 
     topic = @target.new
-    assert !topic.respond_to?(:title=)
+    assert_not_respond_to topic, :title=
     exception = assert_raise(NoMethodError) { topic.title = "Pants" }
     assert_includes exception.message, "private method"
     topic.send(:title=, "Very large pants")
@@ -787,7 +787,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     privatize("title?")
 
     topic = @target.new(title: "Isaac Newton's pants")
-    assert !topic.respond_to?(:title?)
+    assert_not_respond_to topic, :title?
     exception = assert_raise(NoMethodError) { topic.title? }
     assert_includes exception.message, "private method"
     assert topic.send(:title?)
@@ -979,9 +979,9 @@ class AttributeMethodsTest < ActiveRecord::TestCase
   test "came_from_user?" do
     model = @target.first
 
-    assert_not model.id_came_from_user?
+    assert_not_predicate model, :id_came_from_user?
     model.id = "omg"
-    assert model.id_came_from_user?
+    assert_predicate model, :id_came_from_user?
   end
 
   test "accessed_fields" do
diff --git a/activerecord/test/cases/attributes_test.rb b/activerecord/test/cases/attributes_test.rb
index 8ebfee61ff..3bc56694be 100644
--- a/activerecord/test/cases/attributes_test.rb
+++ b/activerecord/test/cases/attributes_test.rb
@@ -211,7 +211,7 @@ module ActiveRecord
     end
 
     test "attributes not backed by database columns are not dirty when unchanged" do
-      refute OverloadedType.new.non_existent_decimal_changed?
+      assert_not_predicate OverloadedType.new, :non_existent_decimal_changed?
     end
 
     test "attributes not backed by database columns are always initialized" do
@@ -245,13 +245,13 @@ module ActiveRecord
 
       model.foo << "asdf"
       assert_equal "lolasdf", model.foo
-      assert model.foo_changed?
+      assert_predicate model, :foo_changed?
 
       model.reload
       assert_equal "lol", model.foo
 
       model.foo = "lol"
-      refute model.changed?
+      assert_not_predicate model, :changed?
     end
 
     test "attributes not backed by database columns appear in inspect" do
diff --git a/activerecord/test/cases/autosave_association_test.rb b/activerecord/test/cases/autosave_association_test.rb
index 4d8368fd8a..09684520d1 100644
--- a/activerecord/test/cases/autosave_association_test.rb
+++ b/activerecord/test/cases/autosave_association_test.rb
@@ -51,7 +51,7 @@ class TestAutosaveAssociationsInGeneral < ActiveRecord::TestCase
 
     u = person.create!(first_name: "cool")
     u.update_attributes!(first_name: "nah") # still valid because validation only applies on 'create'
-    assert reference.create!(person: u).persisted?
+    assert_predicate reference.create!(person: u), :persisted?
   end
 
   def test_should_not_add_the_same_callbacks_multiple_times_for_has_one
@@ -74,7 +74,7 @@ class TestAutosaveAssociationsInGeneral < ActiveRecord::TestCase
     ship = ShipWithoutNestedAttributes.new
     ship.prisoners.build
 
-    assert_not ship.valid?
+    assert_not_predicate ship, :valid?
     assert_equal 1, ship.errors[:name].length
   end
 
@@ -99,35 +99,35 @@ class TestDefaultAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCas
 
   def test_should_save_parent_but_not_invalid_child
     firm = Firm.new(name: "GlobalMegaCorp")
-    assert firm.valid?
+    assert_predicate firm, :valid?
 
     firm.build_account_using_primary_key
-    assert !firm.build_account_using_primary_key.valid?
+    assert_not_predicate firm.build_account_using_primary_key, :valid?
 
     assert firm.save
-    assert !firm.account_using_primary_key.persisted?
+    assert_not_predicate firm.account_using_primary_key, :persisted?
   end
 
   def test_save_fails_for_invalid_has_one
     firm = Firm.first
-    assert firm.valid?
+    assert_predicate firm, :valid?
 
     firm.build_account
 
-    assert !firm.account.valid?
-    assert !firm.valid?
+    assert_not_predicate firm.account, :valid?
+    assert_not_predicate firm, :valid?
     assert !firm.save
     assert_equal ["is invalid"], firm.errors["account"]
   end
 
   def test_save_succeeds_for_invalid_has_one_with_validate_false
     firm = Firm.first
-    assert firm.valid?
+    assert_predicate firm, :valid?
 
     firm.build_unvalidated_account
 
-    assert !firm.unvalidated_account.valid?
-    assert firm.valid?
+    assert_not_predicate firm.unvalidated_account, :valid?
+    assert_predicate firm, :valid?
     assert firm.save
   end
 
@@ -136,10 +136,10 @@ class TestDefaultAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCas
 
     account = firm.build_account("credit_limit" => 1000)
     assert_equal account, firm.account
-    assert !account.persisted?
+    assert_not_predicate account, :persisted?
     assert firm.save
     assert_equal account, firm.account
-    assert account.persisted?
+    assert_predicate account, :persisted?
   end
 
   def test_build_before_either_saved
@@ -147,16 +147,16 @@ class TestDefaultAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCas
 
     firm.account = account = Account.new("credit_limit" => 1000)
     assert_equal account, firm.account
-    assert !account.persisted?
+    assert_not_predicate account, :persisted?
     assert firm.save
     assert_equal account, firm.account
-    assert account.persisted?
+    assert_predicate account, :persisted?
   end
 
   def test_assignment_before_parent_saved
     firm = Firm.new("name" => "GlobalMegaCorp")
     firm.account = a = Account.find(1)
-    assert !firm.persisted?
+    assert_not_predicate firm, :persisted?
     assert_equal a, firm.account
     assert firm.save
     assert_equal a, firm.account
@@ -167,12 +167,12 @@ class TestDefaultAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCas
   def test_assignment_before_either_saved
     firm = Firm.new("name" => "GlobalMegaCorp")
     firm.account = a = Account.new("credit_limit" => 1000)
-    assert !firm.persisted?
-    assert !a.persisted?
+    assert_not_predicate firm, :persisted?
+    assert_not_predicate a, :persisted?
     assert_equal a, firm.account
     assert firm.save
-    assert firm.persisted?
-    assert a.persisted?
+    assert_predicate firm, :persisted?
+    assert_predicate a, :persisted?
     assert_equal a, firm.account
     firm.association(:account).reload
     assert_equal a, firm.account
@@ -221,13 +221,13 @@ class TestDefaultAutosaveAssociationOnABelongsToAssociation < ActiveRecord::Test
 
   def test_should_save_parent_but_not_invalid_child
     client = Client.new(name: "Joe (the Plumber)")
-    assert client.valid?
+    assert_predicate client, :valid?
 
     client.build_firm
-    assert !client.firm.valid?
+    assert_not_predicate client.firm, :valid?
 
     assert client.save
-    assert !client.firm.persisted?
+    assert_not_predicate client.firm, :persisted?
   end
 
   def test_save_fails_for_invalid_belongs_to
@@ -235,8 +235,8 @@ class TestDefaultAutosaveAssociationOnABelongsToAssociation < ActiveRecord::Test
     assert log = AuditLog.create(developer_id: 0, message: " ")
 
     log.developer = Developer.new
-    assert !log.developer.valid?
-    assert !log.valid?
+    assert_not_predicate log.developer, :valid?
+    assert_not_predicate log, :valid?
     assert !log.save
     assert_equal ["is invalid"], log.errors["developer"]
   end
@@ -246,8 +246,8 @@ class TestDefaultAutosaveAssociationOnABelongsToAssociation < ActiveRecord::Test
     assert log = AuditLog.create(developer_id: 0, message: " ")
 
     log.unvalidated_developer = Developer.new
-    assert !log.unvalidated_developer.valid?
-    assert log.valid?
+    assert_not_predicate log.unvalidated_developer, :valid?
+    assert_predicate log, :valid?
     assert log.save
   end
 
@@ -256,10 +256,10 @@ class TestDefaultAutosaveAssociationOnABelongsToAssociation < ActiveRecord::Test
     apple = Firm.new("name" => "Apple")
     client.firm = apple
     assert_equal apple, client.firm
-    assert !apple.persisted?
+    assert_not_predicate apple, :persisted?
     assert client.save
     assert apple.save
-    assert apple.persisted?
+    assert_predicate apple, :persisted?
     assert_equal apple, client.firm
     client.association(:firm).reload
     assert_equal apple, client.firm
@@ -269,11 +269,11 @@ class TestDefaultAutosaveAssociationOnABelongsToAssociation < ActiveRecord::Test
     final_cut = Client.new("name" => "Final Cut")
     apple = Firm.new("name" => "Apple")
     final_cut.firm = apple
-    assert !final_cut.persisted?
-    assert !apple.persisted?
+    assert_not_predicate final_cut, :persisted?
+    assert_not_predicate apple, :persisted?
     assert final_cut.save
-    assert final_cut.persisted?
-    assert apple.persisted?
+    assert_predicate final_cut, :persisted?
+    assert_predicate apple, :persisted?
     assert_equal apple, final_cut.firm
     final_cut.association(:firm).reload
     assert_equal apple, final_cut.firm
@@ -382,7 +382,7 @@ class TestDefaultAutosaveAssociationOnABelongsToAssociation < ActiveRecord::Test
     auditlog.developer    = invalid_developer
     auditlog.developer_id = valid_developer.id
 
-    assert auditlog.valid?
+    assert_predicate auditlog, :valid?
   end
 end
 
@@ -395,8 +395,8 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociationWithAcceptsNestedAttrib
     molecule.electrons = [valid_electron, invalid_electron]
     molecule.save
 
-    assert_not invalid_electron.valid?
-    assert valid_electron.valid?
+    assert_not_predicate invalid_electron, :valid?
+    assert_predicate valid_electron, :valid?
     assert_not molecule.persisted?, "Molecule should not be persisted when its electrons are invalid"
   end
 
@@ -408,9 +408,9 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociationWithAcceptsNestedAttrib
 
     guitar.tuning_pegs = [tuning_peg_valid, tuning_peg_invalid]
 
-    assert_not tuning_peg_invalid.valid?
-    assert tuning_peg_valid.valid?
-    assert_not guitar.valid?
+    assert_not_predicate tuning_peg_invalid, :valid?
+    assert_predicate tuning_peg_valid, :valid?
+    assert_not_predicate guitar, :valid?
     assert_equal ["is not a number"], guitar.errors["tuning_pegs[1].pitch"]
     assert_not_equal ["is not a number"], guitar.errors["tuning_pegs.pitch"]
   end
@@ -425,9 +425,9 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociationWithAcceptsNestedAttrib
 
     molecule.electrons = [valid_electron, invalid_electron]
 
-    assert_not invalid_electron.valid?
-    assert valid_electron.valid?
-    assert_not molecule.valid?
+    assert_not_predicate invalid_electron, :valid?
+    assert_predicate valid_electron, :valid?
+    assert_not_predicate molecule, :valid?
     assert_equal ["can't be blank"], molecule.errors["electrons[1].name"]
     assert_not_equal ["can't be blank"], molecule.errors["electrons.name"]
   ensure
@@ -441,9 +441,9 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociationWithAcceptsNestedAttrib
 
     molecule.electrons = [valid_electron, invalid_electron]
 
-    assert_not invalid_electron.valid?
-    assert valid_electron.valid?
-    assert_not molecule.valid?
+    assert_not_predicate invalid_electron, :valid?
+    assert_predicate valid_electron, :valid?
+    assert_not_predicate molecule, :valid?
     assert_equal [{ error: :blank }], molecule.errors.details[:"electrons.name"]
   end
 
@@ -455,9 +455,9 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociationWithAcceptsNestedAttrib
 
     guitar.tuning_pegs = [tuning_peg_valid, tuning_peg_invalid]
 
-    assert_not tuning_peg_invalid.valid?
-    assert tuning_peg_valid.valid?
-    assert_not guitar.valid?
+    assert_not_predicate tuning_peg_invalid, :valid?
+    assert_predicate tuning_peg_valid, :valid?
+    assert_not_predicate guitar, :valid?
     assert_equal [{ error: :not_a_number, value: nil }], guitar.errors.details[:"tuning_pegs[1].pitch"]
     assert_equal [], guitar.errors.details[:"tuning_pegs.pitch"]
   end
@@ -472,9 +472,9 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociationWithAcceptsNestedAttrib
 
     molecule.electrons = [valid_electron, invalid_electron]
 
-    assert_not invalid_electron.valid?
-    assert valid_electron.valid?
-    assert_not molecule.valid?
+    assert_not_predicate invalid_electron, :valid?
+    assert_predicate valid_electron, :valid?
+    assert_not_predicate molecule, :valid?
     assert_equal [{ error: :blank }], molecule.errors.details[:"electrons[1].name"]
     assert_equal [], molecule.errors.details[:"electrons.name"]
   ensure
@@ -488,8 +488,8 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociationWithAcceptsNestedAttrib
     molecule.electrons = [valid_electron]
     molecule.save
 
-    assert valid_electron.valid?
-    assert molecule.persisted?
+    assert_predicate valid_electron, :valid?
+    assert_predicate molecule, :persisted?
     assert_equal 1, molecule.electrons.count
   end
 end
@@ -500,21 +500,21 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCa
   def test_invalid_adding
     firm = Firm.find(1)
     assert !(firm.clients_of_firm << c = Client.new)
-    assert !c.persisted?
-    assert !firm.valid?
+    assert_not_predicate c, :persisted?
+    assert_not_predicate firm, :valid?
     assert !firm.save
-    assert !c.persisted?
+    assert_not_predicate c, :persisted?
   end
 
   def test_invalid_adding_before_save
     new_firm = Firm.new("name" => "A New Firm, Inc")
     new_firm.clients_of_firm.concat([c = Client.new, Client.new("name" => "Apple")])
-    assert !c.persisted?
-    assert !c.valid?
-    assert !new_firm.valid?
+    assert_not_predicate c, :persisted?
+    assert_not_predicate c, :valid?
+    assert_not_predicate new_firm, :valid?
     assert !new_firm.save
-    assert !c.persisted?
-    assert !new_firm.persisted?
+    assert_not_predicate c, :persisted?
+    assert_not_predicate new_firm, :persisted?
   end
 
   def test_invalid_adding_with_validate_false
@@ -522,10 +522,10 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCa
     client = Client.new
     firm.unvalidated_clients_of_firm << client
 
-    assert firm.valid?
-    assert !client.valid?
+    assert_predicate firm, :valid?
+    assert_not_predicate client, :valid?
     assert firm.save
-    assert !client.persisted?
+    assert_not_predicate client, :persisted?
   end
 
   def test_valid_adding_with_validate_false
@@ -534,24 +534,24 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCa
     firm = Firm.first
     client = Client.new("name" => "Apple")
 
-    assert firm.valid?
-    assert client.valid?
-    assert !client.persisted?
+    assert_predicate firm, :valid?
+    assert_predicate client, :valid?
+    assert_not_predicate client, :persisted?
 
     firm.unvalidated_clients_of_firm << client
 
     assert firm.save
-    assert client.persisted?
+    assert_predicate client, :persisted?
     assert_equal no_of_clients + 1, Client.count
   end
 
   def test_invalid_build
     new_client = companies(:first_firm).clients_of_firm.build
-    assert !new_client.persisted?
-    assert !new_client.valid?
+    assert_not_predicate new_client, :persisted?
+    assert_not_predicate new_client, :valid?
     assert_equal new_client, companies(:first_firm).clients_of_firm.last
     assert !companies(:first_firm).save
-    assert !new_client.persisted?
+    assert_not_predicate new_client, :persisted?
     assert_equal 2, companies(:first_firm).clients_of_firm.reload.size
   end
 
@@ -570,8 +570,8 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCa
     assert_equal no_of_firms, Firm.count      # Firm was not saved to database.
     assert_equal no_of_clients, Client.count  # Clients were not saved to database.
     assert new_firm.save
-    assert new_firm.persisted?
-    assert c.persisted?
+    assert_predicate new_firm, :persisted?
+    assert_predicate c, :persisted?
     assert_equal new_firm, c.firm
     assert_equal no_of_firms + 1, Firm.count      # Firm was saved to database.
     assert_equal no_of_clients + 2, Client.count  # Clients were saved to database.
@@ -601,11 +601,11 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCa
   def test_build_before_save
     company = companies(:first_firm)
     new_client = assert_no_queries(ignore_none: false) { company.clients_of_firm.build("name" => "Another Client") }
-    assert !company.clients_of_firm.loaded?
+    assert_not_predicate company.clients_of_firm, :loaded?
 
     company.name += "-changed"
     assert_queries(2) { assert company.save }
-    assert new_client.persisted?
+    assert_predicate new_client, :persisted?
     assert_equal 3, company.clients_of_firm.reload.size
   end
 
@@ -621,11 +621,11 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCa
   def test_build_via_block_before_save
     company = companies(:first_firm)
     new_client = assert_no_queries(ignore_none: false) { company.clients_of_firm.build { |client| client.name = "Another Client" } }
-    assert !company.clients_of_firm.loaded?
+    assert_not_predicate company.clients_of_firm, :loaded?
 
     company.name += "-changed"
     assert_queries(2) { assert company.save }
-    assert new_client.persisted?
+    assert_predicate new_client, :persisted?
     assert_equal 3, company.clients_of_firm.reload.size
   end
 
@@ -657,62 +657,62 @@ class TestDefaultAutosaveAssociationOnNewRecord < ActiveRecord::TestCase
     new_account = Account.new("credit_limit" => 1000)
     new_firm = Firm.new("name" => "some firm")
 
-    assert !new_firm.persisted?
+    assert_not_predicate new_firm, :persisted?
     new_account.firm = new_firm
     new_account.save!
 
-    assert new_firm.persisted?
+    assert_predicate new_firm, :persisted?
 
     new_account = Account.new("credit_limit" => 1000)
     new_autosaved_firm = Firm.new("name" => "some firm")
 
-    assert !new_autosaved_firm.persisted?
+    assert_not_predicate new_autosaved_firm, :persisted?
     new_account.unautosaved_firm = new_autosaved_firm
     new_account.save!
 
-    assert !new_autosaved_firm.persisted?
+    assert_not_predicate new_autosaved_firm, :persisted?
   end
 
   def test_autosave_new_record_on_has_one_can_be_disabled_per_relationship
     firm = Firm.new("name" => "some firm")
     account = Account.new("credit_limit" => 1000)
 
-    assert !account.persisted?
+    assert_not_predicate account, :persisted?
     firm.account = account
     firm.save!
 
-    assert account.persisted?
+    assert_predicate account, :persisted?
 
     firm = Firm.new("name" => "some firm")
     account = Account.new("credit_limit" => 1000)
 
     firm.unautosaved_account = account
 
-    assert !account.persisted?
+    assert_not_predicate account, :persisted?
     firm.unautosaved_account = account
     firm.save!
 
-    assert !account.persisted?
+    assert_not_predicate account, :persisted?
   end
 
   def test_autosave_new_record_on_has_many_can_be_disabled_per_relationship
     firm = Firm.new("name" => "some firm")
     account = Account.new("credit_limit" => 1000)
 
-    assert !account.persisted?
+    assert_not_predicate account, :persisted?
     firm.accounts << account
 
     firm.save!
-    assert account.persisted?
+    assert_predicate account, :persisted?
 
     firm = Firm.new("name" => "some firm")
     account = Account.new("credit_limit" => 1000)
 
-    assert !account.persisted?
+    assert_not_predicate account, :persisted?
     firm.unautosaved_accounts << account
 
     firm.save!
-    assert !account.persisted?
+    assert_not_predicate account, :persisted?
   end
 
   def test_autosave_new_record_with_after_create_callback
@@ -745,18 +745,18 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
     @pirate.mark_for_destruction
     @pirate.ship.mark_for_destruction
 
-    assert !@pirate.reload.marked_for_destruction?
-    assert !@pirate.ship.reload.marked_for_destruction?
+    assert_not_predicate @pirate.reload, :marked_for_destruction?
+    assert_not_predicate @pirate.ship.reload, :marked_for_destruction?
   end
 
   # has_one
   def test_should_destroy_a_child_association_as_part_of_the_save_transaction_if_it_was_marked_for_destruction
-    assert !@pirate.ship.marked_for_destruction?
+    assert_not_predicate @pirate.ship, :marked_for_destruction?
 
     @pirate.ship.mark_for_destruction
     id = @pirate.ship.id
 
-    assert @pirate.ship.marked_for_destruction?
+    assert_predicate @pirate.ship, :marked_for_destruction?
     assert Ship.find_by_id(id)
 
     @pirate.save
@@ -766,7 +766,7 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
 
   def test_should_skip_validation_on_a_child_association_if_marked_for_destruction
     @pirate.ship.name = ""
-    assert !@pirate.valid?
+    assert_not_predicate @pirate, :valid?
 
     @pirate.ship.mark_for_destruction
     @pirate.ship.expects(:valid?).never
@@ -812,12 +812,12 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
 
   # belongs_to
   def test_should_destroy_a_parent_association_as_part_of_the_save_transaction_if_it_was_marked_for_destruction
-    assert !@ship.pirate.marked_for_destruction?
+    assert_not_predicate @ship.pirate, :marked_for_destruction?
 
     @ship.pirate.mark_for_destruction
     id = @ship.pirate.id
 
-    assert @ship.pirate.marked_for_destruction?
+    assert_predicate @ship.pirate, :marked_for_destruction?
     assert Pirate.find_by_id(id)
 
     @ship.save
@@ -827,7 +827,7 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
 
   def test_should_skip_validation_on_a_parent_association_if_marked_for_destruction
     @ship.pirate.catchphrase = ""
-    assert !@ship.valid?
+    assert_not_predicate @ship, :valid?
 
     @ship.pirate.mark_for_destruction
     @ship.pirate.expects(:valid?).never
@@ -881,7 +881,7 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
     ids.each { |id| assert klass.find_by_id(id) }
 
     @pirate.save
-    assert @pirate.reload.birds.empty?
+    assert_empty @pirate.reload.birds
     ids.each { |id| assert_nil klass.find_by_id(id) }
   end
 
@@ -889,14 +889,14 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
     @pirate.birds.create!(name: :parrot)
     @pirate.birds.first.destroy
     @pirate.save!
-    assert @pirate.reload.birds.empty?
+    assert_empty @pirate.reload.birds
   end
 
   def test_should_skip_validation_on_has_many_if_marked_for_destruction
     2.times { |i| @pirate.birds.create!(name: "birds_#{i}") }
 
     @pirate.birds.each { |bird| bird.name = "" }
-    assert !@pirate.valid?
+    assert_not_predicate @pirate, :valid?
 
     @pirate.birds.each do |bird|
       bird.mark_for_destruction
@@ -909,10 +909,10 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
     @pirate.birds.create!(name: "birds_1")
 
     @pirate.birds.each { |bird| bird.name = "" }
-    assert !@pirate.valid?
+    assert_not_predicate @pirate, :valid?
 
     @pirate.birds.each(&:destroy)
-    assert @pirate.valid?
+    assert_predicate @pirate, :valid?
   end
 
   def test_a_child_marked_for_destruction_should_not_be_destroyed_twice_while_saving_has_many
@@ -1010,17 +1010,17 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
       @pirate.save
     end
 
-    assert @pirate.reload.parrots.empty?
+    assert_empty @pirate.reload.parrots
 
     join_records = Pirate.connection.select_all("SELECT * FROM parrots_pirates WHERE pirate_id = #{@pirate.id}")
-    assert join_records.empty?
+    assert_empty join_records
   end
 
   def test_should_skip_validation_on_habtm_if_marked_for_destruction
     2.times { |i| @pirate.parrots.create!(name: "parrots_#{i}") }
 
     @pirate.parrots.each { |parrot| parrot.name = "" }
-    assert !@pirate.valid?
+    assert_not_predicate @pirate, :valid?
 
     @pirate.parrots.each do |parrot|
       parrot.mark_for_destruction
@@ -1028,17 +1028,17 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
     end
 
     @pirate.save!
-    assert @pirate.reload.parrots.empty?
+    assert_empty @pirate.reload.parrots
   end
 
   def test_should_skip_validation_on_habtm_if_destroyed
     @pirate.parrots.create!(name: "parrots_1")
 
     @pirate.parrots.each { |parrot| parrot.name = "" }
-    assert !@pirate.valid?
+    assert_not_predicate @pirate, :valid?
 
     @pirate.parrots.each(&:destroy)
-    assert @pirate.valid?
+    assert_predicate @pirate, :valid?
   end
 
   def test_a_child_marked_for_destruction_should_not_be_destroyed_twice_while_saving_habtm
@@ -1145,16 +1145,16 @@ class TestAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCase
 
   def test_should_automatically_validate_the_associated_model
     @pirate.ship.name = ""
-    assert @pirate.invalid?
-    assert @pirate.errors[:"ship.name"].any?
+    assert_predicate @pirate, :invalid?
+    assert_predicate @pirate.errors[:"ship.name"], :any?
   end
 
   def test_should_merge_errors_on_the_associated_models_onto_the_parent_even_if_it_is_not_valid
     @pirate.ship.name   = nil
     @pirate.catchphrase = nil
-    assert @pirate.invalid?
-    assert @pirate.errors[:"ship.name"].any?
-    assert @pirate.errors[:catchphrase].any?
+    assert_predicate @pirate, :invalid?
+    assert_predicate @pirate.errors[:"ship.name"], :any?
+    assert_predicate @pirate.errors[:catchphrase], :any?
   end
 
   def test_should_not_ignore_different_error_messages_on_the_same_attribute
@@ -1163,7 +1163,7 @@ class TestAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCase
     Ship.validates_format_of :name, with: /\w/
     @pirate.ship.name   = ""
     @pirate.catchphrase = nil
-    assert @pirate.invalid?
+    assert_predicate @pirate, :invalid?
     assert_equal ["can't be blank", "is invalid"], @pirate.errors[:"ship.name"]
   ensure
     Ship._validators = old_validators if old_validators
@@ -1244,7 +1244,7 @@ class TestAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCase
     ship = ShipWithoutNestedAttributes.new(name: "The Black Flag")
     ship.parts.build.mark_for_destruction
 
-    assert_not ship.valid?
+    assert_not_predicate ship, :valid?
   end
 end
 
@@ -1299,16 +1299,16 @@ class TestAutosaveAssociationOnABelongsToAssociation < ActiveRecord::TestCase
 
   def test_should_automatically_validate_the_associated_model
     @ship.pirate.catchphrase = ""
-    assert @ship.invalid?
-    assert @ship.errors[:"pirate.catchphrase"].any?
+    assert_predicate @ship, :invalid?
+    assert_predicate @ship.errors[:"pirate.catchphrase"], :any?
   end
 
   def test_should_merge_errors_on_the_associated_model_onto_the_parent_even_if_it_is_not_valid
     @ship.name = nil
     @ship.pirate.catchphrase = nil
-    assert @ship.invalid?
-    assert @ship.errors[:name].any?
-    assert @ship.errors[:"pirate.catchphrase"].any?
+    assert_predicate @ship, :invalid?
+    assert_predicate @ship.errors[:name], :any?
+    assert_predicate @ship.errors[:"pirate.catchphrase"], :any?
   end
 
   def test_should_still_allow_to_bypass_validations_on_the_associated_model
@@ -1403,17 +1403,17 @@ module AutosaveAssociationOnACollectionAssociationTests
   def test_should_automatically_validate_the_associated_models
     @pirate.send(@association_name).each { |child| child.name = "" }
 
-    assert !@pirate.valid?
+    assert_not_predicate @pirate, :valid?
     assert_equal ["can't be blank"], @pirate.errors["#{@association_name}.name"]
-    assert @pirate.errors[@association_name].empty?
+    assert_empty @pirate.errors[@association_name]
   end
 
   def test_should_not_use_default_invalid_error_on_associated_models
     @pirate.send(@association_name).build(name: "")
 
-    assert !@pirate.valid?
+    assert_not_predicate @pirate, :valid?
     assert_equal ["can't be blank"], @pirate.errors["#{@association_name}.name"]
-    assert @pirate.errors[@association_name].empty?
+    assert_empty @pirate.errors[@association_name]
   end
 
   def test_should_default_invalid_error_from_i18n
@@ -1423,10 +1423,10 @@ module AutosaveAssociationOnACollectionAssociationTests
 
     @pirate.send(@association_name).build(name: "")
 
-    assert !@pirate.valid?
+    assert_not_predicate @pirate, :valid?
     assert_equal ["cannot be blank"], @pirate.errors["#{@association_name}.name"]
     assert_equal ["#{@association_name.to_s.humanize} name cannot be blank"], @pirate.errors.full_messages
-    assert @pirate.errors[@association_name].empty?
+    assert_empty @pirate.errors[@association_name]
   ensure
     I18n.backend = I18n::Backend::Simple.new
   end
@@ -1435,9 +1435,9 @@ module AutosaveAssociationOnACollectionAssociationTests
     @pirate.send(@association_name).each { |child| child.name = "" }
     @pirate.catchphrase = nil
 
-    assert !@pirate.valid?
+    assert_not_predicate @pirate, :valid?
     assert_equal ["can't be blank"], @pirate.errors["#{@association_name}.name"]
-    assert @pirate.errors[:catchphrase].any?
+    assert_predicate @pirate.errors[:catchphrase], :any?
   end
 
   def test_should_allow_to_bypass_validations_on_the_associated_models_on_update
@@ -1595,10 +1595,10 @@ class TestAutosaveAssociationValidationsOnAHasManyAssociation < ActiveRecord::Te
   end
 
   test "should automatically validate associations" do
-    assert @pirate.valid?
+    assert_predicate @pirate, :valid?
     @pirate.birds.each { |bird| bird.name = "" }
 
-    assert !@pirate.valid?
+    assert_not_predicate @pirate, :valid?
   end
 end
 
@@ -1613,15 +1613,15 @@ class TestAutosaveAssociationValidationsOnAHasOneAssociation < ActiveRecord::Tes
   end
 
   test "should automatically validate associations with :validate => true" do
-    assert @pirate.valid?
+    assert_predicate @pirate, :valid?
     @pirate.ship.name = ""
-    assert !@pirate.valid?
+    assert_not_predicate @pirate, :valid?
   end
 
   test "should not automatically add validate associations without :validate => true" do
-    assert @pirate.valid?
+    assert_predicate @pirate, :valid?
     @pirate.non_validated_ship.name = ""
-    assert @pirate.valid?
+    assert_predicate @pirate, :valid?
   end
 end
 
@@ -1634,15 +1634,15 @@ class TestAutosaveAssociationValidationsOnABelongsToAssociation < ActiveRecord::
   end
 
   test "should automatically validate associations with :validate => true" do
-    assert @pirate.valid?
+    assert_predicate @pirate, :valid?
     @pirate.parrot = Parrot.new(name: "")
-    assert !@pirate.valid?
+    assert_not_predicate @pirate, :valid?
   end
 
   test "should not automatically validate associations without :validate => true" do
-    assert @pirate.valid?
+    assert_predicate @pirate, :valid?
     @pirate.non_validated_parrot = Parrot.new(name: "")
-    assert @pirate.valid?
+    assert_predicate @pirate, :valid?
   end
 end
 
@@ -1655,17 +1655,17 @@ class TestAutosaveAssociationValidationsOnAHABTMAssociation < ActiveRecord::Test
   end
 
   test "should automatically validate associations with :validate => true" do
-    assert @pirate.valid?
+    assert_predicate @pirate, :valid?
     @pirate.parrots = [ Parrot.new(name: "popuga") ]
     @pirate.parrots.each { |parrot| parrot.name = "" }
-    assert !@pirate.valid?
+    assert_not_predicate @pirate, :valid?
   end
 
   test "should not automatically validate associations without :validate => true" do
-    assert @pirate.valid?
+    assert_predicate @pirate, :valid?
     @pirate.non_validated_parrots = [ Parrot.new(name: "popuga") ]
     @pirate.non_validated_parrots.each { |parrot| parrot.name = "" }
-    assert @pirate.valid?
+    assert_predicate @pirate, :valid?
   end
 end
 
@@ -1686,7 +1686,7 @@ class TestAutosaveAssociationValidationMethodsGeneration < ActiveRecord::TestCas
   end
 
   test "should not generate validation methods for has_one associations without :validate => true" do
-    assert !@pirate.respond_to?(:validate_associated_records_for_non_validated_ship)
+    assert_not_respond_to @pirate, :validate_associated_records_for_non_validated_ship
   end
 
   test "should generate validation methods for belongs_to associations with :validate => true" do
@@ -1694,7 +1694,7 @@ class TestAutosaveAssociationValidationMethodsGeneration < ActiveRecord::TestCas
   end
 
   test "should not generate validation methods for belongs_to associations without :validate => true" do
-    assert !@pirate.respond_to?(:validate_associated_records_for_non_validated_parrot)
+    assert_not_respond_to @pirate, :validate_associated_records_for_non_validated_parrot
   end
 
   test "should generate validation methods for HABTM associations with :validate => true" do
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index a49990008c..983a3d366a 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -147,8 +147,8 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_table_exists
-    assert !NonExistentTable.table_exists?
-    assert Topic.table_exists?
+    assert_not_predicate NonExistentTable, :table_exists?
+    assert_predicate Topic, :table_exists?
   end
 
   def test_preserving_date_objects
@@ -450,7 +450,7 @@ class BasicsTest < ActiveRecord::TestCase
 
   def test_default_values
     topic = Topic.new
-    assert topic.approved?
+    assert_predicate topic, :approved?
     assert_nil topic.written_on
     assert_nil topic.bonus_time
     assert_nil topic.last_read
@@ -458,7 +458,7 @@ class BasicsTest < ActiveRecord::TestCase
     topic.save
 
     topic = Topic.find(topic.id)
-    assert topic.approved?
+    assert_predicate topic, :approved?
     assert_nil topic.last_read
 
     # Oracle has some funky default handling, so it requires a bit of
@@ -727,9 +727,9 @@ class BasicsTest < ActiveRecord::TestCase
     b_nil = Boolean.find(nil_id)
     assert_nil b_nil.value
     b_false = Boolean.find(false_id)
-    assert !b_false.value?
+    assert_not_predicate b_false, :value?
     b_true = Boolean.find(true_id)
-    assert b_true.value?
+    assert_predicate b_true, :value?
   end
 
   def test_boolean_without_questionmark
@@ -753,9 +753,9 @@ class BasicsTest < ActiveRecord::TestCase
     b_blank = Boolean.find(blank_id)
     assert_nil b_blank.value
     b_false = Boolean.find(false_id)
-    assert !b_false.value?
+    assert_not_predicate b_false, :value?
     b_true = Boolean.find(true_id)
-    assert b_true.value?
+    assert_predicate b_true, :value?
   end
 
   def test_new_record_returns_boolean
@@ -768,7 +768,7 @@ class BasicsTest < ActiveRecord::TestCase
     duped_topic = nil
     assert_nothing_raised { duped_topic = topic.dup }
     assert_equal topic.title, duped_topic.title
-    assert !duped_topic.persisted?
+    assert_not_predicate duped_topic, :persisted?
 
     # test if the attributes have been duped
     topic.title = "a"
@@ -786,7 +786,7 @@ class BasicsTest < ActiveRecord::TestCase
 
     # test if saved clone object differs from original
     duped_topic.save
-    assert duped_topic.persisted?
+    assert_predicate duped_topic, :persisted?
     assert_not_equal duped_topic.id, topic.id
 
     duped_topic.reload
@@ -807,7 +807,7 @@ class BasicsTest < ActiveRecord::TestCase
     assert_nothing_raised { dup = dev.dup }
     assert_kind_of DeveloperSalary, dup.salary
     assert_equal dev.salary.amount, dup.salary.amount
-    assert !dup.persisted?
+    assert_not_predicate dup, :persisted?
 
     # test if the attributes have been duped
     original_amount = dup.salary.amount
@@ -815,7 +815,7 @@ class BasicsTest < ActiveRecord::TestCase
     assert_equal original_amount, dup.salary.amount
 
     assert dup.save
-    assert dup.persisted?
+    assert_predicate dup, :persisted?
     assert_not_equal dup.id, dev.id
   end
 
@@ -835,22 +835,22 @@ class BasicsTest < ActiveRecord::TestCase
 
   def test_clone_of_new_object_with_defaults
     developer = Developer.new
-    assert !developer.name_changed?
-    assert !developer.salary_changed?
+    assert_not_predicate developer, :name_changed?
+    assert_not_predicate developer, :salary_changed?
 
     cloned_developer = developer.clone
-    assert !cloned_developer.name_changed?
-    assert !cloned_developer.salary_changed?
+    assert_not_predicate cloned_developer, :name_changed?
+    assert_not_predicate cloned_developer, :salary_changed?
   end
 
   def test_clone_of_new_object_marks_attributes_as_dirty
     developer = Developer.new name: "Bjorn", salary: 100000
-    assert developer.name_changed?
-    assert developer.salary_changed?
+    assert_predicate developer, :name_changed?
+    assert_predicate developer, :salary_changed?
 
     cloned_developer = developer.clone
-    assert cloned_developer.name_changed?
-    assert cloned_developer.salary_changed?
+    assert_predicate cloned_developer, :name_changed?
+    assert_predicate cloned_developer, :salary_changed?
   end
 
   def test_clone_of_new_object_marks_as_dirty_only_changed_attributes
@@ -859,24 +859,24 @@ class BasicsTest < ActiveRecord::TestCase
     assert !developer.salary_changed?         # attribute has non-nil default value, so treated as not changed
 
     cloned_developer = developer.clone
-    assert cloned_developer.name_changed?
+    assert_predicate cloned_developer, :name_changed?
     assert !cloned_developer.salary_changed?  # ... and cloned instance should behave same
   end
 
   def test_dup_of_saved_object_marks_attributes_as_dirty
     developer = Developer.create! name: "Bjorn", salary: 100000
-    assert !developer.name_changed?
-    assert !developer.salary_changed?
+    assert_not_predicate developer, :name_changed?
+    assert_not_predicate developer, :salary_changed?
 
     cloned_developer = developer.dup
     assert cloned_developer.name_changed?     # both attributes differ from defaults
-    assert cloned_developer.salary_changed?
+    assert_predicate cloned_developer, :salary_changed?
   end
 
   def test_dup_of_saved_object_marks_as_dirty_only_changed_attributes
     developer = Developer.create! name: "Bjorn"
     assert !developer.name_changed?           # both attributes of saved object should be treated as not changed
-    assert !developer.salary_changed?
+    assert_not_predicate developer, :salary_changed?
 
     cloned_developer = developer.dup
     assert cloned_developer.name_changed?     # ... but on cloned object should be
@@ -951,14 +951,14 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_toggle_attribute
-    assert !topics(:first).approved?
+    assert_not_predicate topics(:first), :approved?
     topics(:first).toggle!(:approved)
-    assert topics(:first).approved?
+    assert_predicate topics(:first), :approved?
     topic = topics(:first)
     topic.toggle(:approved)
-    assert !topic.approved?
+    assert_not_predicate topic, :approved?
     topic.reload
-    assert topic.approved?
+    assert_predicate topic, :approved?
   end
 
   def test_reload
@@ -1431,11 +1431,11 @@ class BasicsTest < ActiveRecord::TestCase
   test "resetting column information doesn't remove attribute methods" do
     topic = topics(:first)
 
-    assert_not topic.id_changed?
+    assert_not_predicate topic, :id_changed?
 
     Topic.reset_column_information
 
-    assert_not topic.id_changed?
+    assert_not_predicate topic, :id_changed?
   end
 
   test "ignored columns are not present in columns_hash" do
@@ -1447,27 +1447,27 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   test "ignored columns have no attribute methods" do
-    refute Developer.new.respond_to?(:first_name)
-    refute Developer.new.respond_to?(:first_name=)
-    refute Developer.new.respond_to?(:first_name?)
-    refute SubDeveloper.new.respond_to?(:first_name)
-    refute SubDeveloper.new.respond_to?(:first_name=)
-    refute SubDeveloper.new.respond_to?(:first_name?)
-    refute SymbolIgnoredDeveloper.new.respond_to?(:first_name)
-    refute SymbolIgnoredDeveloper.new.respond_to?(:first_name=)
-    refute SymbolIgnoredDeveloper.new.respond_to?(:first_name?)
+    assert_not_respond_to Developer.new, :first_name
+    assert_not_respond_to Developer.new, :first_name=
+    assert_not_respond_to Developer.new, :first_name?
+    assert_not_respond_to SubDeveloper.new, :first_name
+    assert_not_respond_to SubDeveloper.new, :first_name=
+    assert_not_respond_to SubDeveloper.new, :first_name?
+    assert_not_respond_to SymbolIgnoredDeveloper.new, :first_name
+    assert_not_respond_to SymbolIgnoredDeveloper.new, :first_name=
+    assert_not_respond_to SymbolIgnoredDeveloper.new, :first_name?
   end
 
   test "ignored columns don't prevent explicit declaration of attribute methods" do
-    assert Developer.new.respond_to?(:last_name)
-    assert Developer.new.respond_to?(:last_name=)
-    assert Developer.new.respond_to?(:last_name?)
-    assert SubDeveloper.new.respond_to?(:last_name)
-    assert SubDeveloper.new.respond_to?(:last_name=)
-    assert SubDeveloper.new.respond_to?(:last_name?)
-    assert SymbolIgnoredDeveloper.new.respond_to?(:last_name)
-    assert SymbolIgnoredDeveloper.new.respond_to?(:last_name=)
-    assert SymbolIgnoredDeveloper.new.respond_to?(:last_name?)
+    assert_respond_to Developer.new, :last_name
+    assert_respond_to Developer.new, :last_name=
+    assert_respond_to Developer.new, :last_name?
+    assert_respond_to SubDeveloper.new, :last_name
+    assert_respond_to SubDeveloper.new, :last_name=
+    assert_respond_to SubDeveloper.new, :last_name?
+    assert_respond_to SymbolIgnoredDeveloper.new, :last_name
+    assert_respond_to SymbolIgnoredDeveloper.new, :last_name=
+    assert_respond_to SymbolIgnoredDeveloper.new, :last_name?
   end
 
   test "ignored columns are stored as an array of string" do
@@ -1477,20 +1477,20 @@ class BasicsTest < ActiveRecord::TestCase
 
   test "when #reload called, ignored columns' attribute methods are not defined" do
     developer = Developer.create!(name: "Developer")
-    refute developer.respond_to?(:first_name)
-    refute developer.respond_to?(:first_name=)
+    assert_not_respond_to developer, :first_name
+    assert_not_respond_to developer, :first_name=
 
     developer.reload
 
-    refute developer.respond_to?(:first_name)
-    refute developer.respond_to?(:first_name=)
+    assert_not_respond_to developer, :first_name
+    assert_not_respond_to developer, :first_name=
   end
 
   test "ignored columns not included in SELECT" do
     query = Developer.all.to_sql.downcase
 
     # ignored column
-    refute query.include?("first_name")
+    assert_not query.include?("first_name")
 
     # regular column
     assert query.include?("name")
diff --git a/activerecord/test/cases/batches_test.rb b/activerecord/test/cases/batches_test.rb
index bbd0b1724a..ad701fb200 100644
--- a/activerecord/test/cases/batches_test.rb
+++ b/activerecord/test/cases/batches_test.rb
@@ -313,7 +313,7 @@ class EachTest < ActiveRecord::TestCase
   def test_in_batches_each_record_should_yield_record_if_block_is_given
     assert_queries(6) do
       Post.in_batches(of: 2).each_record do |post|
-        assert post.title.present?
+        assert_predicate post.title, :present?
         assert_kind_of Post, post
       end
     end
@@ -322,7 +322,7 @@ class EachTest < ActiveRecord::TestCase
   def test_in_batches_each_record_should_return_enumerator_if_no_block_given
     assert_queries(6) do
       Post.in_batches(of: 2).each_record.with_index do |post, i|
-        assert post.title.present?
+        assert_predicate post.title, :present?
         assert_kind_of Post, post
       end
     end
@@ -353,24 +353,24 @@ class EachTest < ActiveRecord::TestCase
 
   def test_in_batches_should_not_be_loaded
     Post.in_batches(of: 1) do |relation|
-      assert_not relation.loaded?
+      assert_not_predicate relation, :loaded?
     end
 
     Post.in_batches(of: 1, load: false) do |relation|
-      assert_not relation.loaded?
+      assert_not_predicate relation, :loaded?
     end
   end
 
   def test_in_batches_should_be_loaded
     Post.in_batches(of: 1, load: true) do |relation|
-      assert relation.loaded?
+      assert_predicate relation, :loaded?
     end
   end
 
   def test_in_batches_if_not_loaded_executes_more_queries
     assert_queries(@total + 1) do
       Post.in_batches(of: 1, load: false) do |relation|
-        assert_not relation.loaded?
+        assert_not_predicate relation, :loaded?
       end
     end
   end
diff --git a/activerecord/test/cases/cache_key_test.rb b/activerecord/test/cases/cache_key_test.rb
index 8f2f2c6186..3a569f226e 100644
--- a/activerecord/test/cases/cache_key_test.rb
+++ b/activerecord/test/cases/cache_key_test.rb
@@ -38,8 +38,8 @@ module ActiveRecord
     end
 
     test "cache_version is only there when versioning is on" do
-      assert CacheMeWithVersion.create.cache_version.present?
-      assert_not CacheMe.create.cache_version.present?
+      assert_predicate CacheMeWithVersion.create.cache_version, :present?
+      assert_not_predicate CacheMe.create.cache_version, :present?
     end
 
     test "cache_key_with_version always has both key and version" do
diff --git a/activerecord/test/cases/callbacks_test.rb b/activerecord/test/cases/callbacks_test.rb
index 55c7475f46..3b283a3aa6 100644
--- a/activerecord/test/cases/callbacks_test.rb
+++ b/activerecord/test/cases/callbacks_test.rb
@@ -394,27 +394,27 @@ class CallbacksTest < ActiveRecord::TestCase
   def test_before_create_throwing_abort
     someone = CallbackHaltedDeveloper.new
     someone.cancel_before_create = true
-    assert someone.valid?
+    assert_predicate someone, :valid?
     assert !someone.save
     assert_save_callbacks_not_called(someone)
   end
 
   def test_before_save_throwing_abort
     david = DeveloperWithCanceledCallbacks.find(1)
-    assert david.valid?
+    assert_predicate david, :valid?
     assert !david.save
     exc = assert_raise(ActiveRecord::RecordNotSaved) { david.save! }
     assert_equal david, exc.record
 
     david = DeveloperWithCanceledCallbacks.find(1)
     david.salary = 10_000_000
-    assert !david.valid?
+    assert_not_predicate david, :valid?
     assert !david.save
     assert_raise(ActiveRecord::RecordInvalid) { david.save! }
 
     someone = CallbackHaltedDeveloper.find(1)
     someone.cancel_before_save = true
-    assert someone.valid?
+    assert_predicate someone, :valid?
     assert !someone.save
     assert_save_callbacks_not_called(someone)
   end
@@ -422,7 +422,7 @@ class CallbacksTest < ActiveRecord::TestCase
   def test_before_update_throwing_abort
     someone = CallbackHaltedDeveloper.find(1)
     someone.cancel_before_update = true
-    assert someone.valid?
+    assert_predicate someone, :valid?
     assert !someone.save
     assert_save_callbacks_not_called(someone)
   end
diff --git a/activerecord/test/cases/clone_test.rb b/activerecord/test/cases/clone_test.rb
index 3187e6aed5..65e5016040 100644
--- a/activerecord/test/cases/clone_test.rb
+++ b/activerecord/test/cases/clone_test.rb
@@ -36,7 +36,7 @@ module ActiveRecord
       cloned = Topic.new
       clone = cloned.clone
       cloned.freeze
-      assert_not clone.frozen?
+      assert_not_predicate clone, :frozen?
     end
   end
 end
diff --git a/activerecord/test/cases/connection_adapters/adapter_leasing_test.rb b/activerecord/test/cases/connection_adapters/adapter_leasing_test.rb
index 82c6cf8dea..72838ff56b 100644
--- a/activerecord/test/cases/connection_adapters/adapter_leasing_test.rb
+++ b/activerecord/test/cases/connection_adapters/adapter_leasing_test.rb
@@ -45,11 +45,11 @@ module ActiveRecord
 
         # Make sure the pool marks the connection in use
         assert_equal @adapter, pool.connection
-        assert @adapter.in_use?
+        assert_predicate @adapter, :in_use?
 
         # Close should put the adapter back in the pool
         @adapter.close
-        assert_not @adapter.in_use?
+        assert_not_predicate @adapter, :in_use?
 
         assert_equal @adapter, pool.connection
       end
diff --git a/activerecord/test/cases/connection_adapters/connection_handler_test.rb b/activerecord/test/cases/connection_adapters/connection_handler_test.rb
index d4b299e330..f4cc251fb9 100644
--- a/activerecord/test/cases/connection_adapters/connection_handler_test.rb
+++ b/activerecord/test/cases/connection_adapters/connection_handler_test.rb
@@ -103,11 +103,11 @@ module ActiveRecord
       end
 
       def test_active_connections?
-        assert !@handler.active_connections?
+        assert_not_predicate @handler, :active_connections?
         assert @handler.retrieve_connection(@spec_name)
-        assert @handler.active_connections?
+        assert_predicate @handler, :active_connections?
         @handler.clear_active_connections!
-        assert !@handler.active_connections?
+        assert_not_predicate @handler, :active_connections?
       end
 
       def test_retrieve_connection_pool
@@ -146,7 +146,7 @@ module ActiveRecord
 
         def test_forked_child_doesnt_mangle_parent_connection
           object_id = ActiveRecord::Base.connection.object_id
-          assert ActiveRecord::Base.connection.active?
+          assert_predicate ActiveRecord::Base.connection, :active?
 
           rd, wr = IO.pipe
           rd.binmode
@@ -174,7 +174,7 @@ module ActiveRecord
         unless in_memory_db?
           def test_forked_child_recovers_from_disconnected_parent
             object_id = ActiveRecord::Base.connection.object_id
-            assert ActiveRecord::Base.connection.active?
+            assert_predicate ActiveRecord::Base.connection, :active?
 
             rd, wr = IO.pipe
             rd.binmode
diff --git a/activerecord/test/cases/connection_management_test.rb b/activerecord/test/cases/connection_management_test.rb
index 9d6ecbde78..0941ee3309 100644
--- a/activerecord/test/cases/connection_management_test.rb
+++ b/activerecord/test/cases/connection_management_test.rb
@@ -27,7 +27,7 @@ module ActiveRecord
 
         # make sure we have an active connection
         assert ActiveRecord::Base.connection
-        assert ActiveRecord::Base.connection_handler.active_connections?
+        assert_predicate ActiveRecord::Base.connection_handler, :active_connections?
       end
 
       def test_app_delegation
@@ -47,14 +47,14 @@ module ActiveRecord
       def test_connections_are_cleared_after_body_close
         _, _, body = @management.call(@env)
         body.close
-        assert !ActiveRecord::Base.connection_handler.active_connections?
+        assert_not_predicate ActiveRecord::Base.connection_handler, :active_connections?
       end
 
       def test_active_connections_are_not_cleared_on_body_close_during_transaction
         ActiveRecord::Base.transaction do
           _, _, body = @management.call(@env)
           body.close
-          assert ActiveRecord::Base.connection_handler.active_connections?
+          assert_predicate ActiveRecord::Base.connection_handler, :active_connections?
         end
       end
 
@@ -62,7 +62,7 @@ module ActiveRecord
         app       = Class.new(App) { def call(env); raise NotImplementedError; end }.new
         explosive = middleware(app)
         assert_raises(NotImplementedError) { explosive.call(@env) }
-        assert !ActiveRecord::Base.connection_handler.active_connections?
+        assert_not_predicate ActiveRecord::Base.connection_handler, :active_connections?
       end
 
       def test_connections_not_closed_if_exception_inside_transaction
@@ -70,14 +70,14 @@ module ActiveRecord
           app               = Class.new(App) { def call(env); raise RuntimeError; end }.new
           explosive         = middleware(app)
           assert_raises(RuntimeError) { explosive.call(@env) }
-          assert ActiveRecord::Base.connection_handler.active_connections?
+          assert_predicate ActiveRecord::Base.connection_handler, :active_connections?
         end
       end
 
       test "doesn't clear active connections when running in a test case" do
         executor.wrap do
           @management.call(@env)
-          assert ActiveRecord::Base.connection_handler.active_connections?
+          assert_predicate ActiveRecord::Base.connection_handler, :active_connections?
         end
       end
 
@@ -85,7 +85,7 @@ module ActiveRecord
         body = Class.new(String) { def to_path; "/path"; end }.new
         app = lambda { |_| [200, {}, body] }
         response_body = middleware(app).call(@env)[2]
-        assert response_body.respond_to?(:to_path)
+        assert_respond_to response_body, :to_path
         assert_equal "/path", response_body.to_path
       end
 
diff --git a/activerecord/test/cases/connection_pool_test.rb b/activerecord/test/cases/connection_pool_test.rb
index cb29c578b7..bfaaa3c54e 100644
--- a/activerecord/test/cases/connection_pool_test.rb
+++ b/activerecord/test/cases/connection_pool_test.rb
@@ -35,12 +35,12 @@ module ActiveRecord
 
       def test_checkout_after_close
         connection = pool.connection
-        assert connection.in_use?
+        assert_predicate connection, :in_use?
 
         connection.close
-        assert !connection.in_use?
+        assert_not_predicate connection, :in_use?
 
-        assert pool.connection.in_use?
+        assert_predicate pool.connection, :in_use?
       end
 
       def test_released_connection_moves_between_threads
@@ -80,14 +80,14 @@ module ActiveRecord
       end
 
       def test_active_connection_in_use
-        assert !pool.active_connection?
+        assert_not_predicate pool, :active_connection?
         main_thread = pool.connection
 
-        assert pool.active_connection?
+        assert_predicate pool, :active_connection?
 
         main_thread.close
 
-        assert !pool.active_connection?
+        assert_not_predicate pool, :active_connection?
       end
 
       def test_full_pool_exception
@@ -205,11 +205,11 @@ module ActiveRecord
 
       def test_remove_connection
         conn = @pool.checkout
-        assert conn.in_use?
+        assert_predicate conn, :in_use?
 
         length = @pool.connections.length
         @pool.remove conn
-        assert conn.in_use?
+        assert_predicate conn, :in_use?
         assert_equal(length - 1, @pool.connections.length)
       ensure
         conn.close
@@ -224,11 +224,11 @@ module ActiveRecord
       end
 
       def test_active_connection?
-        assert !@pool.active_connection?
+        assert_not_predicate @pool, :active_connection?
         assert @pool.connection
-        assert @pool.active_connection?
+        assert_predicate @pool, :active_connection?
         @pool.release_connection
-        assert !@pool.active_connection?
+        assert_not_predicate @pool, :active_connection?
       end
 
       def test_checkout_behaviour
@@ -496,7 +496,7 @@ module ActiveRecord
               assert_nil timed_join_result
 
               # assert that since this is within default timeout our connection hasn't been forcefully taken away from us
-              assert @pool.active_connection?
+              assert_predicate @pool, :active_connection?
             end
           ensure
             thread.join if thread && !timed_join_result # clean up the other thread
@@ -510,7 +510,7 @@ module ActiveRecord
           @pool.with_connection do |connection|
             Thread.new { @pool.send(group_action_method) }.join
             # assert connection has been forcefully taken away from us
-            assert_not @pool.active_connection?
+            assert_not_predicate @pool, :active_connection?
 
             # make a new connection for with_connection to clean up
             @pool.connection
diff --git a/activerecord/test/cases/dirty_test.rb b/activerecord/test/cases/dirty_test.rb
index d4408776d3..14c4e3cbd4 100644
--- a/activerecord/test/cases/dirty_test.rb
+++ b/activerecord/test/cases/dirty_test.rb
@@ -24,18 +24,18 @@ class DirtyTest < ActiveRecord::TestCase
 
     # Change catchphrase.
     pirate.catchphrase = "arrr"
-    assert pirate.catchphrase_changed?
+    assert_predicate pirate, :catchphrase_changed?
     assert_nil pirate.catchphrase_was
     assert_equal [nil, "arrr"], pirate.catchphrase_change
 
     # Saved - no changes.
     pirate.save!
-    assert !pirate.catchphrase_changed?
+    assert_not_predicate pirate, :catchphrase_changed?
     assert_nil pirate.catchphrase_change
 
     # Same value - no changes.
     pirate.catchphrase = "arrr"
-    assert !pirate.catchphrase_changed?
+    assert_not_predicate pirate, :catchphrase_changed?
     assert_nil pirate.catchphrase_change
   end
 
@@ -46,23 +46,23 @@ class DirtyTest < ActiveRecord::TestCase
 
       # New record - no changes.
       pirate = target.new
-      assert !pirate.created_on_changed?
+      assert_not_predicate pirate, :created_on_changed?
       assert_nil pirate.created_on_change
 
       # Saved - no changes.
       pirate.catchphrase = "arrrr, time zone!!"
       pirate.save!
-      assert !pirate.created_on_changed?
+      assert_not_predicate pirate, :created_on_changed?
       assert_nil pirate.created_on_change
 
       # Change created_on.
       old_created_on = pirate.created_on
       pirate.created_on = Time.now - 1.day
-      assert pirate.created_on_changed?
+      assert_predicate pirate, :created_on_changed?
       assert_kind_of ActiveSupport::TimeWithZone, pirate.created_on_was
       assert_equal old_created_on, pirate.created_on_was
       pirate.created_on = old_created_on
-      assert !pirate.created_on_changed?
+      assert_not_predicate pirate, :created_on_changed?
     end
   end
 
@@ -73,7 +73,7 @@ class DirtyTest < ActiveRecord::TestCase
 
       pirate = target.create!
       pirate.created_on = pirate.created_on
-      assert !pirate.created_on_changed?
+      assert_not_predicate pirate, :created_on_changed?
     end
   end
 
@@ -86,19 +86,19 @@ class DirtyTest < ActiveRecord::TestCase
 
       # New record - no changes.
       pirate = target.new
-      assert !pirate.created_on_changed?
+      assert_not_predicate pirate, :created_on_changed?
       assert_nil pirate.created_on_change
 
       # Saved - no changes.
       pirate.catchphrase = "arrrr, time zone!!"
       pirate.save!
-      assert !pirate.created_on_changed?
+      assert_not_predicate pirate, :created_on_changed?
       assert_nil pirate.created_on_change
 
       # Change created_on.
       old_created_on = pirate.created_on
       pirate.created_on = Time.now + 1.day
-      assert pirate.created_on_changed?
+      assert_predicate pirate, :created_on_changed?
       # kind_of does not work because
       # ActiveSupport::TimeWithZone.name == 'Time'
       assert_instance_of Time, pirate.created_on_was
@@ -113,19 +113,19 @@ class DirtyTest < ActiveRecord::TestCase
 
       # New record - no changes.
       pirate = target.new
-      assert !pirate.created_on_changed?
+      assert_not_predicate pirate, :created_on_changed?
       assert_nil pirate.created_on_change
 
       # Saved - no changes.
       pirate.catchphrase = "arrrr, time zone!!"
       pirate.save!
-      assert !pirate.created_on_changed?
+      assert_not_predicate pirate, :created_on_changed?
       assert_nil pirate.created_on_change
 
       # Change created_on.
       old_created_on = pirate.created_on
       pirate.created_on = Time.now + 1.day
-      assert pirate.created_on_changed?
+      assert_predicate pirate, :created_on_changed?
       # kind_of does not work because
       # ActiveSupport::TimeWithZone.name == 'Time'
       assert_instance_of Time, pirate.created_on_was
@@ -137,11 +137,11 @@ class DirtyTest < ActiveRecord::TestCase
     # the actual attribute here is name, title is an
     # alias setup via alias_attribute
     parrot = Parrot.new
-    assert !parrot.title_changed?
+    assert_not_predicate parrot, :title_changed?
     assert_nil parrot.title_change
 
     parrot.name = "Sam"
-    assert parrot.title_changed?
+    assert_predicate parrot, :title_changed?
     assert_nil parrot.title_was
     assert_equal parrot.name_change, parrot.title_change
   end
@@ -153,7 +153,7 @@ class DirtyTest < ActiveRecord::TestCase
     pirate.restore_catchphrase!
     assert_equal "Yar!", pirate.catchphrase
     assert_equal Hash.new, pirate.changes
-    assert !pirate.catchphrase_changed?
+    assert_not_predicate pirate, :catchphrase_changed?
   end
 
   def test_nullable_number_not_marked_as_changed_if_new_value_is_blank
@@ -161,7 +161,7 @@ class DirtyTest < ActiveRecord::TestCase
 
     ["", nil].each do |value|
       pirate.parrot_id = value
-      assert !pirate.parrot_id_changed?
+      assert_not_predicate pirate, :parrot_id_changed?
       assert_nil pirate.parrot_id_change
     end
   end
@@ -171,7 +171,7 @@ class DirtyTest < ActiveRecord::TestCase
 
     ["", nil].each do |value|
       numeric_data.bank_balance = value
-      assert !numeric_data.bank_balance_changed?
+      assert_not_predicate numeric_data, :bank_balance_changed?
       assert_nil numeric_data.bank_balance_change
     end
   end
@@ -181,7 +181,7 @@ class DirtyTest < ActiveRecord::TestCase
 
     ["", nil].each do |value|
       numeric_data.temperature = value
-      assert !numeric_data.temperature_changed?
+      assert_not_predicate numeric_data, :temperature_changed?
       assert_nil numeric_data.temperature_change
     end
   end
@@ -197,7 +197,7 @@ class DirtyTest < ActiveRecord::TestCase
       ["", nil].each do |value|
         topic.written_on = value
         assert_nil topic.written_on
-        assert !topic.written_on_changed?
+        assert_not_predicate topic, :written_on_changed?
       end
     end
   end
@@ -208,10 +208,10 @@ class DirtyTest < ActiveRecord::TestCase
     pirate.catchphrase = "arrr"
     assert pirate.save!
 
-    assert !pirate.changed?
+    assert_not_predicate pirate, :changed?
 
     pirate.parrot_id = "0"
-    assert !pirate.changed?
+    assert_not_predicate pirate, :changed?
   end
 
   def test_integer_zero_to_integer_zero_not_marked_as_changed
@@ -220,17 +220,17 @@ class DirtyTest < ActiveRecord::TestCase
     pirate.catchphrase = "arrr"
     assert pirate.save!
 
-    assert !pirate.changed?
+    assert_not_predicate pirate, :changed?
 
     pirate.parrot_id = 0
-    assert !pirate.changed?
+    assert_not_predicate pirate, :changed?
   end
 
   def test_float_zero_to_string_zero_not_marked_as_changed
     data = NumericData.new temperature: 0.0
     data.save!
 
-    assert_not data.changed?
+    assert_not_predicate data, :changed?
 
     data.temperature = "0"
     assert_empty data.changes
@@ -251,38 +251,38 @@ class DirtyTest < ActiveRecord::TestCase
     # check the change from 1 to ''
     pirate = Pirate.find_by_catchphrase("Yarrrr, me hearties")
     pirate.parrot_id = ""
-    assert pirate.parrot_id_changed?
+    assert_predicate pirate, :parrot_id_changed?
     assert_equal([1, nil], pirate.parrot_id_change)
     pirate.save
 
     # check the change from nil to 0
     pirate = Pirate.find_by_catchphrase("Yarrrr, me hearties")
     pirate.parrot_id = 0
-    assert pirate.parrot_id_changed?
+    assert_predicate pirate, :parrot_id_changed?
     assert_equal([nil, 0], pirate.parrot_id_change)
     pirate.save
 
     # check the change from 0 to ''
     pirate = Pirate.find_by_catchphrase("Yarrrr, me hearties")
     pirate.parrot_id = ""
-    assert pirate.parrot_id_changed?
+    assert_predicate pirate, :parrot_id_changed?
     assert_equal([0, nil], pirate.parrot_id_change)
   end
 
   def test_object_should_be_changed_if_any_attribute_is_changed
     pirate = Pirate.new
-    assert !pirate.changed?
+    assert_not_predicate pirate, :changed?
     assert_equal [], pirate.changed
     assert_equal Hash.new, pirate.changes
 
     pirate.catchphrase = "arrr"
-    assert pirate.changed?
+    assert_predicate pirate, :changed?
     assert_nil pirate.catchphrase_was
     assert_equal %w(catchphrase), pirate.changed
     assert_equal({ "catchphrase" => [nil, "arrr"] }, pirate.changes)
 
     pirate.save
-    assert !pirate.changed?
+    assert_not_predicate pirate, :changed?
     assert_equal [], pirate.changed
     assert_equal Hash.new, pirate.changes
   end
@@ -290,40 +290,40 @@ class DirtyTest < ActiveRecord::TestCase
   def test_attribute_will_change!
     pirate = Pirate.create!(catchphrase: "arr")
 
-    assert !pirate.catchphrase_changed?
+    assert_not_predicate pirate, :catchphrase_changed?
     assert pirate.catchphrase_will_change!
-    assert pirate.catchphrase_changed?
+    assert_predicate pirate, :catchphrase_changed?
     assert_equal ["arr", "arr"], pirate.catchphrase_change
 
     pirate.catchphrase << " matey!"
-    assert pirate.catchphrase_changed?
+    assert_predicate pirate, :catchphrase_changed?
     assert_equal ["arr", "arr matey!"], pirate.catchphrase_change
   end
 
   def test_virtual_attribute_will_change
     parrot = Parrot.create!(name: "Ruby")
     parrot.send(:attribute_will_change!, :cancel_save_from_callback)
-    assert parrot.has_changes_to_save?
+    assert_predicate parrot, :has_changes_to_save?
   end
 
   def test_association_assignment_changes_foreign_key
     pirate = Pirate.create!(catchphrase: "jarl")
     pirate.parrot = Parrot.create!(name: "Lorre")
-    assert pirate.changed?
+    assert_predicate pirate, :changed?
     assert_equal %w(parrot_id), pirate.changed
   end
 
   def test_attribute_should_be_compared_with_type_cast
     topic = Topic.new
-    assert topic.approved?
-    assert !topic.approved_changed?
+    assert_predicate topic, :approved?
+    assert_not_predicate topic, :approved_changed?
 
     # Coming from web form.
     params = { topic: { approved: 1 } }
     # In the controller.
     topic.attributes = params[:topic]
-    assert topic.approved?
-    assert !topic.approved_changed?
+    assert_predicate topic, :approved?
+    assert_not_predicate topic, :approved_changed?
   end
 
   def test_partial_update
@@ -378,9 +378,9 @@ class DirtyTest < ActiveRecord::TestCase
   def test_reload_should_clear_changed_attributes
     pirate = Pirate.create!(catchphrase: "shiver me timbers")
     pirate.catchphrase = "*hic*"
-    assert pirate.changed?
+    assert_predicate pirate, :changed?
     pirate.reload
-    assert !pirate.changed?
+    assert_not_predicate pirate, :changed?
   end
 
   def test_dup_objects_should_not_copy_dirty_flag_from_creator
@@ -388,17 +388,17 @@ class DirtyTest < ActiveRecord::TestCase
     pirate_dup = pirate.dup
     pirate_dup.restore_catchphrase!
     pirate.catchphrase = "I love Rum"
-    assert pirate.catchphrase_changed?
-    assert !pirate_dup.catchphrase_changed?
+    assert_predicate pirate, :catchphrase_changed?
+    assert_not_predicate pirate_dup, :catchphrase_changed?
   end
 
   def test_reverted_changes_are_not_dirty
     phrase = "shiver me timbers"
     pirate = Pirate.create!(catchphrase: phrase)
     pirate.catchphrase = "*hic*"
-    assert pirate.changed?
+    assert_predicate pirate, :changed?
     pirate.catchphrase = phrase
-    assert !pirate.changed?
+    assert_not_predicate pirate, :changed?
   end
 
   def test_reverted_changes_are_not_dirty_after_multiple_changes
@@ -406,40 +406,40 @@ class DirtyTest < ActiveRecord::TestCase
     pirate = Pirate.create!(catchphrase: phrase)
     10.times do |i|
       pirate.catchphrase = "*hic*" * i
-      assert pirate.changed?
+      assert_predicate pirate, :changed?
     end
-    assert pirate.changed?
+    assert_predicate pirate, :changed?
     pirate.catchphrase = phrase
-    assert !pirate.changed?
+    assert_not_predicate pirate, :changed?
   end
 
   def test_reverted_changes_are_not_dirty_going_from_nil_to_value_and_back
     pirate = Pirate.create!(catchphrase: "Yar!")
 
     pirate.parrot_id = 1
-    assert pirate.changed?
-    assert pirate.parrot_id_changed?
-    assert !pirate.catchphrase_changed?
+    assert_predicate pirate, :changed?
+    assert_predicate pirate, :parrot_id_changed?
+    assert_not_predicate pirate, :catchphrase_changed?
 
     pirate.parrot_id = nil
-    assert !pirate.changed?
-    assert !pirate.parrot_id_changed?
-    assert !pirate.catchphrase_changed?
+    assert_not_predicate pirate, :changed?
+    assert_not_predicate pirate, :parrot_id_changed?
+    assert_not_predicate pirate, :catchphrase_changed?
   end
 
   def test_save_should_store_serialized_attributes_even_with_partial_writes
     with_partial_writes(Topic) do
       topic = Topic.create!(content: { a: "a" })
 
-      assert_not topic.changed?
+      assert_not_predicate topic, :changed?
 
       topic.content[:b] = "b"
 
-      assert topic.changed?
+      assert_predicate topic, :changed?
 
       topic.save!
 
-      assert_not topic.changed?
+      assert_not_predicate topic, :changed?
       assert_equal "b", topic.content[:b]
 
       topic.reload
@@ -596,7 +596,7 @@ class DirtyTest < ActiveRecord::TestCase
     pirate = Pirate.create!(catchphrase: "rrrr", created_on: time_in_paris)
 
     pirate.created_on = pirate.created_on.in_time_zone("Tokyo").to_s
-    assert !pirate.created_on_changed?
+    assert_not_predicate pirate, :created_on_changed?
   end
 
   test "partial insert" do
@@ -627,7 +627,7 @@ class DirtyTest < ActiveRecord::TestCase
     pirate = Pirate.create!(catchphrase: "arrrr")
     pirate.catchphrase << " matey!"
 
-    assert pirate.catchphrase_changed?
+    assert_predicate pirate, :catchphrase_changed?
     expected_changes = {
       "catchphrase" => ["arrrr", "arrrr matey!"]
     }
@@ -641,7 +641,7 @@ class DirtyTest < ActiveRecord::TestCase
     pirate.reload
 
     assert_equal "arrrr matey!", pirate.catchphrase
-    assert_not pirate.changed?
+    assert_not_predicate pirate, :changed?
   end
 
   test "in place mutation for binary" do
@@ -652,19 +652,19 @@ class DirtyTest < ActiveRecord::TestCase
 
     binary = klass.create!(data: "\\\\foo")
 
-    assert_not binary.changed?
+    assert_not_predicate binary, :changed?
 
     binary.data = binary.data.dup
 
-    assert_not binary.changed?
+    assert_not_predicate binary, :changed?
 
     binary = klass.last
 
-    assert_not binary.changed?
+    assert_not_predicate binary, :changed?
 
     binary.data << "bar"
 
-    assert binary.changed?
+    assert_predicate binary, :changed?
   end
 
   test "changes is correct for subclass" do
@@ -679,7 +679,7 @@ class DirtyTest < ActiveRecord::TestCase
     new_catchphrase = "arrrr matey!"
 
     pirate.catchphrase = new_catchphrase
-    assert pirate.catchphrase_changed?
+    assert_predicate pirate, :catchphrase_changed?
 
     expected_changes = {
       "catchphrase" => ["arrrr", new_catchphrase]
@@ -698,7 +698,7 @@ class DirtyTest < ActiveRecord::TestCase
     new_catchphrase = "arrrr matey!"
 
     pirate.catchphrase = new_catchphrase
-    assert pirate.catchphrase_changed?
+    assert_predicate pirate, :catchphrase_changed?
 
     expected_changes = {
       "catchphrase" => ["arrrr", new_catchphrase]
@@ -720,7 +720,7 @@ class DirtyTest < ActiveRecord::TestCase
     end
 
     model = klass.new(first_name: "Jim")
-    assert model.first_name_changed?
+    assert_predicate model, :first_name_changed?
   end
 
   test "attribute_will_change! doesn't try to save non-persistable attributes" do
@@ -732,7 +732,7 @@ class DirtyTest < ActiveRecord::TestCase
     record = klass.new(first_name: "Sean")
     record.non_persisted_attribute_will_change!
 
-    assert record.non_persisted_attribute_changed?
+    assert_predicate record, :non_persisted_attribute_changed?
     assert record.save
   end
 
@@ -762,13 +762,13 @@ class DirtyTest < ActiveRecord::TestCase
 
   test "attributes assigned but not selected are dirty" do
     person = Person.select(:id).first
-    refute person.changed?
+    assert_not_predicate person, :changed?
 
     person.first_name = "Sean"
-    assert person.changed?
+    assert_predicate person, :changed?
 
     person.first_name = nil
-    assert person.changed?
+    assert_predicate person, :changed?
   end
 
   test "attributes not selected are still missing after save" do
@@ -781,14 +781,14 @@ class DirtyTest < ActiveRecord::TestCase
   test "saved_change_to_attribute? returns whether a change occurred in the last save" do
     person = Person.create!(first_name: "Sean")
 
-    assert person.saved_change_to_first_name?
-    refute person.saved_change_to_gender?
+    assert_predicate person, :saved_change_to_first_name?
+    assert_not_predicate person, :saved_change_to_gender?
     assert person.saved_change_to_first_name?(from: nil, to: "Sean")
     assert person.saved_change_to_first_name?(from: nil)
     assert person.saved_change_to_first_name?(to: "Sean")
-    refute person.saved_change_to_first_name?(from: "Jim", to: "Sean")
-    refute person.saved_change_to_first_name?(from: "Jim")
-    refute person.saved_change_to_first_name?(to: "Jim")
+    assert_not person.saved_change_to_first_name?(from: "Jim", to: "Sean")
+    assert_not person.saved_change_to_first_name?(from: "Jim")
+    assert_not person.saved_change_to_first_name?(to: "Jim")
   end
 
   test "saved_change_to_attribute returns the change that occurred in the last save" do
@@ -823,11 +823,11 @@ class DirtyTest < ActiveRecord::TestCase
   test "saved_changes? returns whether the last call to save changed anything" do
     person = Person.create!(first_name: "Sean")
 
-    assert person.saved_changes?
+    assert_predicate person, :saved_changes?
 
     person.save
 
-    refute person.saved_changes?
+    assert_not_predicate person, :saved_changes?
   end
 
   test "saved_changes returns a hash of all the changes that occurred" do
@@ -857,7 +857,7 @@ class DirtyTest < ActiveRecord::TestCase
     end
 
     person = klass.create!(first_name: "Sean")
-    refute person.changed?
+    assert_not_predicate person, :changed?
   end
 
   private
@@ -870,8 +870,8 @@ class DirtyTest < ActiveRecord::TestCase
     end
 
     def check_pirate_after_save_failure(pirate)
-      assert pirate.changed?
-      assert pirate.parrot_id_changed?
+      assert_predicate pirate, :changed?
+      assert_predicate pirate, :parrot_id_changed?
       assert_equal %w(parrot_id), pirate.changed
       assert_nil pirate.parrot_id_was
     end
diff --git a/activerecord/test/cases/dup_test.rb b/activerecord/test/cases/dup_test.rb
index 59c3331595..9e33c3110c 100644
--- a/activerecord/test/cases/dup_test.rb
+++ b/activerecord/test/cases/dup_test.rb
@@ -10,7 +10,7 @@ module ActiveRecord
     fixtures :topics
 
     def test_dup
-      assert !Topic.new.freeze.dup.frozen?
+      assert_not_predicate Topic.new.freeze.dup, :frozen?
     end
 
     def test_not_readonly
@@ -41,7 +41,7 @@ module ActiveRecord
       topic.destroy
 
       duped = topic.dup
-      assert_not duped.destroyed?
+      assert_not_predicate duped, :destroyed?
     end
 
     def test_dup_has_no_id
@@ -127,12 +127,12 @@ module ActiveRecord
 
         duped = topic.dup
         duped.title = nil
-        assert duped.invalid?
+        assert_predicate duped, :invalid?
 
         topic.title = nil
         duped.title = "Mathematics"
-        assert topic.invalid?
-        assert duped.valid?
+        assert_predicate topic, :invalid?
+        assert_predicate duped, :valid?
       end
     end
 
diff --git a/activerecord/test/cases/enum_test.rb b/activerecord/test/cases/enum_test.rb
index 7cda712112..d5a1d11e12 100644
--- a/activerecord/test/cases/enum_test.rb
+++ b/activerecord/test/cases/enum_test.rb
@@ -12,16 +12,16 @@ class EnumTest < ActiveRecord::TestCase
   end
 
   test "query state by predicate" do
-    assert @book.published?
-    assert_not @book.written?
-    assert_not @book.proposed?
+    assert_predicate @book, :published?
+    assert_not_predicate @book, :written?
+    assert_not_predicate @book, :proposed?
 
-    assert @book.read?
-    assert @book.in_english?
-    assert @book.author_visibility_visible?
-    assert @book.illustrator_visibility_visible?
-    assert @book.with_medium_font_size?
-    assert @book.medium_to_read?
+    assert_predicate @book, :read?
+    assert_predicate @book, :in_english?
+    assert_predicate @book, :author_visibility_visible?
+    assert_predicate @book, :illustrator_visibility_visible?
+    assert_predicate @book, :with_medium_font_size?
+    assert_predicate @book, :medium_to_read?
   end
 
   test "query state with strings" do
@@ -76,46 +76,46 @@ class EnumTest < ActiveRecord::TestCase
   end
 
   test "build from scope" do
-    assert Book.written.build.written?
-    assert_not Book.written.build.proposed?
+    assert_predicate Book.written.build, :written?
+    assert_not_predicate Book.written.build, :proposed?
   end
 
   test "build from where" do
-    assert Book.where(status: Book.statuses[:written]).build.written?
-    assert_not Book.where(status: Book.statuses[:written]).build.proposed?
-    assert Book.where(status: :written).build.written?
-    assert_not Book.where(status: :written).build.proposed?
-    assert Book.where(status: "written").build.written?
-    assert_not Book.where(status: "written").build.proposed?
+    assert_predicate Book.where(status: Book.statuses[:written]).build, :written?
+    assert_not_predicate Book.where(status: Book.statuses[:written]).build, :proposed?
+    assert_predicate Book.where(status: :written).build, :written?
+    assert_not_predicate Book.where(status: :written).build, :proposed?
+    assert_predicate Book.where(status: "written").build, :written?
+    assert_not_predicate Book.where(status: "written").build, :proposed?
   end
 
   test "update by declaration" do
     @book.written!
-    assert @book.written?
+    assert_predicate @book, :written?
     @book.in_english!
-    assert @book.in_english?
+    assert_predicate @book, :in_english?
     @book.author_visibility_visible!
-    assert @book.author_visibility_visible?
+    assert_predicate @book, :author_visibility_visible?
   end
 
   test "update by setter" do
     @book.update! status: :written
-    assert @book.written?
+    assert_predicate @book, :written?
   end
 
   test "enum methods are overwritable" do
     assert_equal "do publish work...", @book.published!
-    assert @book.published?
+    assert_predicate @book, :published?
   end
 
   test "direct assignment" do
     @book.status = :written
-    assert @book.written?
+    assert_predicate @book, :written?
   end
 
   test "assign string value" do
     @book.status = "written"
-    assert @book.written?
+    assert_predicate @book, :written?
   end
 
   test "enum changed attributes" do
@@ -242,17 +242,17 @@ class EnumTest < ActiveRecord::TestCase
   end
 
   test "building new objects with enum scopes" do
-    assert Book.written.build.written?
-    assert Book.read.build.read?
-    assert Book.in_spanish.build.in_spanish?
-    assert Book.illustrator_visibility_invisible.build.illustrator_visibility_invisible?
+    assert_predicate Book.written.build, :written?
+    assert_predicate Book.read.build, :read?
+    assert_predicate Book.in_spanish.build, :in_spanish?
+    assert_predicate Book.illustrator_visibility_invisible.build, :illustrator_visibility_invisible?
   end
 
   test "creating new objects with enum scopes" do
-    assert Book.written.create.written?
-    assert Book.read.create.read?
-    assert Book.in_spanish.create.in_spanish?
-    assert Book.illustrator_visibility_invisible.create.illustrator_visibility_invisible?
+    assert_predicate Book.written.create, :written?
+    assert_predicate Book.read.create, :read?
+    assert_predicate Book.in_spanish.create, :in_spanish?
+    assert_predicate Book.illustrator_visibility_invisible.create, :illustrator_visibility_invisible?
   end
 
   test "_before_type_cast" do
@@ -355,9 +355,9 @@ class EnumTest < ActiveRecord::TestCase
     klass.delete_all
     klass.create!(status: "proposed")
     book = klass.new(status: "written")
-    assert book.valid?
+    assert_predicate book, :valid?
     book.status = "proposed"
-    assert_not book.valid?
+    assert_not_predicate book, :valid?
   end
 
   test "validate inclusion of value in array" do
@@ -368,9 +368,9 @@ class EnumTest < ActiveRecord::TestCase
     end
     klass.delete_all
     invalid_book = klass.new(status: "proposed")
-    assert_not invalid_book.valid?
+    assert_not_predicate invalid_book, :valid?
     valid_book = klass.new(status: "written")
-    assert valid_book.valid?
+    assert_predicate valid_book, :valid?
   end
 
   test "enums are distinct per class" do
@@ -417,10 +417,10 @@ class EnumTest < ActiveRecord::TestCase
     end
 
     book1 = klass.proposed.create!
-    assert book1.proposed?
+    assert_predicate book1, :proposed?
 
     book2 = klass.single.create!
-    assert book2.single?
+    assert_predicate book2, :single?
   end
 
   test "enum with alias_attribute" do
@@ -431,62 +431,62 @@ class EnumTest < ActiveRecord::TestCase
     end
 
     book = klass.proposed.create!
-    assert book.proposed?
+    assert_predicate book, :proposed?
     assert_equal "proposed", book.aliased_status
 
     book = klass.find(book.id)
-    assert book.proposed?
+    assert_predicate book, :proposed?
     assert_equal "proposed", book.aliased_status
   end
 
   test "query state by predicate with prefix" do
-    assert @book.author_visibility_visible?
-    assert_not @book.author_visibility_invisible?
-    assert @book.illustrator_visibility_visible?
-    assert_not @book.illustrator_visibility_invisible?
+    assert_predicate @book, :author_visibility_visible?
+    assert_not_predicate @book, :author_visibility_invisible?
+    assert_predicate @book, :illustrator_visibility_visible?
+    assert_not_predicate @book, :illustrator_visibility_invisible?
   end
 
   test "query state by predicate with custom prefix" do
-    assert @book.in_english?
-    assert_not @book.in_spanish?
-    assert_not @book.in_french?
+    assert_predicate @book, :in_english?
+    assert_not_predicate @book, :in_spanish?
+    assert_not_predicate @book, :in_french?
   end
 
   test "query state by predicate with custom suffix" do
-    assert     @book.medium_to_read?
-    assert_not @book.easy_to_read?
-    assert_not @book.hard_to_read?
+    assert_predicate @book, :medium_to_read?
+    assert_not_predicate @book, :easy_to_read?
+    assert_not_predicate @book, :hard_to_read?
   end
 
   test "enum methods with custom suffix defined" do
-    assert @book.class.respond_to?(:easy_to_read)
-    assert @book.class.respond_to?(:medium_to_read)
-    assert @book.class.respond_to?(:hard_to_read)
+    assert_respond_to @book.class, :easy_to_read
+    assert_respond_to @book.class, :medium_to_read
+    assert_respond_to @book.class, :hard_to_read
 
-    assert @book.respond_to?(:easy_to_read?)
-    assert @book.respond_to?(:medium_to_read?)
-    assert @book.respond_to?(:hard_to_read?)
+    assert_respond_to @book, :easy_to_read?
+    assert_respond_to @book, :medium_to_read?
+    assert_respond_to @book, :hard_to_read?
 
-    assert @book.respond_to?(:easy_to_read!)
-    assert @book.respond_to?(:medium_to_read!)
-    assert @book.respond_to?(:hard_to_read!)
+    assert_respond_to @book, :easy_to_read!
+    assert_respond_to @book, :medium_to_read!
+    assert_respond_to @book, :hard_to_read!
   end
 
   test "update enum attributes with custom suffix" do
     @book.medium_to_read!
-    assert_not @book.easy_to_read?
-    assert     @book.medium_to_read?
-    assert_not @book.hard_to_read?
+    assert_not_predicate @book, :easy_to_read?
+    assert_predicate @book, :medium_to_read?
+    assert_not_predicate @book, :hard_to_read?
 
     @book.easy_to_read!
-    assert     @book.easy_to_read?
-    assert_not @book.medium_to_read?
-    assert_not @book.hard_to_read?
+    assert_predicate @book, :easy_to_read?
+    assert_not_predicate @book, :medium_to_read?
+    assert_not_predicate @book, :hard_to_read?
 
     @book.hard_to_read!
-    assert_not @book.easy_to_read?
-    assert_not @book.medium_to_read?
-    assert     @book.hard_to_read?
+    assert_not_predicate @book, :easy_to_read?
+    assert_not_predicate @book, :medium_to_read?
+    assert_predicate @book, :hard_to_read?
   end
 
   test "uses default status when no status is provided in fixtures" do
@@ -497,12 +497,12 @@ class EnumTest < ActiveRecord::TestCase
 
   test "uses default value from database on initialization" do
     book = Book.new
-    assert book.proposed?
+    assert_predicate book, :proposed?
   end
 
   test "uses default value from database on initialization when using custom mapping" do
     book = Book.new
-    assert book.hard?
+    assert_predicate book, :hard?
   end
 
   test "data type of Enum type" do
diff --git a/activerecord/test/cases/explain_subscriber_test.rb b/activerecord/test/cases/explain_subscriber_test.rb
index fb698c47cd..82cc891970 100644
--- a/activerecord/test/cases/explain_subscriber_test.rb
+++ b/activerecord/test/cases/explain_subscriber_test.rb
@@ -15,20 +15,20 @@ if ActiveRecord::Base.connection.supports_explain?
 
     def test_collects_nothing_if_the_payload_has_an_exception
       SUBSCRIBER.finish(nil, nil, exception: Exception.new)
-      assert queries.empty?
+      assert_empty queries
     end
 
     def test_collects_nothing_for_ignored_payloads
       ActiveRecord::ExplainSubscriber::IGNORED_PAYLOADS.each do |ip|
         SUBSCRIBER.finish(nil, nil, name: ip)
       end
-      assert queries.empty?
+      assert_empty queries
     end
 
     def test_collects_nothing_if_collect_is_false
       ActiveRecord::ExplainRegistry.collect = false
       SUBSCRIBER.finish(nil, nil, name: "SQL", sql: "select 1 from users", binds: [1, 2])
-      assert queries.empty?
+      assert_empty queries
     end
 
     def test_collects_pairs_of_queries_and_binds
@@ -42,12 +42,12 @@ if ActiveRecord::Base.connection.supports_explain?
 
     def test_collects_nothing_if_the_statement_is_not_whitelisted
       SUBSCRIBER.finish(nil, nil, name: "SQL", sql: "SHOW max_identifier_length")
-      assert queries.empty?
+      assert_empty queries
     end
 
     def test_collects_nothing_if_the_statement_is_only_partially_matched
       SUBSCRIBER.finish(nil, nil, name: "SQL", sql: "select_db yo_mama")
-      assert queries.empty?
+      assert_empty queries
     end
 
     def test_collects_cte_queries
diff --git a/activerecord/test/cases/finder_respond_to_test.rb b/activerecord/test/cases/finder_respond_to_test.rb
index 4039af66d0..59af4e6961 100644
--- a/activerecord/test/cases/finder_respond_to_test.rb
+++ b/activerecord/test/cases/finder_respond_to_test.rb
@@ -8,7 +8,7 @@ class FinderRespondToTest < ActiveRecord::TestCase
 
   def test_should_preserve_normal_respond_to_behaviour_on_base
     assert_respond_to ActiveRecord::Base, :new
-    assert !ActiveRecord::Base.respond_to?(:find_by_something)
+    assert_not_respond_to ActiveRecord::Base, :find_by_something
   end
 
   def test_should_preserve_normal_respond_to_behaviour_and_respond_to_newly_added_method
@@ -43,14 +43,14 @@ class FinderRespondToTest < ActiveRecord::TestCase
   end
 
   def test_should_not_respond_to_find_by_one_missing_attribute
-    assert !Topic.respond_to?(:find_by_undertitle)
+    assert_not_respond_to Topic, :find_by_undertitle
   end
 
   def test_should_not_respond_to_find_by_invalid_method_syntax
-    assert !Topic.respond_to?(:fail_to_find_by_title)
-    assert !Topic.respond_to?(:find_by_title?)
-    assert !Topic.respond_to?(:fail_to_find_or_create_by_title)
-    assert !Topic.respond_to?(:find_or_create_by_title?)
+    assert_not_respond_to Topic, :fail_to_find_by_title
+    assert_not_respond_to Topic, :find_by_title?
+    assert_not_respond_to Topic, :fail_to_find_or_create_by_title
+    assert_not_respond_to Topic, :find_or_create_by_title?
   end
 
   private
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index 4769ffd64d..c78c13ece3 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -648,13 +648,13 @@ class FinderTest < ActiveRecord::TestCase
   def test_last_with_integer_and_order_should_use_sql_limit
     relation = Topic.order("title")
     assert_queries(1) { relation.last(5) }
-    assert !relation.loaded?
+    assert_not_predicate relation, :loaded?
   end
 
   def test_last_with_integer_and_reorder_should_use_sql_limit
     relation = Topic.reorder("title")
     assert_queries(1) { relation.last(5) }
-    assert !relation.loaded?
+    assert_not_predicate relation, :loaded?
   end
 
   def test_last_on_loaded_relation_should_not_use_sql
diff --git a/activerecord/test/cases/fixtures_test.rb b/activerecord/test/cases/fixtures_test.rb
index 34aaadcf7c..c88b90c8eb 100644
--- a/activerecord/test/cases/fixtures_test.rb
+++ b/activerecord/test/cases/fixtures_test.rb
@@ -393,7 +393,7 @@ class FixturesTest < ActiveRecord::TestCase
     nonexistent_fixture_path = FIXTURES_ROOT + "/imnothere"
 
     # sanity check to make sure that this file never exists
-    assert Dir[nonexistent_fixture_path + "*"].empty?
+    assert_empty Dir[nonexistent_fixture_path + "*"]
 
     assert_raise(Errno::ENOENT) do
       ActiveRecord::FixtureSet.new(Account.connection, "companies", Company, nonexistent_fixture_path)
@@ -1143,10 +1143,10 @@ class FoxyFixturesTest < ActiveRecord::TestCase
   end
 
   def test_resolves_enums
-    assert books(:awdr).published?
-    assert books(:awdr).read?
-    assert books(:rfr).proposed?
-    assert books(:ddd).published?
+    assert_predicate books(:awdr), :published?
+    assert_predicate books(:awdr), :read?
+    assert_predicate books(:rfr), :proposed?
+    assert_predicate books(:ddd), :published?
   end
 end
 
diff --git a/activerecord/test/cases/habtm_destroy_order_test.rb b/activerecord/test/cases/habtm_destroy_order_test.rb
index 5e503272e1..b15e1b48c4 100644
--- a/activerecord/test/cases/habtm_destroy_order_test.rb
+++ b/activerecord/test/cases/habtm_destroy_order_test.rb
@@ -15,7 +15,7 @@ class HabtmDestroyOrderTest < ActiveRecord::TestCase
         sicp.destroy
       end
     end
-    assert !sicp.destroyed?
+    assert_not_predicate sicp, :destroyed?
   end
 
   test "should not raise error if have foreign key in the join table" do
@@ -42,7 +42,7 @@ class HabtmDestroyOrderTest < ActiveRecord::TestCase
       ben.lessons << sicp
       ben.save!
       ben.destroy
-      assert !ben.reload.lessons.empty?
+      assert_not_empty ben.reload.lessons
     ensure
       # get rid of it so Student is still like it was
       Student.reset_callbacks(:destroy)
@@ -58,6 +58,6 @@ class HabtmDestroyOrderTest < ActiveRecord::TestCase
     assert_raises LessonError do
       sicp.destroy
     end
-    assert !sicp.reload.students.empty?
+    assert_not_empty sicp.reload.students
   end
 end
diff --git a/activerecord/test/cases/inheritance_test.rb b/activerecord/test/cases/inheritance_test.rb
index ff4385c8b4..e3ca79af99 100644
--- a/activerecord/test/cases/inheritance_test.rb
+++ b/activerecord/test/cases/inheritance_test.rb
@@ -130,46 +130,46 @@ class InheritanceTest < ActiveRecord::TestCase
   end
 
   def test_descends_from_active_record
-    assert !ActiveRecord::Base.descends_from_active_record?
+    assert_not_predicate ActiveRecord::Base, :descends_from_active_record?
 
     # Abstract subclass of AR::Base.
-    assert LoosePerson.descends_from_active_record?
+    assert_predicate LoosePerson, :descends_from_active_record?
 
     # Concrete subclass of an abstract class.
-    assert LooseDescendant.descends_from_active_record?
+    assert_predicate LooseDescendant, :descends_from_active_record?
 
     # Concrete subclass of AR::Base.
-    assert TightPerson.descends_from_active_record?
+    assert_predicate TightPerson, :descends_from_active_record?
 
     # Concrete subclass of a concrete class but has no type column.
-    assert TightDescendant.descends_from_active_record?
+    assert_predicate TightDescendant, :descends_from_active_record?
 
     # Concrete subclass of AR::Base.
-    assert Post.descends_from_active_record?
+    assert_predicate Post, :descends_from_active_record?
 
     # Concrete subclasses of a concrete class which has a type column.
-    assert !StiPost.descends_from_active_record?
-    assert !SubStiPost.descends_from_active_record?
+    assert_not_predicate StiPost, :descends_from_active_record?
+    assert_not_predicate SubStiPost, :descends_from_active_record?
 
     # Abstract subclass of a concrete class which has a type column.
     # This is pathological, as you'll never have Sub < Abstract < Concrete.
-    assert !AbstractStiPost.descends_from_active_record?
+    assert_not_predicate AbstractStiPost, :descends_from_active_record?
 
     # Concrete subclass of an abstract class which has a type column.
-    assert !SubAbstractStiPost.descends_from_active_record?
+    assert_not_predicate SubAbstractStiPost, :descends_from_active_record?
   end
 
   def test_company_descends_from_active_record
-    assert !ActiveRecord::Base.descends_from_active_record?
+    assert_not_predicate ActiveRecord::Base, :descends_from_active_record?
     assert AbstractCompany.descends_from_active_record?, "AbstractCompany should descend from ActiveRecord::Base"
     assert Company.descends_from_active_record?, "Company should descend from ActiveRecord::Base"
     assert !Class.new(Company).descends_from_active_record?, "Company subclass should not descend from ActiveRecord::Base"
   end
 
   def test_abstract_class
-    assert !ActiveRecord::Base.abstract_class?
-    assert LoosePerson.abstract_class?
-    assert !LooseDescendant.abstract_class?
+    assert_not_predicate ActiveRecord::Base, :abstract_class?
+    assert_predicate LoosePerson, :abstract_class?
+    assert_not_predicate LooseDescendant, :abstract_class?
   end
 
   def test_inheritance_base_class
diff --git a/activerecord/test/cases/json_serialization_test.rb b/activerecord/test/cases/json_serialization_test.rb
index 52fe488cd5..82cf281cff 100644
--- a/activerecord/test/cases/json_serialization_test.rb
+++ b/activerecord/test/cases/json_serialization_test.rb
@@ -252,7 +252,7 @@ class DatabaseConnectedJsonEncodingTest < ActiveRecord::TestCase
     def @david.favorite_quote; "Constraints are liberating"; end
     json = @david.to_json(include: :posts, methods: :favorite_quote)
 
-    assert !@david.posts.first.respond_to?(:favorite_quote)
+    assert_not_respond_to @david.posts.first, :favorite_quote
     assert_match %r{"favorite_quote":"Constraints are liberating"}, json
     assert_equal 1, %r{"favorite_quote":}.match(json).size
   end
diff --git a/activerecord/test/cases/json_shared_test_cases.rb b/activerecord/test/cases/json_shared_test_cases.rb
index b0c0f2c283..c60a276850 100644
--- a/activerecord/test/cases/json_shared_test_cases.rb
+++ b/activerecord/test/cases/json_shared_test_cases.rb
@@ -26,7 +26,7 @@ module JSONSharedTestCases
     assert_type_match column_type, column.sql_type
 
     type = klass.type_for_attribute("payload")
-    assert_not type.binary?
+    assert_not_predicate type, :binary?
   end
 
   def test_change_table_supports_json
@@ -152,42 +152,42 @@ module JSONSharedTestCases
 
   def test_changes_in_place
     json = klass.new
-    assert_not json.changed?
+    assert_not_predicate json, :changed?
 
     json.payload = { "one" => "two" }
-    assert json.changed?
-    assert json.payload_changed?
+    assert_predicate json, :changed?
+    assert_predicate json, :payload_changed?
 
     json.save!
-    assert_not json.changed?
+    assert_not_predicate json, :changed?
 
     json.payload["three"] = "four"
-    assert json.payload_changed?
+    assert_predicate json, :payload_changed?
 
     json.save!
     json.reload
 
     assert_equal({ "one" => "two", "three" => "four" }, json.payload)
-    assert_not json.changed?
+    assert_not_predicate json, :changed?
   end
 
   def test_changes_in_place_ignores_key_order
     json = klass.new
-    assert_not json.changed?
+    assert_not_predicate json, :changed?
 
     json.payload = { "three" => "four", "one" => "two" }
     json.save!
     json.reload
 
     json.payload = { "three" => "four", "one" => "two" }
-    assert_not json.changed?
+    assert_not_predicate json, :changed?
 
     json.payload = [{ "three" => "four", "one" => "two" }, { "seven" => "eight", "five" => "six" }]
     json.save!
     json.reload
 
     json.payload = [{ "three" => "four", "one" => "two" }, { "seven" => "eight", "five" => "six" }]
-    assert_not json.changed?
+    assert_not_predicate json, :changed?
   end
 
   def test_changes_in_place_with_ruby_object
@@ -195,10 +195,10 @@ module JSONSharedTestCases
     json = klass.create!(payload: time)
 
     json.reload
-    assert_not json.changed?
+    assert_not_predicate json, :changed?
 
     json.payload = time
-    assert_not json.changed?
+    assert_not_predicate json, :changed?
   end
 
   def test_assigning_string_literal
diff --git a/activerecord/test/cases/locking_test.rb b/activerecord/test/cases/locking_test.rb
index 3701be4b11..bb76137ef5 100644
--- a/activerecord/test/cases/locking_test.rb
+++ b/activerecord/test/cases/locking_test.rb
@@ -69,8 +69,8 @@ class OptimisticLockingTest < ActiveRecord::TestCase
     assert_raise(ActiveRecord::StaleObjectError) { s2.destroy }
 
     assert s1.destroy
-    assert s1.frozen?
-    assert s1.destroyed?
+    assert_predicate s1, :frozen?
+    assert_predicate s1, :destroyed?
     assert_raises(ActiveRecord::RecordNotFound) { StringKeyObject.find("record1") }
   end
 
@@ -104,8 +104,8 @@ class OptimisticLockingTest < ActiveRecord::TestCase
     assert_raises(ActiveRecord::StaleObjectError) { p2.destroy }
 
     assert p1.destroy
-    assert p1.frozen?
-    assert p1.destroyed?
+    assert_predicate p1, :frozen?
+    assert_predicate p1, :destroyed?
     assert_raises(ActiveRecord::RecordNotFound) { Person.find(1) }
   end
 
@@ -201,7 +201,7 @@ class OptimisticLockingTest < ActiveRecord::TestCase
       person.first_name = "Douglas Adams"
       person.lock_version = 42
 
-      assert person.lock_version_changed?
+      assert_predicate person, :lock_version_changed?
 
       person.save
     end
@@ -440,16 +440,16 @@ class OptimisticLockingTest < ActiveRecord::TestCase
     assert_difference "car.wheels.count", -1  do
       car.reload.destroy
     end
-    assert car.destroyed?
+    assert_predicate car, :destroyed?
   end
 
   def test_removing_has_and_belongs_to_many_associations_upon_destroy
     p = RichPerson.create! first_name: "Jon"
     p.treasures.create!
-    assert !p.treasures.empty?
+    assert_not_empty p.treasures
     p.destroy
-    assert p.treasures.empty?
-    assert RichPerson.connection.select_all("SELECT * FROM peoples_treasures WHERE rich_person_id = 1").empty?
+    assert_empty p.treasures
+    assert_empty RichPerson.connection.select_all("SELECT * FROM peoples_treasures WHERE rich_person_id = 1")
   end
 
   def test_yaml_dumping_with_lock_column
@@ -519,7 +519,7 @@ class OptimisticLockingWithSchemaChangeTest < ActiveRecord::TestCase
 
     t1.destroy
 
-    assert t1.destroyed?
+    assert_predicate t1, :destroyed?
   end
 
   def test_destroy_stale_object
@@ -532,7 +532,7 @@ class OptimisticLockingWithSchemaChangeTest < ActiveRecord::TestCase
       stale_object.destroy!
     end
 
-    refute stale_object.destroyed?
+    assert_not_predicate stale_object, :destroyed?
   end
 
   private
diff --git a/activerecord/test/cases/migration/change_schema_test.rb b/activerecord/test/cases/migration/change_schema_test.rb
index 38a906c8f5..1494027182 100644
--- a/activerecord/test/cases/migration/change_schema_test.rb
+++ b/activerecord/test/cases/migration/change_schema_test.rb
@@ -84,7 +84,7 @@ module ActiveRecord
           columns = connection.columns(:testings)
           array_column = columns.detect { |c| c.name == "foo" }
 
-          assert array_column.array?
+          assert_predicate array_column, :array?
         end
 
         def test_create_table_with_array_column
@@ -95,7 +95,7 @@ module ActiveRecord
           columns = connection.columns(:testings)
           array_column = columns.detect { |c| c.name == "foo" }
 
-          assert array_column.array?
+          assert_predicate array_column, :array?
         end
       end
 
diff --git a/activerecord/test/cases/migration/columns_test.rb b/activerecord/test/cases/migration/columns_test.rb
index 8ca20b6172..cedd9c44e3 100644
--- a/activerecord/test/cases/migration/columns_test.rb
+++ b/activerecord/test/cases/migration/columns_test.rb
@@ -67,7 +67,7 @@ module ActiveRecord
       if current_adapter?(:Mysql2Adapter)
         def test_mysql_rename_column_preserves_auto_increment
           rename_column "test_models", "id", "id_test"
-          assert connection.columns("test_models").find { |c| c.name == "id_test" }.auto_increment?
+          assert_predicate connection.columns("test_models").find { |c| c.name == "id_test" }, :auto_increment?
           TestModel.reset_column_information
         ensure
           rename_column "test_models", "id_test", "id"
@@ -223,31 +223,31 @@ module ActiveRecord
 
       def test_change_column_with_nil_default
         add_column "test_models", "contributor", :boolean, default: true
-        assert TestModel.new.contributor?
+        assert_predicate TestModel.new, :contributor?
 
         change_column "test_models", "contributor", :boolean, default: nil
         TestModel.reset_column_information
-        assert_not TestModel.new.contributor?
+        assert_not_predicate TestModel.new, :contributor?
         assert_nil TestModel.new.contributor
       end
 
       def test_change_column_to_drop_default_with_null_false
         add_column "test_models", "contributor", :boolean, default: true, null: false
-        assert TestModel.new.contributor?
+        assert_predicate TestModel.new, :contributor?
 
         change_column "test_models", "contributor", :boolean, default: nil, null: false
         TestModel.reset_column_information
-        assert_not TestModel.new.contributor?
+        assert_not_predicate TestModel.new, :contributor?
         assert_nil TestModel.new.contributor
       end
 
       def test_change_column_with_new_default
         add_column "test_models", "administrator", :boolean, default: true
-        assert TestModel.new.administrator?
+        assert_predicate TestModel.new, :administrator?
 
         change_column "test_models", "administrator", :boolean, default: false
         TestModel.reset_column_information
-        assert_not TestModel.new.administrator?
+        assert_not_predicate TestModel.new, :administrator?
       end
 
       def test_change_column_with_custom_index_name
diff --git a/activerecord/test/cases/migration/command_recorder_test.rb b/activerecord/test/cases/migration/command_recorder_test.rb
index 58bc558619..3a11bb081b 100644
--- a/activerecord/test/cases/migration/command_recorder_test.rb
+++ b/activerecord/test/cases/migration/command_recorder_test.rb
@@ -14,7 +14,7 @@ module ActiveRecord
         recorder = CommandRecorder.new(Class.new {
           def america; end
         }.new)
-        assert recorder.respond_to?(:america)
+        assert_respond_to recorder, :america
       end
 
       def test_send_calls_super
@@ -27,7 +27,7 @@ module ActiveRecord
         recorder = CommandRecorder.new(Class.new {
           def create_table(name); end
         }.new)
-        assert recorder.respond_to?(:create_table), "respond_to? create_table"
+        assert_respond_to recorder, :create_table
         recorder.send(:create_table, :horses)
         assert_equal [[:create_table, [:horses], nil]], recorder.commands
       end
diff --git a/activerecord/test/cases/migration/compatibility_test.rb b/activerecord/test/cases/migration/compatibility_test.rb
index 26d3b3e29d..69a50674af 100644
--- a/activerecord/test/cases/migration/compatibility_test.rb
+++ b/activerecord/test/cases/migration/compatibility_test.rb
@@ -182,7 +182,7 @@ module LegacyPrimaryKeyTestCases
     assert_legacy_primary_key
 
     legacy_ref = LegacyPrimaryKey.columns_hash["legacy_ref_id"]
-    assert_not legacy_ref.bigint?
+    assert_not_predicate legacy_ref, :bigint?
 
     record1 = LegacyPrimaryKey.create!
     assert_not_nil record1.id
@@ -301,8 +301,8 @@ module LegacyPrimaryKeyTestCases
       @migration.migrate(:up)
 
       legacy_pk = LegacyPrimaryKey.columns_hash["id"]
-      assert legacy_pk.bigint?
-      assert legacy_pk.auto_increment?
+      assert_predicate legacy_pk, :bigint?
+      assert_predicate legacy_pk, :auto_increment?
 
       schema = dump_table_schema "legacy_primary_keys"
       assert_match %r{create_table "legacy_primary_keys", (?!id: :bigint, default: nil)}, schema
@@ -334,7 +334,7 @@ module LegacyPrimaryKeyTestCases
       legacy_pk = LegacyPrimaryKey.columns_hash["id"]
 
       assert_equal :integer, legacy_pk.type
-      assert_not legacy_pk.bigint?
+      assert_not_predicate legacy_pk, :bigint?
       assert_not legacy_pk.null
 
       if current_adapter?(:Mysql2Adapter, :PostgreSQLAdapter)
diff --git a/activerecord/test/cases/migration/create_join_table_test.rb b/activerecord/test/cases/migration/create_join_table_test.rb
index 77d32a24a5..83fb4f9385 100644
--- a/activerecord/test/cases/migration/create_join_table_test.rb
+++ b/activerecord/test/cases/migration/create_join_table_test.rb
@@ -69,7 +69,7 @@ module ActiveRecord
       def test_create_join_table_without_indexes
         connection.create_join_table :artists, :musics
 
-        assert connection.indexes(:artists_musics).blank?
+        assert_predicate connection.indexes(:artists_musics), :blank?
       end
 
       def test_create_join_table_with_index
diff --git a/activerecord/test/cases/migration/foreign_key_test.rb b/activerecord/test/cases/migration/foreign_key_test.rb
index 079be04946..de37215e80 100644
--- a/activerecord/test/cases/migration/foreign_key_test.rb
+++ b/activerecord/test/cases/migration/foreign_key_test.rb
@@ -235,39 +235,39 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
             assert_equal 1, foreign_keys.size
 
             fk = foreign_keys.first
-            refute fk.validated?
+            assert_not_predicate fk, :validated?
           end
 
           def test_validate_foreign_key_infers_column
             @connection.add_foreign_key :astronauts, :rockets, validate: false
-            refute @connection.foreign_keys("astronauts").first.validated?
+            assert_not_predicate @connection.foreign_keys("astronauts").first, :validated?
 
             @connection.validate_foreign_key :astronauts, :rockets
-            assert @connection.foreign_keys("astronauts").first.validated?
+            assert_predicate @connection.foreign_keys("astronauts").first, :validated?
           end
 
           def test_validate_foreign_key_by_column
             @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", validate: false
-            refute @connection.foreign_keys("astronauts").first.validated?
+            assert_not_predicate @connection.foreign_keys("astronauts").first, :validated?
 
             @connection.validate_foreign_key :astronauts, column: "rocket_id"
-            assert @connection.foreign_keys("astronauts").first.validated?
+            assert_predicate @connection.foreign_keys("astronauts").first, :validated?
           end
 
           def test_validate_foreign_key_by_symbol_column
             @connection.add_foreign_key :astronauts, :rockets, column: :rocket_id, validate: false
-            refute @connection.foreign_keys("astronauts").first.validated?
+            assert_not_predicate @connection.foreign_keys("astronauts").first, :validated?
 
             @connection.validate_foreign_key :astronauts, column: :rocket_id
-            assert @connection.foreign_keys("astronauts").first.validated?
+            assert_predicate @connection.foreign_keys("astronauts").first, :validated?
           end
 
           def test_validate_foreign_key_by_name
             @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", name: "fancy_named_fk", validate: false
-            refute @connection.foreign_keys("astronauts").first.validated?
+            assert_not_predicate @connection.foreign_keys("astronauts").first, :validated?
 
             @connection.validate_foreign_key :astronauts, name: "fancy_named_fk"
-            assert @connection.foreign_keys("astronauts").first.validated?
+            assert_predicate @connection.foreign_keys("astronauts").first, :validated?
           end
 
           def test_validate_foreign_non_existing_foreign_key_raises
@@ -280,7 +280,7 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
             @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", name: "fancy_named_fk", validate: false
 
             @connection.validate_constraint :astronauts, "fancy_named_fk"
-            assert @connection.foreign_keys("astronauts").first.validated?
+            assert_predicate @connection.foreign_keys("astronauts").first, :validated?
           end
         else
           # Foreign key should still be created, but should not be invalid
@@ -291,7 +291,7 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
             assert_equal 1, foreign_keys.size
 
             fk = foreign_keys.first
-            assert fk.validated?
+            assert_predicate fk, :validated?
           end
         end
 
diff --git a/activerecord/test/cases/migration/rename_table_test.rb b/activerecord/test/cases/migration/rename_table_test.rb
index dfce266253..8514ccd55b 100644
--- a/activerecord/test/cases/migration/rename_table_test.rb
+++ b/activerecord/test/cases/migration/rename_table_test.rb
@@ -86,7 +86,7 @@ module ActiveRecord
           rename_table :cats, :felines
 
           assert connection.table_exists? :felines
-          refute connection.table_exists? :cats
+          assert_not connection.table_exists? :cats
 
           primary_key_name = connection.select_values(<<-SQL.strip_heredoc, "SCHEMA")[0]
             SELECT c.relname
@@ -107,7 +107,7 @@ module ActiveRecord
           connection.create_table :cats, id: :uuid, default: "uuid_generate_v4()"
           assert_nothing_raised { rename_table :cats, :felines }
           assert connection.table_exists? :felines
-          refute connection.table_exists? :cats
+          assert_not connection.table_exists? :cats
         ensure
           connection.drop_table :cats, if_exists: true
           connection.drop_table :felines, if_exists: true
diff --git a/activerecord/test/cases/migration_test.rb b/activerecord/test/cases/migration_test.rb
index 2ef055fb01..a4b8664a85 100644
--- a/activerecord/test/cases/migration_test.rb
+++ b/activerecord/test/cases/migration_test.rb
@@ -120,11 +120,11 @@ class MigrationTest < ActiveRecord::TestCase
     old_path = ActiveRecord::Migrator.migrations_paths
     migrator = ActiveRecord::MigrationContext.new(MIGRATIONS_ROOT + "/valid")
 
-    assert migrator.any_migrations?
+    assert_predicate migrator, :any_migrations?
 
     migrator_empty = ActiveRecord::MigrationContext.new(MIGRATIONS_ROOT + "/empty")
 
-    assert_not migrator_empty.any_migrations?
+    assert_not_predicate migrator_empty, :any_migrations?
   ensure
     ActiveRecord::MigrationContext.new(old_path)
   end
@@ -170,7 +170,7 @@ class MigrationTest < ActiveRecord::TestCase
   def test_add_table_with_decimals
     Person.connection.drop_table :big_numbers rescue nil
 
-    assert !BigNumber.table_exists?
+    assert_not_predicate BigNumber, :table_exists?
     GiveMeBigNumbers.up
     BigNumber.reset_column_information
 
@@ -229,7 +229,7 @@ class MigrationTest < ActiveRecord::TestCase
 
   def test_filtering_migrations
     assert_no_column Person, :last_name
-    assert !Reminder.table_exists?
+    assert_not_predicate Reminder, :table_exists?
 
     name_filter = lambda { |migration| migration.name == "ValidPeopleHaveLastNames" }
     migrator = ActiveRecord::MigrationContext.new(MIGRATIONS_ROOT + "/valid")
@@ -465,7 +465,7 @@ class MigrationTest < ActiveRecord::TestCase
   end
 
   def test_rename_table_with_prefix_and_suffix
-    assert !Thing.table_exists?
+    assert_not_predicate Thing, :table_exists?
     ActiveRecord::Base.table_name_prefix = "p_"
     ActiveRecord::Base.table_name_suffix = "_s"
     Thing.reset_table_name
@@ -486,7 +486,7 @@ class MigrationTest < ActiveRecord::TestCase
   end
 
   def test_add_drop_table_with_prefix_and_suffix
-    assert !Reminder.table_exists?
+    assert_not_predicate Reminder, :table_exists?
     ActiveRecord::Base.table_name_prefix = "prefix_"
     ActiveRecord::Base.table_name_suffix = "_suffix"
     Reminder.reset_table_name
@@ -955,7 +955,7 @@ class CopyMigrationsTest < ActiveRecord::TestCase
     files_count = Dir[@migrations_path + "/*.rb"].length
     copied = ActiveRecord::Migration.copy(@migrations_path, bukkits: MIGRATIONS_ROOT + "/to_copy")
     assert_equal files_count, Dir[@migrations_path + "/*.rb"].length
-    assert copied.empty?
+    assert_empty copied
   ensure
     clear
   end
@@ -996,7 +996,7 @@ class CopyMigrationsTest < ActiveRecord::TestCase
       files_count = Dir[@migrations_path + "/*.rb"].length
       copied = ActiveRecord::Migration.copy(@migrations_path, bukkits: MIGRATIONS_ROOT + "/to_copy_with_timestamps")
       assert_equal files_count, Dir[@migrations_path + "/*.rb"].length
-      assert copied.empty?
+      assert_empty copied
     end
   ensure
     clear
@@ -1038,7 +1038,7 @@ class CopyMigrationsTest < ActiveRecord::TestCase
       files_count = Dir[@migrations_path + "/*.rb"].length
       copied = ActiveRecord::Migration.copy(@migrations_path, bukkits: MIGRATIONS_ROOT + "/to_copy_with_timestamps")
       assert_equal files_count, Dir[@migrations_path + "/*.rb"].length
-      assert copied.empty?
+      assert_empty copied
     end
   ensure
     clear
@@ -1059,7 +1059,7 @@ class CopyMigrationsTest < ActiveRecord::TestCase
     files_count = Dir[@migrations_path + "/*.rb"].length
     copied = ActiveRecord::Migration.copy(@migrations_path, bukkits: MIGRATIONS_ROOT + "/magic")
     assert_equal files_count, Dir[@migrations_path + "/*.rb"].length
-    assert copied.empty?
+    assert_empty copied
   ensure
     clear
   end
diff --git a/activerecord/test/cases/multiparameter_attributes_test.rb b/activerecord/test/cases/multiparameter_attributes_test.rb
index 59be4dc5a8..a24b173cf5 100644
--- a/activerecord/test/cases/multiparameter_attributes_test.rb
+++ b/activerecord/test/cases/multiparameter_attributes_test.rb
@@ -227,7 +227,7 @@ class MultiParameterAttributeTest < ActiveRecord::TestCase
       topic = Topic.find(1)
       topic.attributes = attributes
       assert_equal Time.local(2004, 6, 24, 16, 24, 0), topic.written_on
-      assert_equal false, topic.written_on.respond_to?(:time_zone)
+      assert_not_respond_to topic.written_on, :time_zone
     end
   end
 
@@ -242,7 +242,7 @@ class MultiParameterAttributeTest < ActiveRecord::TestCase
       topic = Topic.find(1)
       topic.attributes = attributes
       assert_equal Time.utc(2004, 6, 24, 16, 24, 0), topic.written_on
-      assert_equal false, topic.written_on.respond_to?(:time_zone)
+      assert_not_respond_to topic.written_on, :time_zone
     end
   ensure
     Topic.skip_time_zone_conversion_for_attributes = []
@@ -261,7 +261,7 @@ class MultiParameterAttributeTest < ActiveRecord::TestCase
         topic = Topic.find(1)
         topic.attributes = attributes
         assert_equal Time.zone.local(2000, 1, 1, 16, 24, 0), topic.bonus_time
-        assert_not topic.bonus_time.utc?
+        assert_not_predicate topic.bonus_time, :utc?
 
         attributes = {
           "written_on(1i)" => "2000", "written_on(2i)" => "", "written_on(3i)" => "",
diff --git a/activerecord/test/cases/nested_attributes_test.rb b/activerecord/test/cases/nested_attributes_test.rb
index a2ccb603a9..1ed3a61bbb 100644
--- a/activerecord/test/cases/nested_attributes_test.rb
+++ b/activerecord/test/cases/nested_attributes_test.rb
@@ -36,7 +36,7 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
     pirate.birds_with_reject_all_blank_attributes = [{ name: "", color: "", _destroy: "0" }]
     pirate.save!
 
-    assert pirate.birds_with_reject_all_blank.empty?
+    assert_empty pirate.birds_with_reject_all_blank
   end
 
   def test_should_not_build_a_new_record_if_reject_all_blank_returns_false
@@ -44,7 +44,7 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
     pirate.birds_with_reject_all_blank_attributes = [{ name: "", color: "" }]
     pirate.save!
 
-    assert pirate.birds_with_reject_all_blank.empty?
+    assert_empty pirate.birds_with_reject_all_blank
   end
 
   def test_should_build_a_new_record_if_reject_all_blank_does_not_return_false
@@ -152,7 +152,7 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
     man = Man.create(name: "Jon")
     interest = man.interests.create(topic: "the ladies")
     man.update(interests_attributes: { _destroy: "1", id: interest.id })
-    assert man.reload.interests.empty?
+    assert_empty man.reload.interests
   end
 
   def test_reject_if_is_not_short_circuited_if_allow_destroy_is_false
@@ -240,7 +240,7 @@ class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
     @ship.destroy
     @pirate.reload.ship_attributes = { name: "Davy Jones Gold Dagger" }
 
-    assert !@pirate.ship.persisted?
+    assert_not_predicate @pirate.ship, :persisted?
     assert_equal "Davy Jones Gold Dagger", @pirate.ship.name
   end
 
@@ -261,7 +261,7 @@ class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
   def test_should_replace_an_existing_record_if_there_is_no_id
     @pirate.reload.ship_attributes = { name: "Davy Jones Gold Dagger" }
 
-    assert !@pirate.ship.persisted?
+    assert_not_predicate @pirate.ship, :persisted?
     assert_equal "Davy Jones Gold Dagger", @pirate.ship.name
     assert_equal "Nights Dirty Lightning", @ship.name
   end
@@ -335,7 +335,7 @@ class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
   def test_should_also_work_with_a_HashWithIndifferentAccess
     @pirate.ship_attributes = ActiveSupport::HashWithIndifferentAccess.new(id: @ship.id, name: "Davy Jones Gold Dagger")
 
-    assert @pirate.ship.persisted?
+    assert_predicate @pirate.ship, :persisted?
     assert_equal "Davy Jones Gold Dagger", @pirate.ship.name
   end
 
@@ -350,12 +350,12 @@ class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
   def test_should_not_destroy_the_associated_model_until_the_parent_is_saved
     @pirate.attributes = { ship_attributes: { id: @ship.id, _destroy: "1" } }
 
-    assert !@pirate.ship.destroyed?
-    assert @pirate.ship.marked_for_destruction?
+    assert_not_predicate @pirate.ship, :destroyed?
+    assert_predicate @pirate.ship, :marked_for_destruction?
 
     @pirate.save
 
-    assert @pirate.ship.destroyed?
+    assert_predicate @pirate.ship, :destroyed?
     assert_nil @pirate.reload.ship
   end
 
@@ -424,7 +424,7 @@ class TestNestedAttributesOnABelongsToAssociation < ActiveRecord::TestCase
     @pirate.destroy
     @ship.reload.pirate_attributes = { catchphrase: "Arr" }
 
-    assert !@ship.pirate.persisted?
+    assert_not_predicate @ship.pirate, :persisted?
     assert_equal "Arr", @ship.pirate.catchphrase
   end
 
@@ -445,7 +445,7 @@ class TestNestedAttributesOnABelongsToAssociation < ActiveRecord::TestCase
   def test_should_replace_an_existing_record_if_there_is_no_id
     @ship.reload.pirate_attributes = { catchphrase: "Arr" }
 
-    assert !@ship.pirate.persisted?
+    assert_not_predicate @ship.pirate, :persisted?
     assert_equal "Arr", @ship.pirate.catchphrase
     assert_equal "Aye", @pirate.catchphrase
   end
@@ -550,7 +550,7 @@ class TestNestedAttributesOnABelongsToAssociation < ActiveRecord::TestCase
     @pirate.delete
     @ship.reload.attributes = { update_only_pirate_attributes: { catchphrase: "Arr" } }
 
-    assert !@ship.update_only_pirate.persisted?
+    assert_not_predicate @ship.update_only_pirate, :persisted?
   end
 
   def test_should_update_existing_when_update_only_is_true_and_no_id_is_given
@@ -632,10 +632,10 @@ module NestedAttributesOnACollectionAssociationTests
   def test_should_not_load_association_when_updating_existing_records
     @pirate.reload
     @pirate.send(association_setter, [{ id: @child_1.id, name: "Grace OMalley" }])
-    assert ! @pirate.send(@association_name).loaded?
+    assert_not_predicate @pirate.send(@association_name), :loaded?
 
     @pirate.save
-    assert ! @pirate.send(@association_name).loaded?
+    assert_not_predicate @pirate.send(@association_name), :loaded?
     assert_equal "Grace OMalley", @child_1.reload.name
   end
 
@@ -663,7 +663,7 @@ module NestedAttributesOnACollectionAssociationTests
   def test_should_not_remove_scheduled_destroys_when_loading_association
     @pirate.reload
     @pirate.send(association_setter, [{ id: @child_1.id, _destroy: "1" }])
-    assert @pirate.send(@association_name).load_target.find { |r| r.id == @child_1.id }.marked_for_destruction?
+    assert_predicate @pirate.send(@association_name).load_target.find { |r| r.id == @child_1.id }, :marked_for_destruction?
   end
 
   def test_should_take_a_hash_with_composite_id_keys_and_assign_the_attributes_to_the_associated_models
@@ -705,10 +705,10 @@ module NestedAttributesOnACollectionAssociationTests
       association_getter => { "foo" => { name: "Grace OMalley" }, "bar" => { name: "Privateers Greed" } }
     }
 
-    assert !@pirate.send(@association_name).first.persisted?
+    assert_not_predicate @pirate.send(@association_name).first, :persisted?
     assert_equal "Grace OMalley", @pirate.send(@association_name).first.name
 
-    assert !@pirate.send(@association_name).last.persisted?
+    assert_not_predicate @pirate.send(@association_name).last, :persisted?
     assert_equal "Privateers Greed", @pirate.send(@association_name).last.name
   end
 
@@ -1091,7 +1091,7 @@ class TestHasManyAutosaveAssociationWhichItselfHasAutosaveAssociations < ActiveR
   test "nested singular associations are validated" do
     part = ShipPart.new(name: "Stern", ship_attributes: { name: nil })
 
-    assert_not part.valid?
+    assert_not_predicate part, :valid?
     assert_equal ["Ship name can't be blank"], part.errors.full_messages
   end
 end
diff --git a/activerecord/test/cases/nested_attributes_with_callbacks_test.rb b/activerecord/test/cases/nested_attributes_with_callbacks_test.rb
index f04c68b08f..1d26057fdc 100644
--- a/activerecord/test/cases/nested_attributes_with_callbacks_test.rb
+++ b/activerecord/test/cases/nested_attributes_with_callbacks_test.rb
@@ -63,7 +63,7 @@ class NestedAttributesWithCallbacksTest < ActiveRecord::TestCase
 
   # Characterizing when :before_add callback is called
   test ":before_add called for new bird when not loaded" do
-    assert_not @pirate.birds_with_add.loaded?
+    assert_not_predicate @pirate.birds_with_add, :loaded?
     @pirate.birds_with_add_attributes = new_bird_attributes
     assert_new_bird_with_callback_called
   end
@@ -80,7 +80,7 @@ class NestedAttributesWithCallbacksTest < ActiveRecord::TestCase
   end
 
   test ":before_add not called for identical assignment when not loaded" do
-    assert_not @pirate.birds_with_add.loaded?
+    assert_not_predicate @pirate.birds_with_add, :loaded?
     @pirate.birds_with_add_attributes = existing_birds_attributes
     assert_callbacks_not_called
   end
@@ -92,7 +92,7 @@ class NestedAttributesWithCallbacksTest < ActiveRecord::TestCase
   end
 
   test ":before_add not called for destroy assignment when not loaded" do
-    assert_not @pirate.birds_with_add.loaded?
+    assert_not_predicate @pirate.birds_with_add, :loaded?
     @pirate.birds_with_add_attributes = destroy_bird_attributes
     assert_callbacks_not_called
   end
@@ -111,7 +111,7 @@ class NestedAttributesWithCallbacksTest < ActiveRecord::TestCase
   # Ensuring that the records in the association target are updated,
   # whether the association is loaded before or not
   test "Assignment updates records in target when not loaded" do
-    assert_not @pirate.birds_with_add.loaded?
+    assert_not_predicate @pirate.birds_with_add, :loaded?
     @pirate.birds_with_add_attributes = update_new_and_destroy_bird_attributes
     assert_assignment_affects_records_in_target(:birds_with_add)
   end
@@ -124,7 +124,7 @@ class NestedAttributesWithCallbacksTest < ActiveRecord::TestCase
 
   test("Assignment updates records in target when not loaded" \
        " and callback loads target") do
-    assert_not @pirate.birds_with_add_load.loaded?
+    assert_not_predicate @pirate.birds_with_add_load, :loaded?
     @pirate.birds_with_add_load_attributes = update_new_and_destroy_bird_attributes
     assert_assignment_affects_records_in_target(:birds_with_add_load)
   end
diff --git a/activerecord/test/cases/persistence_test.rb b/activerecord/test/cases/persistence_test.rb
index d242fff442..e8052914d4 100644
--- a/activerecord/test/cases/persistence_test.rb
+++ b/activerecord/test/cases/persistence_test.rb
@@ -217,7 +217,7 @@ class PersistenceTest < ActiveRecord::TestCase
   def test_destroy_all
     conditions = "author_name = 'Mary'"
     topics_by_mary = Topic.all.merge!(where: conditions, order: "id").to_a
-    assert ! topics_by_mary.empty?
+    assert_not_empty topics_by_mary
 
     assert_difference("Topic.count", -topics_by_mary.size) do
       destroyed = Topic.where(conditions).destroy_all.sort_by(&:id)
@@ -253,7 +253,7 @@ class PersistenceTest < ActiveRecord::TestCase
 
   def test_becomes_includes_errors
     company = Company.new(name: nil)
-    assert !company.valid?
+    assert_not_predicate company, :valid?
     original_errors = company.errors
     client = company.becomes(Client)
     assert_equal original_errors.keys, client.errors.keys
@@ -370,8 +370,8 @@ class PersistenceTest < ActiveRecord::TestCase
     developer.destroy
     new_developer = developer.dup
     new_developer.save
-    assert new_developer.persisted?
-    assert_not new_developer.destroyed?
+    assert_predicate new_developer, :persisted?
+    assert_not_predicate new_developer, :destroyed?
   end
 
   def test_create_many
@@ -387,7 +387,7 @@ class PersistenceTest < ActiveRecord::TestCase
     )
     topic = topic.dup # reset @new_record
     assert_nothing_raised { topic.save }
-    assert topic.persisted?
+    assert_predicate topic, :persisted?
     assert_equal "Another New Topic", topic.reload.title
   end
 
@@ -435,7 +435,7 @@ class PersistenceTest < ActiveRecord::TestCase
     topic_reloaded = Topic.instantiate(topic.attributes.merge("does_not_exist" => "test"))
     topic_reloaded.title = "A New Topic"
     assert_nothing_raised { topic_reloaded.save }
-    assert topic_reloaded.persisted?
+    assert_predicate topic_reloaded, :persisted?
     assert_equal "A New Topic", topic_reloaded.reload.title
   end
 
@@ -617,63 +617,63 @@ class PersistenceTest < ActiveRecord::TestCase
   def test_delete_new_record
     client = Client.new(name: "37signals")
     client.delete
-    assert client.frozen?
+    assert_predicate client, :frozen?
 
     assert_not client.save
     assert_raise(ActiveRecord::RecordNotSaved) { client.save! }
 
-    assert client.frozen?
+    assert_predicate client, :frozen?
     assert_raise(RuntimeError) { client.name = "something else" }
   end
 
   def test_delete_record_with_associations
     client = Client.find(3)
     client.delete
-    assert client.frozen?
+    assert_predicate client, :frozen?
     assert_kind_of Firm, client.firm
 
     assert_not client.save
     assert_raise(ActiveRecord::RecordNotSaved) { client.save! }
 
-    assert client.frozen?
+    assert_predicate client, :frozen?
     assert_raise(RuntimeError) { client.name = "something else" }
   end
 
   def test_destroy_new_record
     client = Client.new(name: "37signals")
     client.destroy
-    assert client.frozen?
+    assert_predicate client, :frozen?
 
     assert_not client.save
     assert_raise(ActiveRecord::RecordNotSaved) { client.save! }
 
-    assert client.frozen?
+    assert_predicate client, :frozen?
     assert_raise(RuntimeError) { client.name = "something else" }
   end
 
   def test_destroy_record_with_associations
     client = Client.find(3)
     client.destroy
-    assert client.frozen?
+    assert_predicate client, :frozen?
     assert_kind_of Firm, client.firm
 
     assert_not client.save
     assert_raise(ActiveRecord::RecordNotSaved) { client.save! }
 
-    assert client.frozen?
+    assert_predicate client, :frozen?
     assert_raise(RuntimeError) { client.name = "something else" }
   end
 
   def test_update_attribute
-    assert !Topic.find(1).approved?
+    assert_not_predicate Topic.find(1), :approved?
     Topic.find(1).update_attribute("approved", true)
-    assert Topic.find(1).approved?
+    assert_predicate Topic.find(1), :approved?
 
     Topic.find(1).update_attribute(:approved, false)
-    assert !Topic.find(1).approved?
+    assert_not_predicate Topic.find(1), :approved?
 
     Topic.find(1).update_attribute(:change_approved_before_save, true)
-    assert Topic.find(1).approved?
+    assert_predicate Topic.find(1), :approved?
   end
 
   def test_update_attribute_for_readonly_attribute
@@ -710,14 +710,14 @@ class PersistenceTest < ActiveRecord::TestCase
   def test_update_column
     topic = Topic.find(1)
     topic.update_column("approved", true)
-    assert topic.approved?
+    assert_predicate topic, :approved?
     topic.reload
-    assert topic.approved?
+    assert_predicate topic, :approved?
 
     topic.update_column(:approved, false)
-    assert !topic.approved?
+    assert_not_predicate topic, :approved?
     topic.reload
-    assert !topic.approved?
+    assert_not_predicate topic, :approved?
   end
 
   def test_update_column_should_not_use_setter_method
@@ -804,10 +804,10 @@ class PersistenceTest < ActiveRecord::TestCase
   def test_update_columns
     topic = Topic.find(1)
     topic.update_columns("approved" => true, title: "Sebastian Topic")
-    assert topic.approved?
+    assert_predicate topic, :approved?
     assert_equal "Sebastian Topic", topic.title
     topic.reload
-    assert topic.approved?
+    assert_predicate topic, :approved?
     assert_equal "Sebastian Topic", topic.title
   end
 
@@ -915,33 +915,33 @@ class PersistenceTest < ActiveRecord::TestCase
 
   def test_update
     topic = Topic.find(1)
-    assert !topic.approved?
+    assert_not_predicate topic, :approved?
     assert_equal "The First Topic", topic.title
 
     topic.update("approved" => true, "title" => "The First Topic Updated")
     topic.reload
-    assert topic.approved?
+    assert_predicate topic, :approved?
     assert_equal "The First Topic Updated", topic.title
 
     topic.update(approved: false, title: "The First Topic")
     topic.reload
-    assert !topic.approved?
+    assert_not_predicate topic, :approved?
     assert_equal "The First Topic", topic.title
   end
 
   def test_update_attributes
     topic = Topic.find(1)
-    assert !topic.approved?
+    assert_not_predicate topic, :approved?
     assert_equal "The First Topic", topic.title
 
     topic.update_attributes("approved" => true, "title" => "The First Topic Updated")
     topic.reload
-    assert topic.approved?
+    assert_predicate topic, :approved?
     assert_equal "The First Topic Updated", topic.title
 
     topic.update_attributes(approved: false, title: "The First Topic")
     topic.reload
-    assert !topic.approved?
+    assert_not_predicate topic, :approved?
     assert_equal "The First Topic", topic.title
 
     error = assert_raise(ActiveRecord::RecordNotUnique, ActiveRecord::StatementInvalid) do
@@ -1042,7 +1042,7 @@ class PersistenceTest < ActiveRecord::TestCase
     Topic.find(1).replies << should_be_destroyed_reply
 
     topic = Topic.destroy(1)
-    assert topic.destroyed?
+    assert_predicate topic, :destroyed?
 
     assert_raise(ActiveRecord::RecordNotFound) { Topic.find(1) }
     assert_raise(ActiveRecord::RecordNotFound) { Reply.find(should_be_destroyed_reply.id) }
@@ -1122,13 +1122,13 @@ class PersistenceTest < ActiveRecord::TestCase
   def test_find_via_reload
     post = Post.new
 
-    assert post.new_record?
+    assert_predicate post, :new_record?
 
     post.id = 1
     post.reload
 
     assert_equal "Welcome to the weblog", post.title
-    assert_not post.new_record?
+    assert_not_predicate post, :new_record?
   end
 
   def test_reload_via_querycache
diff --git a/activerecord/test/cases/primary_keys_test.rb b/activerecord/test/cases/primary_keys_test.rb
index 80016fc19d..60dac91ec9 100644
--- a/activerecord/test/cases/primary_keys_test.rb
+++ b/activerecord/test/cases/primary_keys_test.rb
@@ -207,13 +207,13 @@ class PrimaryKeysTest < ActiveRecord::TestCase
     def test_serial_with_quoted_sequence_name
       column = MixedCaseMonkey.columns_hash[MixedCaseMonkey.primary_key]
       assert_equal "nextval('\"mixed_case_monkeys_monkeyID_seq\"'::regclass)", column.default_function
-      assert column.serial?
+      assert_predicate column, :serial?
     end
 
     def test_serial_with_unquoted_sequence_name
       column = Topic.columns_hash[Topic.primary_key]
       assert_equal "nextval('topics_id_seq'::regclass)", column.default_function
-      assert column.serial?
+      assert_predicate column, :serial?
     end
   end
 end
@@ -430,7 +430,7 @@ if current_adapter?(:PostgreSQLAdapter, :Mysql2Adapter)
       @connection.create_table(:widgets, id: @pk_type, force: true)
       column = @connection.columns(:widgets).find { |c| c.name == "id" }
       assert_equal :integer, column.type
-      assert_not column.bigint?
+      assert_not_predicate column, :bigint?
     end
 
     test "primary key with serial/integer are automatically numbered" do
@@ -449,10 +449,10 @@ if current_adapter?(:PostgreSQLAdapter, :Mysql2Adapter)
       test "primary key column type with options" do
         @connection.create_table(:widgets, id: :primary_key, limit: 4, unsigned: true, force: true)
         column = @connection.columns(:widgets).find { |c| c.name == "id" }
-        assert column.auto_increment?
+        assert_predicate column, :auto_increment?
         assert_equal :integer, column.type
-        assert_not column.bigint?
-        assert column.unsigned?
+        assert_not_predicate column, :bigint?
+        assert_predicate column, :unsigned?
 
         schema = dump_table_schema "widgets"
         assert_match %r{create_table "widgets", id: :integer, unsigned: true, }, schema
@@ -461,10 +461,10 @@ if current_adapter?(:PostgreSQLAdapter, :Mysql2Adapter)
       test "bigint primary key with unsigned" do
         @connection.create_table(:widgets, id: :bigint, unsigned: true, force: true)
         column = @connection.columns(:widgets).find { |c| c.name == "id" }
-        assert column.auto_increment?
+        assert_predicate column, :auto_increment?
         assert_equal :integer, column.type
-        assert column.bigint?
-        assert column.unsigned?
+        assert_predicate column, :bigint?
+        assert_predicate column, :unsigned?
 
         schema = dump_table_schema "widgets"
         assert_match %r{create_table "widgets", id: :bigint, unsigned: true, }, schema
diff --git a/activerecord/test/cases/query_cache_test.rb b/activerecord/test/cases/query_cache_test.rb
index ad05f70933..8d37f5ea95 100644
--- a/activerecord/test/cases/query_cache_test.rb
+++ b/activerecord/test/cases/query_cache_test.rb
@@ -82,7 +82,7 @@ class QueryCacheTest < ActiveRecord::TestCase
           assert_cache :off, conn
         end
 
-        assert !ActiveRecord::Base.connection.nil?
+        assert_not_predicate ActiveRecord::Base.connection, :nil?
         assert_cache :off
 
         middleware {
@@ -327,7 +327,7 @@ class QueryCacheTest < ActiveRecord::TestCase
       conf = ActiveRecord::Base.configurations["arunit"].merge("name" => "test2")
       ActiveRecord::Base.connection_handler.establish_connection(conf)
       Task.connection_specification_name = "test2"
-      refute Task.connected?
+      assert_not_predicate Task, :connected?
 
       Task.cache do
         begin
@@ -414,20 +414,20 @@ class QueryCacheTest < ActiveRecord::TestCase
   def test_query_cache_does_not_establish_connection_if_unconnected
     with_temporary_connection_pool do
       ActiveRecord::Base.clear_active_connections!
-      refute ActiveRecord::Base.connection_handler.active_connections? # sanity check
+      assert_not ActiveRecord::Base.connection_handler.active_connections? # sanity check
 
       middleware {
-        refute ActiveRecord::Base.connection_handler.active_connections?, "QueryCache forced ActiveRecord::Base to establish a connection in setup"
+        assert_not ActiveRecord::Base.connection_handler.active_connections?, "QueryCache forced ActiveRecord::Base to establish a connection in setup"
       }.call({})
 
-      refute ActiveRecord::Base.connection_handler.active_connections?, "QueryCache forced ActiveRecord::Base to establish a connection in cleanup"
+      assert_not ActiveRecord::Base.connection_handler.active_connections?, "QueryCache forced ActiveRecord::Base to establish a connection in cleanup"
     end
   end
 
   def test_query_cache_is_enabled_on_connections_established_after_middleware_runs
     with_temporary_connection_pool do
       ActiveRecord::Base.clear_active_connections!
-      refute ActiveRecord::Base.connection_handler.active_connections? # sanity check
+      assert_not ActiveRecord::Base.connection_handler.active_connections? # sanity check
 
       middleware {
         assert ActiveRecord::Base.connection.query_cache_enabled, "QueryCache did not get lazily enabled"
@@ -444,8 +444,8 @@ class QueryCacheTest < ActiveRecord::TestCase
         assert ActiveRecord::Base.connection.query_cache_enabled
 
         Thread.new {
-          refute ActiveRecord::Base.connection_pool.query_cache_enabled
-          refute ActiveRecord::Base.connection.query_cache_enabled
+          assert_not ActiveRecord::Base.connection_pool.query_cache_enabled
+          assert_not ActiveRecord::Base.connection.query_cache_enabled
         }.join
       }.call({})
 
@@ -562,7 +562,7 @@ class QueryCacheExpiryTest < ActiveRecord::TestCase
     assert_called(ActiveRecord::Base.connection, :clear_query_cache, times: 2) do
       ActiveRecord::Base.cache do
         p = Post.find(1)
-        assert p.categories.any?
+        assert_predicate p.categories, :any?
         p.categories.delete_all
       end
     end
diff --git a/activerecord/test/cases/readonly_test.rb b/activerecord/test/cases/readonly_test.rb
index d1b85cb4ef..383e43ed55 100644
--- a/activerecord/test/cases/readonly_test.rb
+++ b/activerecord/test/cases/readonly_test.rb
@@ -16,10 +16,10 @@ class ReadOnlyTest < ActiveRecord::TestCase
 
   def test_cant_save_readonly_record
     dev = Developer.find(1)
-    assert !dev.readonly?
+    assert_not_predicate dev, :readonly?
 
     dev.readonly!
-    assert dev.readonly?
+    assert_predicate dev, :readonly?
 
     assert_nothing_raised do
       dev.name = "Luscious forbidden fruit."
@@ -54,7 +54,7 @@ class ReadOnlyTest < ActiveRecord::TestCase
 
   def test_has_many_find_readonly
     post = Post.find(1)
-    assert !post.comments.empty?
+    assert_not_empty post.comments
     assert !post.comments.any?(&:readonly?)
     assert !post.comments.to_a.any?(&:readonly?)
     assert post.comments.readonly(true).all?(&:readonly?)
@@ -66,44 +66,44 @@ class ReadOnlyTest < ActiveRecord::TestCase
   end
 
   def test_has_many_with_through_is_not_implicitly_marked_readonly_while_finding_by_id
-    assert !posts(:welcome).people.find(1).readonly?
+    assert_not_predicate posts(:welcome).people.find(1), :readonly?
   end
 
   def test_has_many_with_through_is_not_implicitly_marked_readonly_while_finding_first
-    assert !posts(:welcome).people.first.readonly?
+    assert_not_predicate posts(:welcome).people.first, :readonly?
   end
 
   def test_has_many_with_through_is_not_implicitly_marked_readonly_while_finding_last
-    assert !posts(:welcome).people.last.readonly?
+    assert_not_predicate posts(:welcome).people.last, :readonly?
   end
 
   def test_readonly_scoping
     Post.where("1=1").scoping do
-      assert !Post.find(1).readonly?
-      assert Post.readonly(true).find(1).readonly?
-      assert !Post.readonly(false).find(1).readonly?
+      assert_not_predicate Post.find(1), :readonly?
+      assert_predicate Post.readonly(true).find(1), :readonly?
+      assert_not_predicate Post.readonly(false).find(1), :readonly?
     end
 
     Post.joins("   ").scoping do
-      assert !Post.find(1).readonly?
-      assert Post.readonly.find(1).readonly?
-      assert !Post.readonly(false).find(1).readonly?
+      assert_not_predicate Post.find(1), :readonly?
+      assert_predicate Post.readonly.find(1), :readonly?
+      assert_not_predicate Post.readonly(false).find(1), :readonly?
     end
 
     # Oracle barfs on this because the join includes unqualified and
     # conflicting column names
     unless current_adapter?(:OracleAdapter)
       Post.joins(", developers").scoping do
-        assert_not Post.find(1).readonly?
-        assert Post.readonly.find(1).readonly?
-        assert !Post.readonly(false).find(1).readonly?
+        assert_not_predicate Post.find(1), :readonly?
+        assert_predicate Post.readonly.find(1), :readonly?
+        assert_not_predicate Post.readonly(false).find(1), :readonly?
       end
     end
 
     Post.readonly(true).scoping do
-      assert Post.find(1).readonly?
-      assert Post.readonly.find(1).readonly?
-      assert !Post.readonly(false).find(1).readonly?
+      assert_predicate Post.find(1), :readonly?
+      assert_predicate Post.readonly.find(1), :readonly?
+      assert_not_predicate Post.readonly(false).find(1), :readonly?
     end
   end
 
@@ -111,10 +111,10 @@ class ReadOnlyTest < ActiveRecord::TestCase
     developer = Developer.find(1)
     project   = Post.find(1)
 
-    assert !developer.projects.all_as_method.first.readonly?
-    assert !developer.projects.all_as_scope.first.readonly?
+    assert_not_predicate developer.projects.all_as_method.first, :readonly?
+    assert_not_predicate developer.projects.all_as_scope.first, :readonly?
 
-    assert !project.comments.all_as_method.first.readonly?
-    assert !project.comments.all_as_scope.first.readonly?
+    assert_not_predicate project.comments.all_as_method.first, :readonly?
+    assert_not_predicate project.comments.all_as_scope.first, :readonly?
   end
 end
diff --git a/activerecord/test/cases/reaper_test.rb b/activerecord/test/cases/reaper_test.rb
index 6c7727ab1b..61cb0f130d 100644
--- a/activerecord/test/cases/reaper_test.rb
+++ b/activerecord/test/cases/reaper_test.rb
@@ -79,14 +79,14 @@ module ActiveRecord
         end
         Thread.pass while conn.nil?
 
-        assert conn.in_use?
+        assert_predicate conn, :in_use?
 
         child.terminate
 
         while conn.in_use?
           Thread.pass
         end
-        assert !conn.in_use?
+        assert_not_predicate conn, :in_use?
       end
     end
   end
diff --git a/activerecord/test/cases/reflection_test.rb b/activerecord/test/cases/reflection_test.rb
index e78c3cee8a..ee343ba380 100644
--- a/activerecord/test/cases/reflection_test.rb
+++ b/activerecord/test/cases/reflection_test.rb
@@ -149,7 +149,7 @@ class ReflectionTest < ActiveRecord::TestCase
     expected = Pirate.reflect_on_all_associations.select { |r| r.options[:autosave] }
     received = Pirate.reflect_on_all_autosave_associations
 
-    assert !received.empty?
+    assert_not_empty received
     assert_not_equal Pirate.reflect_on_all_associations.length, received.length
     assert_equal expected, received
   end
@@ -301,12 +301,12 @@ class ReflectionTest < ActiveRecord::TestCase
   end
 
   def test_nested?
-    assert !Author.reflect_on_association(:comments).nested?
-    assert Author.reflect_on_association(:tags).nested?
+    assert_not_predicate Author.reflect_on_association(:comments), :nested?
+    assert_predicate Author.reflect_on_association(:tags), :nested?
 
     # Only goes :through once, but the through_reflection is a has_and_belongs_to_many, so this is
     # a nested through association
-    assert Category.reflect_on_association(:post_comments).nested?
+    assert_predicate Category.reflect_on_association(:post_comments), :nested?
   end
 
   def test_association_primary_key
@@ -354,36 +354,36 @@ class ReflectionTest < ActiveRecord::TestCase
   end
 
   def test_collection_association
-    assert Pirate.reflect_on_association(:birds).collection?
-    assert Pirate.reflect_on_association(:parrots).collection?
+    assert_predicate Pirate.reflect_on_association(:birds), :collection?
+    assert_predicate Pirate.reflect_on_association(:parrots), :collection?
 
-    assert !Pirate.reflect_on_association(:ship).collection?
-    assert !Ship.reflect_on_association(:pirate).collection?
+    assert_not_predicate Pirate.reflect_on_association(:ship), :collection?
+    assert_not_predicate Ship.reflect_on_association(:pirate), :collection?
   end
 
   def test_default_association_validation
-    assert ActiveRecord::Reflection.create(:has_many, :clients, nil, {}, Firm).validate?
+    assert_predicate ActiveRecord::Reflection.create(:has_many, :clients, nil, {}, Firm), :validate?
 
-    assert !ActiveRecord::Reflection.create(:has_one, :client, nil, {}, Firm).validate?
-    assert !ActiveRecord::Reflection.create(:belongs_to, :client, nil, {}, Firm).validate?
+    assert_not_predicate ActiveRecord::Reflection.create(:has_one, :client, nil, {}, Firm), :validate?
+    assert_not_predicate ActiveRecord::Reflection.create(:belongs_to, :client, nil, {}, Firm), :validate?
   end
 
   def test_always_validate_association_if_explicit
-    assert ActiveRecord::Reflection.create(:has_one, :client, nil, { validate: true }, Firm).validate?
-    assert ActiveRecord::Reflection.create(:belongs_to, :client, nil, { validate: true }, Firm).validate?
-    assert ActiveRecord::Reflection.create(:has_many, :clients, nil, { validate: true }, Firm).validate?
+    assert_predicate ActiveRecord::Reflection.create(:has_one, :client, nil, { validate: true }, Firm), :validate?
+    assert_predicate ActiveRecord::Reflection.create(:belongs_to, :client, nil, { validate: true }, Firm), :validate?
+    assert_predicate ActiveRecord::Reflection.create(:has_many, :clients, nil, { validate: true }, Firm), :validate?
   end
 
   def test_validate_association_if_autosave
-    assert ActiveRecord::Reflection.create(:has_one, :client, nil, { autosave: true }, Firm).validate?
-    assert ActiveRecord::Reflection.create(:belongs_to, :client, nil, { autosave: true }, Firm).validate?
-    assert ActiveRecord::Reflection.create(:has_many, :clients, nil, { autosave: true }, Firm).validate?
+    assert_predicate ActiveRecord::Reflection.create(:has_one, :client, nil, { autosave: true }, Firm), :validate?
+    assert_predicate ActiveRecord::Reflection.create(:belongs_to, :client, nil, { autosave: true }, Firm), :validate?
+    assert_predicate ActiveRecord::Reflection.create(:has_many, :clients, nil, { autosave: true }, Firm), :validate?
   end
 
   def test_never_validate_association_if_explicit
-    assert !ActiveRecord::Reflection.create(:has_one, :client, nil, { autosave: true, validate: false }, Firm).validate?
-    assert !ActiveRecord::Reflection.create(:belongs_to, :client, nil, { autosave: true, validate: false }, Firm).validate?
-    assert !ActiveRecord::Reflection.create(:has_many, :clients, nil, { autosave: true, validate: false }, Firm).validate?
+    assert_not_predicate ActiveRecord::Reflection.create(:has_one, :client, nil, { autosave: true, validate: false }, Firm), :validate?
+    assert_not_predicate ActiveRecord::Reflection.create(:belongs_to, :client, nil, { autosave: true, validate: false }, Firm), :validate?
+    assert_not_predicate ActiveRecord::Reflection.create(:has_many, :clients, nil, { autosave: true, validate: false }, Firm), :validate?
   end
 
   def test_foreign_key
diff --git a/activerecord/test/cases/relation/merging_test.rb b/activerecord/test/cases/relation/merging_test.rb
index f31df40c91..074ce9454f 100644
--- a/activerecord/test/cases/relation/merging_test.rb
+++ b/activerecord/test/cases/relation/merging_test.rb
@@ -58,7 +58,7 @@ class RelationMergingTest < ActiveRecord::TestCase
 
   def test_relation_merging_with_locks
     devs = Developer.lock.where("salary >= 80000").order("id DESC").merge(Developer.limit(2))
-    assert devs.locked?
+    assert_predicate devs, :locked?
   end
 
   def test_relation_merging_with_preload
@@ -113,9 +113,9 @@ class RelationMergingTest < ActiveRecord::TestCase
 
   def test_merging_with_from_clause
     relation = Post.all
-    assert relation.from_clause.empty?
+    assert_empty relation.from_clause
     relation = relation.merge(Post.from("posts"))
-    refute relation.from_clause.empty?
+    assert_not_empty relation.from_clause
   end
 end
 
diff --git a/activerecord/test/cases/relation/mutation_test.rb b/activerecord/test/cases/relation/mutation_test.rb
index 932a4eca2c..1428b3e132 100644
--- a/activerecord/test/cases/relation/mutation_test.rb
+++ b/activerecord/test/cases/relation/mutation_test.rb
@@ -25,7 +25,7 @@ module ActiveRecord
     test "#order! with symbol prepends the table name" do
       assert relation.order!(:name).equal?(relation)
       node = relation.order_values.first
-      assert node.ascending?
+      assert_predicate node, :ascending?
       assert_equal :name, node.expr.name
       assert_equal "posts", node.expr.relation.name
     end
@@ -88,7 +88,7 @@ module ActiveRecord
       assert relation.reorder!(:name).equal?(relation)
       node = relation.order_values.first
 
-      assert node.ascending?
+      assert_predicate node, :ascending?
       assert_equal :name, node.expr.name
       assert_equal "posts", node.expr.relation.name
     end
diff --git a/activerecord/test/cases/relation/where_clause_test.rb b/activerecord/test/cases/relation/where_clause_test.rb
index e5eb159d36..8703d238a0 100644
--- a/activerecord/test/cases/relation/where_clause_test.rb
+++ b/activerecord/test/cases/relation/where_clause_test.rb
@@ -75,8 +75,8 @@ class ActiveRecord::Relation
     end
 
     test "a clause knows if it is empty" do
-      assert WhereClause.empty.empty?
-      assert_not WhereClause.new(["anything"]).empty?
+      assert_empty WhereClause.empty
+      assert_not_empty WhereClause.new(["anything"])
     end
 
     test "invert cannot handle nil" do
diff --git a/activerecord/test/cases/relation_test.rb b/activerecord/test/cases/relation_test.rb
index 3d64bfb810..4e75371147 100644
--- a/activerecord/test/cases/relation_test.rb
+++ b/activerecord/test/cases/relation_test.rb
@@ -96,10 +96,10 @@ module ActiveRecord
 
     def test_empty_scope
       relation = Relation.new(Post)
-      assert relation.empty_scope?
+      assert_predicate relation, :empty_scope?
 
       relation.merge!(relation)
-      assert relation.empty_scope?
+      assert_predicate relation, :empty_scope?
     end
 
     def test_bad_constants_raise_errors
@@ -110,13 +110,13 @@ module ActiveRecord
 
     def test_empty_eager_loading?
       relation = Relation.new(FakeKlass)
-      assert !relation.eager_loading?
+      assert_not_predicate relation, :eager_loading?
     end
 
     def test_eager_load_values
       relation = Relation.new(FakeKlass)
       relation.eager_load! :b
-      assert relation.eager_loading?
+      assert_predicate relation, :eager_loading?
     end
 
     def test_references_values
@@ -242,10 +242,10 @@ module ActiveRecord
 
     def test_respond_to_for_non_selected_element
       post = Post.select(:title).first
-      assert_equal false, post.respond_to?(:body), "post should not respond_to?(:body) since invoking it raises exception"
+      assert_not_respond_to post, :body, "post should not respond_to?(:body) since invoking it raises exception"
 
       silence_warnings { post = Post.select("'title' as post_title").first }
-      assert_equal false, post.respond_to?(:title), "post should not respond_to?(:body) since invoking it raises exception"
+      assert_not_respond_to post, :title, "post should not respond_to?(:body) since invoking it raises exception"
     end
 
     def test_select_quotes_when_using_from_clause
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index 673ff95bc2..bc7c54dbe0 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -56,7 +56,7 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_dynamic_finder
     x = Post.where("author_id = ?", 1)
-    assert x.klass.respond_to?(:find_by_id), "@klass should handle dynamic finders"
+    assert_respond_to x.klass, :find_by_id
   end
 
   def test_multivalue_where
@@ -98,7 +98,7 @@ class RelationTest < ActiveRecord::TestCase
       2.times { assert_equal 5, topics.to_a.size }
     end
 
-    assert topics.loaded?
+    assert_predicate topics, :loaded?
   end
 
   def test_scoped_first
@@ -108,7 +108,7 @@ class RelationTest < ActiveRecord::TestCase
       2.times { assert_equal "The First Topic", topics.first.title }
     end
 
-    assert ! topics.loaded?
+    assert_not_predicate topics, :loaded?
   end
 
   def test_loaded_first
@@ -119,7 +119,7 @@ class RelationTest < ActiveRecord::TestCase
       assert_equal "The First Topic", topics.first.title
     end
 
-    assert topics.loaded?
+    assert_predicate topics, :loaded?
   end
 
   def test_loaded_first_with_limit
@@ -131,7 +131,7 @@ class RelationTest < ActiveRecord::TestCase
                     "The Second Topic of the day"], topics.first(2).map(&:title)
     end
 
-    assert topics.loaded?
+    assert_predicate topics, :loaded?
   end
 
   def test_first_get_more_than_available
@@ -152,14 +152,14 @@ class RelationTest < ActiveRecord::TestCase
       2.times { topics.to_a }
     end
 
-    assert topics.loaded?
+    assert_predicate topics, :loaded?
 
     original_size = topics.to_a.size
     Topic.create! title: "fake"
 
     assert_queries(1) { topics.reload }
     assert_equal original_size + 1, topics.size
-    assert topics.loaded?
+    assert_predicate topics, :loaded?
   end
 
   def test_finding_with_subquery
@@ -501,12 +501,12 @@ class RelationTest < ActiveRecord::TestCase
     relation = Topic.all
 
     ["find_by_title", "find_by_title_and_author_name"].each do |method|
-      assert_respond_to relation, method, "Topic.all should respond to #{method.inspect}"
+      assert_respond_to relation, method
     end
   end
 
   def test_respond_to_class_methods_and_scopes
-    assert Topic.all.respond_to?(:by_lifo)
+    assert_respond_to Topic.all, :by_lifo
   end
 
   def test_find_with_readonly_option
@@ -601,7 +601,7 @@ class RelationTest < ActiveRecord::TestCase
     reader = Reader.create! post_id: post.id, person_id: 1
     comment = Comment.create! post_id: post.id, body: "body"
 
-    assert !comment.respond_to?(:readers)
+    assert_not_respond_to comment, :readers
 
     post_rel = Post.preload(:readers).joins(:readers).where(title: "Uhuu")
     result_comment = Comment.joins(:post).merge(post_rel).to_a.first
@@ -722,7 +722,7 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_find_in_empty_array
     authors = Author.all.where(id: [])
-    assert authors.to_a.blank?
+    assert_predicate authors.to_a, :blank?
   end
 
   def test_where_with_ar_object
@@ -863,19 +863,19 @@ class RelationTest < ActiveRecord::TestCase
 
     # Force load
     assert_equal [authors(:david)], davids.to_a
-    assert davids.loaded?
+    assert_predicate davids, :loaded?
 
     assert_difference("Author.count", -1) { davids.destroy_all }
 
     assert_equal [], davids.to_a
-    assert davids.loaded?
+    assert_predicate davids, :loaded?
   end
 
   def test_delete_all
     davids = Author.where(name: "David")
 
     assert_difference("Author.count", -1) { davids.delete_all }
-    assert ! davids.loaded?
+    assert_not_predicate davids, :loaded?
   end
 
   def test_delete_all_loaded
@@ -883,12 +883,12 @@ class RelationTest < ActiveRecord::TestCase
 
     # Force load
     assert_equal [authors(:david)], davids.to_a
-    assert davids.loaded?
+    assert_predicate davids, :loaded?
 
     assert_difference("Author.count", -1) { davids.delete_all }
 
     assert_equal [], davids.to_a
-    assert davids.loaded?
+    assert_predicate davids, :loaded?
   end
 
   def test_delete_all_with_unpermitted_relation_raises_error
@@ -902,9 +902,9 @@ class RelationTest < ActiveRecord::TestCase
 
     assert_equal 11, posts.count(:all)
     assert_equal 11, posts.size
-    assert posts.any?
-    assert posts.many?
-    assert_not posts.empty?
+    assert_predicate posts, :any?
+    assert_predicate posts, :many?
+    assert_not_empty posts
   end
 
   def test_select_takes_a_variable_list_of_args
@@ -950,7 +950,7 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal author.posts.where(author_id: author.id).size, posts.count
 
     assert_equal 0, author.posts.where(author_id: another_author.id).size
-    assert author.posts.where(author_id: another_author.id).empty?
+    assert_empty author.posts.where(author_id: another_author.id)
   end
 
   def test_count_with_distinct
@@ -1006,7 +1006,7 @@ class RelationTest < ActiveRecord::TestCase
     posts = Post.all
 
     assert_queries(1) { assert_equal 11, posts.size }
-    assert ! posts.loaded?
+    assert_not_predicate posts, :loaded?
 
     best_posts = posts.where(comments_count: 0)
     best_posts.load # force load
@@ -1017,7 +1017,7 @@ class RelationTest < ActiveRecord::TestCase
     posts = Post.limit(10)
 
     assert_queries(1) { assert_equal 10, posts.size }
-    assert ! posts.loaded?
+    assert_not_predicate posts, :loaded?
 
     best_posts = posts.where(comments_count: 0)
     best_posts.load # force load
@@ -1028,7 +1028,7 @@ class RelationTest < ActiveRecord::TestCase
     posts = Post.limit(0)
 
     assert_no_queries { assert_equal 0, posts.size }
-    assert ! posts.loaded?
+    assert_not_predicate posts, :loaded?
 
     posts.load # force load
     assert_no_queries { assert_equal 0, posts.size }
@@ -1038,7 +1038,7 @@ class RelationTest < ActiveRecord::TestCase
     posts = Post.limit(0)
 
     assert_no_queries { assert_equal true, posts.empty? }
-    assert ! posts.loaded?
+    assert_not_predicate posts, :loaded?
   end
 
   def test_count_complex_chained_relations
@@ -1052,11 +1052,11 @@ class RelationTest < ActiveRecord::TestCase
     posts = Post.all
 
     assert_queries(1) { assert_equal false, posts.empty? }
-    assert ! posts.loaded?
+    assert_not_predicate posts, :loaded?
 
     no_posts = posts.where(title: "")
     assert_queries(1) { assert_equal true, no_posts.empty? }
-    assert ! no_posts.loaded?
+    assert_not_predicate no_posts, :loaded?
 
     best_posts = posts.where(comments_count: 0)
     best_posts.load # force load
@@ -1067,11 +1067,11 @@ class RelationTest < ActiveRecord::TestCase
     posts = Post.select("comments_count").where("id is not null").group("author_id").where("comments_count > 0")
 
     assert_queries(1) { assert_equal false, posts.empty? }
-    assert ! posts.loaded?
+    assert_not_predicate posts, :loaded?
 
     no_posts = posts.where(title: "")
     assert_queries(1) { assert_equal true, no_posts.empty? }
-    assert ! no_posts.loaded?
+    assert_not_predicate no_posts, :loaded?
   end
 
   def test_any
@@ -1087,13 +1087,13 @@ class RelationTest < ActiveRecord::TestCase
 
     assert_queries(3) do
       assert posts.any? # Uses COUNT()
-      assert ! posts.where(id: nil).any?
+      assert_not_predicate posts.where(id: nil), :any?
 
       assert posts.any? { |p| p.id > 0 }
       assert ! posts.any? { |p| p.id <= 0 }
     end
 
-    assert posts.loaded?
+    assert_predicate posts, :loaded?
   end
 
   def test_many
@@ -1105,14 +1105,14 @@ class RelationTest < ActiveRecord::TestCase
       assert ! posts.many? { |p| p.id < 2 }
     end
 
-    assert posts.loaded?
+    assert_predicate posts, :loaded?
   end
 
   def test_many_with_limits
     posts = Post.all
 
-    assert posts.many?
-    assert ! posts.limit(1).many?
+    assert_predicate posts, :many?
+    assert_not_predicate posts.limit(1), :many?
   end
 
   def test_none?
@@ -1121,14 +1121,14 @@ class RelationTest < ActiveRecord::TestCase
       assert ! posts.none? # Uses COUNT()
     end
 
-    assert ! posts.loaded?
+    assert_not_predicate posts, :loaded?
 
     assert_queries(1) do
       assert posts.none? { |p| p.id < 0 }
       assert ! posts.none? { |p| p.id == 1 }
     end
 
-    assert posts.loaded?
+    assert_predicate posts, :loaded?
   end
 
   def test_one
@@ -1137,14 +1137,14 @@ class RelationTest < ActiveRecord::TestCase
       assert ! posts.one? # Uses COUNT()
     end
 
-    assert ! posts.loaded?
+    assert_not_predicate posts, :loaded?
 
     assert_queries(1) do
       assert ! posts.one? { |p| p.id < 3 }
       assert posts.one? { |p| p.id == 1 }
     end
 
-    assert posts.loaded?
+    assert_predicate posts, :loaded?
   end
 
   def test_to_a_should_dup_target
@@ -1177,10 +1177,10 @@ class RelationTest < ActiveRecord::TestCase
 
     sparrow = birds.create
     assert_kind_of Bird, sparrow
-    assert !sparrow.persisted?
+    assert_not_predicate sparrow, :persisted?
 
     hen = birds.where(name: "hen").create
-    assert hen.persisted?
+    assert_predicate hen, :persisted?
     assert_equal "hen", hen.name
   end
 
@@ -1191,7 +1191,7 @@ class RelationTest < ActiveRecord::TestCase
 
     hen = birds.where(name: "hen").create!
     assert_kind_of Bird, hen
-    assert hen.persisted?
+    assert_predicate hen, :persisted?
     assert_equal "hen", hen.name
   end
 
@@ -1207,27 +1207,27 @@ class RelationTest < ActiveRecord::TestCase
   def test_first_or_create
     parrot = Bird.where(color: "green").first_or_create(name: "parrot")
     assert_kind_of Bird, parrot
-    assert parrot.persisted?
+    assert_predicate parrot, :persisted?
     assert_equal "parrot", parrot.name
     assert_equal "green", parrot.color
 
     same_parrot = Bird.where(color: "green").first_or_create(name: "parakeet")
     assert_kind_of Bird, same_parrot
-    assert same_parrot.persisted?
+    assert_predicate same_parrot, :persisted?
     assert_equal parrot, same_parrot
   end
 
   def test_first_or_create_with_no_parameters
     parrot = Bird.where(color: "green").first_or_create
     assert_kind_of Bird, parrot
-    assert !parrot.persisted?
+    assert_not_predicate parrot, :persisted?
     assert_equal "green", parrot.color
   end
 
   def test_first_or_create_with_block
     parrot = Bird.where(color: "green").first_or_create { |bird| bird.name = "parrot" }
     assert_kind_of Bird, parrot
-    assert parrot.persisted?
+    assert_predicate parrot, :persisted?
     assert_equal "green", parrot.color
     assert_equal "parrot", parrot.name
 
@@ -1248,13 +1248,13 @@ class RelationTest < ActiveRecord::TestCase
   def test_first_or_create_bang_with_valid_options
     parrot = Bird.where(color: "green").first_or_create!(name: "parrot")
     assert_kind_of Bird, parrot
-    assert parrot.persisted?
+    assert_predicate parrot, :persisted?
     assert_equal "parrot", parrot.name
     assert_equal "green", parrot.color
 
     same_parrot = Bird.where(color: "green").first_or_create!(name: "parakeet")
     assert_kind_of Bird, same_parrot
-    assert same_parrot.persisted?
+    assert_predicate same_parrot, :persisted?
     assert_equal parrot, same_parrot
   end
 
@@ -1269,7 +1269,7 @@ class RelationTest < ActiveRecord::TestCase
   def test_first_or_create_bang_with_valid_block
     parrot = Bird.where(color: "green").first_or_create! { |bird| bird.name = "parrot" }
     assert_kind_of Bird, parrot
-    assert parrot.persisted?
+    assert_predicate parrot, :persisted?
     assert_equal "green", parrot.color
     assert_equal "parrot", parrot.name
 
@@ -1300,9 +1300,9 @@ class RelationTest < ActiveRecord::TestCase
   def test_first_or_initialize
     parrot = Bird.where(color: "green").first_or_initialize(name: "parrot")
     assert_kind_of Bird, parrot
-    assert !parrot.persisted?
-    assert parrot.valid?
-    assert parrot.new_record?
+    assert_not_predicate parrot, :persisted?
+    assert_predicate parrot, :valid?
+    assert_predicate parrot, :new_record?
     assert_equal "parrot", parrot.name
     assert_equal "green", parrot.color
   end
@@ -1310,18 +1310,18 @@ class RelationTest < ActiveRecord::TestCase
   def test_first_or_initialize_with_no_parameters
     parrot = Bird.where(color: "green").first_or_initialize
     assert_kind_of Bird, parrot
-    assert !parrot.persisted?
-    assert !parrot.valid?
-    assert parrot.new_record?
+    assert_not_predicate parrot, :persisted?
+    assert_not_predicate parrot, :valid?
+    assert_predicate parrot, :new_record?
     assert_equal "green", parrot.color
   end
 
   def test_first_or_initialize_with_block
     parrot = Bird.where(color: "green").first_or_initialize { |bird| bird.name = "parrot" }
     assert_kind_of Bird, parrot
-    assert !parrot.persisted?
-    assert parrot.valid?
-    assert parrot.new_record?
+    assert_not_predicate parrot, :persisted?
+    assert_predicate parrot, :valid?
+    assert_predicate parrot, :new_record?
     assert_equal "green", parrot.color
     assert_equal "parrot", parrot.name
   end
@@ -1330,7 +1330,7 @@ class RelationTest < ActiveRecord::TestCase
     assert_nil Bird.find_by(name: "bob")
 
     bird = Bird.find_or_create_by(name: "bob")
-    assert bird.persisted?
+    assert_predicate bird, :persisted?
 
     assert_equal bird, Bird.find_or_create_by(name: "bob")
   end
@@ -1339,7 +1339,7 @@ class RelationTest < ActiveRecord::TestCase
     assert_nil Bird.find_by(name: "bob")
 
     bird = Bird.create_with(color: "green").find_or_create_by(name: "bob")
-    assert bird.persisted?
+    assert_predicate bird, :persisted?
     assert_equal "green", bird.color
 
     assert_equal bird, Bird.create_with(color: "blue").find_or_create_by(name: "bob")
@@ -1353,7 +1353,7 @@ class RelationTest < ActiveRecord::TestCase
     assert_nil Bird.find_by(name: "bob")
 
     bird = Bird.find_or_initialize_by(name: "bob")
-    assert bird.new_record?
+    assert_predicate bird, :new_record?
     bird.save!
 
     assert_equal bird, Bird.find_or_initialize_by(name: "bob")
@@ -1528,10 +1528,10 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_doesnt_add_having_values_if_options_are_blank
     scope = Post.having("")
-    assert scope.having_clause.empty?
+    assert_empty scope.having_clause
 
     scope = Post.having([])
-    assert scope.having_clause.empty?
+    assert_empty scope.having_clause
   end
 
   def test_having_with_binds_for_both_where_and_having
@@ -1557,13 +1557,13 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_references_triggers_eager_loading
     scope = Post.includes(:comments)
-    assert !scope.eager_loading?
-    assert scope.references(:comments).eager_loading?
+    assert_not_predicate scope, :eager_loading?
+    assert_predicate scope.references(:comments), :eager_loading?
   end
 
   def test_references_doesnt_trigger_eager_loading_if_reference_not_included
     scope = Post.references(:comments)
-    assert !scope.eager_loading?
+    assert_not_predicate scope, :eager_loading?
   end
 
   def test_automatically_added_where_references
@@ -1671,7 +1671,7 @@ class RelationTest < ActiveRecord::TestCase
     # count always trigger the COUNT query.
     assert_queries(1) { topics.count }
 
-    assert topics.loaded?
+    assert_predicate topics, :loaded?
   end
 
   test "find_by with hash conditions returns the first matching record" do
@@ -1846,7 +1846,7 @@ class RelationTest < ActiveRecord::TestCase
   test "delegations do not leak to other classes" do
     Topic.all.by_lifo
     assert Topic.all.class.method_defined?(:by_lifo)
-    assert !Post.all.respond_to?(:by_lifo)
+    assert_not_respond_to Post.all, :by_lifo
   end
 
   def test_unscope_with_subquery
@@ -1871,7 +1871,7 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_locked_should_not_build_arel
     posts = Post.locked
-    assert posts.locked?
+    assert_predicate posts, :locked?
     assert_nothing_raised { posts.lock!(false) }
   end
 
diff --git a/activerecord/test/cases/reserved_word_test.rb b/activerecord/test/cases/reserved_word_test.rb
index 4f8ca392b9..e32605fd11 100644
--- a/activerecord/test/cases/reserved_word_test.rb
+++ b/activerecord/test/cases/reserved_word_test.rb
@@ -116,7 +116,7 @@ class ReservedWordTest < ActiveRecord::TestCase
   end
 
   def test_activerecord_introspection
-    assert Group.table_exists?
+    assert_predicate Group, :table_exists?
     assert_equal ["id", "order", "select_id"], Group.columns.map(&:name).sort
   end
 
diff --git a/activerecord/test/cases/scoping/default_scoping_test.rb b/activerecord/test/cases/scoping/default_scoping_test.rb
index 6ff0f93cf3..0804de1fb3 100644
--- a/activerecord/test/cases/scoping/default_scoping_test.rb
+++ b/activerecord/test/cases/scoping/default_scoping_test.rb
@@ -302,8 +302,8 @@ class DefaultScopingTest < ActiveRecord::TestCase
 
   def test_unscope_merging
     merged = Developer.where(name: "Jamis").merge(Developer.unscope(:where))
-    assert merged.where_clause.empty?
-    assert !merged.where(name: "Jon").where_clause.empty?
+    assert_empty merged.where_clause
+    assert_not_empty merged.where(name: "Jon").where_clause
   end
 
   def test_order_in_default_scope_should_not_prevail
diff --git a/activerecord/test/cases/scoping/named_scoping_test.rb b/activerecord/test/cases/scoping/named_scoping_test.rb
index 17d3f27bb1..ea71a5ce28 100644
--- a/activerecord/test/cases/scoping/named_scoping_test.rb
+++ b/activerecord/test/cases/scoping/named_scoping_test.rb
@@ -13,7 +13,7 @@ class NamedScopingTest < ActiveRecord::TestCase
   fixtures :posts, :authors, :topics, :comments, :author_addresses
 
   def test_implements_enumerable
-    assert !Topic.all.empty?
+    assert_not_empty Topic.all
 
     assert_equal Topic.all.to_a, Topic.base
     assert_equal Topic.all.to_a, Topic.base.to_a
@@ -40,7 +40,7 @@ class NamedScopingTest < ActiveRecord::TestCase
   end
 
   def test_delegates_finds_and_calculations_to_the_base_class
-    assert !Topic.all.empty?
+    assert_not_empty Topic.all
 
     assert_equal Topic.all.to_a,                Topic.base.to_a
     assert_equal Topic.first,                   Topic.base.first
@@ -65,13 +65,13 @@ class NamedScopingTest < ActiveRecord::TestCase
   end
 
   def test_scope_should_respond_to_own_methods_and_methods_of_the_proxy
-    assert Topic.approved.respond_to?(:limit)
-    assert Topic.approved.respond_to?(:count)
-    assert Topic.approved.respond_to?(:length)
+    assert_respond_to Topic.approved, :limit
+    assert_respond_to Topic.approved, :count
+    assert_respond_to Topic.approved, :length
   end
 
   def test_scopes_with_options_limit_finds_to_those_matching_the_criteria_specified
-    assert !Topic.all.merge!(where: { approved: true }).to_a.empty?
+    assert_not_empty Topic.all.merge!(where: { approved: true }).to_a
 
     assert_equal Topic.all.merge!(where: { approved: true }).to_a, Topic.approved
     assert_equal Topic.where(approved: true).count, Topic.approved.count
@@ -87,7 +87,7 @@ class NamedScopingTest < ActiveRecord::TestCase
     assert_equal((approved = Topic.all.merge!(where: { approved: true }).to_a), Topic.approved)
     assert_equal((replied = Topic.all.merge!(where: "replies_count > 0").to_a), Topic.replied)
     assert !(approved == replied)
-    assert !(approved & replied).empty?
+    assert_not_empty (approved & replied)
 
     assert_equal approved & replied, Topic.approved.replied
   end
@@ -115,7 +115,7 @@ class NamedScopingTest < ActiveRecord::TestCase
 
   def test_has_many_associations_have_access_to_scopes
     assert_not_equal Post.containing_the_letter_a, authors(:david).posts
-    assert !Post.containing_the_letter_a.empty?
+    assert_not_empty Post.containing_the_letter_a
 
     expected = authors(:david).posts & Post.containing_the_letter_a
     assert_equal expected.sort_by(&:id), authors(:david).posts.containing_the_letter_a.sort_by(&:id)
@@ -128,15 +128,15 @@ class NamedScopingTest < ActiveRecord::TestCase
 
   def test_has_many_through_associations_have_access_to_scopes
     assert_not_equal Comment.containing_the_letter_e, authors(:david).comments
-    assert !Comment.containing_the_letter_e.empty?
+    assert_not_empty Comment.containing_the_letter_e
 
     expected = authors(:david).comments & Comment.containing_the_letter_e
     assert_equal expected.sort_by(&:id), authors(:david).comments.containing_the_letter_e.sort_by(&:id)
   end
 
   def test_scopes_honor_current_scopes_from_when_defined
-    assert !Post.ranked_by_comments.limit_by(5).empty?
-    assert !authors(:david).posts.ranked_by_comments.limit_by(5).empty?
+    assert_not_empty Post.ranked_by_comments.limit_by(5)
+    assert_not_empty authors(:david).posts.ranked_by_comments.limit_by(5)
     assert_not_equal Post.ranked_by_comments.limit_by(5), authors(:david).posts.ranked_by_comments.limit_by(5)
     assert_not_equal Post.top(5), authors(:david).posts.top(5)
     # Oracle sometimes sorts differently if WHERE condition is changed
@@ -168,14 +168,14 @@ class NamedScopingTest < ActiveRecord::TestCase
   end
 
   def test_active_records_have_scope_named__all__
-    assert !Topic.all.empty?
+    assert_not_empty Topic.all
 
     assert_equal Topic.all.to_a, Topic.base
   end
 
   def test_active_records_have_scope_named__scoped__
     scope = Topic.where("content LIKE '%Have%'")
-    assert !scope.empty?
+    assert_not_empty scope
 
     assert_equal scope, Topic.all.merge!(where: "content LIKE '%Have%'")
   end
@@ -228,9 +228,9 @@ class NamedScopingTest < ActiveRecord::TestCase
   end
 
   def test_model_class_should_respond_to_any
-    assert Topic.any?
+    assert_predicate Topic, :any?
     Topic.delete_all
-    assert !Topic.any?
+    assert_not_predicate Topic, :any?
   end
 
   def test_many_should_not_load_results
@@ -259,22 +259,22 @@ class NamedScopingTest < ActiveRecord::TestCase
 
   def test_many_should_return_false_if_none_or_one
     topics = Topic.base.where(id: 0)
-    assert !topics.many?
+    assert_not_predicate topics, :many?
     topics = Topic.base.where(id: 1)
-    assert !topics.many?
+    assert_not_predicate topics, :many?
   end
 
   def test_many_should_return_true_if_more_than_one
-    assert Topic.base.many?
+    assert_predicate Topic.base, :many?
   end
 
   def test_model_class_should_respond_to_many
     Topic.delete_all
-    assert !Topic.many?
+    assert_not_predicate Topic, :many?
     Topic.create!
-    assert !Topic.many?
+    assert_not_predicate Topic, :many?
     Topic.create!
-    assert Topic.many?
+    assert_predicate Topic, :many?
   end
 
   def test_should_build_on_top_of_scope
@@ -423,16 +423,16 @@ class NamedScopingTest < ActiveRecord::TestCase
 
   def test_chaining_applies_last_conditions_when_creating
     post = Topic.rejected.new
-    assert !post.approved?
+    assert_not_predicate post, :approved?
 
     post = Topic.rejected.approved.new
-    assert post.approved?
+    assert_predicate post, :approved?
 
     post = Topic.approved.rejected.new
-    assert !post.approved?
+    assert_not_predicate post, :approved?
 
     post = Topic.approved.rejected.approved.new
-    assert post.approved?
+    assert_predicate post, :approved?
   end
 
   def test_chaining_combines_conditions_when_searching
@@ -498,7 +498,7 @@ class NamedScopingTest < ActiveRecord::TestCase
   def test_index_on_scope
     approved = Topic.approved.order("id ASC")
     assert_equal topics(:second), approved[0]
-    assert approved.loaded?
+    assert_predicate approved, :loaded?
   end
 
   def test_nested_scopes_queries_size
@@ -578,16 +578,16 @@ class NamedScopingTest < ActiveRecord::TestCase
   end
 
   def test_model_class_should_respond_to_none
-    assert !Topic.none?
+    assert_not_predicate Topic, :none?
     Topic.delete_all
-    assert Topic.none?
+    assert_predicate Topic, :none?
   end
 
   def test_model_class_should_respond_to_one
-    assert !Topic.one?
+    assert_not_predicate Topic, :one?
     Topic.delete_all
-    assert !Topic.one?
+    assert_not_predicate Topic, :one?
     Topic.create!
-    assert Topic.one?
+    assert_predicate Topic, :one?
   end
 end
diff --git a/activerecord/test/cases/scoping/relation_scoping_test.rb b/activerecord/test/cases/scoping/relation_scoping_test.rb
index 116f8e83aa..5c86bc892d 100644
--- a/activerecord/test/cases/scoping/relation_scoping_test.rb
+++ b/activerecord/test/cases/scoping/relation_scoping_test.rb
@@ -213,21 +213,21 @@ class RelationScopingTest < ActiveRecord::TestCase
 
   def test_current_scope_does_not_pollute_sibling_subclasses
     Comment.none.scoping do
-      assert_not SpecialComment.all.any?
-      assert_not VerySpecialComment.all.any?
-      assert_not SubSpecialComment.all.any?
+      assert_not_predicate SpecialComment.all, :any?
+      assert_not_predicate VerySpecialComment.all, :any?
+      assert_not_predicate SubSpecialComment.all, :any?
     end
 
     SpecialComment.none.scoping do
-      assert Comment.all.any?
-      assert VerySpecialComment.all.any?
-      assert_not SubSpecialComment.all.any?
+      assert_predicate Comment.all, :any?
+      assert_predicate VerySpecialComment.all, :any?
+      assert_not_predicate SubSpecialComment.all, :any?
     end
 
     SubSpecialComment.none.scoping do
-      assert Comment.all.any?
-      assert VerySpecialComment.all.any?
-      assert SpecialComment.all.any?
+      assert_predicate Comment.all, :any?
+      assert_predicate VerySpecialComment.all, :any?
+      assert_predicate SpecialComment.all, :any?
     end
   end
 
@@ -334,7 +334,7 @@ class NestedRelationScopingTest < ActiveRecord::TestCase
   def test_nested_exclusive_scope_for_create
     comment = Comment.create_with(body: "Hey guys, nested scopes are broken. Please fix!").scoping do
       Comment.unscoped.create_with(post_id: 1).scoping do
-        assert Comment.new.body.blank?
+        assert_predicate Comment.new.body, :blank?
         Comment.create body: "Hey guys"
       end
     end
diff --git a/activerecord/test/cases/serialized_attribute_test.rb b/activerecord/test/cases/serialized_attribute_test.rb
index 32dafbd458..7de5429cbb 100644
--- a/activerecord/test/cases/serialized_attribute_test.rb
+++ b/activerecord/test/cases/serialized_attribute_test.rb
@@ -279,7 +279,7 @@ class SerializedAttributeTest < ActiveRecord::TestCase
 
     topic = Topic.new(content: nil)
 
-    assert_not topic.content_changed?
+    assert_not_predicate topic, :content_changed?
   end
 
   def test_classes_without_no_arg_constructors_are_not_supported
@@ -349,7 +349,7 @@ class SerializedAttributeTest < ActiveRecord::TestCase
 
     topic = model.create!(foo: "bar")
     topic.foo
-    refute topic.changed?
+    assert_not_predicate topic, :changed?
   end
 
   def test_serialized_attribute_works_under_concurrent_initial_access
diff --git a/activerecord/test/cases/store_test.rb b/activerecord/test/cases/store_test.rb
index ebf4016960..a30d13632a 100644
--- a/activerecord/test/cases/store_test.rb
+++ b/activerecord/test/cases/store_test.rb
@@ -45,7 +45,7 @@ class StoreTest < ActiveRecord::TestCase
 
   test "updating the store will mark it as changed" do
     @john.color = "red"
-    assert @john.settings_changed?
+    assert_predicate @john, :settings_changed?
   end
 
   test "updating the store populates the changed array correctly" do
@@ -56,7 +56,7 @@ class StoreTest < ActiveRecord::TestCase
 
   test "updating the store won't mark it as changed if an attribute isn't changed" do
     @john.color = @john.color
-    assert !@john.settings_changed?
+    assert_not_predicate @john, :settings_changed?
   end
 
   test "object initialization with not nullable column" do
@@ -137,7 +137,7 @@ class StoreTest < ActiveRecord::TestCase
 
   test "updating the store will mark it as changed encoded with JSON" do
     @john.height = "short"
-    assert @john.json_data_changed?
+    assert_predicate @john, :json_data_changed?
   end
 
   test "object initialization with not nullable column encoded with JSON" do
diff --git a/activerecord/test/cases/timestamp_test.rb b/activerecord/test/cases/timestamp_test.rb
index 54e3f47e16..e95446c0a7 100644
--- a/activerecord/test/cases/timestamp_test.rb
+++ b/activerecord/test/cases/timestamp_test.rb
@@ -139,13 +139,13 @@ class TimestampTest < ActiveRecord::TestCase
 
   def test_touching_a_no_touching_object
     Developer.no_touching do
-      assert @developer.no_touching?
-      assert !@owner.no_touching?
+      assert_predicate @developer, :no_touching?
+      assert_not_predicate @owner, :no_touching?
       @developer.touch
     end
 
-    assert !@developer.no_touching?
-    assert !@owner.no_touching?
+    assert_not_predicate @developer, :no_touching?
+    assert_not_predicate @owner, :no_touching?
     assert_equal @previously_updated_at, @developer.updated_at
   end
 
@@ -162,26 +162,26 @@ class TimestampTest < ActiveRecord::TestCase
 
   def test_global_no_touching
     ActiveRecord::Base.no_touching do
-      assert @developer.no_touching?
-      assert @owner.no_touching?
+      assert_predicate @developer, :no_touching?
+      assert_predicate @owner, :no_touching?
       @developer.touch
     end
 
-    assert !@developer.no_touching?
-    assert !@owner.no_touching?
+    assert_not_predicate @developer, :no_touching?
+    assert_not_predicate @owner, :no_touching?
     assert_equal @previously_updated_at, @developer.updated_at
   end
 
   def test_no_touching_threadsafe
     Thread.new do
       Developer.no_touching do
-        assert @developer.no_touching?
+        assert_predicate @developer, :no_touching?
 
         sleep(1)
       end
     end
 
-    assert !@developer.no_touching?
+    assert_not_predicate @developer, :no_touching?
   end
 
   def test_no_touching_with_callbacks
@@ -237,7 +237,7 @@ class TimestampTest < ActiveRecord::TestCase
     pet = Pet.new(owner: klass.new)
     pet.save!
 
-    assert pet.owner.new_record?
+    assert_predicate pet.owner, :new_record?
   end
 
   def test_saving_a_record_with_a_belongs_to_that_specifies_touching_a_specific_attribute_the_parent_should_update_that_attribute
diff --git a/activerecord/test/cases/touch_later_test.rb b/activerecord/test/cases/touch_later_test.rb
index 1757031371..925a4609a2 100644
--- a/activerecord/test/cases/touch_later_test.rb
+++ b/activerecord/test/cases/touch_later_test.rb
@@ -13,7 +13,7 @@ class TouchLaterTest < ActiveRecord::TestCase
   def test_touch_laster_raise_if_non_persisted
     invoice = Invoice.new
     Invoice.transaction do
-      assert_not invoice.persisted?
+      assert_not_predicate invoice, :persisted?
       assert_raises(ActiveRecord::ActiveRecordError) do
         invoice.touch_later
       end
@@ -23,7 +23,7 @@ class TouchLaterTest < ActiveRecord::TestCase
   def test_touch_later_dont_set_dirty_attributes
     invoice = Invoice.create!
     invoice.touch_later
-    assert_not invoice.changed?
+    assert_not_predicate invoice, :changed?
   end
 
   def test_touch_later_respects_no_touching_policy
diff --git a/activerecord/test/cases/transaction_callbacks_test.rb b/activerecord/test/cases/transaction_callbacks_test.rb
index 1f370a80ee..1c7cec4dad 100644
--- a/activerecord/test/cases/transaction_callbacks_test.rb
+++ b/activerecord/test/cases/transaction_callbacks_test.rb
@@ -158,13 +158,13 @@ class TransactionCallbacksTest < ActiveRecord::TestCase
 
   def test_only_call_after_commit_on_top_level_transactions
     @first.after_commit_block { |r| r.history << :after_commit }
-    assert @first.history.empty?
+    assert_empty @first.history
 
     @first.transaction do
       @first.transaction(requires_new: true) do
         @first.touch
       end
-      assert @first.history.empty?
+      assert_empty @first.history
     end
     assert_equal [:after_commit], @first.history
   end
@@ -518,7 +518,7 @@ class TransactionEnrollmentCallbacksTest < ActiveRecord::TestCase
       @topic.content = "foo"
       @topic.save!
     end
-    assert @topic.history.empty?
+    assert_empty @topic.history
   end
 
   def test_commit_run_transactions_callbacks_with_explicit_enrollment
@@ -538,7 +538,7 @@ class TransactionEnrollmentCallbacksTest < ActiveRecord::TestCase
       @topic.save!
       raise ActiveRecord::Rollback
     end
-    assert @topic.history.empty?
+    assert_empty @topic.history
   end
 
   def test_rollback_run_transactions_callbacks_with_explicit_enrollment
diff --git a/activerecord/test/cases/transactions_test.rb b/activerecord/test/cases/transactions_test.rb
index c110fa2f7d..c70286d52a 100644
--- a/activerecord/test/cases/transactions_test.rb
+++ b/activerecord/test/cases/transactions_test.rb
@@ -20,22 +20,22 @@ class TransactionTest < ActiveRecord::TestCase
 
   def test_persisted_in_a_model_with_custom_primary_key_after_failed_save
     movie = Movie.create
-    assert !movie.persisted?
+    assert_not_predicate movie, :persisted?
   end
 
   def test_raise_after_destroy
-    assert_not @first.frozen?
+    assert_not_predicate @first, :frozen?
 
     assert_raises(RuntimeError) {
       Topic.transaction do
         @first.destroy
-        assert @first.frozen?
+        assert_predicate @first, :frozen?
         raise
       end
     }
 
     assert @first.reload
-    assert_not @first.frozen?
+    assert_not_predicate @first, :frozen?
   end
 
   def test_successful
@@ -152,7 +152,7 @@ class TransactionTest < ActiveRecord::TestCase
     @first.approved = true
     e = assert_raises(RuntimeError) { @first.save }
     assert_equal "Make the transaction rollback", e.message
-    assert !Topic.find(1).approved?
+    assert_not_predicate Topic.find(1), :approved?
   end
 
   def test_rolling_back_in_a_callback_rollbacks_before_save
@@ -186,7 +186,7 @@ class TransactionTest < ActiveRecord::TestCase
     author = Author.create! name: "foo"
     author.name = nil
     assert_not author.save
-    assert_not author.new_record?
+    assert_not_predicate author, :new_record?
   end
 
   def test_update_should_rollback_on_failure
@@ -417,8 +417,8 @@ class TransactionTest < ActiveRecord::TestCase
       end
     end
 
-    assert @first.reload.approved?
-    assert !@second.reload.approved?
+    assert_predicate @first.reload, :approved?
+    assert_not_predicate @second.reload, :approved?
   end if Topic.connection.supports_savepoints?
 
   def test_force_savepoint_on_instance
@@ -438,8 +438,8 @@ class TransactionTest < ActiveRecord::TestCase
       end
     end
 
-    assert @first.reload.approved?
-    assert !@second.reload.approved?
+    assert_predicate @first.reload, :approved?
+    assert_not_predicate @second.reload, :approved?
   end if Topic.connection.supports_savepoints?
 
   def test_no_savepoint_in_nested_transaction_without_force
@@ -459,8 +459,8 @@ class TransactionTest < ActiveRecord::TestCase
       end
     end
 
-    assert !@first.reload.approved?
-    assert !@second.reload.approved?
+    assert_not_predicate @first.reload, :approved?
+    assert_not_predicate @second.reload, :approved?
   end if Topic.connection.supports_savepoints?
 
   def test_many_savepoints
@@ -516,12 +516,12 @@ class TransactionTest < ActiveRecord::TestCase
       @first.approved = false
       @first.save!
       Topic.connection.rollback_to_savepoint("first")
-      assert @first.reload.approved?
+      assert_predicate @first.reload, :approved?
 
       @first.approved = false
       @first.save!
       Topic.connection.release_savepoint("first")
-      assert_not @first.reload.approved?
+      assert_not_predicate @first.reload, :approved?
     end
   end if Topic.connection.supports_savepoints?
 
@@ -663,8 +663,8 @@ class TransactionTest < ActiveRecord::TestCase
       raise ActiveRecord::Rollback
     end
 
-    assert_not reply.frozen?
-    assert_not topic.frozen?
+    assert_not_predicate reply, :frozen?
+    assert_not_predicate topic, :frozen?
   end
 
   def test_restore_id_after_rollback
@@ -819,28 +819,28 @@ class TransactionTest < ActiveRecord::TestCase
     connection = Topic.connection
     transaction = ActiveRecord::ConnectionAdapters::TransactionManager.new(connection).begin_transaction
 
-    assert transaction.open?
-    assert !transaction.state.rolledback?
-    assert !transaction.state.committed?
+    assert_predicate transaction, :open?
+    assert_not_predicate transaction.state, :rolledback?
+    assert_not_predicate transaction.state, :committed?
 
     transaction.rollback
 
-    assert transaction.state.rolledback?
-    assert !transaction.state.committed?
+    assert_predicate transaction.state, :rolledback?
+    assert_not_predicate transaction.state, :committed?
   end
 
   def test_transactions_state_from_commit
     connection = Topic.connection
     transaction = ActiveRecord::ConnectionAdapters::TransactionManager.new(connection).begin_transaction
 
-    assert transaction.open?
-    assert !transaction.state.rolledback?
-    assert !transaction.state.committed?
+    assert_predicate transaction, :open?
+    assert_not_predicate transaction.state, :rolledback?
+    assert_not_predicate transaction.state, :committed?
 
     transaction.commit
 
-    assert !transaction.state.rolledback?
-    assert transaction.state.committed?
+    assert_not_predicate transaction.state, :rolledback?
+    assert_predicate transaction.state, :committed?
   end
 
   def test_set_state_method_is_deprecated
@@ -929,7 +929,7 @@ class TransactionsWithTransactionalFixturesTest < ActiveRecord::TestCase
         raise
       end
     rescue
-      assert !@first.reload.approved?
+      assert_not_predicate @first.reload, :approved?
     end
   end
 
@@ -950,7 +950,7 @@ class TransactionsWithTransactionalFixturesTest < ActiveRecord::TestCase
       end
     end
 
-    assert !@first.reload.approved?
+    assert_not_predicate @first.reload, :approved?
   end
 end if Topic.connection.supports_savepoints?
 
diff --git a/activerecord/test/cases/type/string_test.rb b/activerecord/test/cases/type/string_test.rb
index 8c51b30fdd..9e7810a6a5 100644
--- a/activerecord/test/cases/type/string_test.rb
+++ b/activerecord/test/cases/type/string_test.rb
@@ -9,16 +9,16 @@ module ActiveRecord
       klass.table_name = "authors"
 
       author = klass.create!(name: "Sean")
-      assert_not author.changed?
+      assert_not_predicate author, :changed?
 
       author.name << " Griffin"
-      assert author.name_changed?
+      assert_predicate author, :name_changed?
 
       author.save!
       author.reload
 
       assert_equal "Sean Griffin", author.name
-      assert_not author.changed?
+      assert_not_predicate author, :changed?
     end
   end
 end
diff --git a/activerecord/test/cases/validations/absence_validation_test.rb b/activerecord/test/cases/validations/absence_validation_test.rb
index a997f8be9c..8235a54d8a 100644
--- a/activerecord/test/cases/validations/absence_validation_test.rb
+++ b/activerecord/test/cases/validations/absence_validation_test.rb
@@ -13,8 +13,8 @@ class AbsenceValidationTest < ActiveRecord::TestCase
       validates_absence_of :name
     end
 
-    assert boy_klass.new.valid?
-    assert_not boy_klass.new(name: "Alex").valid?
+    assert_predicate boy_klass.new, :valid?
+    assert_not_predicate boy_klass.new(name: "Alex"), :valid?
   end
 
   def test_has_one_marked_for_destruction
@@ -44,7 +44,7 @@ class AbsenceValidationTest < ActiveRecord::TestCase
     assert_not boy.valid?, "should not be valid if has_many association is present"
 
     i2.mark_for_destruction
-    assert boy.valid?
+    assert_predicate boy, :valid?
   end
 
   def test_does_not_call_to_a_on_associations
@@ -65,11 +65,11 @@ class AbsenceValidationTest < ActiveRecord::TestCase
       Interest.validates_absence_of(:token)
 
       interest = Interest.create!(topic: "Thought Leadering")
-      assert interest.valid?
+      assert_predicate interest, :valid?
 
       interest.token = "tl"
 
-      assert interest.invalid?
+      assert_predicate interest, :invalid?
     end
   end
 end
diff --git a/activerecord/test/cases/validations/association_validation_test.rb b/activerecord/test/cases/validations/association_validation_test.rb
index 80fe375ae5..ce6d42b34b 100644
--- a/activerecord/test/cases/validations/association_validation_test.rb
+++ b/activerecord/test/cases/validations/association_validation_test.rb
@@ -16,14 +16,14 @@ class AssociationValidationTest < ActiveRecord::TestCase
     Reply.validates_presence_of(:content)
     t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
     t.replies << [r = Reply.new("title" => "A reply"), r2 = Reply.new("title" => "Another reply", "content" => "non-empty"), r3 = Reply.new("title" => "Yet another reply"), r4 = Reply.new("title" => "The last reply", "content" => "non-empty")]
-    assert !t.valid?
-    assert t.errors[:replies].any?
+    assert_not_predicate t, :valid?
+    assert_predicate t.errors[:replies], :any?
     assert_equal 1, r.errors.count  # make sure all associated objects have been validated
     assert_equal 0, r2.errors.count
     assert_equal 1, r3.errors.count
     assert_equal 0, r4.errors.count
     r.content = r3.content = "non-empty"
-    assert t.valid?
+    assert_predicate t, :valid?
   end
 
   def test_validates_associated_one
@@ -31,10 +31,10 @@ class AssociationValidationTest < ActiveRecord::TestCase
     Topic.validates_presence_of(:content)
     r = Reply.new("title" => "A reply", "content" => "with content!")
     r.topic = Topic.create("title" => "uhohuhoh")
-    assert !r.valid?
-    assert r.errors[:topic].any?
+    assert_not_predicate r, :valid?
+    assert_predicate r.errors[:topic], :any?
     r.topic.content = "non-empty"
-    assert r.valid?
+    assert_predicate r, :valid?
   end
 
   def test_validates_associated_marked_for_destruction
@@ -42,9 +42,9 @@ class AssociationValidationTest < ActiveRecord::TestCase
     Reply.validates_presence_of(:content)
     t = Topic.new
     t.replies << Reply.new
-    assert t.invalid?
+    assert_predicate t, :invalid?
     t.replies.first.mark_for_destruction
-    assert t.valid?
+    assert_predicate t, :valid?
   end
 
   def test_validates_associated_without_marked_for_destruction
@@ -56,7 +56,7 @@ class AssociationValidationTest < ActiveRecord::TestCase
     Topic.validates_associated(:replies)
     t = Topic.new
     t.define_singleton_method(:replies) { [reply.new] }
-    assert t.valid?
+    assert_predicate t, :valid?
   end
 
   def test_validates_associated_with_custom_message_using_quotes
@@ -71,11 +71,11 @@ class AssociationValidationTest < ActiveRecord::TestCase
   def test_validates_associated_missing
     Reply.validates_presence_of(:topic)
     r = Reply.create("title" => "A reply", "content" => "with content!")
-    assert !r.valid?
-    assert r.errors[:topic].any?
+    assert_not_predicate r, :valid?
+    assert_predicate r.errors[:topic], :any?
 
     r.topic = Topic.first
-    assert r.valid?
+    assert_predicate r, :valid?
   end
 
   def test_validates_presence_of_belongs_to_association__parent_is_new_record
diff --git a/activerecord/test/cases/validations/length_validation_test.rb b/activerecord/test/cases/validations/length_validation_test.rb
index 87ce4c6f37..73422a31cd 100644
--- a/activerecord/test/cases/validations/length_validation_test.rb
+++ b/activerecord/test/cases/validations/length_validation_test.rb
@@ -18,47 +18,47 @@ class LengthValidationTest < ActiveRecord::TestCase
     assert_nothing_raised { @owner.validates_size_of :pets, minimum: 1 }
     o = @owner.new("name" => "nopets")
     assert !o.save
-    assert o.errors[:pets].any?
+    assert_predicate o.errors[:pets], :any?
     o.pets.build("name" => "apet")
-    assert o.valid?
+    assert_predicate o, :valid?
   end
 
   def test_validates_size_of_association_using_within
     assert_nothing_raised { @owner.validates_size_of :pets, within: 1..2 }
     o = @owner.new("name" => "nopets")
     assert !o.save
-    assert o.errors[:pets].any?
+    assert_predicate o.errors[:pets], :any?
 
     o.pets.build("name" => "apet")
-    assert o.valid?
+    assert_predicate o, :valid?
 
     2.times { o.pets.build("name" => "apet") }
     assert !o.save
-    assert o.errors[:pets].any?
+    assert_predicate o.errors[:pets], :any?
   end
 
   def test_validates_size_of_association_utf8
     @owner.validates_size_of :pets, minimum: 1
     o = @owner.new("name" => "あいうえおかきくけこ")
     assert !o.save
-    assert o.errors[:pets].any?
+    assert_predicate o.errors[:pets], :any?
     o.pets.build("name" => "あいうえおかきくけこ")
-    assert o.valid?
+    assert_predicate o, :valid?
   end
 
   def test_validates_size_of_respects_records_marked_for_destruction
     @owner.validates_size_of :pets, minimum: 1
     owner = @owner.new
     assert_not owner.save
-    assert owner.errors[:pets].any?
+    assert_predicate owner.errors[:pets], :any?
     pet = owner.pets.build
-    assert owner.valid?
+    assert_predicate owner, :valid?
     assert owner.save
 
     pet_count = Pet.count
     assert_not owner.update_attributes pets_attributes: [ { _destroy: 1, id: pet.id } ]
-    assert_not owner.valid?
-    assert owner.errors[:pets].any?
+    assert_not_predicate owner, :valid?
+    assert_predicate owner.errors[:pets], :any?
     assert_equal pet_count, Pet.count
   end
 
@@ -70,11 +70,11 @@ class LengthValidationTest < ActiveRecord::TestCase
 
       pet = Pet.create!(name: "Fancy Pants", nickname: "Fancy")
 
-      assert pet.valid?
+      assert_predicate pet, :valid?
 
       pet.nickname = ""
 
-      assert pet.invalid?
+      assert_predicate pet, :invalid?
     end
   end
 end
diff --git a/activerecord/test/cases/validations/presence_validation_test.rb b/activerecord/test/cases/validations/presence_validation_test.rb
index 3ab1567b51..63c3f67da2 100644
--- a/activerecord/test/cases/validations/presence_validation_test.rb
+++ b/activerecord/test/cases/validations/presence_validation_test.rb
@@ -15,10 +15,10 @@ class PresenceValidationTest < ActiveRecord::TestCase
   def test_validates_presence_of_non_association
     Boy.validates_presence_of(:name)
     b = Boy.new
-    assert b.invalid?
+    assert_predicate b, :invalid?
 
     b.name = "Alex"
-    assert b.valid?
+    assert_predicate b, :valid?
   end
 
   def test_validates_presence_of_has_one
@@ -33,23 +33,23 @@ class PresenceValidationTest < ActiveRecord::TestCase
     b = Boy.new
     f = Face.new
     b.face = f
-    assert b.valid?
+    assert_predicate b, :valid?
 
     f.mark_for_destruction
-    assert b.invalid?
+    assert_predicate b, :invalid?
   end
 
   def test_validates_presence_of_has_many_marked_for_destruction
     Boy.validates_presence_of(:interests)
     b = Boy.new
     b.interests << [i1 = Interest.new, i2 = Interest.new]
-    assert b.valid?
+    assert_predicate b, :valid?
 
     i1.mark_for_destruction
-    assert b.valid?
+    assert_predicate b, :valid?
 
     i2.mark_for_destruction
-    assert b.invalid?
+    assert_predicate b, :invalid?
   end
 
   def test_validates_presence_doesnt_convert_to_array
@@ -74,11 +74,11 @@ class PresenceValidationTest < ActiveRecord::TestCase
       Interest.validates_presence_of(:abbreviation)
 
       interest = Interest.create!(topic: "Thought Leadering", abbreviation: "tl")
-      assert interest.valid?
+      assert_predicate interest, :valid?
 
       interest.abbreviation = ""
 
-      assert interest.invalid?
+      assert_predicate interest, :invalid?
     end
   end
 
diff --git a/activerecord/test/cases/validations/uniqueness_validation_test.rb b/activerecord/test/cases/validations/uniqueness_validation_test.rb
index a10567f066..1fa94a5b75 100644
--- a/activerecord/test/cases/validations/uniqueness_validation_test.rb
+++ b/activerecord/test/cases/validations/uniqueness_validation_test.rb
@@ -96,7 +96,7 @@ class UniquenessValidationTest < ActiveRecord::TestCase
     Topic.validates_uniqueness_of(:new_title)
 
     topic = Topic.new(new_title: "abc")
-    assert topic.valid?
+    assert_predicate topic, :valid?
   end
 
   def test_validates_uniqueness_with_nil_value
@@ -116,7 +116,7 @@ class UniquenessValidationTest < ActiveRecord::TestCase
     Topic.create!("title" => "abc")
 
     t2 = Topic.new("title" => "abc")
-    assert !t2.valid?
+    assert_not_predicate t2, :valid?
     assert t2.errors[:title]
   end
 
@@ -259,15 +259,15 @@ class UniquenessValidationTest < ActiveRecord::TestCase
     t2 = Topic.new("title" => "I'm UNIQUE!", :parent_id => 1)
     assert !t2.valid?, "Shouldn't be valid"
     assert !t2.save, "Shouldn't save t2 as unique"
-    assert t2.errors[:title].any?
-    assert t2.errors[:parent_id].any?
+    assert_predicate t2.errors[:title], :any?
+    assert_predicate t2.errors[:parent_id], :any?
     assert_equal ["has already been taken"], t2.errors[:title]
 
     t2.title = "I'm truly UNIQUE!"
     assert !t2.valid?, "Shouldn't be valid"
     assert !t2.save, "Shouldn't save t2 as unique"
-    assert t2.errors[:title].empty?
-    assert t2.errors[:parent_id].any?
+    assert_empty t2.errors[:title]
+    assert_predicate t2.errors[:parent_id], :any?
 
     t2.parent_id = 4
     assert t2.save, "Should now save t2 as unique"
@@ -326,15 +326,15 @@ class UniquenessValidationTest < ActiveRecord::TestCase
     t2 = Topic.new("title" => "I'M UNIQUE!")
     assert t2.valid?, "Should be valid"
     assert t2.save, "Should save t2 as unique"
-    assert t2.errors[:title].empty?
-    assert t2.errors[:parent_id].empty?
+    assert_empty t2.errors[:title]
+    assert_empty t2.errors[:parent_id]
     assert_not_equal ["has already been taken"], t2.errors[:title]
 
     t3 = Topic.new("title" => "I'M uNiQUe!")
     assert t3.valid?, "Should be valid"
     assert t3.save, "Should save t2 as unique"
-    assert t3.errors[:title].empty?
-    assert t3.errors[:parent_id].empty?
+    assert_empty t3.errors[:title]
+    assert_empty t3.errors[:parent_id]
     assert_not_equal ["has already been taken"], t3.errors[:title]
   end
 
@@ -343,7 +343,7 @@ class UniquenessValidationTest < ActiveRecord::TestCase
     Topic.create!("title" => 101)
 
     t2 = Topic.new("title" => 101)
-    assert !t2.valid?
+    assert_not_predicate t2, :valid?
     assert t2.errors[:title]
   end
 
@@ -360,7 +360,7 @@ class UniquenessValidationTest < ActiveRecord::TestCase
       t1 = Topic.new("title" => "I'm unique!", "author_name" => "Mary")
       assert t1.save
       t2 = Topic.new("title" => "I'm unique!", "author_name" => "David")
-      assert !t2.valid?
+      assert_not_predicate t2, :valid?
     end
   end
 
@@ -460,16 +460,16 @@ class UniquenessValidationTest < ActiveRecord::TestCase
 
   def test_validate_uniqueness_on_existing_relation
     event = Event.create
-    assert TopicWithUniqEvent.create(event: event).valid?
+    assert_predicate TopicWithUniqEvent.create(event: event), :valid?
 
     topic = TopicWithUniqEvent.new(event: event)
-    assert_not topic.valid?
+    assert_not_predicate topic, :valid?
     assert_equal ["has already been taken"], topic.errors[:event]
   end
 
   def test_validate_uniqueness_on_empty_relation
     topic = TopicWithUniqEvent.new
-    assert topic.valid?
+    assert_predicate topic, :valid?
   end
 
   def test_validate_uniqueness_of_custom_primary_key
@@ -488,7 +488,7 @@ class UniquenessValidationTest < ActiveRecord::TestCase
     key2 = klass.create!(key_number: 11)
 
     key2.key_number = 10
-    assert_not key2.valid?
+    assert_not_predicate key2, :valid?
   end
 
   def test_validate_uniqueness_without_primary_key
@@ -501,8 +501,8 @@ class UniquenessValidationTest < ActiveRecord::TestCase
     end
 
     abc = klass.create!(dashboard_id: "abc")
-    assert klass.new(dashboard_id: "xyz").valid?
-    assert_not klass.new(dashboard_id: "abc").valid?
+    assert_predicate klass.new(dashboard_id: "xyz"), :valid?
+    assert_not_predicate klass.new(dashboard_id: "abc"), :valid?
 
     abc.dashboard_id = "def"
 
@@ -530,7 +530,7 @@ class UniquenessValidationTest < ActiveRecord::TestCase
     assert topic.author_name.start_with?("Title1")
 
     topic2 = TopicWithAfterCreate.new(title: "Title1")
-    refute topic2.valid?
+    assert_not_predicate topic2, :valid?
     assert_equal(["has already been taken"], topic2.errors[:title])
   end
 
@@ -550,7 +550,7 @@ class UniquenessValidationTest < ActiveRecord::TestCase
     assert_empty item.errors
 
     item2 = CoolTopic.new(id: item.id, title: "MyItem2")
-    refute item2.valid?
+    assert_not_predicate item2, :valid?
 
     assert_equal(["has already been taken"], item2.errors[:id])
   end
diff --git a/activerecord/test/cases/validations_test.rb b/activerecord/test/cases/validations_test.rb
index 14623c43d2..6c83bbd15c 100644
--- a/activerecord/test/cases/validations_test.rb
+++ b/activerecord/test/cases/validations_test.rb
@@ -19,7 +19,7 @@ class ValidationsTest < ActiveRecord::TestCase
   def test_valid_uses_create_context_when_new
     r = WrongReply.new
     r.title = "Wrong Create"
-    assert_not r.valid?
+    assert_not_predicate r, :valid?
     assert r.errors[:title].any?, "A reply with a bad title should mark that attribute as invalid"
     assert_equal ["is Wrong Create"], r.errors[:title], "A reply with a bad content should contain an error"
   end
@@ -139,7 +139,7 @@ class ValidationsTest < ActiveRecord::TestCase
 
   def test_throw_away_typing
     d = Developer.new("name" => "David", "salary" => "100,000")
-    assert !d.valid?
+    assert_not_predicate d, :valid?
     assert_equal 100, d.salary
     assert_equal "100,000", d.salary_before_type_cast
   end
@@ -166,7 +166,7 @@ class ValidationsTest < ActiveRecord::TestCase
     topic = klass.new(wibble: "123-4567")
     topic.wibble.gsub!("-", "")
 
-    assert topic.valid?
+    assert_predicate topic, :valid?
   end
 
   def test_numericality_validation_checks_against_raw_value
@@ -178,9 +178,9 @@ class ValidationsTest < ActiveRecord::TestCase
       validates_numericality_of :wibble, greater_than_or_equal_to: BigDecimal("97.18")
     end
 
-    assert_not klass.new(wibble: "97.179").valid?
-    assert_not klass.new(wibble: 97.179).valid?
-    assert_not klass.new(wibble: BigDecimal("97.179")).valid?
+    assert_not_predicate klass.new(wibble: "97.179"), :valid?
+    assert_not_predicate klass.new(wibble: 97.179), :valid?
+    assert_not_predicate klass.new(wibble: BigDecimal("97.179")), :valid?
   end
 
   def test_acceptance_validator_doesnt_require_db_connection
diff --git a/activerecord/test/cases/yaml_serialization_test.rb b/activerecord/test/cases/yaml_serialization_test.rb
index 578881f754..60ebdce178 100644
--- a/activerecord/test/cases/yaml_serialization_test.rb
+++ b/activerecord/test/cases/yaml_serialization_test.rb
@@ -96,7 +96,7 @@ class YamlSerializationTest < ActiveRecord::TestCase
   def test_deserializing_rails_41_yaml
     topic = YAML.load(yaml_fixture("rails_4_1"))
 
-    assert topic.new_record?
+    assert_predicate topic, :new_record?
     assert_nil topic.id
     assert_equal "The First Topic", topic.title
     assert_equal({ omg: :lol }, topic.content)
@@ -105,7 +105,7 @@ class YamlSerializationTest < ActiveRecord::TestCase
   def test_deserializing_rails_4_2_0_yaml
     topic = YAML.load(yaml_fixture("rails_4_2_0"))
 
-    assert_not topic.new_record?
+    assert_not_predicate topic, :new_record?
     assert_equal 1, topic.id
     assert_equal "The First Topic", topic.title
     assert_equal("Have a nice day", topic.content)