Merge branch 'master' into make-reverse-merge-bang-order-consistent

199 files changed, 3389 insertions, 2010 deletions

diff --git a/activesupport/test/abstract_unit.rb b/activesupport/test/abstract_unit.rb
index c4f34c0abf..3ac11e0fe0 100644
--- a/activesupport/test/abstract_unit.rb
+++ b/activesupport/test/abstract_unit.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ORIG_ARGV = ARGV.dup
 
 require "active_support/core_ext/kernel/reporting"
diff --git a/activesupport/test/array_inquirer_test.rb b/activesupport/test/array_inquirer_test.rb
index 5b2bc82905..d5419b862d 100644
--- a/activesupport/test/array_inquirer_test.rb
+++ b/activesupport/test/array_inquirer_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/array"
 
diff --git a/activesupport/test/autoload_test.rb b/activesupport/test/autoload_test.rb
index 6c8aa3e055..216b069420 100644
--- a/activesupport/test/autoload_test.rb
+++ b/activesupport/test/autoload_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class TestAutoloadModule < ActiveSupport::TestCase
diff --git a/activesupport/test/autoloading_fixtures/a/b.rb b/activesupport/test/autoloading_fixtures/a/b.rb
index 0dbbbbd181..27baaea08c 100644
--- a/activesupport/test/autoloading_fixtures/a/b.rb
+++ b/activesupport/test/autoloading_fixtures/a/b.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class A::B
 end
diff --git a/activesupport/test/autoloading_fixtures/a/c/d.rb b/activesupport/test/autoloading_fixtures/a/c/d.rb
index 2c0ec5f182..f07128673f 100644
--- a/activesupport/test/autoloading_fixtures/a/c/d.rb
+++ b/activesupport/test/autoloading_fixtures/a/c/d.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class A::C::D
 end
diff --git a/activesupport/test/autoloading_fixtures/a/c/em/f.rb b/activesupport/test/autoloading_fixtures/a/c/em/f.rb
index 3ff1b7efa0..78c96cf45f 100644
--- a/activesupport/test/autoloading_fixtures/a/c/em/f.rb
+++ b/activesupport/test/autoloading_fixtures/a/c/em/f.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class A::C::EM::F
 end
diff --git a/activesupport/test/autoloading_fixtures/application.rb b/activesupport/test/autoloading_fixtures/application.rb
index d7d3096dcb..971cbe1b17 100644
--- a/activesupport/test/autoloading_fixtures/application.rb
+++ b/activesupport/test/autoloading_fixtures/application.rb
@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 ApplicationController = 10
diff --git a/activesupport/test/autoloading_fixtures/circular1.rb b/activesupport/test/autoloading_fixtures/circular1.rb
index a45761f066..7f891b5eb1 100644
--- a/activesupport/test/autoloading_fixtures/circular1.rb
+++ b/activesupport/test/autoloading_fixtures/circular1.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 silence_warnings do
   Circular2
 end
diff --git a/activesupport/test/autoloading_fixtures/circular2.rb b/activesupport/test/autoloading_fixtures/circular2.rb
index c847fa5001..1fdb4c261f 100644
--- a/activesupport/test/autoloading_fixtures/circular2.rb
+++ b/activesupport/test/autoloading_fixtures/circular2.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 Circular1
 
 class Circular2
diff --git a/activesupport/test/autoloading_fixtures/class_folder.rb b/activesupport/test/autoloading_fixtures/class_folder.rb
index 6ee8182214..ff0826c298 100644
--- a/activesupport/test/autoloading_fixtures/class_folder.rb
+++ b/activesupport/test/autoloading_fixtures/class_folder.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ClassFolder
   ConstantInClassFolder = "indeed"
 end
diff --git a/activesupport/test/autoloading_fixtures/class_folder/class_folder_subclass.rb b/activesupport/test/autoloading_fixtures/class_folder/class_folder_subclass.rb
index 4df069cab6..cd901e9d71 100644
--- a/activesupport/test/autoloading_fixtures/class_folder/class_folder_subclass.rb
+++ b/activesupport/test/autoloading_fixtures/class_folder/class_folder_subclass.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ClassFolder::ClassFolderSubclass < ClassFolder
   ConstantInClassFolder = "indeed"
 end
diff --git a/activesupport/test/autoloading_fixtures/class_folder/inline_class.rb b/activesupport/test/autoloading_fixtures/class_folder/inline_class.rb
index 8235e90724..960bfcbc70 100644
--- a/activesupport/test/autoloading_fixtures/class_folder/inline_class.rb
+++ b/activesupport/test/autoloading_fixtures/class_folder/inline_class.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class ClassFolder::InlineClass
 end
diff --git a/activesupport/test/autoloading_fixtures/class_folder/nested_class.rb b/activesupport/test/autoloading_fixtures/class_folder/nested_class.rb
index 57a13d89ea..98426b797d 100644
--- a/activesupport/test/autoloading_fixtures/class_folder/nested_class.rb
+++ b/activesupport/test/autoloading_fixtures/class_folder/nested_class.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ClassFolder
   class NestedClass
   end
diff --git a/activesupport/test/autoloading_fixtures/conflict.rb b/activesupport/test/autoloading_fixtures/conflict.rb
index d7f42b5d5f..c5d3f6bdc0 100644
--- a/activesupport/test/autoloading_fixtures/conflict.rb
+++ b/activesupport/test/autoloading_fixtures/conflict.rb
@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 Conflict = 2
diff --git a/activesupport/test/autoloading_fixtures/counting_loader.rb b/activesupport/test/autoloading_fixtures/counting_loader.rb
index 4225c4412c..6ac3a9828d 100644
--- a/activesupport/test/autoloading_fixtures/counting_loader.rb
+++ b/activesupport/test/autoloading_fixtures/counting_loader.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 $counting_loaded_times ||= 0
 $counting_loaded_times += 1
 
diff --git a/activesupport/test/autoloading_fixtures/cross_site_dependency.rb b/activesupport/test/autoloading_fixtures/cross_site_dependency.rb
index de941bf271..8a18dcff10 100644
--- a/activesupport/test/autoloading_fixtures/cross_site_dependency.rb
+++ b/activesupport/test/autoloading_fixtures/cross_site_dependency.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class CrossSiteDependency
 end
diff --git a/activesupport/test/autoloading_fixtures/d.rb b/activesupport/test/autoloading_fixtures/d.rb
index 52850e1e1a..72752d878e 100644
--- a/activesupport/test/autoloading_fixtures/d.rb
+++ b/activesupport/test/autoloading_fixtures/d.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class D
 end
diff --git a/activesupport/test/autoloading_fixtures/em.rb b/activesupport/test/autoloading_fixtures/em.rb
index e47024999e..2e0ac9a6f9 100644
--- a/activesupport/test/autoloading_fixtures/em.rb
+++ b/activesupport/test/autoloading_fixtures/em.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class EM
 end
diff --git a/activesupport/test/autoloading_fixtures/html/some_class.rb b/activesupport/test/autoloading_fixtures/html/some_class.rb
index b43d15d891..fbbfd4a214 100644
--- a/activesupport/test/autoloading_fixtures/html/some_class.rb
+++ b/activesupport/test/autoloading_fixtures/html/some_class.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module HTML
   class SomeClass
   end
diff --git a/activesupport/test/autoloading_fixtures/load_path/loaded_constant.rb b/activesupport/test/autoloading_fixtures/load_path/loaded_constant.rb
index d2c4f6b0c5..8735ce87e1 100644
--- a/activesupport/test/autoloading_fixtures/load_path/loaded_constant.rb
+++ b/activesupport/test/autoloading_fixtures/load_path/loaded_constant.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 module LoadedConstant
 end
diff --git a/activesupport/test/autoloading_fixtures/loads_constant.rb b/activesupport/test/autoloading_fixtures/loads_constant.rb
index 0b30dc8bca..0bb434a956 100644
--- a/activesupport/test/autoloading_fixtures/loads_constant.rb
+++ b/activesupport/test/autoloading_fixtures/loads_constant.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module LoadsConstant
 end
 
diff --git a/activesupport/test/autoloading_fixtures/module_folder/inline_class.rb b/activesupport/test/autoloading_fixtures/module_folder/inline_class.rb
index ca83437046..c11246b528 100644
--- a/activesupport/test/autoloading_fixtures/module_folder/inline_class.rb
+++ b/activesupport/test/autoloading_fixtures/module_folder/inline_class.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class ModuleFolder::InlineClass
 end
diff --git a/activesupport/test/autoloading_fixtures/module_folder/nested_class.rb b/activesupport/test/autoloading_fixtures/module_folder/nested_class.rb
index fc4076bd0a..69226b405c 100644
--- a/activesupport/test/autoloading_fixtures/module_folder/nested_class.rb
+++ b/activesupport/test/autoloading_fixtures/module_folder/nested_class.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ModuleFolder
   class NestedClass
   end
diff --git a/activesupport/test/autoloading_fixtures/module_folder/nested_sibling.rb b/activesupport/test/autoloading_fixtures/module_folder/nested_sibling.rb
index 04c426833e..30de83af11 100644
--- a/activesupport/test/autoloading_fixtures/module_folder/nested_sibling.rb
+++ b/activesupport/test/autoloading_fixtures/module_folder/nested_sibling.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class ModuleFolder::NestedSibling
 end
diff --git a/activesupport/test/autoloading_fixtures/module_with_custom_const_missing/a/b.rb b/activesupport/test/autoloading_fixtures/module_with_custom_const_missing/a/b.rb
index 4f2020c503..f688c1ef35 100644
--- a/activesupport/test/autoloading_fixtures/module_with_custom_const_missing/a/b.rb
+++ b/activesupport/test/autoloading_fixtures/module_with_custom_const_missing/a/b.rb
@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 ModuleWithCustomConstMissing::A::B = "10"
diff --git a/activesupport/test/autoloading_fixtures/multiple_constant_file.rb b/activesupport/test/autoloading_fixtures/multiple_constant_file.rb
index a9ff4eb89c..1da26e6c2c 100644
--- a/activesupport/test/autoloading_fixtures/multiple_constant_file.rb
+++ b/activesupport/test/autoloading_fixtures/multiple_constant_file.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 MultipleConstantFile = 10
 SiblingConstant = MultipleConstantFile * 2
diff --git a/activesupport/test/autoloading_fixtures/prepend.rb b/activesupport/test/autoloading_fixtures/prepend.rb
index 3134d1df2b..bf9e36e12c 100644
--- a/activesupport/test/autoloading_fixtures/prepend.rb
+++ b/activesupport/test/autoloading_fixtures/prepend.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class SubClassConflict
 end
 
diff --git a/activesupport/test/autoloading_fixtures/prepend/sub_class_conflict.rb b/activesupport/test/autoloading_fixtures/prepend/sub_class_conflict.rb
index 090dda3043..506c3c5920 100644
--- a/activesupport/test/autoloading_fixtures/prepend/sub_class_conflict.rb
+++ b/activesupport/test/autoloading_fixtures/prepend/sub_class_conflict.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class Prepend::SubClassConflict
 end
diff --git a/activesupport/test/autoloading_fixtures/raises_arbitrary_exception.rb b/activesupport/test/autoloading_fixtures/raises_arbitrary_exception.rb
index e477ab21d0..118ee6bdd1 100644
--- a/activesupport/test/autoloading_fixtures/raises_arbitrary_exception.rb
+++ b/activesupport/test/autoloading_fixtures/raises_arbitrary_exception.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 RaisesArbitraryException = 1
 _ = A::B # Autoloading recursion, also expected to be watched and discarded.
 
diff --git a/activesupport/test/autoloading_fixtures/raises_name_error.rb b/activesupport/test/autoloading_fixtures/raises_name_error.rb
index a49960abf0..c23afb7b12 100644
--- a/activesupport/test/autoloading_fixtures/raises_name_error.rb
+++ b/activesupport/test/autoloading_fixtures/raises_name_error.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class RaisesNameError
   FooBarBaz
 end
diff --git a/activesupport/test/autoloading_fixtures/raises_no_method_error.rb b/activesupport/test/autoloading_fixtures/raises_no_method_error.rb
index e1b8fce24a..1000ce1cf5 100644
--- a/activesupport/test/autoloading_fixtures/raises_no_method_error.rb
+++ b/activesupport/test/autoloading_fixtures/raises_no_method_error.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class RaisesNoMethodError
   self.foobar_method_doesnt_exist
 end
diff --git a/activesupport/test/autoloading_fixtures/requires_constant.rb b/activesupport/test/autoloading_fixtures/requires_constant.rb
index f04dcc4091..6e51998949 100644
--- a/activesupport/test/autoloading_fixtures/requires_constant.rb
+++ b/activesupport/test/autoloading_fixtures/requires_constant.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "loaded_constant"
 
 module RequiresConstant
diff --git a/activesupport/test/autoloading_fixtures/should_not_be_required.rb b/activesupport/test/autoloading_fixtures/should_not_be_required.rb
index 1fcf170cc5..8deffa1816 100644
--- a/activesupport/test/autoloading_fixtures/should_not_be_required.rb
+++ b/activesupport/test/autoloading_fixtures/should_not_be_required.rb
@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 ShouldNotBeAutoloaded = 0
diff --git a/activesupport/test/autoloading_fixtures/throws.rb b/activesupport/test/autoloading_fixtures/throws.rb
index e1d96cc512..b6fb391032 100644
--- a/activesupport/test/autoloading_fixtures/throws.rb
+++ b/activesupport/test/autoloading_fixtures/throws.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 Throws = 1
 _ = A::B # Autoloading recursion, expected to be discarded.
 
diff --git a/activesupport/test/autoloading_fixtures/typo.rb b/activesupport/test/autoloading_fixtures/typo.rb
index 0ffe07c2b3..d45cddbcf5 100644
--- a/activesupport/test/autoloading_fixtures/typo.rb
+++ b/activesupport/test/autoloading_fixtures/typo.rb
@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 TypO = 1
diff --git a/activesupport/test/benchmarkable_test.rb b/activesupport/test/benchmarkable_test.rb
index 210b9cb9fd..424da0a52c 100644
--- a/activesupport/test/benchmarkable_test.rb
+++ b/activesupport/test/benchmarkable_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class BenchmarkableTest < ActiveSupport::TestCase
diff --git a/activesupport/test/broadcast_logger_test.rb b/activesupport/test/broadcast_logger_test.rb
index 184d0ebddd..181113e70a 100644
--- a/activesupport/test/broadcast_logger_test.rb
+++ b/activesupport/test/broadcast_logger_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module ActiveSupport
diff --git a/activesupport/test/cache/behaviors.rb b/activesupport/test/cache/behaviors.rb
new file mode 100644
index 0000000000..cb08a10bba
--- /dev/null
+++ b/activesupport/test/cache/behaviors.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "behaviors/autoloading_cache_behavior"
+require_relative "behaviors/cache_delete_matched_behavior"
+require_relative "behaviors/cache_increment_decrement_behavior"
+require_relative "behaviors/cache_store_behavior"
+require_relative "behaviors/cache_store_version_behavior"
+require_relative "behaviors/encoded_key_cache_behavior"
+require_relative "behaviors/local_cache_behavior"
diff --git a/activesupport/test/cache/behaviors/autoloading_cache_behavior.rb b/activesupport/test/cache/behaviors/autoloading_cache_behavior.rb
new file mode 100644
index 0000000000..b340eb6c48
--- /dev/null
+++ b/activesupport/test/cache/behaviors/autoloading_cache_behavior.rb
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "dependencies_test_helpers"
+
+module AutoloadingCacheBehavior
+  include DependenciesTestHelpers
+
+  def test_simple_autoloading
+    with_autoloading_fixtures do
+      @cache.write("foo", EM.new)
+    end
+
+    remove_constants(:EM)
+    ActiveSupport::Dependencies.clear
+
+    with_autoloading_fixtures do
+      assert_kind_of EM, @cache.read("foo")
+    end
+
+    remove_constants(:EM)
+    ActiveSupport::Dependencies.clear
+  end
+
+  def test_two_classes_autoloading
+    with_autoloading_fixtures do
+      @cache.write("foo", [EM.new, ClassFolder.new])
+    end
+
+    remove_constants(:EM, :ClassFolder)
+    ActiveSupport::Dependencies.clear
+
+    with_autoloading_fixtures do
+      loaded = @cache.read("foo")
+      assert_kind_of Array, loaded
+      assert_equal 2, loaded.size
+      assert_kind_of EM, loaded[0]
+      assert_kind_of ClassFolder, loaded[1]
+    end
+
+    remove_constants(:EM, :ClassFolder)
+    ActiveSupport::Dependencies.clear
+  end
+end
diff --git a/activesupport/test/cache/behaviors/cache_delete_matched_behavior.rb b/activesupport/test/cache/behaviors/cache_delete_matched_behavior.rb
new file mode 100644
index 0000000000..6f59ce48d2
--- /dev/null
+++ b/activesupport/test/cache/behaviors/cache_delete_matched_behavior.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module CacheDeleteMatchedBehavior
+  def test_delete_matched
+    @cache.write("foo", "bar")
+    @cache.write("fu", "baz")
+    @cache.write("foo/bar", "baz")
+    @cache.write("fu/baz", "bar")
+    @cache.delete_matched(/oo/)
+    assert !@cache.exist?("foo")
+    assert @cache.exist?("fu")
+    assert !@cache.exist?("foo/bar")
+    assert @cache.exist?("fu/baz")
+  end
+end
diff --git a/activesupport/test/cache/behaviors/cache_increment_decrement_behavior.rb b/activesupport/test/cache/behaviors/cache_increment_decrement_behavior.rb
new file mode 100644
index 0000000000..2fa2d7af88
--- /dev/null
+++ b/activesupport/test/cache/behaviors/cache_increment_decrement_behavior.rb
@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module CacheIncrementDecrementBehavior
+  def test_increment
+    @cache.write("foo", 1, raw: true)
+    assert_equal 1, @cache.read("foo").to_i
+    assert_equal 2, @cache.increment("foo")
+    assert_equal 2, @cache.read("foo").to_i
+    assert_equal 3, @cache.increment("foo")
+    assert_equal 3, @cache.read("foo").to_i
+    assert_nil @cache.increment("bar")
+  end
+
+  def test_decrement
+    @cache.write("foo", 3, raw: true)
+    assert_equal 3, @cache.read("foo").to_i
+    assert_equal 2, @cache.decrement("foo")
+    assert_equal 2, @cache.read("foo").to_i
+    assert_equal 1, @cache.decrement("foo")
+    assert_equal 1, @cache.read("foo").to_i
+    assert_nil @cache.decrement("bar")
+  end
+end
diff --git a/activesupport/test/cache/behaviors/cache_store_behavior.rb b/activesupport/test/cache/behaviors/cache_store_behavior.rb
new file mode 100644
index 0000000000..582e902f72
--- /dev/null
+++ b/activesupport/test/cache/behaviors/cache_store_behavior.rb
@@ -0,0 +1,331 @@
+# frozen_string_literal: true
+
+# Tests the base functionality that should be identical across all cache stores.
+module CacheStoreBehavior
+  def test_should_read_and_write_strings
+    assert @cache.write("foo", "bar")
+    assert_equal "bar", @cache.read("foo")
+  end
+
+  def test_should_overwrite
+    @cache.write("foo", "bar")
+    @cache.write("foo", "baz")
+    assert_equal "baz", @cache.read("foo")
+  end
+
+  def test_fetch_without_cache_miss
+    @cache.write("foo", "bar")
+    assert_not_called(@cache, :write) do
+      assert_equal "bar", @cache.fetch("foo") { "baz" }
+    end
+  end
+
+  def test_fetch_with_cache_miss
+    assert_called_with(@cache, :write, ["foo", "baz", @cache.options]) do
+      assert_equal "baz", @cache.fetch("foo") { "baz" }
+    end
+  end
+
+  def test_fetch_with_cache_miss_passes_key_to_block
+    cache_miss = false
+    assert_equal 3, @cache.fetch("foo") { |key| cache_miss = true; key.length }
+    assert cache_miss
+
+    cache_miss = false
+    assert_equal 3, @cache.fetch("foo") { |key| cache_miss = true; key.length }
+    assert !cache_miss
+  end
+
+  def test_fetch_with_forced_cache_miss
+    @cache.write("foo", "bar")
+    assert_not_called(@cache, :read) do
+      assert_called_with(@cache, :write, ["foo", "bar", @cache.options.merge(force: true)]) do
+        @cache.fetch("foo", force: true) { "bar" }
+      end
+    end
+  end
+
+  def test_fetch_with_cached_nil
+    @cache.write("foo", nil)
+    assert_not_called(@cache, :write) do
+      assert_nil @cache.fetch("foo") { "baz" }
+    end
+  end
+
+  def test_fetch_with_forced_cache_miss_with_block
+    @cache.write("foo", "bar")
+    assert_equal "foo_bar", @cache.fetch("foo", force: true) { "foo_bar" }
+  end
+
+  def test_fetch_with_forced_cache_miss_without_block
+    @cache.write("foo", "bar")
+    assert_raises(ArgumentError) do
+      @cache.fetch("foo", force: true)
+    end
+
+    assert_equal "bar", @cache.read("foo")
+  end
+
+  def test_should_read_and_write_hash
+    assert @cache.write("foo", a: "b")
+    assert_equal({ a: "b" }, @cache.read("foo"))
+  end
+
+  def test_should_read_and_write_integer
+    assert @cache.write("foo", 1)
+    assert_equal 1, @cache.read("foo")
+  end
+
+  def test_should_read_and_write_nil
+    assert @cache.write("foo", nil)
+    assert_nil @cache.read("foo")
+  end
+
+  def test_should_read_and_write_false
+    assert @cache.write("foo", false)
+    assert_equal false, @cache.read("foo")
+  end
+
+  def test_read_multi
+    @cache.write("foo", "bar")
+    @cache.write("fu", "baz")
+    @cache.write("fud", "biz")
+    assert_equal({ "foo" => "bar", "fu" => "baz" }, @cache.read_multi("foo", "fu"))
+  end
+
+  def test_read_multi_with_expires
+    time = Time.now
+    @cache.write("foo", "bar", expires_in: 10)
+    @cache.write("fu", "baz")
+    @cache.write("fud", "biz")
+    Time.stub(:now, time + 11) do
+      assert_equal({ "fu" => "baz" }, @cache.read_multi("foo", "fu"))
+    end
+  end
+
+  def test_fetch_multi
+    @cache.write("foo", "bar")
+    @cache.write("fud", "biz")
+
+    values = @cache.fetch_multi("foo", "fu", "fud") { |value| value * 2 }
+
+    assert_equal({ "foo" => "bar", "fu" => "fufu", "fud" => "biz" }, values)
+    assert_equal("fufu", @cache.read("fu"))
+  end
+
+  def test_multi_with_objects
+    cache_struct = Struct.new(:cache_key, :title)
+    foo = cache_struct.new("foo", "FOO!")
+    bar = cache_struct.new("bar")
+
+    @cache.write("bar", "BAM!")
+
+    values = @cache.fetch_multi(foo, bar) { |object| object.title }
+
+    assert_equal({ foo => "FOO!", bar => "BAM!" }, values)
+  end
+
+  def test_fetch_multi_without_block
+    assert_raises(ArgumentError) do
+      @cache.fetch_multi("foo")
+    end
+  end
+
+  def test_read_and_write_compressed_small_data
+    @cache.write("foo", "bar", compress: true)
+    assert_equal "bar", @cache.read("foo")
+  end
+
+  def test_read_and_write_compressed_large_data
+    @cache.write("foo", "bar", compress: true, compress_threshold: 2)
+    assert_equal "bar", @cache.read("foo")
+  end
+
+  def test_read_and_write_compressed_nil
+    @cache.write("foo", nil, compress: true)
+    assert_nil @cache.read("foo")
+  end
+
+  def test_cache_key
+    obj = Object.new
+    def obj.cache_key
+      :foo
+    end
+    @cache.write(obj, "bar")
+    assert_equal "bar", @cache.read("foo")
+  end
+
+  def test_param_as_cache_key
+    obj = Object.new
+    def obj.to_param
+      "foo"
+    end
+    @cache.write(obj, "bar")
+    assert_equal "bar", @cache.read("foo")
+  end
+
+  def test_array_as_cache_key
+    @cache.write([:fu, "foo"], "bar")
+    assert_equal "bar", @cache.read("fu/foo")
+  end
+
+  def test_hash_as_cache_key
+    @cache.write({ foo: 1, fu: 2 }, "bar")
+    assert_equal "bar", @cache.read("foo=1/fu=2")
+  end
+
+  def test_keys_are_case_sensitive
+    @cache.write("foo", "bar")
+    assert_nil @cache.read("FOO")
+  end
+
+  def test_exist
+    @cache.write("foo", "bar")
+    assert_equal true, @cache.exist?("foo")
+    assert_equal false, @cache.exist?("bar")
+  end
+
+  def test_nil_exist
+    @cache.write("foo", nil)
+    assert @cache.exist?("foo")
+  end
+
+  def test_delete
+    @cache.write("foo", "bar")
+    assert @cache.exist?("foo")
+    assert @cache.delete("foo")
+    assert !@cache.exist?("foo")
+  end
+
+  def test_original_store_objects_should_not_be_immutable
+    bar = "bar".dup
+    @cache.write("foo", bar)
+    assert_nothing_raised { bar.gsub!(/.*/, "baz") }
+  end
+
+  def test_expires_in
+    time = Time.local(2008, 4, 24)
+
+    Time.stub(:now, time) do
+      @cache.write("foo", "bar")
+      assert_equal "bar", @cache.read("foo")
+    end
+
+    Time.stub(:now, time + 30) do
+      assert_equal "bar", @cache.read("foo")
+    end
+
+    Time.stub(:now, time + 61) do
+      assert_nil @cache.read("foo")
+    end
+  end
+
+  def test_race_condition_protection_skipped_if_not_defined
+    @cache.write("foo", "bar")
+    time = @cache.send(:read_entry, @cache.send(:normalize_key, "foo", {}), {}).expires_at
+
+    Time.stub(:now, Time.at(time)) do
+      result = @cache.fetch("foo") do
+        assert_nil @cache.read("foo")
+        "baz"
+      end
+      assert_equal "baz", result
+    end
+  end
+
+  def test_race_condition_protection_is_limited
+    time = Time.now
+    @cache.write("foo", "bar", expires_in: 60)
+    Time.stub(:now, time + 71) do
+      result = @cache.fetch("foo", race_condition_ttl: 10) do
+        assert_nil @cache.read("foo")
+        "baz"
+      end
+      assert_equal "baz", result
+    end
+  end
+
+  def test_race_condition_protection_is_safe
+    time = Time.now
+    @cache.write("foo", "bar", expires_in: 60)
+    Time.stub(:now, time + 61) do
+      begin
+        @cache.fetch("foo", race_condition_ttl: 10) do
+          assert_equal "bar", @cache.read("foo")
+          raise ArgumentError.new
+        end
+      rescue ArgumentError
+      end
+      assert_equal "bar", @cache.read("foo")
+    end
+    Time.stub(:now, time + 91) do
+      assert_nil @cache.read("foo")
+    end
+  end
+
+  def test_race_condition_protection
+    time = Time.now
+    @cache.write("foo", "bar", expires_in: 60)
+    Time.stub(:now, time + 61) do
+      result = @cache.fetch("foo", race_condition_ttl: 10) do
+        assert_equal "bar", @cache.read("foo")
+        "baz"
+      end
+      assert_equal "baz", result
+    end
+  end
+
+  def test_crazy_key_characters
+    crazy_key = "#/:*(<+=> )&$%@?;'\"\'`~-"
+    assert @cache.write(crazy_key, "1", raw: true)
+    assert_equal "1", @cache.read(crazy_key)
+    assert_equal "1", @cache.fetch(crazy_key)
+    assert @cache.delete(crazy_key)
+    assert_equal "2", @cache.fetch(crazy_key, raw: true) { "2" }
+    assert_equal 3, @cache.increment(crazy_key)
+    assert_equal 2, @cache.decrement(crazy_key)
+  end
+
+  def test_really_long_keys
+    key = "".dup
+    900.times { key << "x" }
+    assert @cache.write(key, "bar")
+    assert_equal "bar", @cache.read(key)
+    assert_equal "bar", @cache.fetch(key)
+    assert_nil @cache.read("#{key}x")
+    assert_equal({ key => "bar" }, @cache.read_multi(key))
+    assert @cache.delete(key)
+  end
+
+  def test_cache_hit_instrumentation
+    key = "test_key"
+    @events = []
+    ActiveSupport::Notifications.subscribe "cache_read.active_support" do |*args|
+      @events << ActiveSupport::Notifications::Event.new(*args)
+    end
+    assert @cache.write(key, "1", raw: true)
+    assert @cache.fetch(key) {}
+    assert_equal 1, @events.length
+    assert_equal "cache_read.active_support", @events[0].name
+    assert_equal :fetch, @events[0].payload[:super_operation]
+    assert @events[0].payload[:hit]
+  ensure
+    ActiveSupport::Notifications.unsubscribe "cache_read.active_support"
+  end
+
+  def test_cache_miss_instrumentation
+    @events = []
+    ActiveSupport::Notifications.subscribe(/^cache_(.*)\.active_support$/) do |*args|
+      @events << ActiveSupport::Notifications::Event.new(*args)
+    end
+    assert_not @cache.fetch("bad_key") {}
+    assert_equal 3, @events.length
+    assert_equal "cache_read.active_support", @events[0].name
+    assert_equal "cache_generate.active_support", @events[1].name
+    assert_equal "cache_write.active_support", @events[2].name
+    assert_equal :fetch, @events[0].payload[:super_operation]
+    assert_not @events[0].payload[:hit]
+  ensure
+    ActiveSupport::Notifications.unsubscribe "cache_read.active_support"
+  end
+end
diff --git a/activesupport/test/cache/behaviors/cache_store_version_behavior.rb b/activesupport/test/cache/behaviors/cache_store_version_behavior.rb
new file mode 100644
index 0000000000..c2e4d046af
--- /dev/null
+++ b/activesupport/test/cache/behaviors/cache_store_version_behavior.rb
@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module CacheStoreVersionBehavior
+  ModelWithKeyAndVersion = Struct.new(:cache_key, :cache_version)
+
+  def test_fetch_with_right_version_should_hit
+    @cache.fetch("foo", version: 1) { "bar" }
+    assert_equal "bar", @cache.read("foo", version: 1)
+  end
+
+  def test_fetch_with_wrong_version_should_miss
+    @cache.fetch("foo", version: 1) { "bar" }
+    assert_nil @cache.read("foo", version: 2)
+  end
+
+  def test_read_with_right_version_should_hit
+    @cache.write("foo", "bar", version: 1)
+    assert_equal "bar", @cache.read("foo", version: 1)
+  end
+
+  def test_read_with_wrong_version_should_miss
+    @cache.write("foo", "bar", version: 1)
+    assert_nil @cache.read("foo", version: 2)
+  end
+
+  def test_exist_with_right_version_should_be_true
+    @cache.write("foo", "bar", version: 1)
+    assert @cache.exist?("foo", version: 1)
+  end
+
+  def test_exist_with_wrong_version_should_be_false
+    @cache.write("foo", "bar", version: 1)
+    assert !@cache.exist?("foo", version: 2)
+  end
+
+  def test_reading_and_writing_with_model_supporting_cache_version
+    m1v1 = ModelWithKeyAndVersion.new("model/1", 1)
+    m1v2 = ModelWithKeyAndVersion.new("model/1", 2)
+
+    @cache.write(m1v1, "bar")
+    assert_equal "bar", @cache.read(m1v1)
+    assert_nil @cache.read(m1v2)
+  end
+
+  def test_reading_and_writing_with_model_supporting_cache_version_using_nested_key
+    m1v1 = ModelWithKeyAndVersion.new("model/1", 1)
+    m1v2 = ModelWithKeyAndVersion.new("model/1", 2)
+
+    @cache.write([ "something", m1v1 ], "bar")
+    assert_equal "bar", @cache.read([ "something", m1v1 ])
+    assert_nil @cache.read([ "something", m1v2 ])
+  end
+
+  def test_fetching_with_model_supporting_cache_version
+    m1v1 = ModelWithKeyAndVersion.new("model/1", 1)
+    m1v2 = ModelWithKeyAndVersion.new("model/1", 2)
+
+    @cache.fetch(m1v1) { "bar" }
+    assert_equal "bar", @cache.fetch(m1v1) { "bu" }
+    assert_equal "bu", @cache.fetch(m1v2) { "bu" }
+  end
+
+  def test_exist_with_model_supporting_cache_version
+    m1v1 = ModelWithKeyAndVersion.new("model/1", 1)
+    m1v2 = ModelWithKeyAndVersion.new("model/1", 2)
+
+    @cache.write(m1v1, "bar")
+    assert     @cache.exist?(m1v1)
+    assert_not @cache.fetch(m1v2)
+  end
+
+  def test_fetch_multi_with_model_supporting_cache_version
+    m1v1 = ModelWithKeyAndVersion.new("model/1", 1)
+    m2v1 = ModelWithKeyAndVersion.new("model/2", 1)
+    m2v2 = ModelWithKeyAndVersion.new("model/2", 2)
+
+    first_fetch_values  = @cache.fetch_multi(m1v1, m2v1) { |m| m.cache_key }
+    second_fetch_values = @cache.fetch_multi(m1v1, m2v2) { |m| m.cache_key + " 2nd" }
+
+    assert_equal({ m1v1 => "model/1", m2v1 => "model/2" }, first_fetch_values)
+    assert_equal({ m1v1 => "model/1", m2v2 => "model/2 2nd" }, second_fetch_values)
+  end
+
+  def test_version_is_normalized
+    @cache.write("foo", "bar", version: 1)
+    assert_equal "bar", @cache.read("foo", version: "1")
+  end
+end
diff --git a/activesupport/test/cache/behaviors/encoded_key_cache_behavior.rb b/activesupport/test/cache/behaviors/encoded_key_cache_behavior.rb
new file mode 100644
index 0000000000..da16142496
--- /dev/null
+++ b/activesupport/test/cache/behaviors/encoded_key_cache_behavior.rb
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# https://rails.lighthouseapp.com/projects/8994/tickets/6225-memcachestore-cant-deal-with-umlauts-and-special-characters
+# The error is caused by character encodings that can't be compared with ASCII-8BIT regular expressions and by special
+# characters like the umlaut in UTF-8.
+module EncodedKeyCacheBehavior
+  Encoding.list.each do |encoding|
+    define_method "test_#{encoding.name.underscore}_encoded_values" do
+      key = "foo".dup.force_encoding(encoding)
+      assert @cache.write(key, "1", raw: true)
+      assert_equal "1", @cache.read(key)
+      assert_equal "1", @cache.fetch(key)
+      assert @cache.delete(key)
+      assert_equal "2", @cache.fetch(key, raw: true) { "2" }
+      assert_equal 3, @cache.increment(key)
+      assert_equal 2, @cache.decrement(key)
+    end
+  end
+
+  def test_common_utf8_values
+    key = "\xC3\xBCmlaut".dup.force_encoding(Encoding::UTF_8)
+    assert @cache.write(key, "1", raw: true)
+    assert_equal "1", @cache.read(key)
+    assert_equal "1", @cache.fetch(key)
+    assert @cache.delete(key)
+    assert_equal "2", @cache.fetch(key, raw: true) { "2" }
+    assert_equal 3, @cache.increment(key)
+    assert_equal 2, @cache.decrement(key)
+  end
+
+  def test_retains_encoding
+    key = "\xC3\xBCmlaut".dup.force_encoding(Encoding::UTF_8)
+    assert @cache.write(key, "1", raw: true)
+    assert_equal Encoding::UTF_8, key.encoding
+  end
+end
diff --git a/activesupport/test/cache/behaviors/local_cache_behavior.rb b/activesupport/test/cache/behaviors/local_cache_behavior.rb
new file mode 100644
index 0000000000..8dec8090b1
--- /dev/null
+++ b/activesupport/test/cache/behaviors/local_cache_behavior.rb
@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module LocalCacheBehavior
+  def test_local_writes_are_persistent_on_the_remote_cache
+    retval = @cache.with_local_cache do
+      @cache.write("foo", "bar")
+    end
+    assert retval
+    assert_equal "bar", @cache.read("foo")
+  end
+
+  def test_clear_also_clears_local_cache
+    @cache.with_local_cache do
+      @cache.write("foo", "bar")
+      @cache.clear
+      assert_nil @cache.read("foo")
+    end
+
+    assert_nil @cache.read("foo")
+  end
+
+  def test_cleanup_clears_local_cache_but_not_remote_cache
+    skip unless @cache.class.instance_methods(false).include?(:cleanup)
+
+    @cache.with_local_cache do
+      @cache.write("foo", "bar")
+      assert_equal "bar", @cache.read("foo")
+
+      @cache.send(:bypass_local_cache) { @cache.write("foo", "baz") }
+      assert_equal "bar", @cache.read("foo")
+
+      @cache.cleanup
+      assert_equal "baz", @cache.read("foo")
+    end
+  end
+
+  def test_local_cache_of_write
+    @cache.with_local_cache do
+      @cache.write("foo", "bar")
+      @peek.delete("foo")
+      assert_equal "bar", @cache.read("foo")
+    end
+  end
+
+  def test_local_cache_of_read
+    @cache.write("foo", "bar")
+    @cache.with_local_cache do
+      assert_equal "bar", @cache.read("foo")
+    end
+  end
+
+  def test_local_cache_of_read_nil
+    @cache.with_local_cache do
+      assert_nil @cache.read("foo")
+      @cache.send(:bypass_local_cache) { @cache.write "foo", "bar" }
+      assert_nil @cache.read("foo")
+    end
+  end
+
+  def test_local_cache_fetch
+    @cache.with_local_cache do
+      @cache.send(:local_cache).write "foo", "bar"
+      assert_equal "bar", @cache.send(:local_cache).fetch("foo")
+    end
+  end
+
+  def test_local_cache_of_write_nil
+    @cache.with_local_cache do
+      assert @cache.write("foo", nil)
+      assert_nil @cache.read("foo")
+      @peek.write("foo", "bar")
+      assert_nil @cache.read("foo")
+    end
+  end
+
+  def test_local_cache_of_write_with_unless_exist
+    @cache.with_local_cache do
+      @cache.write("foo", "bar")
+      @cache.write("foo", "baz", unless_exist: true)
+      assert_equal @peek.read("foo"), @cache.read("foo")
+    end
+  end
+
+  def test_local_cache_of_delete
+    @cache.with_local_cache do
+      @cache.write("foo", "bar")
+      @cache.delete("foo")
+      assert_nil @cache.read("foo")
+    end
+  end
+
+  def test_local_cache_of_exist
+    @cache.with_local_cache do
+      @cache.write("foo", "bar")
+      @peek.delete("foo")
+      assert @cache.exist?("foo")
+    end
+  end
+
+  def test_local_cache_of_increment
+    @cache.with_local_cache do
+      @cache.write("foo", 1, raw: true)
+      @peek.write("foo", 2, raw: true)
+      @cache.increment("foo")
+      assert_equal 3, @cache.read("foo")
+    end
+  end
+
+  def test_local_cache_of_decrement
+    @cache.with_local_cache do
+      @cache.write("foo", 1, raw: true)
+      @peek.write("foo", 3, raw: true)
+      @cache.decrement("foo")
+      assert_equal 2, @cache.read("foo")
+    end
+  end
+
+  def test_middleware
+    app = lambda { |env|
+      result = @cache.write("foo", "bar")
+      assert_equal "bar", @cache.read("foo") # make sure 'foo' was written
+      assert result
+      [200, {}, []]
+    }
+    app = @cache.middleware.new(app)
+    app.call({})
+  end
+end
diff --git a/activesupport/test/cache/cache_entry_test.rb b/activesupport/test/cache/cache_entry_test.rb
new file mode 100644
index 0000000000..51b214ad8f
--- /dev/null
+++ b/activesupport/test/cache/cache_entry_test.rb
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "active_support/cache"
+
+class CacheEntryTest < ActiveSupport::TestCase
+  def test_expired
+    entry = ActiveSupport::Cache::Entry.new("value")
+    assert !entry.expired?, "entry not expired"
+    entry = ActiveSupport::Cache::Entry.new("value", expires_in: 60)
+    assert !entry.expired?, "entry not expired"
+    Time.stub(:now, Time.now + 61) do
+      assert entry.expired?, "entry is expired"
+    end
+  end
+
+  def test_compress_values
+    value = "value" * 100
+    entry = ActiveSupport::Cache::Entry.new(value, compress: true, compress_threshold: 1)
+    assert_equal value, entry.value
+    assert(value.bytesize > entry.size, "value is compressed")
+  end
+
+  def test_non_compress_values
+    value = "value" * 100
+    entry = ActiveSupport::Cache::Entry.new(value)
+    assert_equal value, entry.value
+    assert_equal value.bytesize, entry.size
+  end
+end
diff --git a/activesupport/test/cache/cache_key_test.rb b/activesupport/test/cache/cache_key_test.rb
new file mode 100644
index 0000000000..84e656f504
--- /dev/null
+++ b/activesupport/test/cache/cache_key_test.rb
@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "active_support/cache"
+
+class CacheKeyTest < ActiveSupport::TestCase
+  def test_entry_legacy_optional_ivars
+    legacy = Class.new(ActiveSupport::Cache::Entry) do
+      def initialize(value, options = {})
+        @value = value
+        @expires_in = nil
+        @created_at = nil
+        super
+      end
+    end
+
+    entry = legacy.new "foo"
+    assert_equal "foo", entry.value
+  end
+
+  def test_expand_cache_key
+    assert_equal "1/2/true", ActiveSupport::Cache.expand_cache_key([1, "2", true])
+    assert_equal "name/1/2/true", ActiveSupport::Cache.expand_cache_key([1, "2", true], :name)
+  end
+
+  def test_expand_cache_key_with_rails_cache_id
+    with_env("RAILS_CACHE_ID" => "c99") do
+      assert_equal "c99/foo", ActiveSupport::Cache.expand_cache_key(:foo)
+      assert_equal "c99/foo", ActiveSupport::Cache.expand_cache_key([:foo])
+      assert_equal "c99/foo/bar", ActiveSupport::Cache.expand_cache_key([:foo, :bar])
+      assert_equal "nm/c99/foo", ActiveSupport::Cache.expand_cache_key(:foo, :nm)
+      assert_equal "nm/c99/foo", ActiveSupport::Cache.expand_cache_key([:foo], :nm)
+      assert_equal "nm/c99/foo/bar", ActiveSupport::Cache.expand_cache_key([:foo, :bar], :nm)
+    end
+  end
+
+  def test_expand_cache_key_with_rails_app_version
+    with_env("RAILS_APP_VERSION" => "rails3") do
+      assert_equal "rails3/foo", ActiveSupport::Cache.expand_cache_key(:foo)
+    end
+  end
+
+  def test_expand_cache_key_rails_cache_id_should_win_over_rails_app_version
+    with_env("RAILS_CACHE_ID" => "c99", "RAILS_APP_VERSION" => "rails3") do
+      assert_equal "c99/foo", ActiveSupport::Cache.expand_cache_key(:foo)
+    end
+  end
+
+  def test_expand_cache_key_respond_to_cache_key
+    key = "foo".dup
+    def key.cache_key
+      :foo_key
+    end
+    assert_equal "foo_key", ActiveSupport::Cache.expand_cache_key(key)
+  end
+
+  def test_expand_cache_key_array_with_something_that_responds_to_cache_key
+    key = "foo".dup
+    def key.cache_key
+      :foo_key
+    end
+    assert_equal "foo_key", ActiveSupport::Cache.expand_cache_key([key])
+  end
+
+  def test_expand_cache_key_of_nil
+    assert_equal "", ActiveSupport::Cache.expand_cache_key(nil)
+  end
+
+  def test_expand_cache_key_of_false
+    assert_equal "false", ActiveSupport::Cache.expand_cache_key(false)
+  end
+
+  def test_expand_cache_key_of_true
+    assert_equal "true", ActiveSupport::Cache.expand_cache_key(true)
+  end
+
+  def test_expand_cache_key_of_array_like_object
+    assert_equal "foo/bar/baz", ActiveSupport::Cache.expand_cache_key(%w{foo bar baz}.to_enum)
+  end
+
+  private
+
+    def with_env(kv)
+      old_values = {}
+      kv.each { |key, value| old_values[key], ENV[key] = ENV[key], value }
+      yield
+    ensure
+      old_values.each { |key, value| ENV[key] = value }
+    end
+end
diff --git a/activesupport/test/cache/cache_store_logger_test.rb b/activesupport/test/cache/cache_store_logger_test.rb
new file mode 100644
index 0000000000..1af6893cc9
--- /dev/null
+++ b/activesupport/test/cache/cache_store_logger_test.rb
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "active_support/cache"
+
+class CacheStoreLoggerTest < ActiveSupport::TestCase
+  def setup
+    @cache = ActiveSupport::Cache.lookup_store(:memory_store)
+
+    @buffer = StringIO.new
+    @cache.logger = ActiveSupport::Logger.new(@buffer)
+  end
+
+  def test_logging
+    @cache.fetch("foo") { "bar" }
+    assert @buffer.string.present?
+  end
+
+  def test_log_with_string_namespace
+    @cache.fetch("foo", namespace: "string_namespace") { "bar" }
+    assert_match %r{string_namespace:foo}, @buffer.string
+  end
+
+  def test_log_with_proc_namespace
+    proc = Proc.new do
+      "proc_namespace"
+    end
+    @cache.fetch("foo", namespace: proc) { "bar" }
+    assert_match %r{proc_namespace:foo}, @buffer.string
+  end
+
+  def test_mute_logging
+    @cache.mute { @cache.fetch("foo") { "bar" } }
+    assert @buffer.string.blank?
+  end
+end
diff --git a/activesupport/test/cache/cache_store_namespace_test.rb b/activesupport/test/cache/cache_store_namespace_test.rb
new file mode 100644
index 0000000000..b52a61c500
--- /dev/null
+++ b/activesupport/test/cache/cache_store_namespace_test.rb
@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "active_support/cache"
+
+class CacheStoreNamespaceTest < ActiveSupport::TestCase
+  def test_static_namespace
+    cache = ActiveSupport::Cache.lookup_store(:memory_store, namespace: "tester")
+    cache.write("foo", "bar")
+    assert_equal "bar", cache.read("foo")
+    assert_equal "bar", cache.instance_variable_get(:@data)["tester:foo"].value
+  end
+
+  def test_proc_namespace
+    test_val = "tester"
+    proc = lambda { test_val }
+    cache = ActiveSupport::Cache.lookup_store(:memory_store, namespace: proc)
+    cache.write("foo", "bar")
+    assert_equal "bar", cache.read("foo")
+    assert_equal "bar", cache.instance_variable_get(:@data)["tester:foo"].value
+  end
+
+  def test_delete_matched_key_start
+    cache = ActiveSupport::Cache.lookup_store(:memory_store, namespace: "tester")
+    cache.write("foo", "bar")
+    cache.write("fu", "baz")
+    cache.delete_matched(/^fo/)
+    assert !cache.exist?("foo")
+    assert cache.exist?("fu")
+  end
+
+  def test_delete_matched_key
+    cache = ActiveSupport::Cache.lookup_store(:memory_store, namespace: "foo")
+    cache.write("foo", "bar")
+    cache.write("fu", "baz")
+    cache.delete_matched(/OO/i)
+    assert !cache.exist?("foo")
+    assert cache.exist?("fu")
+  end
+end
diff --git a/activesupport/test/cache/cache_store_setting_test.rb b/activesupport/test/cache/cache_store_setting_test.rb
new file mode 100644
index 0000000000..368cb39f97
--- /dev/null
+++ b/activesupport/test/cache/cache_store_setting_test.rb
@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "active_support/cache"
+require "dalli"
+
+class CacheStoreSettingTest < ActiveSupport::TestCase
+  def test_memory_store_gets_created_if_no_arguments_passed_to_lookup_store_method
+    store = ActiveSupport::Cache.lookup_store
+    assert_kind_of(ActiveSupport::Cache::MemoryStore, store)
+  end
+
+  def test_memory_store
+    store = ActiveSupport::Cache.lookup_store :memory_store
+    assert_kind_of(ActiveSupport::Cache::MemoryStore, store)
+  end
+
+  def test_file_fragment_cache_store
+    store = ActiveSupport::Cache.lookup_store :file_store, "/path/to/cache/directory"
+    assert_kind_of(ActiveSupport::Cache::FileStore, store)
+    assert_equal "/path/to/cache/directory", store.cache_path
+  end
+
+  def test_mem_cache_fragment_cache_store
+    assert_called_with(Dalli::Client, :new, [%w[localhost], {}]) do
+      store = ActiveSupport::Cache.lookup_store :mem_cache_store, "localhost"
+      assert_kind_of(ActiveSupport::Cache::MemCacheStore, store)
+    end
+  end
+
+  def test_mem_cache_fragment_cache_store_with_given_mem_cache
+    mem_cache = Dalli::Client.new
+    assert_not_called(Dalli::Client, :new) do
+      store = ActiveSupport::Cache.lookup_store :mem_cache_store, mem_cache
+      assert_kind_of(ActiveSupport::Cache::MemCacheStore, store)
+    end
+  end
+
+  def test_mem_cache_fragment_cache_store_with_not_dalli_client
+    assert_not_called(Dalli::Client, :new) do
+      memcache = Object.new
+      assert_raises(ArgumentError) do
+        ActiveSupport::Cache.lookup_store :mem_cache_store, memcache
+      end
+    end
+  end
+
+  def test_mem_cache_fragment_cache_store_with_multiple_servers
+    assert_called_with(Dalli::Client, :new, [%w[localhost 192.168.1.1], {}]) do
+      store = ActiveSupport::Cache.lookup_store :mem_cache_store, "localhost", "192.168.1.1"
+      assert_kind_of(ActiveSupport::Cache::MemCacheStore, store)
+    end
+  end
+
+  def test_mem_cache_fragment_cache_store_with_options
+    assert_called_with(Dalli::Client, :new, [%w[localhost 192.168.1.1], { timeout: 10 }]) do
+      store = ActiveSupport::Cache.lookup_store :mem_cache_store, "localhost", "192.168.1.1", namespace: "foo", timeout: 10
+      assert_kind_of(ActiveSupport::Cache::MemCacheStore, store)
+      assert_equal "foo", store.options[:namespace]
+    end
+  end
+
+  def test_object_assigned_fragment_cache_store
+    store = ActiveSupport::Cache.lookup_store ActiveSupport::Cache::FileStore.new("/path/to/cache/directory")
+    assert_kind_of(ActiveSupport::Cache::FileStore, store)
+    assert_equal "/path/to/cache/directory", store.cache_path
+  end
+end
diff --git a/activesupport/test/cache/cache_store_write_multi_test.rb b/activesupport/test/cache/cache_store_write_multi_test.rb
new file mode 100644
index 0000000000..5b6fd678c5
--- /dev/null
+++ b/activesupport/test/cache/cache_store_write_multi_test.rb
@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "active_support/cache"
+
+class CacheStoreWriteMultiEntriesStoreProviderInterfaceTest < ActiveSupport::TestCase
+  setup do
+    @cache = ActiveSupport::Cache.lookup_store(:null_store)
+  end
+
+  test "fetch_multi uses write_multi_entries store provider interface" do
+    assert_called_with(@cache, :write_multi_entries) do
+      @cache.fetch_multi "a", "b", "c" do |key|
+        key * 2
+      end
+    end
+  end
+end
+
+class CacheStoreWriteMultiInstrumentationTest < ActiveSupport::TestCase
+  setup do
+    @cache = ActiveSupport::Cache.lookup_store(:null_store)
+  end
+
+  test "instrumentation" do
+    writes = { "a" => "aa", "b" => "bb" }
+
+    events = with_instrumentation "write_multi" do
+      @cache.write_multi(writes)
+    end
+
+    assert_equal %w[ cache_write_multi.active_support ], events.map(&:name)
+    assert_nil events[0].payload[:super_operation]
+    assert_equal({ "a" => "aa", "b" => "bb" }, events[0].payload[:key])
+  end
+
+  test "instrumentation with fetch_multi as super operation" do
+    skip "fetch_multi isn't instrumented yet"
+
+    events = with_instrumentation "write_multi" do
+      @cache.fetch_multi("a", "b") { |key| key * 2 }
+    end
+
+    assert_equal %w[ cache_write_multi.active_support ], events.map(&:name)
+    assert_nil events[0].payload[:super_operation]
+    assert !events[0].payload[:hit]
+  end
+
+  private
+    def with_instrumentation(method)
+      event_name = "cache_#{method}.active_support"
+
+      [].tap do |events|
+        ActiveSupport::Notifications.subscribe event_name do |*args|
+          events << ActiveSupport::Notifications::Event.new(*args)
+        end
+        yield
+      end
+    ensure
+      ActiveSupport::Notifications.unsubscribe event_name
+    end
+end
diff --git a/activesupport/test/cache/local_cache_middleware_test.rb b/activesupport/test/cache/local_cache_middleware_test.rb
new file mode 100644
index 0000000000..e59fae0b4c
--- /dev/null
+++ b/activesupport/test/cache/local_cache_middleware_test.rb
@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "active_support/cache"
+
+module ActiveSupport
+  module Cache
+    module Strategy
+      module LocalCache
+        class MiddlewareTest < ActiveSupport::TestCase
+          def test_local_cache_cleared_on_close
+            key = "super awesome key"
+            assert_nil LocalCacheRegistry.cache_for key
+            middleware = Middleware.new("<3", key).new(->(env) {
+              assert LocalCacheRegistry.cache_for(key), "should have a cache"
+              [200, {}, []]
+            })
+            _, _, body = middleware.call({})
+            assert LocalCacheRegistry.cache_for(key), "should still have a cache"
+            body.each {}
+            assert LocalCacheRegistry.cache_for(key), "should still have a cache"
+            body.close
+            assert_nil LocalCacheRegistry.cache_for(key)
+          end
+
+          def test_local_cache_cleared_and_response_should_be_present_on_invalid_parameters_error
+            key = "super awesome key"
+            assert_nil LocalCacheRegistry.cache_for key
+            middleware = Middleware.new("<3", key).new(->(env) {
+              assert LocalCacheRegistry.cache_for(key), "should have a cache"
+              raise Rack::Utils::InvalidParameterError
+            })
+            response = middleware.call({})
+            assert response, "response should exist"
+            assert_nil LocalCacheRegistry.cache_for(key)
+          end
+
+          def test_local_cache_cleared_on_exception
+            key = "super awesome key"
+            assert_nil LocalCacheRegistry.cache_for key
+            middleware = Middleware.new("<3", key).new(->(env) {
+              assert LocalCacheRegistry.cache_for(key), "should have a cache"
+              raise
+            })
+            assert_raises(RuntimeError) { middleware.call({}) }
+            assert_nil LocalCacheRegistry.cache_for(key)
+          end
+
+          def test_local_cache_cleared_on_throw
+            key = "super awesome key"
+            assert_nil LocalCacheRegistry.cache_for key
+            middleware = Middleware.new("<3", key).new(->(env) {
+              assert LocalCacheRegistry.cache_for(key), "should have a cache"
+              throw :warden
+            })
+            assert_throws(:warden) { middleware.call({}) }
+            assert_nil LocalCacheRegistry.cache_for(key)
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activesupport/test/cache/stores/file_store_test.rb b/activesupport/test/cache/stores/file_store_test.rb
new file mode 100644
index 0000000000..391ab60b3a
--- /dev/null
+++ b/activesupport/test/cache/stores/file_store_test.rb
@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "active_support/cache"
+require_relative "../behaviors"
+require "pathname"
+
+class FileStoreTest < ActiveSupport::TestCase
+  def setup
+    Dir.mkdir(cache_dir) unless File.exist?(cache_dir)
+    @cache = ActiveSupport::Cache.lookup_store(:file_store, cache_dir, expires_in: 60)
+    @peek = ActiveSupport::Cache.lookup_store(:file_store, cache_dir, expires_in: 60)
+    @cache_with_pathname = ActiveSupport::Cache.lookup_store(:file_store, Pathname.new(cache_dir), expires_in: 60)
+
+    @buffer = StringIO.new
+    @cache.logger = ActiveSupport::Logger.new(@buffer)
+  end
+
+  def teardown
+    FileUtils.rm_r(cache_dir)
+  rescue Errno::ENOENT
+  end
+
+  def cache_dir
+    File.join(Dir.pwd, "tmp_cache")
+  end
+
+  include CacheStoreBehavior
+  include CacheStoreVersionBehavior
+  include LocalCacheBehavior
+  include CacheDeleteMatchedBehavior
+  include CacheIncrementDecrementBehavior
+  include AutoloadingCacheBehavior
+
+  def test_clear
+    gitkeep = File.join(cache_dir, ".gitkeep")
+    keep = File.join(cache_dir, ".keep")
+    FileUtils.touch([gitkeep, keep])
+    @cache.clear
+    assert File.exist?(gitkeep)
+    assert File.exist?(keep)
+  end
+
+  def test_clear_without_cache_dir
+    FileUtils.rm_r(cache_dir)
+    @cache.clear
+  end
+
+  def test_long_uri_encoded_keys
+    @cache.write("%" * 870, 1)
+    assert_equal 1, @cache.read("%" * 870)
+  end
+
+  def test_key_transformation
+    key = @cache.send(:normalize_key, "views/index?id=1", {})
+    assert_equal "views/index?id=1", @cache.send(:file_path_key, key)
+  end
+
+  def test_key_transformation_with_pathname
+    FileUtils.touch(File.join(cache_dir, "foo"))
+    key = @cache_with_pathname.send(:normalize_key, "views/index?id=1", {})
+    assert_equal "views/index?id=1", @cache_with_pathname.send(:file_path_key, key)
+  end
+
+  # Test that generated cache keys are short enough to have Tempfile stuff added to them and
+  # remain valid
+  def test_filename_max_size
+    key = "#{'A' * ActiveSupport::Cache::FileStore::FILENAME_MAX_SIZE}"
+    path = @cache.send(:normalize_key, key, {})
+    Dir::Tmpname.create(path) do |tmpname, n, opts|
+      assert File.basename(tmpname + ".lock").length <= 255, "Temp filename too long: #{File.basename(tmpname + '.lock').length}"
+    end
+  end
+
+  # Because file systems have a maximum filename size, filenames > max size should be split in to directories
+  # If filename is 'AAAAB', where max size is 4, the returned path should be AAAA/B
+  def test_key_transformation_max_filename_size
+    key = "#{'A' * ActiveSupport::Cache::FileStore::FILENAME_MAX_SIZE}B"
+    path = @cache.send(:normalize_key, key, {})
+    assert path.split("/").all? { |dir_name| dir_name.size <= ActiveSupport::Cache::FileStore::FILENAME_MAX_SIZE }
+    assert_equal "B", File.basename(path)
+  end
+
+  # If nothing has been stored in the cache, there is a chance the cache directory does not yet exist
+  # Ensure delete_matched gracefully handles this case
+  def test_delete_matched_when_cache_directory_does_not_exist
+    assert_nothing_raised do
+      ActiveSupport::Cache::FileStore.new("/test/cache/directory").delete_matched(/does_not_exist/)
+    end
+  end
+
+  def test_delete_does_not_delete_empty_parent_dir
+    sub_cache_dir = File.join(cache_dir, "subdir/")
+    sub_cache_store = ActiveSupport::Cache::FileStore.new(sub_cache_dir)
+    assert_nothing_raised do
+      assert sub_cache_store.write("foo", "bar")
+      assert sub_cache_store.delete("foo")
+    end
+    assert File.exist?(cache_dir), "Parent of top level cache dir was deleted!"
+    assert File.exist?(sub_cache_dir), "Top level cache dir was deleted!"
+    assert Dir.entries(sub_cache_dir).reject { |f| ActiveSupport::Cache::FileStore::EXCLUDED_DIRS.include?(f) }.empty?
+  end
+
+  def test_log_exception_when_cache_read_fails
+    File.stub(:exist?, -> { raise StandardError.new("failed") }) do
+      @cache.send(:read_entry, "winston", {})
+      assert @buffer.string.present?
+    end
+  end
+
+  def test_cleanup_removes_all_expired_entries
+    time = Time.now
+    @cache.write("foo", "bar", expires_in: 10)
+    @cache.write("baz", "qux")
+    @cache.write("quux", "corge", expires_in: 20)
+    Time.stub(:now, time + 15) do
+      @cache.cleanup
+      assert_not @cache.exist?("foo")
+      assert @cache.exist?("baz")
+      assert @cache.exist?("quux")
+    end
+  end
+
+  def test_write_with_unless_exist
+    assert_equal true, @cache.write(1, "aaaaaaaaaa")
+    assert_equal false, @cache.write(1, "aaaaaaaaaa", unless_exist: true)
+    @cache.write(1, nil)
+    assert_equal false, @cache.write(1, "aaaaaaaaaa", unless_exist: true)
+  end
+end
diff --git a/activesupport/test/cache/stores/mem_cache_store_test.rb b/activesupport/test/cache/stores/mem_cache_store_test.rb
new file mode 100644
index 0000000000..becc1f7fbf
--- /dev/null
+++ b/activesupport/test/cache/stores/mem_cache_store_test.rb
@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "active_support/cache"
+require_relative "../behaviors"
+require "dalli"
+
+class MemCacheStoreTest < ActiveSupport::TestCase
+  begin
+    ss = Dalli::Client.new("localhost:11211").stats
+    raise Dalli::DalliError unless ss["localhost:11211"]
+
+    MEMCACHE_UP = true
+  rescue Dalli::DalliError
+    $stderr.puts "Skipping memcached tests. Start memcached and try again."
+    MEMCACHE_UP = false
+  end
+
+  def setup
+    skip "memcache server is not up" unless MEMCACHE_UP
+
+    @cache = ActiveSupport::Cache.lookup_store(:mem_cache_store, expires_in: 60)
+    @peek = ActiveSupport::Cache.lookup_store(:mem_cache_store)
+    @data = @cache.instance_variable_get(:@data)
+    @cache.clear
+    @cache.silence!
+    @cache.logger = ActiveSupport::Logger.new("/dev/null")
+  end
+
+  include CacheStoreBehavior
+  include CacheStoreVersionBehavior
+  include LocalCacheBehavior
+  include CacheIncrementDecrementBehavior
+  include EncodedKeyCacheBehavior
+  include AutoloadingCacheBehavior
+
+  def test_raw_values
+    cache = ActiveSupport::Cache.lookup_store(:mem_cache_store, raw: true)
+    cache.clear
+    cache.write("foo", 2)
+    assert_equal "2", cache.read("foo")
+  end
+
+  def test_raw_values_with_marshal
+    cache = ActiveSupport::Cache.lookup_store(:mem_cache_store, raw: true)
+    cache.clear
+    cache.write("foo", Marshal.dump([]))
+    assert_equal [], cache.read("foo")
+  end
+
+  def test_local_cache_raw_values
+    cache = ActiveSupport::Cache.lookup_store(:mem_cache_store, raw: true)
+    cache.clear
+    cache.with_local_cache do
+      cache.write("foo", 2)
+      assert_equal "2", cache.read("foo")
+    end
+  end
+
+  def test_local_cache_raw_values_with_marshal
+    cache = ActiveSupport::Cache.lookup_store(:mem_cache_store, raw: true)
+    cache.clear
+    cache.with_local_cache do
+      cache.write("foo", Marshal.dump([]))
+      assert_equal [], cache.read("foo")
+    end
+  end
+
+  def test_read_should_return_a_different_object_id_each_time_it_is_called
+    @cache.write("foo", "bar")
+    value = @cache.read("foo")
+    assert_not_equal value.object_id, @cache.read("foo").object_id
+    value << "bingo"
+    assert_not_equal value, @cache.read("foo")
+  end
+end
diff --git a/activesupport/test/cache/stores/memory_store_test.rb b/activesupport/test/cache/stores/memory_store_test.rb
new file mode 100644
index 0000000000..3981f05331
--- /dev/null
+++ b/activesupport/test/cache/stores/memory_store_test.rb
@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "active_support/cache"
+require_relative "../behaviors"
+
+class MemoryStoreTest < ActiveSupport::TestCase
+  def setup
+    @record_size = ActiveSupport::Cache.lookup_store(:memory_store).send(:cached_size, 1, ActiveSupport::Cache::Entry.new("aaaaaaaaaa"))
+    @cache = ActiveSupport::Cache.lookup_store(:memory_store, expires_in: 60, size: @record_size * 10 + 1)
+  end
+
+  include CacheStoreBehavior
+  include CacheStoreVersionBehavior
+  include CacheDeleteMatchedBehavior
+  include CacheIncrementDecrementBehavior
+
+  def test_prune_size
+    @cache.write(1, "aaaaaaaaaa") && sleep(0.001)
+    @cache.write(2, "bbbbbbbbbb") && sleep(0.001)
+    @cache.write(3, "cccccccccc") && sleep(0.001)
+    @cache.write(4, "dddddddddd") && sleep(0.001)
+    @cache.write(5, "eeeeeeeeee") && sleep(0.001)
+    @cache.read(2) && sleep(0.001)
+    @cache.read(4)
+    @cache.prune(@record_size * 3)
+    assert @cache.exist?(5)
+    assert @cache.exist?(4)
+    assert !@cache.exist?(3), "no entry"
+    assert @cache.exist?(2)
+    assert !@cache.exist?(1), "no entry"
+  end
+
+  def test_prune_size_on_write
+    @cache.write(1, "aaaaaaaaaa") && sleep(0.001)
+    @cache.write(2, "bbbbbbbbbb") && sleep(0.001)
+    @cache.write(3, "cccccccccc") && sleep(0.001)
+    @cache.write(4, "dddddddddd") && sleep(0.001)
+    @cache.write(5, "eeeeeeeeee") && sleep(0.001)
+    @cache.write(6, "ffffffffff") && sleep(0.001)
+    @cache.write(7, "gggggggggg") && sleep(0.001)
+    @cache.write(8, "hhhhhhhhhh") && sleep(0.001)
+    @cache.write(9, "iiiiiiiiii") && sleep(0.001)
+    @cache.write(10, "kkkkkkkkkk") && sleep(0.001)
+    @cache.read(2) && sleep(0.001)
+    @cache.read(4) && sleep(0.001)
+    @cache.write(11, "llllllllll")
+    assert @cache.exist?(11)
+    assert @cache.exist?(10)
+    assert @cache.exist?(9)
+    assert @cache.exist?(8)
+    assert @cache.exist?(7)
+    assert !@cache.exist?(6), "no entry"
+    assert !@cache.exist?(5), "no entry"
+    assert @cache.exist?(4)
+    assert !@cache.exist?(3), "no entry"
+    assert @cache.exist?(2)
+    assert !@cache.exist?(1), "no entry"
+  end
+
+  def test_prune_size_on_write_based_on_key_length
+    @cache.write(1, "aaaaaaaaaa") && sleep(0.001)
+    @cache.write(2, "bbbbbbbbbb") && sleep(0.001)
+    @cache.write(3, "cccccccccc") && sleep(0.001)
+    @cache.write(4, "dddddddddd") && sleep(0.001)
+    @cache.write(5, "eeeeeeeeee") && sleep(0.001)
+    @cache.write(6, "ffffffffff") && sleep(0.001)
+    @cache.write(7, "gggggggggg") && sleep(0.001)
+    @cache.write(8, "hhhhhhhhhh") && sleep(0.001)
+    @cache.write(9, "iiiiiiiiii") && sleep(0.001)
+    long_key = "*" * 2 * @record_size
+    @cache.write(long_key, "llllllllll")
+    assert @cache.exist?(long_key)
+    assert @cache.exist?(9)
+    assert @cache.exist?(8)
+    assert @cache.exist?(7)
+    assert @cache.exist?(6)
+    assert !@cache.exist?(5), "no entry"
+    assert !@cache.exist?(4), "no entry"
+    assert !@cache.exist?(3), "no entry"
+    assert !@cache.exist?(2), "no entry"
+    assert !@cache.exist?(1), "no entry"
+  end
+
+  def test_pruning_is_capped_at_a_max_time
+    def @cache.delete_entry(*args)
+      sleep(0.01)
+      super
+    end
+    @cache.write(1, "aaaaaaaaaa") && sleep(0.001)
+    @cache.write(2, "bbbbbbbbbb") && sleep(0.001)
+    @cache.write(3, "cccccccccc") && sleep(0.001)
+    @cache.write(4, "dddddddddd") && sleep(0.001)
+    @cache.write(5, "eeeeeeeeee") && sleep(0.001)
+    @cache.prune(30, 0.001)
+    assert @cache.exist?(5)
+    assert @cache.exist?(4)
+    assert @cache.exist?(3)
+    assert @cache.exist?(2)
+    assert !@cache.exist?(1)
+  end
+
+  def test_write_with_unless_exist
+    assert_equal true, @cache.write(1, "aaaaaaaaaa")
+    assert_equal false, @cache.write(1, "aaaaaaaaaa", unless_exist: true)
+    @cache.write(1, nil)
+    assert_equal false, @cache.write(1, "aaaaaaaaaa", unless_exist: true)
+  end
+end
diff --git a/activesupport/test/cache/stores/null_store_test.rb b/activesupport/test/cache/stores/null_store_test.rb
new file mode 100644
index 0000000000..a891cbffc8
--- /dev/null
+++ b/activesupport/test/cache/stores/null_store_test.rb
@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "active_support/cache"
+require_relative "../behaviors"
+
+class NullStoreTest < ActiveSupport::TestCase
+  def setup
+    @cache = ActiveSupport::Cache.lookup_store(:null_store)
+  end
+
+  def test_clear
+    @cache.clear
+  end
+
+  def test_cleanup
+    @cache.cleanup
+  end
+
+  def test_write
+    assert_equal true, @cache.write("name", "value")
+  end
+
+  def test_read
+    @cache.write("name", "value")
+    assert_nil @cache.read("name")
+  end
+
+  def test_delete
+    @cache.write("name", "value")
+    assert_equal false, @cache.delete("name")
+  end
+
+  def test_increment
+    @cache.write("name", 1, raw: true)
+    assert_nil @cache.increment("name")
+  end
+
+  def test_decrement
+    @cache.write("name", 1, raw: true)
+    assert_nil @cache.increment("name")
+  end
+
+  def test_delete_matched
+    @cache.write("name", "value")
+    @cache.delete_matched(/name/)
+  end
+
+  def test_local_store_strategy
+    @cache.with_local_cache do
+      @cache.write("name", "value")
+      assert_equal "value", @cache.read("name")
+      @cache.delete("name")
+      assert_nil @cache.read("name")
+      @cache.write("name", "value")
+    end
+    assert_nil @cache.read("name")
+  end
+end
diff --git a/activesupport/test/caching_test.rb b/activesupport/test/caching_test.rb
deleted file mode 100644
index c543122d91..0000000000
--- a/activesupport/test/caching_test.rb
+++ /dev/null
@@ -1,1192 +0,0 @@
-require "logger"
-require "abstract_unit"
-require "active_support/cache"
-require "dependencies_test_helpers"
-
-require "pathname"
-
-module ActiveSupport
-  module Cache
-    module Strategy
-      module LocalCache
-        class MiddlewareTest < ActiveSupport::TestCase
-          def test_local_cache_cleared_on_close
-            key = "super awesome key"
-            assert_nil LocalCacheRegistry.cache_for key
-            middleware = Middleware.new("<3", key).new(->(env) {
-              assert LocalCacheRegistry.cache_for(key), "should have a cache"
-              [200, {}, []]
-            })
-            _, _, body = middleware.call({})
-            assert LocalCacheRegistry.cache_for(key), "should still have a cache"
-            body.each {}
-            assert LocalCacheRegistry.cache_for(key), "should still have a cache"
-            body.close
-            assert_nil LocalCacheRegistry.cache_for(key)
-          end
-
-          def test_local_cache_cleared_and_response_should_be_present_on_invalid_parameters_error
-            key = "super awesome key"
-            assert_nil LocalCacheRegistry.cache_for key
-            middleware = Middleware.new("<3", key).new(->(env) {
-              assert LocalCacheRegistry.cache_for(key), "should have a cache"
-              raise Rack::Utils::InvalidParameterError
-            })
-            response = middleware.call({})
-            assert response, "response should exist"
-            assert_nil LocalCacheRegistry.cache_for(key)
-          end
-
-          def test_local_cache_cleared_on_exception
-            key = "super awesome key"
-            assert_nil LocalCacheRegistry.cache_for key
-            middleware = Middleware.new("<3", key).new(->(env) {
-              assert LocalCacheRegistry.cache_for(key), "should have a cache"
-              raise
-            })
-            assert_raises(RuntimeError) { middleware.call({}) }
-            assert_nil LocalCacheRegistry.cache_for(key)
-          end
-        end
-      end
-    end
-  end
-end
-
-class CacheKeyTest < ActiveSupport::TestCase
-  def test_entry_legacy_optional_ivars
-    legacy = Class.new(ActiveSupport::Cache::Entry) do
-      def initialize(value, options = {})
-        @value = value
-        @expires_in = nil
-        @created_at = nil
-        super
-      end
-    end
-
-    entry = legacy.new "foo"
-    assert_equal "foo", entry.value
-  end
-
-  def test_expand_cache_key
-    assert_equal "1/2/true", ActiveSupport::Cache.expand_cache_key([1, "2", true])
-    assert_equal "name/1/2/true", ActiveSupport::Cache.expand_cache_key([1, "2", true], :name)
-  end
-
-  def test_expand_cache_key_with_rails_cache_id
-    with_env("RAILS_CACHE_ID" => "c99") do
-      assert_equal "c99/foo", ActiveSupport::Cache.expand_cache_key(:foo)
-      assert_equal "c99/foo", ActiveSupport::Cache.expand_cache_key([:foo])
-      assert_equal "c99/foo/bar", ActiveSupport::Cache.expand_cache_key([:foo, :bar])
-      assert_equal "nm/c99/foo", ActiveSupport::Cache.expand_cache_key(:foo, :nm)
-      assert_equal "nm/c99/foo", ActiveSupport::Cache.expand_cache_key([:foo], :nm)
-      assert_equal "nm/c99/foo/bar", ActiveSupport::Cache.expand_cache_key([:foo, :bar], :nm)
-    end
-  end
-
-  def test_expand_cache_key_with_rails_app_version
-    with_env("RAILS_APP_VERSION" => "rails3") do
-      assert_equal "rails3/foo", ActiveSupport::Cache.expand_cache_key(:foo)
-    end
-  end
-
-  def test_expand_cache_key_rails_cache_id_should_win_over_rails_app_version
-    with_env("RAILS_CACHE_ID" => "c99", "RAILS_APP_VERSION" => "rails3") do
-      assert_equal "c99/foo", ActiveSupport::Cache.expand_cache_key(:foo)
-    end
-  end
-
-  def test_expand_cache_key_respond_to_cache_key
-    key = "foo"
-    def key.cache_key
-      :foo_key
-    end
-    assert_equal "foo_key", ActiveSupport::Cache.expand_cache_key(key)
-  end
-
-  def test_expand_cache_key_array_with_something_that_responds_to_cache_key
-    key = "foo"
-    def key.cache_key
-      :foo_key
-    end
-    assert_equal "foo_key", ActiveSupport::Cache.expand_cache_key([key])
-  end
-
-  def test_expand_cache_key_of_nil
-    assert_equal "", ActiveSupport::Cache.expand_cache_key(nil)
-  end
-
-  def test_expand_cache_key_of_false
-    assert_equal "false", ActiveSupport::Cache.expand_cache_key(false)
-  end
-
-  def test_expand_cache_key_of_true
-    assert_equal "true", ActiveSupport::Cache.expand_cache_key(true)
-  end
-
-  def test_expand_cache_key_of_array_like_object
-    assert_equal "foo/bar/baz", ActiveSupport::Cache.expand_cache_key(%w{foo bar baz}.to_enum)
-  end
-
-  private
-
-    def with_env(kv)
-      old_values = {}
-      kv.each { |key, value| old_values[key], ENV[key] = ENV[key], value }
-      yield
-    ensure
-      old_values.each { |key, value| ENV[key] = value }
-    end
-end
-
-class CacheStoreSettingTest < ActiveSupport::TestCase
-  def test_memory_store_gets_created_if_no_arguments_passed_to_lookup_store_method
-    store = ActiveSupport::Cache.lookup_store
-    assert_kind_of(ActiveSupport::Cache::MemoryStore, store)
-  end
-
-  def test_memory_store
-    store = ActiveSupport::Cache.lookup_store :memory_store
-    assert_kind_of(ActiveSupport::Cache::MemoryStore, store)
-  end
-
-  def test_file_fragment_cache_store
-    store = ActiveSupport::Cache.lookup_store :file_store, "/path/to/cache/directory"
-    assert_kind_of(ActiveSupport::Cache::FileStore, store)
-    assert_equal "/path/to/cache/directory", store.cache_path
-  end
-
-  def test_mem_cache_fragment_cache_store
-    assert_called_with(Dalli::Client, :new, [%w[localhost], {}]) do
-      store = ActiveSupport::Cache.lookup_store :mem_cache_store, "localhost"
-      assert_kind_of(ActiveSupport::Cache::MemCacheStore, store)
-    end
-  end
-
-  def test_mem_cache_fragment_cache_store_with_given_mem_cache
-    mem_cache = Dalli::Client.new
-    assert_not_called(Dalli::Client, :new) do
-      store = ActiveSupport::Cache.lookup_store :mem_cache_store, mem_cache
-      assert_kind_of(ActiveSupport::Cache::MemCacheStore, store)
-    end
-  end
-
-  def test_mem_cache_fragment_cache_store_with_not_dalli_client
-    assert_not_called(Dalli::Client, :new) do
-      memcache = Object.new
-      assert_raises(ArgumentError) do
-        ActiveSupport::Cache.lookup_store :mem_cache_store, memcache
-      end
-    end
-  end
-
-  def test_mem_cache_fragment_cache_store_with_multiple_servers
-    assert_called_with(Dalli::Client, :new, [%w[localhost 192.168.1.1], {}]) do
-      store = ActiveSupport::Cache.lookup_store :mem_cache_store, "localhost", "192.168.1.1"
-      assert_kind_of(ActiveSupport::Cache::MemCacheStore, store)
-    end
-  end
-
-  def test_mem_cache_fragment_cache_store_with_options
-    assert_called_with(Dalli::Client, :new, [%w[localhost 192.168.1.1], { timeout: 10 }]) do
-      store = ActiveSupport::Cache.lookup_store :mem_cache_store, "localhost", "192.168.1.1", namespace: "foo", timeout: 10
-      assert_kind_of(ActiveSupport::Cache::MemCacheStore, store)
-      assert_equal "foo", store.options[:namespace]
-    end
-  end
-
-  def test_object_assigned_fragment_cache_store
-    store = ActiveSupport::Cache.lookup_store ActiveSupport::Cache::FileStore.new("/path/to/cache/directory")
-    assert_kind_of(ActiveSupport::Cache::FileStore, store)
-    assert_equal "/path/to/cache/directory", store.cache_path
-  end
-end
-
-class CacheStoreNamespaceTest < ActiveSupport::TestCase
-  def test_static_namespace
-    cache = ActiveSupport::Cache.lookup_store(:memory_store, namespace: "tester")
-    cache.write("foo", "bar")
-    assert_equal "bar", cache.read("foo")
-    assert_equal "bar", cache.instance_variable_get(:@data)["tester:foo"].value
-  end
-
-  def test_proc_namespace
-    test_val = "tester"
-    proc = lambda { test_val }
-    cache = ActiveSupport::Cache.lookup_store(:memory_store, namespace: proc)
-    cache.write("foo", "bar")
-    assert_equal "bar", cache.read("foo")
-    assert_equal "bar", cache.instance_variable_get(:@data)["tester:foo"].value
-  end
-
-  def test_delete_matched_key_start
-    cache = ActiveSupport::Cache.lookup_store(:memory_store, namespace: "tester")
-    cache.write("foo", "bar")
-    cache.write("fu", "baz")
-    cache.delete_matched(/^fo/)
-    assert !cache.exist?("foo")
-    assert cache.exist?("fu")
-  end
-
-  def test_delete_matched_key
-    cache = ActiveSupport::Cache.lookup_store(:memory_store, namespace: "foo")
-    cache.write("foo", "bar")
-    cache.write("fu", "baz")
-    cache.delete_matched(/OO/i)
-    assert !cache.exist?("foo")
-    assert cache.exist?("fu")
-  end
-end
-
-# Tests the base functionality that should be identical across all cache stores.
-module CacheStoreBehavior
-  def test_should_read_and_write_strings
-    assert @cache.write("foo", "bar")
-    assert_equal "bar", @cache.read("foo")
-  end
-
-  def test_should_overwrite
-    @cache.write("foo", "bar")
-    @cache.write("foo", "baz")
-    assert_equal "baz", @cache.read("foo")
-  end
-
-  def test_fetch_without_cache_miss
-    @cache.write("foo", "bar")
-    assert_not_called(@cache, :write) do
-      assert_equal "bar", @cache.fetch("foo") { "baz" }
-    end
-  end
-
-  def test_fetch_with_cache_miss
-    assert_called_with(@cache, :write, ["foo", "baz", @cache.options]) do
-      assert_equal "baz", @cache.fetch("foo") { "baz" }
-    end
-  end
-
-  def test_fetch_with_cache_miss_passes_key_to_block
-    cache_miss = false
-    assert_equal 3, @cache.fetch("foo") { |key| cache_miss = true; key.length }
-    assert cache_miss
-
-    cache_miss = false
-    assert_equal 3, @cache.fetch("foo") { |key| cache_miss = true; key.length }
-    assert !cache_miss
-  end
-
-  def test_fetch_with_forced_cache_miss
-    @cache.write("foo", "bar")
-    assert_not_called(@cache, :read) do
-      assert_called_with(@cache, :write, ["foo", "bar", @cache.options.merge(force: true)]) do
-        @cache.fetch("foo", force: true) { "bar" }
-      end
-    end
-  end
-
-  def test_fetch_with_cached_nil
-    @cache.write("foo", nil)
-    assert_not_called(@cache, :write) do
-      assert_nil @cache.fetch("foo") { "baz" }
-    end
-  end
-
-  def test_fetch_with_forced_cache_miss_with_block
-    @cache.write("foo", "bar")
-    assert_equal "foo_bar", @cache.fetch("foo", force: true) { "foo_bar" }
-  end
-
-  def test_fetch_with_forced_cache_miss_without_block
-    @cache.write("foo", "bar")
-    assert_raises(ArgumentError) do
-      @cache.fetch("foo", force: true)
-    end
-
-    assert_equal "bar", @cache.read("foo")
-  end
-
-  def test_should_read_and_write_hash
-    assert @cache.write("foo", a: "b")
-    assert_equal({ a: "b" }, @cache.read("foo"))
-  end
-
-  def test_should_read_and_write_integer
-    assert @cache.write("foo", 1)
-    assert_equal 1, @cache.read("foo")
-  end
-
-  def test_should_read_and_write_nil
-    assert @cache.write("foo", nil)
-    assert_nil @cache.read("foo")
-  end
-
-  def test_should_read_and_write_false
-    assert @cache.write("foo", false)
-    assert_equal false, @cache.read("foo")
-  end
-
-  def test_read_multi
-    @cache.write("foo", "bar")
-    @cache.write("fu", "baz")
-    @cache.write("fud", "biz")
-    assert_equal({ "foo" => "bar", "fu" => "baz" }, @cache.read_multi("foo", "fu"))
-  end
-
-  def test_read_multi_with_expires
-    time = Time.now
-    @cache.write("foo", "bar", expires_in: 10)
-    @cache.write("fu", "baz")
-    @cache.write("fud", "biz")
-    Time.stub(:now, time + 11) do
-      assert_equal({ "fu" => "baz" }, @cache.read_multi("foo", "fu"))
-    end
-  end
-
-  def test_fetch_multi
-    @cache.write("foo", "bar")
-    @cache.write("fud", "biz")
-
-    values = @cache.fetch_multi("foo", "fu", "fud") { |value| value * 2 }
-
-    assert_equal({ "foo" => "bar", "fu" => "fufu", "fud" => "biz" }, values)
-    assert_equal("fufu", @cache.read("fu"))
-  end
-
-  def test_multi_with_objects
-    cache_struct = Struct.new(:cache_key, :title)
-    foo = cache_struct.new("foo", "FOO!")
-    bar = cache_struct.new("bar")
-
-    @cache.write("bar", "BAM!")
-
-    values = @cache.fetch_multi(foo, bar) { |object| object.title }
-
-    assert_equal({ foo => "FOO!", bar => "BAM!" }, values)
-  end
-
-  def test_fetch_multi_without_block
-    assert_raises(ArgumentError) do
-      @cache.fetch_multi("foo")
-    end
-  end
-
-  def test_read_and_write_compressed_small_data
-    @cache.write("foo", "bar", compress: true)
-    assert_equal "bar", @cache.read("foo")
-  end
-
-  def test_read_and_write_compressed_large_data
-    @cache.write("foo", "bar", compress: true, compress_threshold: 2)
-    assert_equal "bar", @cache.read("foo")
-  end
-
-  def test_read_and_write_compressed_nil
-    @cache.write("foo", nil, compress: true)
-    assert_nil @cache.read("foo")
-  end
-
-  def test_cache_key
-    obj = Object.new
-    def obj.cache_key
-      :foo
-    end
-    @cache.write(obj, "bar")
-    assert_equal "bar", @cache.read("foo")
-  end
-
-  def test_param_as_cache_key
-    obj = Object.new
-    def obj.to_param
-      "foo"
-    end
-    @cache.write(obj, "bar")
-    assert_equal "bar", @cache.read("foo")
-  end
-
-  def test_array_as_cache_key
-    @cache.write([:fu, "foo"], "bar")
-    assert_equal "bar", @cache.read("fu/foo")
-  end
-
-  def test_hash_as_cache_key
-    @cache.write({ foo: 1, fu: 2 }, "bar")
-    assert_equal "bar", @cache.read("foo=1/fu=2")
-  end
-
-  def test_keys_are_case_sensitive
-    @cache.write("foo", "bar")
-    assert_nil @cache.read("FOO")
-  end
-
-  def test_exist
-    @cache.write("foo", "bar")
-    assert_equal true, @cache.exist?("foo")
-    assert_equal false, @cache.exist?("bar")
-  end
-
-  def test_nil_exist
-    @cache.write("foo", nil)
-    assert @cache.exist?("foo")
-  end
-
-  def test_delete
-    @cache.write("foo", "bar")
-    assert @cache.exist?("foo")
-    assert @cache.delete("foo")
-    assert !@cache.exist?("foo")
-  end
-
-  def test_original_store_objects_should_not_be_immutable
-    bar = "bar"
-    @cache.write("foo", bar)
-    assert_nothing_raised { bar.gsub!(/.*/, "baz") }
-  end
-
-  def test_expires_in
-    time = Time.local(2008, 4, 24)
-
-    Time.stub(:now, time) do
-      @cache.write("foo", "bar")
-      assert_equal "bar", @cache.read("foo")
-    end
-
-    Time.stub(:now, time + 30) do
-      assert_equal "bar", @cache.read("foo")
-    end
-
-    Time.stub(:now, time + 61) do
-      assert_nil @cache.read("foo")
-    end
-  end
-
-  def test_race_condition_protection_skipped_if_not_defined
-    @cache.write("foo", "bar")
-    time = @cache.send(:read_entry, @cache.send(:normalize_key, "foo", {}), {}).expires_at
-
-    Time.stub(:now, Time.at(time)) do
-      result = @cache.fetch("foo") do
-        assert_nil @cache.read("foo")
-        "baz"
-      end
-      assert_equal "baz", result
-    end
-  end
-
-  def test_race_condition_protection_is_limited
-    time = Time.now
-    @cache.write("foo", "bar", expires_in: 60)
-    Time.stub(:now, time + 71) do
-      result = @cache.fetch("foo", race_condition_ttl: 10) do
-        assert_nil @cache.read("foo")
-        "baz"
-      end
-      assert_equal "baz", result
-    end
-  end
-
-  def test_race_condition_protection_is_safe
-    time = Time.now
-    @cache.write("foo", "bar", expires_in: 60)
-    Time.stub(:now, time + 61) do
-      begin
-        @cache.fetch("foo", race_condition_ttl: 10) do
-          assert_equal "bar", @cache.read("foo")
-          raise ArgumentError.new
-        end
-      rescue ArgumentError
-      end
-      assert_equal "bar", @cache.read("foo")
-    end
-    Time.stub(:now, time + 91) do
-      assert_nil @cache.read("foo")
-    end
-  end
-
-  def test_race_condition_protection
-    time = Time.now
-    @cache.write("foo", "bar", expires_in: 60)
-    Time.stub(:now, time + 61) do
-      result = @cache.fetch("foo", race_condition_ttl: 10) do
-        assert_equal "bar", @cache.read("foo")
-        "baz"
-      end
-      assert_equal "baz", result
-    end
-  end
-
-  def test_crazy_key_characters
-    crazy_key = "#/:*(<+=> )&$%@?;'\"\'`~-"
-    assert @cache.write(crazy_key, "1", raw: true)
-    assert_equal "1", @cache.read(crazy_key)
-    assert_equal "1", @cache.fetch(crazy_key)
-    assert @cache.delete(crazy_key)
-    assert_equal "2", @cache.fetch(crazy_key, raw: true) { "2" }
-    assert_equal 3, @cache.increment(crazy_key)
-    assert_equal 2, @cache.decrement(crazy_key)
-  end
-
-  def test_really_long_keys
-    key = ""
-    900.times { key << "x" }
-    assert @cache.write(key, "bar")
-    assert_equal "bar", @cache.read(key)
-    assert_equal "bar", @cache.fetch(key)
-    assert_nil @cache.read("#{key}x")
-    assert_equal({ key => "bar" }, @cache.read_multi(key))
-    assert @cache.delete(key)
-  end
-
-  def test_cache_hit_instrumentation
-    key = "test_key"
-    @events = []
-    ActiveSupport::Notifications.subscribe "cache_read.active_support" do |*args|
-      @events << ActiveSupport::Notifications::Event.new(*args)
-    end
-    assert @cache.write(key, "1", raw: true)
-    assert @cache.fetch(key) {}
-    assert_equal 1, @events.length
-    assert_equal "cache_read.active_support", @events[0].name
-    assert_equal :fetch, @events[0].payload[:super_operation]
-    assert @events[0].payload[:hit]
-  ensure
-    ActiveSupport::Notifications.unsubscribe "cache_read.active_support"
-  end
-
-  def test_cache_miss_instrumentation
-    @events = []
-    ActiveSupport::Notifications.subscribe(/^cache_(.*)\.active_support$/) do |*args|
-      @events << ActiveSupport::Notifications::Event.new(*args)
-    end
-    assert_not @cache.fetch("bad_key") {}
-    assert_equal 3, @events.length
-    assert_equal "cache_read.active_support", @events[0].name
-    assert_equal "cache_generate.active_support", @events[1].name
-    assert_equal "cache_write.active_support", @events[2].name
-    assert_equal :fetch, @events[0].payload[:super_operation]
-    assert_not @events[0].payload[:hit]
-  ensure
-    ActiveSupport::Notifications.unsubscribe "cache_read.active_support"
-  end
-end
-
-# https://rails.lighthouseapp.com/projects/8994/tickets/6225-memcachestore-cant-deal-with-umlauts-and-special-characters
-# The error is caused by character encodings that can't be compared with ASCII-8BIT regular expressions and by special
-# characters like the umlaut in UTF-8.
-module EncodedKeyCacheBehavior
-  Encoding.list.each do |encoding|
-    define_method "test_#{encoding.name.underscore}_encoded_values" do
-      key = "foo".force_encoding(encoding)
-      assert @cache.write(key, "1", raw: true)
-      assert_equal "1", @cache.read(key)
-      assert_equal "1", @cache.fetch(key)
-      assert @cache.delete(key)
-      assert_equal "2", @cache.fetch(key, raw: true) { "2" }
-      assert_equal 3, @cache.increment(key)
-      assert_equal 2, @cache.decrement(key)
-    end
-  end
-
-  def test_common_utf8_values
-    key = "\xC3\xBCmlaut".force_encoding(Encoding::UTF_8)
-    assert @cache.write(key, "1", raw: true)
-    assert_equal "1", @cache.read(key)
-    assert_equal "1", @cache.fetch(key)
-    assert @cache.delete(key)
-    assert_equal "2", @cache.fetch(key, raw: true) { "2" }
-    assert_equal 3, @cache.increment(key)
-    assert_equal 2, @cache.decrement(key)
-  end
-
-  def test_retains_encoding
-    key = "\xC3\xBCmlaut".force_encoding(Encoding::UTF_8)
-    assert @cache.write(key, "1", raw: true)
-    assert_equal Encoding::UTF_8, key.encoding
-  end
-end
-
-module CacheDeleteMatchedBehavior
-  def test_delete_matched
-    @cache.write("foo", "bar")
-    @cache.write("fu", "baz")
-    @cache.write("foo/bar", "baz")
-    @cache.write("fu/baz", "bar")
-    @cache.delete_matched(/oo/)
-    assert !@cache.exist?("foo")
-    assert @cache.exist?("fu")
-    assert !@cache.exist?("foo/bar")
-    assert @cache.exist?("fu/baz")
-  end
-end
-
-module CacheIncrementDecrementBehavior
-  def test_increment
-    @cache.write("foo", 1, raw: true)
-    assert_equal 1, @cache.read("foo").to_i
-    assert_equal 2, @cache.increment("foo")
-    assert_equal 2, @cache.read("foo").to_i
-    assert_equal 3, @cache.increment("foo")
-    assert_equal 3, @cache.read("foo").to_i
-    assert_nil @cache.increment("bar")
-  end
-
-  def test_decrement
-    @cache.write("foo", 3, raw: true)
-    assert_equal 3, @cache.read("foo").to_i
-    assert_equal 2, @cache.decrement("foo")
-    assert_equal 2, @cache.read("foo").to_i
-    assert_equal 1, @cache.decrement("foo")
-    assert_equal 1, @cache.read("foo").to_i
-    assert_nil @cache.decrement("bar")
-  end
-end
-
-module LocalCacheBehavior
-  def test_local_writes_are_persistent_on_the_remote_cache
-    retval = @cache.with_local_cache do
-      @cache.write("foo", "bar")
-    end
-    assert retval
-    assert_equal "bar", @cache.read("foo")
-  end
-
-  def test_clear_also_clears_local_cache
-    @cache.with_local_cache do
-      @cache.write("foo", "bar")
-      @cache.clear
-      assert_nil @cache.read("foo")
-    end
-
-    assert_nil @cache.read("foo")
-  end
-
-  def test_local_cache_of_write
-    @cache.with_local_cache do
-      @cache.write("foo", "bar")
-      @peek.delete("foo")
-      assert_equal "bar", @cache.read("foo")
-    end
-  end
-
-  def test_local_cache_of_read
-    @cache.write("foo", "bar")
-    @cache.with_local_cache do
-      assert_equal "bar", @cache.read("foo")
-    end
-  end
-
-  def test_local_cache_of_read_nil
-    @cache.with_local_cache do
-      assert_nil @cache.read("foo")
-      @cache.send(:bypass_local_cache) { @cache.write "foo", "bar" }
-      assert_nil @cache.read("foo")
-    end
-  end
-
-  def test_local_cache_fetch
-    @cache.with_local_cache do
-      @cache.send(:local_cache).write "foo", "bar"
-      assert_equal "bar", @cache.send(:local_cache).fetch("foo")
-    end
-  end
-
-  def test_local_cache_of_write_nil
-    @cache.with_local_cache do
-      assert @cache.write("foo", nil)
-      assert_nil @cache.read("foo")
-      @peek.write("foo", "bar")
-      assert_nil @cache.read("foo")
-    end
-  end
-
-  def test_local_cache_of_delete
-    @cache.with_local_cache do
-      @cache.write("foo", "bar")
-      @cache.delete("foo")
-      assert_nil @cache.read("foo")
-    end
-  end
-
-  def test_local_cache_of_exist
-    @cache.with_local_cache do
-      @cache.write("foo", "bar")
-      @peek.delete("foo")
-      assert @cache.exist?("foo")
-    end
-  end
-
-  def test_local_cache_of_increment
-    @cache.with_local_cache do
-      @cache.write("foo", 1, raw: true)
-      @peek.write("foo", 2, raw: true)
-      @cache.increment("foo")
-      assert_equal 3, @cache.read("foo")
-    end
-  end
-
-  def test_local_cache_of_decrement
-    @cache.with_local_cache do
-      @cache.write("foo", 1, raw: true)
-      @peek.write("foo", 3, raw: true)
-      @cache.decrement("foo")
-      assert_equal 2, @cache.read("foo")
-    end
-  end
-
-  def test_middleware
-    app = lambda { |env|
-      result = @cache.write("foo", "bar")
-      assert_equal "bar", @cache.read("foo") # make sure 'foo' was written
-      assert result
-      [200, {}, []]
-    }
-    app = @cache.middleware.new(app)
-    app.call({})
-  end
-end
-
-module AutoloadingCacheBehavior
-  include DependenciesTestHelpers
-  def test_simple_autoloading
-    with_autoloading_fixtures do
-      @cache.write("foo", EM.new)
-    end
-
-    remove_constants(:EM)
-    ActiveSupport::Dependencies.clear
-
-    with_autoloading_fixtures do
-      assert_kind_of EM, @cache.read("foo")
-    end
-
-    remove_constants(:EM)
-    ActiveSupport::Dependencies.clear
-  end
-
-  def test_two_classes_autoloading
-    with_autoloading_fixtures do
-      @cache.write("foo", [EM.new, ClassFolder.new])
-    end
-
-    remove_constants(:EM, :ClassFolder)
-    ActiveSupport::Dependencies.clear
-
-    with_autoloading_fixtures do
-      loaded = @cache.read("foo")
-      assert_kind_of Array, loaded
-      assert_equal 2, loaded.size
-      assert_kind_of EM, loaded[0]
-      assert_kind_of ClassFolder, loaded[1]
-    end
-
-    remove_constants(:EM, :ClassFolder)
-    ActiveSupport::Dependencies.clear
-  end
-end
-
-class FileStoreTest < ActiveSupport::TestCase
-  def setup
-    Dir.mkdir(cache_dir) unless File.exist?(cache_dir)
-    @cache = ActiveSupport::Cache.lookup_store(:file_store, cache_dir, expires_in: 60)
-    @peek = ActiveSupport::Cache.lookup_store(:file_store, cache_dir, expires_in: 60)
-    @cache_with_pathname = ActiveSupport::Cache.lookup_store(:file_store, Pathname.new(cache_dir), expires_in: 60)
-
-    @buffer = StringIO.new
-    @cache.logger = ActiveSupport::Logger.new(@buffer)
-  end
-
-  def teardown
-    FileUtils.rm_r(cache_dir)
-  rescue Errno::ENOENT
-  end
-
-  def cache_dir
-    File.join(Dir.pwd, "tmp_cache")
-  end
-
-  include CacheStoreBehavior
-  include LocalCacheBehavior
-  include CacheDeleteMatchedBehavior
-  include CacheIncrementDecrementBehavior
-  include AutoloadingCacheBehavior
-
-  def test_clear
-    gitkeep = File.join(cache_dir, ".gitkeep")
-    keep = File.join(cache_dir, ".keep")
-    FileUtils.touch([gitkeep, keep])
-    @cache.clear
-    assert File.exist?(gitkeep)
-    assert File.exist?(keep)
-  end
-
-  def test_clear_without_cache_dir
-    FileUtils.rm_r(cache_dir)
-    @cache.clear
-  end
-
-  def test_long_uri_encoded_keys
-    @cache.write("%" * 870, 1)
-    assert_equal 1, @cache.read("%" * 870)
-  end
-
-  def test_key_transformation
-    key = @cache.send(:normalize_key, "views/index?id=1", {})
-    assert_equal "views/index?id=1", @cache.send(:file_path_key, key)
-  end
-
-  def test_key_transformation_with_pathname
-    FileUtils.touch(File.join(cache_dir, "foo"))
-    key = @cache_with_pathname.send(:normalize_key, "views/index?id=1", {})
-    assert_equal "views/index?id=1", @cache_with_pathname.send(:file_path_key, key)
-  end
-
-  # Test that generated cache keys are short enough to have Tempfile stuff added to them and
-  # remain valid
-  def test_filename_max_size
-    key = "#{'A' * ActiveSupport::Cache::FileStore::FILENAME_MAX_SIZE}"
-    path = @cache.send(:normalize_key, key, {})
-    Dir::Tmpname.create(path) do |tmpname, n, opts|
-      assert File.basename(tmpname + ".lock").length <= 255, "Temp filename too long: #{File.basename(tmpname + '.lock').length}"
-    end
-  end
-
-  # Because file systems have a maximum filename size, filenames > max size should be split in to directories
-  # If filename is 'AAAAB', where max size is 4, the returned path should be AAAA/B
-  def test_key_transformation_max_filename_size
-    key = "#{'A' * ActiveSupport::Cache::FileStore::FILENAME_MAX_SIZE}B"
-    path = @cache.send(:normalize_key, key, {})
-    assert path.split("/").all? { |dir_name| dir_name.size <= ActiveSupport::Cache::FileStore::FILENAME_MAX_SIZE }
-    assert_equal "B", File.basename(path)
-  end
-
-  # If nothing has been stored in the cache, there is a chance the cache directory does not yet exist
-  # Ensure delete_matched gracefully handles this case
-  def test_delete_matched_when_cache_directory_does_not_exist
-    assert_nothing_raised do
-      ActiveSupport::Cache::FileStore.new("/test/cache/directory").delete_matched(/does_not_exist/)
-    end
-  end
-
-  def test_delete_does_not_delete_empty_parent_dir
-    sub_cache_dir = File.join(cache_dir, "subdir/")
-    sub_cache_store = ActiveSupport::Cache::FileStore.new(sub_cache_dir)
-    assert_nothing_raised do
-      assert sub_cache_store.write("foo", "bar")
-      assert sub_cache_store.delete("foo")
-    end
-    assert File.exist?(cache_dir), "Parent of top level cache dir was deleted!"
-    assert File.exist?(sub_cache_dir), "Top level cache dir was deleted!"
-    assert Dir.entries(sub_cache_dir).reject { |f| ActiveSupport::Cache::FileStore::EXCLUDED_DIRS.include?(f) }.empty?
-  end
-
-  def test_log_exception_when_cache_read_fails
-    File.stub(:exist?, -> { raise StandardError.new("failed") }) do
-      @cache.send(:read_entry, "winston", {})
-      assert @buffer.string.present?
-    end
-  end
-
-  def test_cleanup_removes_all_expired_entries
-    time = Time.now
-    @cache.write("foo", "bar", expires_in: 10)
-    @cache.write("baz", "qux")
-    @cache.write("quux", "corge", expires_in: 20)
-    Time.stub(:now, time + 15) do
-      @cache.cleanup
-      assert_not @cache.exist?("foo")
-      assert @cache.exist?("baz")
-      assert @cache.exist?("quux")
-    end
-  end
-
-  def test_write_with_unless_exist
-    assert_equal true, @cache.write(1, "aaaaaaaaaa")
-    assert_equal false, @cache.write(1, "aaaaaaaaaa", unless_exist: true)
-    @cache.write(1, nil)
-    assert_equal false, @cache.write(1, "aaaaaaaaaa", unless_exist: true)
-  end
-end
-
-class MemoryStoreTest < ActiveSupport::TestCase
-  def setup
-    @record_size = ActiveSupport::Cache.lookup_store(:memory_store).send(:cached_size, 1, ActiveSupport::Cache::Entry.new("aaaaaaaaaa"))
-    @cache = ActiveSupport::Cache.lookup_store(:memory_store, expires_in: 60, size: @record_size * 10 + 1)
-  end
-
-  include CacheStoreBehavior
-  include CacheDeleteMatchedBehavior
-  include CacheIncrementDecrementBehavior
-
-  def test_prune_size
-    @cache.write(1, "aaaaaaaaaa") && sleep(0.001)
-    @cache.write(2, "bbbbbbbbbb") && sleep(0.001)
-    @cache.write(3, "cccccccccc") && sleep(0.001)
-    @cache.write(4, "dddddddddd") && sleep(0.001)
-    @cache.write(5, "eeeeeeeeee") && sleep(0.001)
-    @cache.read(2) && sleep(0.001)
-    @cache.read(4)
-    @cache.prune(@record_size * 3)
-    assert @cache.exist?(5)
-    assert @cache.exist?(4)
-    assert !@cache.exist?(3), "no entry"
-    assert @cache.exist?(2)
-    assert !@cache.exist?(1), "no entry"
-  end
-
-  def test_prune_size_on_write
-    @cache.write(1, "aaaaaaaaaa") && sleep(0.001)
-    @cache.write(2, "bbbbbbbbbb") && sleep(0.001)
-    @cache.write(3, "cccccccccc") && sleep(0.001)
-    @cache.write(4, "dddddddddd") && sleep(0.001)
-    @cache.write(5, "eeeeeeeeee") && sleep(0.001)
-    @cache.write(6, "ffffffffff") && sleep(0.001)
-    @cache.write(7, "gggggggggg") && sleep(0.001)
-    @cache.write(8, "hhhhhhhhhh") && sleep(0.001)
-    @cache.write(9, "iiiiiiiiii") && sleep(0.001)
-    @cache.write(10, "kkkkkkkkkk") && sleep(0.001)
-    @cache.read(2) && sleep(0.001)
-    @cache.read(4) && sleep(0.001)
-    @cache.write(11, "llllllllll")
-    assert @cache.exist?(11)
-    assert @cache.exist?(10)
-    assert @cache.exist?(9)
-    assert @cache.exist?(8)
-    assert @cache.exist?(7)
-    assert !@cache.exist?(6), "no entry"
-    assert !@cache.exist?(5), "no entry"
-    assert @cache.exist?(4)
-    assert !@cache.exist?(3), "no entry"
-    assert @cache.exist?(2)
-    assert !@cache.exist?(1), "no entry"
-  end
-
-  def test_prune_size_on_write_based_on_key_length
-    @cache.write(1, "aaaaaaaaaa") && sleep(0.001)
-    @cache.write(2, "bbbbbbbbbb") && sleep(0.001)
-    @cache.write(3, "cccccccccc") && sleep(0.001)
-    @cache.write(4, "dddddddddd") && sleep(0.001)
-    @cache.write(5, "eeeeeeeeee") && sleep(0.001)
-    @cache.write(6, "ffffffffff") && sleep(0.001)
-    @cache.write(7, "gggggggggg") && sleep(0.001)
-    @cache.write(8, "hhhhhhhhhh") && sleep(0.001)
-    @cache.write(9, "iiiiiiiiii") && sleep(0.001)
-    long_key = "*" * 2 * @record_size
-    @cache.write(long_key, "llllllllll")
-    assert @cache.exist?(long_key)
-    assert @cache.exist?(9)
-    assert @cache.exist?(8)
-    assert @cache.exist?(7)
-    assert @cache.exist?(6)
-    assert !@cache.exist?(5), "no entry"
-    assert !@cache.exist?(4), "no entry"
-    assert !@cache.exist?(3), "no entry"
-    assert !@cache.exist?(2), "no entry"
-    assert !@cache.exist?(1), "no entry"
-  end
-
-  def test_pruning_is_capped_at_a_max_time
-    def @cache.delete_entry(*args)
-      sleep(0.01)
-      super
-    end
-    @cache.write(1, "aaaaaaaaaa") && sleep(0.001)
-    @cache.write(2, "bbbbbbbbbb") && sleep(0.001)
-    @cache.write(3, "cccccccccc") && sleep(0.001)
-    @cache.write(4, "dddddddddd") && sleep(0.001)
-    @cache.write(5, "eeeeeeeeee") && sleep(0.001)
-    @cache.prune(30, 0.001)
-    assert @cache.exist?(5)
-    assert @cache.exist?(4)
-    assert @cache.exist?(3)
-    assert @cache.exist?(2)
-    assert !@cache.exist?(1)
-  end
-
-  def test_write_with_unless_exist
-    assert_equal true, @cache.write(1, "aaaaaaaaaa")
-    assert_equal false, @cache.write(1, "aaaaaaaaaa", unless_exist: true)
-    @cache.write(1, nil)
-    assert_equal false, @cache.write(1, "aaaaaaaaaa", unless_exist: true)
-  end
-end
-
-class MemCacheStoreTest < ActiveSupport::TestCase
-  require "dalli"
-
-  begin
-    ss = Dalli::Client.new("localhost:11211").stats
-    raise Dalli::DalliError unless ss["localhost:11211"]
-
-    MEMCACHE_UP = true
-  rescue Dalli::DalliError
-    $stderr.puts "Skipping memcached tests. Start memcached and try again."
-    MEMCACHE_UP = false
-  end
-
-  def setup
-    skip "memcache server is not up" unless MEMCACHE_UP
-
-    @cache = ActiveSupport::Cache.lookup_store(:mem_cache_store, expires_in: 60)
-    @peek = ActiveSupport::Cache.lookup_store(:mem_cache_store)
-    @data = @cache.instance_variable_get(:@data)
-    @cache.clear
-    @cache.silence!
-    @cache.logger = ActiveSupport::Logger.new("/dev/null")
-  end
-
-  include CacheStoreBehavior
-  include LocalCacheBehavior
-  include CacheIncrementDecrementBehavior
-  include EncodedKeyCacheBehavior
-  include AutoloadingCacheBehavior
-
-  def test_raw_values
-    cache = ActiveSupport::Cache.lookup_store(:mem_cache_store, raw: true)
-    cache.clear
-    cache.write("foo", 2)
-    assert_equal "2", cache.read("foo")
-  end
-
-  def test_raw_values_with_marshal
-    cache = ActiveSupport::Cache.lookup_store(:mem_cache_store, raw: true)
-    cache.clear
-    cache.write("foo", Marshal.dump([]))
-    assert_equal [], cache.read("foo")
-  end
-
-  def test_local_cache_raw_values
-    cache = ActiveSupport::Cache.lookup_store(:mem_cache_store, raw: true)
-    cache.clear
-    cache.with_local_cache do
-      cache.write("foo", 2)
-      assert_equal "2", cache.read("foo")
-    end
-  end
-
-  def test_local_cache_raw_values_with_marshal
-    cache = ActiveSupport::Cache.lookup_store(:mem_cache_store, raw: true)
-    cache.clear
-    cache.with_local_cache do
-      cache.write("foo", Marshal.dump([]))
-      assert_equal [], cache.read("foo")
-    end
-  end
-
-  def test_read_should_return_a_different_object_id_each_time_it_is_called
-    @cache.write("foo", "bar")
-    value = @cache.read("foo")
-    assert_not_equal value.object_id, @cache.read("foo").object_id
-    value << "bingo"
-    assert_not_equal value, @cache.read("foo")
-  end
-end
-
-class NullStoreTest < ActiveSupport::TestCase
-  def setup
-    @cache = ActiveSupport::Cache.lookup_store(:null_store)
-  end
-
-  def test_clear
-    @cache.clear
-  end
-
-  def test_cleanup
-    @cache.cleanup
-  end
-
-  def test_write
-    assert_equal true, @cache.write("name", "value")
-  end
-
-  def test_read
-    @cache.write("name", "value")
-    assert_nil @cache.read("name")
-  end
-
-  def test_delete
-    @cache.write("name", "value")
-    assert_equal false, @cache.delete("name")
-  end
-
-  def test_increment
-    @cache.write("name", 1, raw: true)
-    assert_nil @cache.increment("name")
-  end
-
-  def test_decrement
-    @cache.write("name", 1, raw: true)
-    assert_nil @cache.increment("name")
-  end
-
-  def test_delete_matched
-    @cache.write("name", "value")
-    @cache.delete_matched(/name/)
-  end
-
-  def test_local_store_strategy
-    @cache.with_local_cache do
-      @cache.write("name", "value")
-      assert_equal "value", @cache.read("name")
-      @cache.delete("name")
-      assert_nil @cache.read("name")
-      @cache.write("name", "value")
-    end
-    assert_nil @cache.read("name")
-  end
-end
-
-class CacheStoreLoggerTest < ActiveSupport::TestCase
-  def setup
-    @cache = ActiveSupport::Cache.lookup_store(:memory_store)
-
-    @buffer = StringIO.new
-    @cache.logger = ActiveSupport::Logger.new(@buffer)
-  end
-
-  def test_logging
-    @cache.fetch("foo") { "bar" }
-    assert @buffer.string.present?
-  end
-
-  def test_log_with_string_namespace
-    @cache.fetch("foo", namespace: "string_namespace") { "bar" }
-    assert_match %r{string_namespace:foo}, @buffer.string
-  end
-
-  def test_log_with_proc_namespace
-    proc = Proc.new do
-      "proc_namespace"
-    end
-    @cache.fetch("foo", namespace: proc) { "bar" }
-    assert_match %r{proc_namespace:foo}, @buffer.string
-  end
-
-  def test_mute_logging
-    @cache.mute { @cache.fetch("foo") { "bar" } }
-    assert @buffer.string.blank?
-  end
-end
-
-class CacheEntryTest < ActiveSupport::TestCase
-  def test_expired
-    entry = ActiveSupport::Cache::Entry.new("value")
-    assert !entry.expired?, "entry not expired"
-    entry = ActiveSupport::Cache::Entry.new("value", expires_in: 60)
-    assert !entry.expired?, "entry not expired"
-    Time.stub(:now, Time.now + 61) do
-      assert entry.expired?, "entry is expired"
-    end
-  end
-
-  def test_compress_values
-    value = "value" * 100
-    entry = ActiveSupport::Cache::Entry.new(value, compress: true, compress_threshold: 1)
-    assert_equal value, entry.value
-    assert(value.bytesize > entry.size, "value is compressed")
-  end
-
-  def test_non_compress_values
-    value = "value" * 100
-    entry = ActiveSupport::Cache::Entry.new(value)
-    assert_equal value, entry.value
-    assert_equal value.bytesize, entry.size
-  end
-end
diff --git a/activesupport/test/callback_inheritance_test.rb b/activesupport/test/callback_inheritance_test.rb
index 9e2f7527e0..67813a749e 100644
--- a/activesupport/test/callback_inheritance_test.rb
+++ b/activesupport/test/callback_inheritance_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class GrandParent
diff --git a/activesupport/test/callbacks_test.rb b/activesupport/test/callbacks_test.rb
index 4f00afb581..3902e41a60 100644
--- a/activesupport/test/callbacks_test.rb
+++ b/activesupport/test/callbacks_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module CallbacksTest
diff --git a/activesupport/test/class_cache_test.rb b/activesupport/test/class_cache_test.rb
index 004b4dc9ce..7b97028e8c 100644
--- a/activesupport/test/class_cache_test.rb
+++ b/activesupport/test/class_cache_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/dependencies"
 
diff --git a/activesupport/test/clean_backtrace_test.rb b/activesupport/test/clean_backtrace_test.rb
index 5ed518cdb0..1b44c7c9bf 100644
--- a/activesupport/test/clean_backtrace_test.rb
+++ b/activesupport/test/clean_backtrace_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class BacktraceCleanerFilterTest < ActiveSupport::TestCase
@@ -8,8 +10,8 @@ class BacktraceCleanerFilterTest < ActiveSupport::TestCase
 
   test "backtrace should filter all lines in a backtrace, removing prefixes" do
     assert_equal \
-        ["/my/class.rb", "/my/module.rb"],
-        @bc.clean(["/my/prefix/my/class.rb", "/my/prefix/my/module.rb"])
+      ["/my/class.rb", "/my/module.rb"],
+      @bc.clean(["/my/prefix/my/class.rb", "/my/prefix/my/module.rb"])
   end
 
   test "backtrace cleaner should allow removing filters" do
diff --git a/activesupport/test/clean_logger_test.rb b/activesupport/test/clean_logger_test.rb
index cf37fc5639..6d8f7064ce 100644
--- a/activesupport/test/clean_logger_test.rb
+++ b/activesupport/test/clean_logger_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "stringio"
 require "active_support/logger"
diff --git a/activesupport/test/concern_test.rb b/activesupport/test/concern_test.rb
index 7a5a5414a7..ef75a320d1 100644
--- a/activesupport/test/concern_test.rb
+++ b/activesupport/test/concern_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/concern"
 
diff --git a/activesupport/test/configurable_test.rb b/activesupport/test/configurable_test.rb
index 3cd6d2d4d0..10719596df 100644
--- a/activesupport/test/configurable_test.rb
+++ b/activesupport/test/configurable_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/configurable"
 
diff --git a/activesupport/test/constantize_test_cases.rb b/activesupport/test/constantize_test_cases.rb
index 32b720bcbb..2c6145940b 100644
--- a/activesupport/test/constantize_test_cases.rb
+++ b/activesupport/test/constantize_test_cases.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "dependencies_test_helpers"
 
 module Ace
diff --git a/activesupport/test/core_ext/array/access_test.rb b/activesupport/test/core_ext/array/access_test.rb
index a38ea36d00..8c217023cf 100644
--- a/activesupport/test/core_ext/array/access_test.rb
+++ b/activesupport/test/core_ext/array/access_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/array"
 
diff --git a/activesupport/test/core_ext/array/conversions_test.rb b/activesupport/test/core_ext/array/conversions_test.rb
index 29e661a99b..0f919efcb0 100644
--- a/activesupport/test/core_ext/array/conversions_test.rb
+++ b/activesupport/test/core_ext/array/conversions_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/array"
 require "active_support/core_ext/big_decimal"
@@ -58,7 +60,7 @@ class ToSentenceTest < ActiveSupport::TestCase
       ["one", "two"].to_sentence(passing: "invalid option")
     end
 
-    assert_equal exception.message, "Unknown key: :passing. Valid keys are: :words_connector, :two_words_connector, :last_word_connector, :locale"
+    assert_equal "Unknown key: :passing. Valid keys are: :words_connector, :two_words_connector, :last_word_connector, :locale", exception.message
   end
 
   def test_always_returns_string
diff --git a/activesupport/test/core_ext/array/extract_options_test.rb b/activesupport/test/core_ext/array/extract_options_test.rb
index 1651bee0f6..7a4b15cd71 100644
--- a/activesupport/test/core_ext/array/extract_options_test.rb
+++ b/activesupport/test/core_ext/array/extract_options_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/array"
 require "active_support/core_ext/hash"
diff --git a/activesupport/test/core_ext/array/grouping_test.rb b/activesupport/test/core_ext/array/grouping_test.rb
index 4c6aadba8c..da9d4963d8 100644
--- a/activesupport/test/core_ext/array/grouping_test.rb
+++ b/activesupport/test/core_ext/array/grouping_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/array"
 
diff --git a/activesupport/test/core_ext/array/prepend_append_test.rb b/activesupport/test/core_ext/array/prepend_append_test.rb
index 763e26191d..c34acd66ad 100644
--- a/activesupport/test/core_ext/array/prepend_append_test.rb
+++ b/activesupport/test/core_ext/array/prepend_append_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/array"
 
diff --git a/activesupport/test/core_ext/array/wrap_test.rb b/activesupport/test/core_ext/array/wrap_test.rb
index ae846cb3f2..46564b4d73 100644
--- a/activesupport/test/core_ext/array/wrap_test.rb
+++ b/activesupport/test/core_ext/array/wrap_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/array"
 
diff --git a/activesupport/test/core_ext/bigdecimal_test.rb b/activesupport/test/core_ext/bigdecimal_test.rb
index 43b659546f..66e81f1162 100644
--- a/activesupport/test/core_ext/bigdecimal_test.rb
+++ b/activesupport/test/core_ext/bigdecimal_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/big_decimal"
 
diff --git a/activesupport/test/core_ext/class/attribute_test.rb b/activesupport/test/core_ext/class/attribute_test.rb
index 5a9ec78cc1..be6ad82367 100644
--- a/activesupport/test/core_ext/class/attribute_test.rb
+++ b/activesupport/test/core_ext/class/attribute_test.rb
@@ -1,9 +1,15 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/class/attribute"
 
 class ClassAttributeTest < ActiveSupport::TestCase
   def setup
-    @klass = Class.new { class_attribute :setting }
+    @klass = Class.new do
+      class_attribute :setting
+      class_attribute :timeout, default: 5
+    end
+
     @sub = Class.new(@klass)
   end
 
@@ -12,6 +18,10 @@ class ClassAttributeTest < ActiveSupport::TestCase
     assert_nil @sub.setting
   end
 
+  test "custom default" do
+    assert_equal 5, @klass.timeout
+  end
+
   test "inheritable" do
     @klass.setting = 1
     assert_equal 1, @sub.setting
diff --git a/activesupport/test/core_ext/class_test.rb b/activesupport/test/core_ext/class_test.rb
index a7905196ae..9cc006fc63 100644
--- a/activesupport/test/core_ext/class_test.rb
+++ b/activesupport/test/core_ext/class_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/class"
 require "set"
diff --git a/activesupport/test/core_ext/date_and_time_behavior.rb b/activesupport/test/core_ext/date_and_time_behavior.rb
index 6c77e8f313..256353c309 100644
--- a/activesupport/test/core_ext/date_and_time_behavior.rb
+++ b/activesupport/test/core_ext/date_and_time_behavior.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module DateAndTimeBehavior
diff --git a/activesupport/test/core_ext/date_and_time_compatibility_test.rb b/activesupport/test/core_ext/date_and_time_compatibility_test.rb
index 4c90460032..266829a452 100644
--- a/activesupport/test/core_ext/date_and_time_compatibility_test.rb
+++ b/activesupport/test/core_ext/date_and_time_compatibility_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/time"
 require "time_zone_test_helpers"
@@ -16,11 +18,13 @@ class DateAndTimeCompatibilityTest < ActiveSupport::TestCase
   def test_time_to_time_preserves_timezone
     with_preserve_timezone(true) do
       with_env_tz "US/Eastern" do
-        time = Time.new(2016, 4, 23, 15, 11, 12, 3600).to_time
+        source = Time.new(2016, 4, 23, 15, 11, 12, 3600)
+        time = source.to_time
 
         assert_instance_of Time, time
         assert_equal @utc_time, time.getutc
         assert_equal @utc_offset, time.utc_offset
+        assert_equal source.object_id, time.object_id
       end
     end
   end
@@ -28,11 +32,43 @@ class DateAndTimeCompatibilityTest < ActiveSupport::TestCase
   def test_time_to_time_does_not_preserve_time_zone
     with_preserve_timezone(false) do
       with_env_tz "US/Eastern" do
-        time = Time.new(2016, 4, 23, 15, 11, 12, 3600).to_time
+        source = Time.new(2016, 4, 23, 15, 11, 12, 3600)
+        time = source.to_time
+
+        assert_instance_of Time, time
+        assert_equal @utc_time, time.getutc
+        assert_equal @system_offset, time.utc_offset
+        assert_not_equal source.object_id, time.object_id
+      end
+    end
+  end
+
+  def test_time_to_time_frozen_preserves_timezone
+    with_preserve_timezone(true) do
+      with_env_tz "US/Eastern" do
+        source = Time.new(2016, 4, 23, 15, 11, 12, 3600).freeze
+        time = source.to_time
+
+        assert_instance_of Time, time
+        assert_equal @utc_time, time.getutc
+        assert_equal @utc_offset, time.utc_offset
+        assert_equal source.object_id, time.object_id
+        assert_predicate time, :frozen?
+      end
+    end
+  end
+
+  def test_time_to_time_frozen_does_not_preserve_time_zone
+    with_preserve_timezone(false) do
+      with_env_tz "US/Eastern" do
+        source = Time.new(2016, 4, 23, 15, 11, 12, 3600).freeze
+        time = source.to_time
 
         assert_instance_of Time, time
         assert_equal @utc_time, time.getutc
         assert_equal @system_offset, time.utc_offset
+        assert_not_equal source.object_id, time.object_id
+        assert_not_predicate time, :frozen?
       end
     end
   end
@@ -40,7 +76,8 @@ class DateAndTimeCompatibilityTest < ActiveSupport::TestCase
   def test_datetime_to_time_preserves_timezone
     with_preserve_timezone(true) do
       with_env_tz "US/Eastern" do
-        time = DateTime.new(2016, 4, 23, 15, 11, 12, Rational(1, 24)).to_time
+        source = DateTime.new(2016, 4, 23, 15, 11, 12, Rational(1, 24))
+        time = source.to_time
 
         assert_instance_of Time, time
         assert_equal @utc_time, time.getutc
@@ -52,11 +89,40 @@ class DateAndTimeCompatibilityTest < ActiveSupport::TestCase
   def test_datetime_to_time_does_not_preserve_time_zone
     with_preserve_timezone(false) do
       with_env_tz "US/Eastern" do
-        time = DateTime.new(2016, 4, 23, 15, 11, 12, Rational(1, 24)).to_time
+        source = DateTime.new(2016, 4, 23, 15, 11, 12, Rational(1, 24))
+        time = source.to_time
+
+        assert_instance_of Time, time
+        assert_equal @utc_time, time.getutc
+        assert_equal @system_offset, time.utc_offset
+      end
+    end
+  end
+
+  def test_datetime_to_time_frozen_preserves_timezone
+    with_preserve_timezone(true) do
+      with_env_tz "US/Eastern" do
+        source = DateTime.new(2016, 4, 23, 15, 11, 12, Rational(1, 24)).freeze
+        time = source.to_time
+
+        assert_instance_of Time, time
+        assert_equal @utc_time, time.getutc
+        assert_equal @utc_offset, time.utc_offset
+        assert_not_predicate time, :frozen?
+      end
+    end
+  end
+
+  def test_datetime_to_time_frozen_does_not_preserve_time_zone
+    with_preserve_timezone(false) do
+      with_env_tz "US/Eastern" do
+        source = DateTime.new(2016, 4, 23, 15, 11, 12, Rational(1, 24)).freeze
+        time = source.to_time
 
         assert_instance_of Time, time
         assert_equal @utc_time, time.getutc
         assert_equal @system_offset, time.utc_offset
+        assert_not_predicate time, :frozen?
       end
     end
   end
@@ -64,14 +130,16 @@ class DateAndTimeCompatibilityTest < ActiveSupport::TestCase
   def test_twz_to_time_preserves_timezone
     with_preserve_timezone(true) do
       with_env_tz "US/Eastern" do
-        time = ActiveSupport::TimeWithZone.new(@utc_time, @zone).to_time
+        source = ActiveSupport::TimeWithZone.new(@utc_time, @zone)
+        time = source.to_time
 
         assert_instance_of Time, time
         assert_equal @utc_time, time.getutc
         assert_instance_of Time, time.getutc
         assert_equal @utc_offset, time.utc_offset
 
-        time = ActiveSupport::TimeWithZone.new(@date_time, @zone).to_time
+        source = ActiveSupport::TimeWithZone.new(@date_time, @zone)
+        time = source.to_time
 
         assert_instance_of Time, time
         assert_equal @date_time, time.getutc
@@ -84,14 +152,16 @@ class DateAndTimeCompatibilityTest < ActiveSupport::TestCase
   def test_twz_to_time_does_not_preserve_time_zone
     with_preserve_timezone(false) do
       with_env_tz "US/Eastern" do
-        time = ActiveSupport::TimeWithZone.new(@utc_time, @zone).to_time
+        source = ActiveSupport::TimeWithZone.new(@utc_time, @zone)
+        time = source.to_time
 
         assert_instance_of Time, time
         assert_equal @utc_time, time.getutc
         assert_instance_of Time, time.getutc
         assert_equal @system_offset, time.utc_offset
 
-        time = ActiveSupport::TimeWithZone.new(@date_time, @zone).to_time
+        source = ActiveSupport::TimeWithZone.new(@date_time, @zone)
+        time = source.to_time
 
         assert_instance_of Time, time
         assert_equal @date_time, time.getutc
@@ -101,10 +171,59 @@ class DateAndTimeCompatibilityTest < ActiveSupport::TestCase
     end
   end
 
+  def test_twz_to_time_frozen_preserves_timezone
+    with_preserve_timezone(true) do
+      with_env_tz "US/Eastern" do
+        source = ActiveSupport::TimeWithZone.new(@utc_time, @zone).freeze
+        time = source.to_time
+
+        assert_instance_of Time, time
+        assert_equal @utc_time, time.getutc
+        assert_instance_of Time, time.getutc
+        assert_equal @utc_offset, time.utc_offset
+        assert_not_predicate time, :frozen?
+
+        source = ActiveSupport::TimeWithZone.new(@date_time, @zone).freeze
+        time = source.to_time
+
+        assert_instance_of Time, time
+        assert_equal @date_time, time.getutc
+        assert_instance_of Time, time.getutc
+        assert_equal @utc_offset, time.utc_offset
+        assert_not_predicate time, :frozen?
+      end
+    end
+  end
+
+  def test_twz_to_time_frozen_does_not_preserve_time_zone
+    with_preserve_timezone(false) do
+      with_env_tz "US/Eastern" do
+        source = ActiveSupport::TimeWithZone.new(@utc_time, @zone).freeze
+        time = source.to_time
+
+        assert_instance_of Time, time
+        assert_equal @utc_time, time.getutc
+        assert_instance_of Time, time.getutc
+        assert_equal @system_offset, time.utc_offset
+        assert_not_predicate time, :frozen?
+
+        source = ActiveSupport::TimeWithZone.new(@date_time, @zone).freeze
+        time = source.to_time
+
+        assert_instance_of Time, time
+        assert_equal @date_time, time.getutc
+        assert_instance_of Time, time.getutc
+        assert_equal @system_offset, time.utc_offset
+        assert_not_predicate time, :frozen?
+      end
+    end
+  end
+
   def test_string_to_time_preserves_timezone
     with_preserve_timezone(true) do
       with_env_tz "US/Eastern" do
-        time = "2016-04-23T15:11:12+01:00".to_time
+        source = "2016-04-23T15:11:12+01:00"
+        time = source.to_time
 
         assert_instance_of Time, time
         assert_equal @utc_time, time.getutc
@@ -116,11 +235,40 @@ class DateAndTimeCompatibilityTest < ActiveSupport::TestCase
   def test_string_to_time_does_not_preserve_time_zone
     with_preserve_timezone(false) do
       with_env_tz "US/Eastern" do
-        time = "2016-04-23T15:11:12+01:00".to_time
+        source = "2016-04-23T15:11:12+01:00"
+        time = source.to_time
+
+        assert_instance_of Time, time
+        assert_equal @utc_time, time.getutc
+        assert_equal @system_offset, time.utc_offset
+      end
+    end
+  end
+
+  def test_string_to_time_frozen_preserves_timezone
+    with_preserve_timezone(true) do
+      with_env_tz "US/Eastern" do
+        source = "2016-04-23T15:11:12+01:00".freeze
+        time = source.to_time
+
+        assert_instance_of Time, time
+        assert_equal @utc_time, time.getutc
+        assert_equal @utc_offset, time.utc_offset
+        assert_not_predicate time, :frozen?
+      end
+    end
+  end
+
+  def test_string_to_time_frozen_does_not_preserve_time_zone
+    with_preserve_timezone(false) do
+      with_env_tz "US/Eastern" do
+        source = "2016-04-23T15:11:12+01:00".freeze
+        time = source.to_time
 
         assert_instance_of Time, time
         assert_equal @utc_time, time.getutc
         assert_equal @system_offset, time.utc_offset
+        assert_not_predicate time, :frozen?
       end
     end
   end
diff --git a/activesupport/test/core_ext/date_ext_test.rb b/activesupport/test/core_ext/date_ext_test.rb
index 50bb1004f7..b8672eac4b 100644
--- a/activesupport/test/core_ext/date_ext_test.rb
+++ b/activesupport/test/core_ext/date_ext_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/time"
 require "core_ext/date_and_time_behavior"
diff --git a/activesupport/test/core_ext/date_time_ext_test.rb b/activesupport/test/core_ext/date_time_ext_test.rb
index 36f0ee22b8..a3c2018a31 100644
--- a/activesupport/test/core_ext/date_time_ext_test.rb
+++ b/activesupport/test/core_ext/date_time_ext_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/time"
 require "core_ext/date_and_time_behavior"
@@ -28,6 +30,28 @@ class DateTimeExtCalculationsTest < ActiveSupport::TestCase
     end
   end
 
+  def test_next_occur
+    datetime = DateTime.new(2016, 9, 24, 0, 0) # saturday
+    assert_equal datetime.next_occurring(:monday), datetime.since(2.days)
+    assert_equal datetime.next_occurring(:tuesday), datetime.since(3.days)
+    assert_equal datetime.next_occurring(:wednesday), datetime.since(4.days)
+    assert_equal datetime.next_occurring(:thursday), datetime.since(5.days)
+    assert_equal datetime.next_occurring(:friday), datetime.since(6.days)
+    assert_equal datetime.next_occurring(:saturday), datetime.since(1.week)
+    assert_equal datetime.next_occurring(:sunday), datetime.since(1.day)
+  end
+
+  def test_prev_occur
+    datetime = DateTime.new(2016, 9, 24, 0, 0) # saturday
+    assert_equal datetime.prev_occurring(:monday), datetime.ago(5.days)
+    assert_equal datetime.prev_occurring(:tuesday), datetime.ago(4.days)
+    assert_equal datetime.prev_occurring(:wednesday), datetime.ago(3.days)
+    assert_equal datetime.prev_occurring(:thursday), datetime.ago(2.days)
+    assert_equal datetime.prev_occurring(:friday), datetime.ago(1.day)
+    assert_equal datetime.prev_occurring(:saturday), datetime.ago(1.week)
+    assert_equal datetime.prev_occurring(:sunday), datetime.ago(6.days)
+  end
+
   def test_readable_inspect
     datetime = DateTime.new(2005, 2, 21, 14, 30, 0)
     assert_equal "Mon, 21 Feb 2005 14:30:00 +0000", datetime.readable_inspect
@@ -166,6 +190,9 @@ class DateTimeExtCalculationsTest < ActiveSupport::TestCase
     assert_equal DateTime.civil(2005, 2, 22, 16, 45),     DateTime.civil(2005, 2, 22, 15, 15, 10).change(hour: 16, min: 45)
     assert_equal DateTime.civil(2005, 2, 22, 15, 45),     DateTime.civil(2005, 2, 22, 15, 15, 10).change(min: 45)
 
+    # datetime with non-zero offset
+    assert_equal DateTime.civil(2005, 2, 22, 15, 15, 10, Rational(-5, 24)), DateTime.civil(2005, 2, 22, 15, 15, 10, 0).change(offset: Rational(-5, 24))
+
     # datetime with fractions of a second
     assert_equal DateTime.civil(2005, 2, 1, 15, 15, 10.7), DateTime.civil(2005, 2, 22, 15, 15, 10.7).change(day: 1)
     assert_equal DateTime.civil(2005, 1, 2, 11, 22, Rational(33000008, 1000000)), DateTime.civil(2005, 1, 2, 11, 22, 33).change(usec: 8)
diff --git a/activesupport/test/core_ext/digest/uuid_test.rb b/activesupport/test/core_ext/digest/uuid_test.rb
index 866a03259a..94cb7d9418 100644
--- a/activesupport/test/core_ext/digest/uuid_test.rb
+++ b/activesupport/test/core_ext/digest/uuid_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/digest/uuid"
 
diff --git a/activesupport/test/core_ext/duration_test.rb b/activesupport/test/core_ext/duration_test.rb
index 2b1a715b7a..c655f466f2 100644
--- a/activesupport/test/core_ext/duration_test.rb
+++ b/activesupport/test/core_ext/duration_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/inflector"
 require "active_support/time"
@@ -96,24 +98,20 @@ class DurationTest < ActiveSupport::TestCase
     assert_instance_of ActiveSupport::Duration, 2.seconds - 1.second
     assert_equal 1.second, 2.seconds - 1
     assert_instance_of ActiveSupport::Duration, 2.seconds - 1
+    assert_equal 1.second, 2 - 1.second
+    assert_instance_of ActiveSupport::Duration, 2.seconds - 1
   end
 
   def test_multiply
     assert_equal 7.days, 1.day * 7
     assert_instance_of ActiveSupport::Duration, 1.day * 7
-
-    assert_deprecated do
-      assert_equal 86400, 1.day * 1.second
-    end
+    assert_equal 86400, 1.day * 1.second
   end
 
   def test_divide
     assert_equal 1.day, 7.days / 7
     assert_instance_of ActiveSupport::Duration, 7.days / 7
-
-    assert_deprecated do
-      assert_equal 1, 1.day / 1.day
-    end
+    assert_equal 1, 1.day / 1.day
   end
 
   def test_date_added_with_multiplied_duration
@@ -121,9 +119,7 @@ class DurationTest < ActiveSupport::TestCase
   end
 
   def test_plus_with_time
-    assert_deprecated do
-      assert_equal 1 + 1.second, 1.second + 1, "Duration + Numeric should == Numeric + Duration"
-    end
+    assert_equal 1 + 1.second, 1.second + 1, "Duration + Numeric should == Numeric + Duration"
   end
 
   def test_time_plus_duration_returns_same_time_datatype
@@ -142,13 +138,6 @@ class DurationTest < ActiveSupport::TestCase
     assert_equal 'expected a time or date, got ""', e.message, "ensure ArgumentError is not being raised by dependencies.rb"
   end
 
-  def test_implicit_coercion_is_deprecated
-    assert_deprecated { 1 + 1.second }
-    assert_deprecated { 1 - 1.second }
-    assert_deprecated { 1 * 1.second }
-    assert_deprecated { 1 / 1.second }
-  end
-
   def test_fractional_weeks
     assert_equal((86400 * 7) * 1.5, 1.5.weeks)
     assert_equal((86400 * 7) * 1.7, 1.7.weeks)
@@ -286,20 +275,159 @@ class DurationTest < ActiveSupport::TestCase
   def test_comparable
     assert_equal(-1, (0.seconds <=> 1.second))
     assert_equal(-1, (1.second <=> 1.minute))
-
-    assert_deprecated do
-      assert_equal(-1, (1 <=> 1.minute))
-    end
-
+    assert_equal(-1, (1 <=> 1.minute))
     assert_equal(0, (0.seconds <=> 0.seconds))
     assert_equal(0, (0.seconds <=> 0.minutes))
     assert_equal(0, (1.second <=> 1.second))
     assert_equal(1, (1.second <=> 0.second))
     assert_equal(1, (1.minute <=> 1.second))
+    assert_equal(1, (61 <=> 1.minute))
+  end
+
+  def test_implicit_coercion
+    assert_equal 2.days, 2 * 1.day
+    assert_instance_of ActiveSupport::Duration, 2 * 1.day
+    assert_equal Time.utc(2017, 1, 3), Time.utc(2017, 1, 1) + 2 * 1.day
+    assert_equal Date.civil(2017, 1, 3), Date.civil(2017, 1, 1) + 2 * 1.day
+  end
+
+  def test_scalar_coerce
+    scalar = ActiveSupport::Duration::Scalar.new(10)
+    assert_instance_of ActiveSupport::Duration::Scalar, 10 + scalar
+    assert_instance_of ActiveSupport::Duration, 10.seconds + scalar
+  end
+
+  def test_scalar_delegations
+    scalar = ActiveSupport::Duration::Scalar.new(10)
+    assert_kind_of Float, scalar.to_f
+    assert_kind_of Integer, scalar.to_i
+    assert_kind_of String, scalar.to_s
+  end
+
+  def test_scalar_unary_minus
+    scalar = ActiveSupport::Duration::Scalar.new(10)
+
+    assert_equal(-10, -scalar)
+    assert_instance_of ActiveSupport::Duration::Scalar, -scalar
+  end
+
+  def test_scalar_compare
+    scalar = ActiveSupport::Duration::Scalar.new(10)
+
+    assert_equal(1, scalar <=> 5)
+    assert_equal(0, scalar <=> 10)
+    assert_equal(-1, scalar <=> 15)
+    assert_nil(scalar <=> "foo")
+  end
+
+  def test_scalar_plus
+    scalar = ActiveSupport::Duration::Scalar.new(10)
+
+    assert_equal 20, 10 + scalar
+    assert_instance_of ActiveSupport::Duration::Scalar, 10 + scalar
+    assert_equal 20, scalar + 10
+    assert_instance_of ActiveSupport::Duration::Scalar, scalar + 10
+    assert_equal 20, 10.seconds + scalar
+    assert_instance_of ActiveSupport::Duration, 10.seconds + scalar
+    assert_equal 20, scalar + 10.seconds
+    assert_instance_of ActiveSupport::Duration, scalar + 10.seconds
+
+    exception = assert_raises(TypeError) do
+      scalar + "foo"
+    end
 
-    assert_deprecated do
-      assert_equal(1, (61 <=> 1.minute))
+    assert_equal "no implicit conversion of String into ActiveSupport::Duration::Scalar", exception.message
+  end
+
+  def test_scalar_plus_parts
+    scalar = ActiveSupport::Duration::Scalar.new(10)
+
+    assert_equal({ days: 1, seconds: 10 }, (scalar + 1.day).parts)
+    assert_equal({ days: -1, seconds: 10 }, (scalar + -1.day).parts)
+  end
+
+  def test_scalar_minus
+    scalar = ActiveSupport::Duration::Scalar.new(10)
+
+    assert_equal 10, 20 - scalar
+    assert_instance_of ActiveSupport::Duration::Scalar, 20 - scalar
+    assert_equal 5, scalar - 5
+    assert_instance_of ActiveSupport::Duration::Scalar, scalar - 5
+    assert_equal 10, 20.seconds - scalar
+    assert_instance_of ActiveSupport::Duration, 20.seconds - scalar
+    assert_equal 5, scalar - 5.seconds
+    assert_instance_of ActiveSupport::Duration, scalar - 5.seconds
+
+    assert_equal({ days: -1, seconds: 10 }, (scalar - 1.day).parts)
+    assert_equal({ days: 1, seconds: 10 }, (scalar - -1.day).parts)
+
+    exception = assert_raises(TypeError) do
+      scalar - "foo"
     end
+
+    assert_equal "no implicit conversion of String into ActiveSupport::Duration::Scalar", exception.message
+  end
+
+  def test_scalar_minus_parts
+    scalar = ActiveSupport::Duration::Scalar.new(10)
+
+    assert_equal({ days: -1, seconds: 10 }, (scalar - 1.day).parts)
+    assert_equal({ days: 1, seconds: 10 }, (scalar - -1.day).parts)
+  end
+
+  def test_scalar_multiply
+    scalar = ActiveSupport::Duration::Scalar.new(5)
+
+    assert_equal 10, 2 * scalar
+    assert_instance_of ActiveSupport::Duration::Scalar, 2 * scalar
+    assert_equal 10, scalar * 2
+    assert_instance_of ActiveSupport::Duration::Scalar, scalar * 2
+    assert_equal 10, 2.seconds * scalar
+    assert_instance_of ActiveSupport::Duration, 2.seconds * scalar
+    assert_equal 10, scalar * 2.seconds
+    assert_instance_of ActiveSupport::Duration, scalar * 2.seconds
+
+    exception = assert_raises(TypeError) do
+      scalar * "foo"
+    end
+
+    assert_equal "no implicit conversion of String into ActiveSupport::Duration::Scalar", exception.message
+  end
+
+  def test_scalar_multiply_parts
+    scalar = ActiveSupport::Duration::Scalar.new(1)
+    assert_equal({ days: 2 }, (scalar * 2.days).parts)
+    assert_equal(172800, (scalar * 2.days).value)
+    assert_equal({ days: -2 }, (scalar * -2.days).parts)
+    assert_equal(-172800, (scalar * -2.days).value)
+  end
+
+  def test_scalar_divide
+    scalar = ActiveSupport::Duration::Scalar.new(10)
+
+    assert_equal 10, 100 / scalar
+    assert_instance_of ActiveSupport::Duration::Scalar, 100 / scalar
+    assert_equal 5, scalar / 2
+    assert_instance_of ActiveSupport::Duration::Scalar, scalar / 2
+    assert_equal 10, 100.seconds / scalar
+    assert_instance_of ActiveSupport::Duration, 2.seconds * scalar
+    assert_equal 5, scalar / 2.seconds
+    assert_instance_of ActiveSupport::Duration, scalar / 2.seconds
+
+    exception = assert_raises(TypeError) do
+      scalar / "foo"
+    end
+
+    assert_equal "no implicit conversion of String into ActiveSupport::Duration::Scalar", exception.message
+  end
+
+  def test_scalar_divide_parts
+    scalar = ActiveSupport::Duration::Scalar.new(10)
+
+    assert_equal({ days: 2 }, (scalar / 5.days).parts)
+    assert_equal(172800, (scalar / 5.days).value)
+    assert_equal({ days: -2 }, (scalar / -5.days).parts)
+    assert_equal(-172800, (scalar / -5.days).value)
   end
 
   def test_twelve_months_equals_one_year
diff --git a/activesupport/test/core_ext/enumerable_test.rb b/activesupport/test/core_ext/enumerable_test.rb
index 4f1ab993b8..8d71320931 100644
--- a/activesupport/test/core_ext/enumerable_test.rb
+++ b/activesupport/test/core_ext/enumerable_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/array"
 require "active_support/core_ext/enumerable"
@@ -171,10 +173,8 @@ class EnumerableTests < ActiveSupport::TestCase
     assert_equal({ 5 => Payment.new(5), 15 => Payment.new(15), 10 => Payment.new(10) },
                  payments.index_by(&:price))
     assert_equal Enumerator, payments.index_by.class
-    if Enumerator.method_defined? :size
-      assert_nil payments.index_by.size
-      assert_equal 42, (1..42).index_by.size
-    end
+    assert_nil payments.index_by.size
+    assert_equal 42, (1..42).index_by.size
     assert_equal({ 5 => Payment.new(5), 15 => Payment.new(15), 10 => Payment.new(10) },
                  payments.index_by.each(&:price))
   end
diff --git a/activesupport/test/core_ext/file_test.rb b/activesupport/test/core_ext/file_test.rb
index df5d09acd0..23e3c277cc 100644
--- a/activesupport/test/core_ext/file_test.rb
+++ b/activesupport/test/core_ext/file_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/file"
 
diff --git a/activesupport/test/core_ext/hash/transform_keys_test.rb b/activesupport/test/core_ext/hash/transform_keys_test.rb
index 7a11d827f8..b9e41f7b25 100644
--- a/activesupport/test/core_ext/hash/transform_keys_test.rb
+++ b/activesupport/test/core_ext/hash/transform_keys_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/hash/keys"
 
diff --git a/activesupport/test/core_ext/hash/transform_values_test.rb b/activesupport/test/core_ext/hash/transform_values_test.rb
index f2ac4ce6ce..d34b7fa7b9 100644
--- a/activesupport/test/core_ext/hash/transform_values_test.rb
+++ b/activesupport/test/core_ext/hash/transform_values_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/hash/indifferent_access"
 require "active_support/core_ext/hash/transform_values"
diff --git a/activesupport/test/core_ext/hash_ext_test.rb b/activesupport/test/core_ext/hash_ext_test.rb
index 49a6800cf3..746d7ad416 100644
--- a/activesupport/test/core_ext/hash_ext_test.rb
+++ b/activesupport/test/core_ext/hash_ext_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/hash"
 require "bigdecimal"
@@ -8,33 +10,6 @@ require "active_support/core_ext/object/deep_dup"
 require "active_support/inflections"
 
 class HashExtTest < ActiveSupport::TestCase
-  HashWithIndifferentAccess = ActiveSupport::HashWithIndifferentAccess
-
-  class IndifferentHash < ActiveSupport::HashWithIndifferentAccess
-  end
-
-  class SubclassingArray < Array
-  end
-
-  class SubclassingHash < Hash
-  end
-
-  class NonIndifferentHash < Hash
-    def nested_under_indifferent_access
-      self
-    end
-  end
-
-  class HashByConversion
-    def initialize(hash)
-      @hash = hash
-    end
-
-    def to_hash
-      @hash
-    end
-  end
-
   def setup
     @strings = { "a" => 1, "b" => 2 }
     @nested_strings = { "a" => { "b" => { "c" => 3 } } }
@@ -264,471 +239,6 @@ class HashExtTest < ActiveSupport::TestCase
     assert_equal({ "a" => { b: { "c" => 3 } } }, @nested_mixed)
   end
 
-  def test_symbolize_keys_for_hash_with_indifferent_access
-    assert_instance_of Hash, @symbols.with_indifferent_access.symbolize_keys
-    assert_equal @symbols, @symbols.with_indifferent_access.symbolize_keys
-    assert_equal @symbols, @strings.with_indifferent_access.symbolize_keys
-    assert_equal @symbols, @mixed.with_indifferent_access.symbolize_keys
-  end
-
-  def test_deep_symbolize_keys_for_hash_with_indifferent_access
-    assert_instance_of Hash, @nested_symbols.with_indifferent_access.deep_symbolize_keys
-    assert_equal @nested_symbols, @nested_symbols.with_indifferent_access.deep_symbolize_keys
-    assert_equal @nested_symbols, @nested_strings.with_indifferent_access.deep_symbolize_keys
-    assert_equal @nested_symbols, @nested_mixed.with_indifferent_access.deep_symbolize_keys
-  end
-
-  def test_symbolize_keys_bang_for_hash_with_indifferent_access
-    assert_raise(NoMethodError) { @symbols.with_indifferent_access.dup.symbolize_keys! }
-    assert_raise(NoMethodError) { @strings.with_indifferent_access.dup.symbolize_keys! }
-    assert_raise(NoMethodError) { @mixed.with_indifferent_access.dup.symbolize_keys! }
-  end
-
-  def test_deep_symbolize_keys_bang_for_hash_with_indifferent_access
-    assert_raise(NoMethodError) { @nested_symbols.with_indifferent_access.deep_dup.deep_symbolize_keys! }
-    assert_raise(NoMethodError) { @nested_strings.with_indifferent_access.deep_dup.deep_symbolize_keys! }
-    assert_raise(NoMethodError) { @nested_mixed.with_indifferent_access.deep_dup.deep_symbolize_keys! }
-  end
-
-  def test_symbolize_keys_preserves_keys_that_cant_be_symbolized_for_hash_with_indifferent_access
-    assert_equal @illegal_symbols, @illegal_symbols.with_indifferent_access.symbolize_keys
-    assert_raise(NoMethodError) { @illegal_symbols.with_indifferent_access.dup.symbolize_keys! }
-  end
-
-  def test_deep_symbolize_keys_preserves_keys_that_cant_be_symbolized_for_hash_with_indifferent_access
-    assert_equal @nested_illegal_symbols, @nested_illegal_symbols.with_indifferent_access.deep_symbolize_keys
-    assert_raise(NoMethodError) { @nested_illegal_symbols.with_indifferent_access.deep_dup.deep_symbolize_keys! }
-  end
-
-  def test_symbolize_keys_preserves_integer_keys_for_hash_with_indifferent_access
-    assert_equal @integers, @integers.with_indifferent_access.symbolize_keys
-    assert_raise(NoMethodError) { @integers.with_indifferent_access.dup.symbolize_keys! }
-  end
-
-  def test_deep_symbolize_keys_preserves_integer_keys_for_hash_with_indifferent_access
-    assert_equal @nested_integers, @nested_integers.with_indifferent_access.deep_symbolize_keys
-    assert_raise(NoMethodError) { @nested_integers.with_indifferent_access.deep_dup.deep_symbolize_keys! }
-  end
-
-  def test_stringify_keys_for_hash_with_indifferent_access
-    assert_instance_of ActiveSupport::HashWithIndifferentAccess, @symbols.with_indifferent_access.stringify_keys
-    assert_equal @strings, @symbols.with_indifferent_access.stringify_keys
-    assert_equal @strings, @strings.with_indifferent_access.stringify_keys
-    assert_equal @strings, @mixed.with_indifferent_access.stringify_keys
-  end
-
-  def test_deep_stringify_keys_for_hash_with_indifferent_access
-    assert_instance_of ActiveSupport::HashWithIndifferentAccess, @nested_symbols.with_indifferent_access.deep_stringify_keys
-    assert_equal @nested_strings, @nested_symbols.with_indifferent_access.deep_stringify_keys
-    assert_equal @nested_strings, @nested_strings.with_indifferent_access.deep_stringify_keys
-    assert_equal @nested_strings, @nested_mixed.with_indifferent_access.deep_stringify_keys
-  end
-
-  def test_stringify_keys_bang_for_hash_with_indifferent_access
-    assert_instance_of ActiveSupport::HashWithIndifferentAccess, @symbols.with_indifferent_access.dup.stringify_keys!
-    assert_equal @strings, @symbols.with_indifferent_access.dup.stringify_keys!
-    assert_equal @strings, @strings.with_indifferent_access.dup.stringify_keys!
-    assert_equal @strings, @mixed.with_indifferent_access.dup.stringify_keys!
-  end
-
-  def test_deep_stringify_keys_bang_for_hash_with_indifferent_access
-    assert_instance_of ActiveSupport::HashWithIndifferentAccess, @nested_symbols.with_indifferent_access.dup.deep_stringify_keys!
-    assert_equal @nested_strings, @nested_symbols.with_indifferent_access.deep_dup.deep_stringify_keys!
-    assert_equal @nested_strings, @nested_strings.with_indifferent_access.deep_dup.deep_stringify_keys!
-    assert_equal @nested_strings, @nested_mixed.with_indifferent_access.deep_dup.deep_stringify_keys!
-  end
-
-  def test_nested_under_indifferent_access
-    foo = { "foo" => SubclassingHash.new.tap { |h| h["bar"] = "baz" } }.with_indifferent_access
-    assert_kind_of ActiveSupport::HashWithIndifferentAccess, foo["foo"]
-
-    foo = { "foo" => NonIndifferentHash.new.tap { |h| h["bar"] = "baz" } }.with_indifferent_access
-    assert_kind_of NonIndifferentHash, foo["foo"]
-
-    foo = { "foo" => IndifferentHash.new.tap { |h| h["bar"] = "baz" } }.with_indifferent_access
-    assert_kind_of IndifferentHash, foo["foo"]
-  end
-
-  def test_indifferent_assorted
-    @strings = @strings.with_indifferent_access
-    @symbols = @symbols.with_indifferent_access
-    @mixed   = @mixed.with_indifferent_access
-
-    assert_equal "a", @strings.__send__(:convert_key, :a)
-
-    assert_equal 1, @strings.fetch("a")
-    assert_equal 1, @strings.fetch(:a.to_s)
-    assert_equal 1, @strings.fetch(:a)
-
-    hashes = { :@strings => @strings, :@symbols => @symbols, :@mixed => @mixed }
-    method_map = { '[]': 1, fetch: 1, values_at: [1],
-      has_key?: true, include?: true, key?: true,
-      member?: true }
-
-    hashes.each do |name, hash|
-      method_map.sort_by(&:to_s).each do |meth, expected|
-        assert_equal(expected, hash.__send__(meth, "a"),
-                     "Calling #{name}.#{meth} 'a'")
-        assert_equal(expected, hash.__send__(meth, :a),
-                     "Calling #{name}.#{meth} :a")
-      end
-    end
-
-    assert_equal [1, 2], @strings.values_at("a", "b")
-    assert_equal [1, 2], @strings.values_at(:a, :b)
-    assert_equal [1, 2], @symbols.values_at("a", "b")
-    assert_equal [1, 2], @symbols.values_at(:a, :b)
-    assert_equal [1, 2], @mixed.values_at("a", "b")
-    assert_equal [1, 2], @mixed.values_at(:a, :b)
-  end
-
-  def test_indifferent_reading
-    hash = HashWithIndifferentAccess.new
-    hash["a"] = 1
-    hash["b"] = true
-    hash["c"] = false
-    hash["d"] = nil
-
-    assert_equal 1, hash[:a]
-    assert_equal true, hash[:b]
-    assert_equal false, hash[:c]
-    assert_nil hash[:d]
-    assert_nil hash[:e]
-  end
-
-  def test_indifferent_reading_with_nonnil_default
-    hash = HashWithIndifferentAccess.new(1)
-    hash["a"] = 1
-    hash["b"] = true
-    hash["c"] = false
-    hash["d"] = nil
-
-    assert_equal 1, hash[:a]
-    assert_equal true, hash[:b]
-    assert_equal false, hash[:c]
-    assert_nil hash[:d]
-    assert_equal 1, hash[:e]
-  end
-
-  def test_indifferent_writing
-    hash = HashWithIndifferentAccess.new
-    hash[:a] = 1
-    hash["b"] = 2
-    hash[3] = 3
-
-    assert_equal 1, hash["a"]
-    assert_equal 2, hash["b"]
-    assert_equal 1, hash[:a]
-    assert_equal 2, hash[:b]
-    assert_equal 3, hash[3]
-  end
-
-  def test_indifferent_update
-    hash = HashWithIndifferentAccess.new
-    hash[:a] = "a"
-    hash["b"] = "b"
-
-    updated_with_strings = hash.update(@strings)
-    updated_with_symbols = hash.update(@symbols)
-    updated_with_mixed = hash.update(@mixed)
-
-    assert_equal 1, updated_with_strings[:a]
-    assert_equal 1, updated_with_strings["a"]
-    assert_equal 2, updated_with_strings["b"]
-
-    assert_equal 1, updated_with_symbols[:a]
-    assert_equal 2, updated_with_symbols["b"]
-    assert_equal 2, updated_with_symbols[:b]
-
-    assert_equal 1, updated_with_mixed[:a]
-    assert_equal 2, updated_with_mixed["b"]
-
-    assert [updated_with_strings, updated_with_symbols, updated_with_mixed].all? { |h| h.keys.size == 2 }
-  end
-
-  def test_update_with_to_hash_conversion
-    hash = HashWithIndifferentAccess.new
-    hash.update HashByConversion.new(a: 1)
-    assert_equal 1, hash["a"]
-  end
-
-  def test_indifferent_merging
-    hash = HashWithIndifferentAccess.new
-    hash[:a] = "failure"
-    hash["b"] = "failure"
-
-    other = { "a" => 1, :b => 2 }
-
-    merged = hash.merge(other)
-
-    assert_equal HashWithIndifferentAccess, merged.class
-    assert_equal 1, merged[:a]
-    assert_equal 2, merged["b"]
-
-    hash.update(other)
-
-    assert_equal 1, hash[:a]
-    assert_equal 2, hash["b"]
-  end
-
-  def test_merge_with_to_hash_conversion
-    hash = HashWithIndifferentAccess.new
-    merged = hash.merge HashByConversion.new(a: 1)
-    assert_equal 1, merged["a"]
-  end
-
-  def test_indifferent_replace
-    hash = HashWithIndifferentAccess.new
-    hash[:a] = 42
-
-    replaced = hash.replace(b: 12)
-
-    assert hash.key?("b")
-    assert !hash.key?(:a)
-    assert_equal 12, hash[:b]
-    assert_same hash, replaced
-  end
-
-  def test_replace_with_to_hash_conversion
-    hash = HashWithIndifferentAccess.new
-    hash[:a] = 42
-
-    replaced = hash.replace(HashByConversion.new(b: 12))
-
-    assert hash.key?("b")
-    assert !hash.key?(:a)
-    assert_equal 12, hash[:b]
-    assert_same hash, replaced
-  end
-
-  def test_indifferent_merging_with_block
-    hash = HashWithIndifferentAccess.new
-    hash[:a] = 1
-    hash["b"] = 3
-
-    other = { "a" => 4, :b => 2, "c" => 10 }
-
-    merged = hash.merge(other) { |key, old, new| old > new ? old : new }
-
-    assert_equal HashWithIndifferentAccess, merged.class
-    assert_equal 4, merged[:a]
-    assert_equal 3, merged["b"]
-    assert_equal 10, merged[:c]
-
-    other_indifferent = HashWithIndifferentAccess.new("a" => 9, :b => 2)
-
-    merged = hash.merge(other_indifferent) { |key, old, new| old + new }
-
-    assert_equal HashWithIndifferentAccess, merged.class
-    assert_equal 10, merged[:a]
-    assert_equal 5, merged[:b]
-  end
-
-  def test_indifferent_reverse_merging
-    hash = HashWithIndifferentAccess.new key: :old_value
-    hash.reverse_merge! key: :new_value
-    assert_equal :old_value, hash[:key]
-
-    hash = HashWithIndifferentAccess.new("some" => "value", "other" => "value")
-    hash.reverse_merge!(some: "noclobber", another: "clobber")
-    assert_equal "value", hash[:some]
-    assert_equal "clobber", hash[:another]
-  end
-
-  def test_indifferent_deleting
-    get_hash = proc { { a: "foo" }.with_indifferent_access }
-    hash = get_hash.call
-    assert_equal "foo", hash.delete(:a)
-    assert_nil hash.delete(:a)
-    hash = get_hash.call
-    assert_equal "foo", hash.delete("a")
-    assert_nil hash.delete("a")
-  end
-
-  def test_indifferent_select
-    hash = ActiveSupport::HashWithIndifferentAccess.new(@strings).select { |k, v| v == 1 }
-
-    assert_equal({ "a" => 1 }, hash)
-    assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
-  end
-
-  def test_indifferent_select_returns_enumerator
-    enum = ActiveSupport::HashWithIndifferentAccess.new(@strings).select
-    assert_instance_of Enumerator, enum
-  end
-
-  def test_indifferent_select_returns_a_hash_when_unchanged
-    hash = ActiveSupport::HashWithIndifferentAccess.new(@strings).select { |k, v| true }
-
-    assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
-  end
-
-  def test_indifferent_select_bang
-    indifferent_strings = ActiveSupport::HashWithIndifferentAccess.new(@strings)
-    indifferent_strings.select! { |k, v| v == 1 }
-
-    assert_equal({ "a" => 1 }, indifferent_strings)
-    assert_instance_of ActiveSupport::HashWithIndifferentAccess, indifferent_strings
-  end
-
-  def test_indifferent_reject
-    hash = ActiveSupport::HashWithIndifferentAccess.new(@strings).reject { |k, v| v != 1 }
-
-    assert_equal({ "a" => 1 }, hash)
-    assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
-  end
-
-  def test_indifferent_reject_returns_enumerator
-    enum = ActiveSupport::HashWithIndifferentAccess.new(@strings).reject
-    assert_instance_of Enumerator, enum
-  end
-
-  def test_indifferent_reject_bang
-    indifferent_strings = ActiveSupport::HashWithIndifferentAccess.new(@strings)
-    indifferent_strings.reject! { |k, v| v != 1 }
-
-    assert_equal({ "a" => 1 }, indifferent_strings)
-    assert_instance_of ActiveSupport::HashWithIndifferentAccess, indifferent_strings
-  end
-
-  def test_indifferent_compact
-    hash_contain_nil_value = @strings.merge("z" => nil)
-    hash = ActiveSupport::HashWithIndifferentAccess.new(hash_contain_nil_value)
-    compacted_hash = hash.compact
-
-    assert_equal(@strings, compacted_hash)
-    assert_equal(hash_contain_nil_value, hash)
-    assert_instance_of ActiveSupport::HashWithIndifferentAccess, compacted_hash
-
-    empty_hash = ActiveSupport::HashWithIndifferentAccess.new
-    compacted_hash = empty_hash.compact
-
-    assert_equal compacted_hash, empty_hash
-
-    non_empty_hash = ActiveSupport::HashWithIndifferentAccess.new(foo: :bar)
-    compacted_hash = non_empty_hash.compact
-
-    assert_equal compacted_hash, non_empty_hash
-  end
-
-  def test_indifferent_to_hash
-    # Should convert to a Hash with String keys.
-    assert_equal @strings, @mixed.with_indifferent_access.to_hash
-
-    # Should preserve the default value.
-    mixed_with_default = @mixed.dup
-    mixed_with_default.default = "1234"
-    roundtrip = mixed_with_default.with_indifferent_access.to_hash
-    assert_equal @strings, roundtrip
-    assert_equal "1234", roundtrip.default
-
-    # Ensure nested hashes are not HashWithIndiffereneAccess
-    new_to_hash = @nested_mixed.with_indifferent_access.to_hash
-    assert_not new_to_hash.instance_of?(HashWithIndifferentAccess)
-    assert_not new_to_hash["a"].instance_of?(HashWithIndifferentAccess)
-    assert_not new_to_hash["a"]["b"].instance_of?(HashWithIndifferentAccess)
-  end
-
-  def test_lookup_returns_the_same_object_that_is_stored_in_hash_indifferent_access
-    hash = HashWithIndifferentAccess.new { |h, k| h[k] = [] }
-    hash[:a] << 1
-
-    assert_equal [1], hash[:a]
-  end
-
-  def test_with_indifferent_access_has_no_side_effects_on_existing_hash
-    hash = { content: [{ :foo => :bar, "bar" => "baz" }] }
-    hash.with_indifferent_access
-
-    assert_equal [:foo, "bar"], hash[:content].first.keys
-  end
-
-  def test_indifferent_hash_with_array_of_hashes
-    hash = { "urls" => { "url" => [ { "address" => "1" }, { "address" => "2" } ] } }.with_indifferent_access
-    assert_equal "1", hash[:urls][:url].first[:address]
-
-    hash = hash.to_hash
-    assert_not hash.instance_of?(HashWithIndifferentAccess)
-    assert_not hash["urls"].instance_of?(HashWithIndifferentAccess)
-    assert_not hash["urls"]["url"].first.instance_of?(HashWithIndifferentAccess)
-  end
-
-  def test_should_preserve_array_subclass_when_value_is_array
-    array = SubclassingArray.new
-    array << { "address" => "1" }
-    hash = { "urls" => { "url" => array } }.with_indifferent_access
-    assert_equal SubclassingArray, hash[:urls][:url].class
-  end
-
-  def test_should_preserve_array_class_when_hash_value_is_frozen_array
-    array = SubclassingArray.new
-    array << { "address" => "1" }
-    hash = { "urls" => { "url" => array.freeze } }.with_indifferent_access
-    assert_equal SubclassingArray, hash[:urls][:url].class
-  end
-
-  def test_stringify_and_symbolize_keys_on_indifferent_preserves_hash
-    h = HashWithIndifferentAccess.new
-    h[:first] = 1
-    h = h.stringify_keys
-    assert_equal 1, h["first"]
-    h = HashWithIndifferentAccess.new
-    h["first"] = 1
-    h = h.symbolize_keys
-    assert_equal 1, h[:first]
-  end
-
-  def test_deep_stringify_and_deep_symbolize_keys_on_indifferent_preserves_hash
-    h = HashWithIndifferentAccess.new
-    h[:first] = 1
-    h = h.deep_stringify_keys
-    assert_equal 1, h["first"]
-    h = HashWithIndifferentAccess.new
-    h["first"] = 1
-    h = h.deep_symbolize_keys
-    assert_equal 1, h[:first]
-  end
-
-  def test_to_options_on_indifferent_preserves_hash
-    h = HashWithIndifferentAccess.new
-    h["first"] = 1
-    h.to_options!
-    assert_equal 1, h["first"]
-  end
-
-  def test_to_options_on_indifferent_preserves_works_as_hash_with_dup
-    h = HashWithIndifferentAccess.new(a: { b: "b" })
-    dup = h.dup
-
-    dup[:a][:c] = "c"
-    assert_equal "c", h[:a][:c]
-  end
-
-  def test_indifferent_sub_hashes
-    h = { "user" => { "id" => 5 } }.with_indifferent_access
-    ["user", :user].each { |user| [:id, "id"].each { |id| assert_equal 5, h[user][id], "h[#{user.inspect}][#{id.inspect}] should be 5" } }
-
-    h = { user: { id: 5 } }.with_indifferent_access
-    ["user", :user].each { |user| [:id, "id"].each { |id| assert_equal 5, h[user][id], "h[#{user.inspect}][#{id.inspect}] should be 5" } }
-  end
-
-  def test_indifferent_duplication
-    # Should preserve default value
-    h = HashWithIndifferentAccess.new
-    h.default = "1234"
-    assert_equal h.default, h.dup.default
-
-    # Should preserve class for subclasses
-    h = IndifferentHash.new
-    assert_equal h.class, h.dup.class
-  end
-
-  def test_nested_dig_indifferent_access
-    skip if RUBY_VERSION < "2.3.0"
-    data = { "this" => { "views" => 1234 } }.with_indifferent_access
-    assert_equal 1234, data.dig(:this, :views)
-  end
-
   def test_assert_valid_keys
     assert_nothing_raised do
       { failure: "stuff", funny: "business" }.assert_valid_keys([ :failure, :funny ])
@@ -761,12 +271,6 @@ class HashExtTest < ActiveSupport::TestCase
     assert_equal "Unknown key: :failore. Valid keys are: :failure", exception.message
   end
 
-  def test_assorted_keys_not_stringified
-    original = { Object.new => 2, 1 => 2, [] => true }
-    indiff = original.with_indifferent_access
-    assert(!indiff.keys.any? { |k| k.kind_of? String }, "A key was converted to a string!")
-  end
-
   def test_deep_merge
     hash_1 = { a: "a", b: "b", c: { c1: "c1", c2: "c2", c3: { d1: "d1" } } }
     hash_2 = { a: 1, c: { c1: 2, c3: { d2: "d2" } } }
@@ -797,37 +301,6 @@ class HashExtTest < ActiveSupport::TestCase
     assert_equal expected, hash_1
   end
 
-  def test_deep_merge_on_indifferent_access
-    hash_1 = HashWithIndifferentAccess.new(a: "a", b: "b", c: { c1: "c1", c2: "c2", c3: { d1: "d1" } })
-    hash_2 = HashWithIndifferentAccess.new(a: 1, c: { c1: 2, c3: { d2: "d2" } })
-    hash_3 = { a: 1, c: { c1: 2, c3: { d2: "d2" } } }
-    expected = { "a" => 1, "b" => "b", "c" => { "c1" => 2, "c2" => "c2", "c3" => { "d1" => "d1", "d2" => "d2" } } }
-    assert_equal expected, hash_1.deep_merge(hash_2)
-    assert_equal expected, hash_1.deep_merge(hash_3)
-
-    hash_1.deep_merge!(hash_2)
-    assert_equal expected, hash_1
-  end
-
-  def test_store_on_indifferent_access
-    hash = HashWithIndifferentAccess.new
-    hash.store(:test1, 1)
-    hash.store("test1", 11)
-    hash[:test2] = 2
-    hash["test2"] = 22
-    expected = { "test1" => 11, "test2" => 22 }
-    assert_equal expected, hash
-  end
-
-  def test_constructor_on_indifferent_access
-    hash = HashWithIndifferentAccess[:foo, 1]
-    assert_equal 1, hash[:foo]
-    assert_equal 1, hash["foo"]
-    hash[:foo] = 3
-    assert_equal 3, hash[:foo]
-    assert_equal 3, hash["foo"]
-  end
-
   def test_reverse_merge
     defaults = { d: 0, a: "x", b: "y", c: 10 }.freeze
     options  = { a: 1, b: 2 }
@@ -851,6 +324,21 @@ class HashExtTest < ActiveSupport::TestCase
     assert_equal expected, merged
   end
 
+  def test_with_defaults_aliases_reverse_merge
+    defaults = { a: "x", b: "y", c: 10 }.freeze
+    options  = { a: 1, b: 2 }
+    expected = { a: 1, b: 2, c: 10 }
+
+    # Should be an alias for reverse_merge
+    assert_equal expected, options.with_defaults(defaults)
+    assert_not_equal expected, options
+
+    # Should be an alias for reverse_merge!
+    merged = options.dup
+    assert_equal expected, merged.with_defaults!(defaults)
+    assert_equal expected, merged
+  end
+
   def test_slice
     original = { a: "x", b: "y", c: 10 }
     expected = { a: "x", b: "y" }
@@ -893,38 +381,6 @@ class HashExtTest < ActiveSupport::TestCase
     assert_equal expected, original.slice(*[:a, :b])
   end
 
-  def test_indifferent_slice
-    original = { a: "x", b: "y", c: 10 }.with_indifferent_access
-    expected = { a: "x", b: "y" }.with_indifferent_access
-
-    [["a", "b"], [:a, :b]].each do |keys|
-      # Should return a new hash with only the given keys.
-      assert_equal expected, original.slice(*keys), keys.inspect
-      assert_not_equal expected, original
-    end
-  end
-
-  def test_indifferent_slice_inplace
-    original = { a: "x", b: "y", c: 10 }.with_indifferent_access
-    expected = { c: 10 }.with_indifferent_access
-
-    [["a", "b"], [:a, :b]].each do |keys|
-      # Should replace the hash with only the given keys.
-      copy = original.dup
-      assert_equal expected, copy.slice!(*keys)
-    end
-  end
-
-  def test_indifferent_slice_access_with_symbols
-    original = { "login" => "bender", "password" => "shiny", "stuff" => "foo" }
-    original = original.with_indifferent_access
-
-    slice = original.slice(:login, :password)
-
-    assert_equal "bender", slice[:login]
-    assert_equal "bender", slice["login"]
-  end
-
   def test_slice_bang_does_not_override_default
     hash = Hash.new(0)
     hash.update(a: 1, b: 2)
@@ -962,18 +418,6 @@ class HashExtTest < ActiveSupport::TestCase
     assert_nil extracted[:x]
   end
 
-  def test_indifferent_extract
-    original = { :a => 1, "b" => 2, :c => 3, "d" => 4 }.with_indifferent_access
-    expected = { a: 1, b: 2 }.with_indifferent_access
-    remaining = { c: 3, d: 4 }.with_indifferent_access
-
-    [["a", "b"], [:a, :b]].each do |keys|
-      copy = original.dup
-      assert_equal expected, copy.extract!(*keys)
-      assert_equal remaining, copy
-    end
-  end
-
   def test_except
     original = { a: "x", b: "y", c: 10 }
     expected = { a: "x", b: "y" }
@@ -1045,78 +489,6 @@ class HashExtTest < ActiveSupport::TestCase
     assert_nil(h.compact!)
     assert_equal(@symbols, h)
   end
-
-  def test_new_with_to_hash_conversion
-    hash = HashWithIndifferentAccess.new(HashByConversion.new(a: 1))
-    assert hash.key?("a")
-    assert_equal 1, hash[:a]
-  end
-
-  def test_dup_with_default_proc
-    hash = HashWithIndifferentAccess.new
-    hash.default_proc = proc { |h, v| raise "walrus" }
-    assert_nothing_raised { hash.dup }
-  end
-
-  def test_dup_with_default_proc_sets_proc
-    hash = HashWithIndifferentAccess.new
-    hash.default_proc = proc { |h, k| k + 1 }
-    new_hash = hash.dup
-
-    assert_equal 3, new_hash[2]
-
-    new_hash.default = 2
-    assert_equal 2, new_hash[:non_existent]
-  end
-
-  def test_to_hash_with_raising_default_proc
-    hash = HashWithIndifferentAccess.new
-    hash.default_proc = proc { |h, k| raise "walrus" }
-
-    assert_nothing_raised { hash.to_hash }
-  end
-
-  def test_new_with_to_hash_conversion_copies_default
-    normal_hash = Hash.new(3)
-    normal_hash[:a] = 1
-
-    hash = HashWithIndifferentAccess.new(HashByConversion.new(normal_hash))
-    assert_equal 1, hash[:a]
-    assert_equal 3, hash[:b]
-  end
-
-  def test_new_with_to_hash_conversion_copies_default_proc
-    normal_hash = Hash.new { 1 + 2 }
-    normal_hash[:a] = 1
-
-    hash = HashWithIndifferentAccess.new(HashByConversion.new(normal_hash))
-    assert_equal 1, hash[:a]
-    assert_equal 3, hash[:b]
-  end
-
-  def test_inheriting_from_top_level_hash_with_indifferent_access_preserves_ancestors_chain
-    klass = Class.new(::HashWithIndifferentAccess)
-    assert_equal ActiveSupport::HashWithIndifferentAccess, klass.ancestors[1]
-  end
-
-  def test_inheriting_from_hash_with_indifferent_access_properly_dumps_ivars
-    klass = Class.new(::HashWithIndifferentAccess) do
-      def initialize(*)
-        @foo = "bar"
-        super
-      end
-    end
-
-    yaml_output = klass.new.to_yaml
-
-    # `hash-with-ivars` was introduced in 2.0.9 (https://git.io/vyUQW)
-    if Gem::Version.new(Psych::VERSION) >= Gem::Version.new("2.0.9")
-      assert_includes yaml_output, "hash-with-ivars"
-      assert_includes yaml_output, "@foo: bar"
-    else
-      assert_includes yaml_output, "hash"
-    end
-  end
 end
 
 class IWriteMyOwnXML
@@ -1162,8 +534,6 @@ class HashExtToParamTests < ActiveSupport::TestCase
 end
 
 class HashToXmlTest < ActiveSupport::TestCase
-  HashWithIndifferentAccess = ActiveSupport::HashWithIndifferentAccess
-
   def setup
     @xml_options = { root: :person, skip_instruct: true, indent: 0 }
   end
@@ -1639,61 +1009,6 @@ class HashToXmlTest < ActiveSupport::TestCase
     assert_equal expected, Hash.from_trusted_xml('<product><name type="yaml">:value</name></product>')
   end
 
-  def test_should_use_default_proc_for_unknown_key
-    hash_wia = HashWithIndifferentAccess.new { 1 + 2 }
-    assert_equal 3, hash_wia[:new_key]
-  end
-
-  def test_should_return_nil_if_no_key_is_supplied
-    hash_wia = HashWithIndifferentAccess.new { 1 + 2 }
-    assert_nil hash_wia.default
-  end
-
-  def test_should_use_default_value_for_unknown_key
-    hash_wia = HashWithIndifferentAccess.new(3)
-    assert_equal 3, hash_wia[:new_key]
-  end
-
-  def test_should_use_default_value_if_no_key_is_supplied
-    hash_wia = HashWithIndifferentAccess.new(3)
-    assert_equal 3, hash_wia.default
-  end
-
-  def test_should_nil_if_no_default_value_is_supplied
-    hash_wia = HashWithIndifferentAccess.new
-    assert_nil hash_wia.default
-  end
-
-  def test_should_return_dup_for_with_indifferent_access
-    hash_wia = HashWithIndifferentAccess.new
-    assert_equal hash_wia, hash_wia.with_indifferent_access
-    assert_not_same hash_wia, hash_wia.with_indifferent_access
-  end
-
-  def test_allows_setting_frozen_array_values_with_indifferent_access
-    value = [1, 2, 3].freeze
-    hash = HashWithIndifferentAccess.new
-    hash[:key] = value
-    assert_equal hash[:key], value
-  end
-
-  def test_should_copy_the_default_value_when_converting_to_hash_with_indifferent_access
-    hash = Hash.new(3)
-    hash_wia = hash.with_indifferent_access
-    assert_equal 3, hash_wia.default
-  end
-
-  def test_should_copy_the_default_proc_when_converting_to_hash_with_indifferent_access
-    hash = Hash.new do
-      2 + 1
-    end
-    assert_equal 3, hash[:foo]
-
-    hash_wia = hash.with_indifferent_access
-    assert_equal 3, hash_wia[:foo]
-    assert_equal 3, hash_wia[:bar]
-  end
-
   # The XML builder seems to fail miserably when trying to tag something
   # with the same name as a Kernel method (throw, test, loop, select ...)
   def test_kernel_method_names_to_xml
diff --git a/activesupport/test/core_ext/integer_ext_test.rb b/activesupport/test/core_ext/integer_ext_test.rb
index 137e8ce85f..14169b084d 100644
--- a/activesupport/test/core_ext/integer_ext_test.rb
+++ b/activesupport/test/core_ext/integer_ext_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/integer"
 
diff --git a/activesupport/test/core_ext/kernel/concern_test.rb b/activesupport/test/core_ext/kernel/concern_test.rb
index e7e4f99d7e..b40ff6a623 100644
--- a/activesupport/test/core_ext/kernel/concern_test.rb
+++ b/activesupport/test/core_ext/kernel/concern_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/kernel/concern"
 
diff --git a/activesupport/test/core_ext/kernel_test.rb b/activesupport/test/core_ext/kernel_test.rb
index 26f5088ede..ef11e10af8 100644
--- a/activesupport/test/core_ext/kernel_test.rb
+++ b/activesupport/test/core_ext/kernel_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/kernel"
 
diff --git a/activesupport/test/core_ext/load_error_test.rb b/activesupport/test/core_ext/load_error_test.rb
index 44ff6bb051..4fdd228ff8 100644
--- a/activesupport/test/core_ext/load_error_test.rb
+++ b/activesupport/test/core_ext/load_error_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/load_error"
 
diff --git a/activesupport/test/core_ext/marshal_test.rb b/activesupport/test/core_ext/marshal_test.rb
index cabeed2fae..7ac051b4b1 100644
--- a/activesupport/test/core_ext/marshal_test.rb
+++ b/activesupport/test/core_ext/marshal_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/marshal"
 require "dependencies_test_helpers"
diff --git a/activesupport/test/core_ext/module/anonymous_test.rb b/activesupport/test/core_ext/module/anonymous_test.rb
index f885444284..606f22c9b5 100644
--- a/activesupport/test/core_ext/module/anonymous_test.rb
+++ b/activesupport/test/core_ext/module/anonymous_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/module/anonymous"
 
diff --git a/activesupport/test/core_ext/module/attr_internal_test.rb b/activesupport/test/core_ext/module/attr_internal_test.rb
index 8458e278ee..c2a28eced4 100644
--- a/activesupport/test/core_ext/module/attr_internal_test.rb
+++ b/activesupport/test/core_ext/module/attr_internal_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/module/attr_internal"
 
diff --git a/activesupport/test/core_ext/module/attribute_accessor_per_thread_test.rb b/activesupport/test/core_ext/module/attribute_accessor_per_thread_test.rb
index af240bc38d..e0fbd1002c 100644
--- a/activesupport/test/core_ext/module/attribute_accessor_per_thread_test.rb
+++ b/activesupport/test/core_ext/module/attribute_accessor_per_thread_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/module/attribute_accessors_per_thread"
 
diff --git a/activesupport/test/core_ext/module/attribute_accessor_test.rb b/activesupport/test/core_ext/module/attribute_accessor_test.rb
index 464a000d59..f1d6859a88 100644
--- a/activesupport/test/core_ext/module/attribute_accessor_test.rb
+++ b/activesupport/test/core_ext/module/attribute_accessor_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/module/attribute_accessors"
 
@@ -12,7 +14,14 @@ class ModuleAttributeAccessorTest < ActiveSupport::TestCase
       cattr_accessor(:defa) { "default_accessor_value" }
       cattr_reader(:defr) { "default_reader_value" }
       cattr_writer(:defw) { "default_writer_value" }
+      cattr_accessor(:deff) { false }
       cattr_accessor(:quux) { :quux }
+
+      cattr_accessor :def_accessor, default: "default_accessor_value"
+      cattr_reader :def_reader, default: "default_reader_value"
+      cattr_writer :def_writer, default: "default_writer_value"
+      cattr_accessor :def_false, default: false
+      cattr_accessor(:def_priority, default: false) { :no_priority }
     end
     @class = Class.new
     @class.instance_eval { include m }
@@ -24,6 +33,21 @@ class ModuleAttributeAccessorTest < ActiveSupport::TestCase
     assert_nil @object.foo
   end
 
+  def test_mattr_default_keyword_arguments
+    assert_equal "default_accessor_value", @module.def_accessor
+    assert_equal "default_reader_value", @module.def_reader
+    assert_equal "default_writer_value", @module.class_variable_get(:@@def_writer)
+  end
+
+  def test_mattr_can_default_to_false
+    assert_equal false, @module.def_false
+    assert_equal false, @module.deff
+  end
+
+  def test_mattr_default_priority
+    assert_equal false, @module.def_priority
+  end
+
   def test_should_set_mattr_value
     @module.foo = :test
     assert_equal :test, @object.foo
@@ -91,9 +115,23 @@ class ModuleAttributeAccessorTest < ActiveSupport::TestCase
     assert_equal "default_writer_value", @module.class_variable_get("@@defw")
   end
 
-  def test_should_not_invoke_default_value_block_multiple_times
+  def test_method_invocation_should_not_invoke_the_default_block
     count = 0
+
     @module.cattr_accessor(:defcount) { count += 1 }
+
     assert_equal 1, count
+    assert_no_difference "count" do
+      @module.defcount
+    end
+  end
+
+  def test_declaring_multiple_attributes_at_once_invokes_the_block_multiple_times
+    count = 0
+
+    @module.cattr_accessor(:defn1, :defn2) { count += 1 }
+
+    assert_equal 1, @module.defn1
+    assert_equal 2, @module.defn2
   end
 end
diff --git a/activesupport/test/core_ext/module/attribute_aliasing_test.rb b/activesupport/test/core_ext/module/attribute_aliasing_test.rb
index fdfa868851..187a0f4da2 100644
--- a/activesupport/test/core_ext/module/attribute_aliasing_test.rb
+++ b/activesupport/test/core_ext/module/attribute_aliasing_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/module/aliasing"
 
diff --git a/activesupport/test/core_ext/module/concerning_test.rb b/activesupport/test/core_ext/module/concerning_test.rb
index 098036828a..192c3d5a9c 100644
--- a/activesupport/test/core_ext/module/concerning_test.rb
+++ b/activesupport/test/core_ext/module/concerning_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/module/concerning"
 
diff --git a/activesupport/test/core_ext/module/introspection_test.rb b/activesupport/test/core_ext/module/introspection_test.rb
index db383850cd..76d3012239 100644
--- a/activesupport/test/core_ext/module/introspection_test.rb
+++ b/activesupport/test/core_ext/module/introspection_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/module/introspection"
 
diff --git a/activesupport/test/core_ext/module/reachable_test.rb b/activesupport/test/core_ext/module/reachable_test.rb
index 487c7dee16..a69fc6839e 100644
--- a/activesupport/test/core_ext/module/reachable_test.rb
+++ b/activesupport/test/core_ext/module/reachable_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/module/reachable"
 
diff --git a/activesupport/test/core_ext/module/remove_method_test.rb b/activesupport/test/core_ext/module/remove_method_test.rb
index 0c627f1e74..dbf71b477d 100644
--- a/activesupport/test/core_ext/module/remove_method_test.rb
+++ b/activesupport/test/core_ext/module/remove_method_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/module/remove_method"
 
diff --git a/activesupport/test/core_ext/module_test.rb b/activesupport/test/core_ext/module_test.rb
index a17438bf4d..69c8a312d8 100644
--- a/activesupport/test/core_ext/module_test.rb
+++ b/activesupport/test/core_ext/module_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/module"
 
@@ -70,7 +72,23 @@ Product = Struct.new(:name) do
   end
 end
 
+module ExtraMissing
+  def method_missing(sym, *args)
+    if sym == :extra_missing
+      42
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(sym, priv = false)
+    sym == :extra_missing || super
+  end
+end
+
 DecoratedTester = Struct.new(:client) do
+  include ExtraMissing
+
   delegate_missing_to :client
 end
 
@@ -332,15 +350,15 @@ class ModuleTest < ActiveSupport::TestCase
     assert has_block.hello?
   end
 
-  def test_delegate_to_missing_with_method
+  def test_delegate_missing_to_with_method
     assert_equal "David", DecoratedTester.new(@david).name
   end
 
-  def test_delegate_to_missing_with_reserved_methods
+  def test_delegate_missing_to_with_reserved_methods
     assert_equal "David", DecoratedReserved.new(@david).name
   end
 
-  def test_delegate_to_missing_does_not_delegate_to_private_methods
+  def test_delegate_missing_to_does_not_delegate_to_private_methods
     e = assert_raises(NoMethodError) do
       DecoratedReserved.new(@david).private_name
     end
@@ -348,7 +366,7 @@ class ModuleTest < ActiveSupport::TestCase
     assert_match(/undefined method `private_name' for/, e.message)
   end
 
-  def test_delegate_to_missing_does_not_delegate_to_fake_methods
+  def test_delegate_missing_to_does_not_delegate_to_fake_methods
     e = assert_raises(NoMethodError) do
       DecoratedReserved.new(@david).my_fake_method
     end
@@ -356,8 +374,62 @@ class ModuleTest < ActiveSupport::TestCase
     assert_match(/undefined method `my_fake_method' for/, e.message)
   end
 
+  def test_delegate_missing_to_affects_respond_to
+    assert DecoratedTester.new(@david).respond_to?(:name)
+    assert_not DecoratedTester.new(@david).respond_to?(:private_name)
+    assert_not DecoratedTester.new(@david).respond_to?(:my_fake_method)
+
+    assert DecoratedTester.new(@david).respond_to?(:name, true)
+    assert_not DecoratedTester.new(@david).respond_to?(:private_name, true)
+    assert_not DecoratedTester.new(@david).respond_to?(:my_fake_method, true)
+  end
+
+  def test_delegate_missing_to_respects_superclass_missing
+    assert_equal 42, DecoratedTester.new(@david).extra_missing
+
+    assert_respond_to DecoratedTester.new(@david), :extra_missing
+  end
+
   def test_delegate_with_case
     event = Event.new(Tester.new)
     assert_equal 1, event.foo
   end
+
+  def test_private_delegate
+    location = Class.new do
+      def initialize(place)
+        @place = place
+      end
+
+      private(*delegate(:street, :city, to: :@place))
+    end
+
+    place = location.new(Somewhere.new("Such street", "Sad city"))
+
+    assert_not place.respond_to?(:street)
+    assert_not place.respond_to?(:city)
+
+    assert place.respond_to?(:street, true) # Asking for private method
+    assert place.respond_to?(:city, true)
+  end
+
+  def test_private_delegate_prefixed
+    location = Class.new do
+      def initialize(place)
+        @place = place
+      end
+
+      private(*delegate(:street, :city, to: :@place, prefix: :the))
+    end
+
+    place = location.new(Somewhere.new("Such street", "Sad city"))
+
+    assert_not place.respond_to?(:street)
+    assert_not place.respond_to?(:city)
+
+    assert_not place.respond_to?(:the_street)
+    assert place.respond_to?(:the_street, true)
+    assert_not place.respond_to?(:the_city)
+    assert place.respond_to?(:the_city, true)
+  end
 end
diff --git a/activesupport/test/core_ext/name_error_test.rb b/activesupport/test/core_ext/name_error_test.rb
index fdb9493d3c..d1dace3713 100644
--- a/activesupport/test/core_ext/name_error_test.rb
+++ b/activesupport/test/core_ext/name_error_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/name_error"
 
diff --git a/activesupport/test/core_ext/numeric_ext_test.rb b/activesupport/test/core_ext/numeric_ext_test.rb
index 3cfbe6e7e6..d38124b214 100644
--- a/activesupport/test/core_ext/numeric_ext_test.rb
+++ b/activesupport/test/core_ext/numeric_ext_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/time"
 require "active_support/core_ext/numeric"
diff --git a/activesupport/test/core_ext/object/acts_like_test.rb b/activesupport/test/core_ext/object/acts_like_test.rb
index 631f4e63a8..9f7b81f7fc 100644
--- a/activesupport/test/core_ext/object/acts_like_test.rb
+++ b/activesupport/test/core_ext/object/acts_like_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/object"
 
diff --git a/activesupport/test/core_ext/object/blank_test.rb b/activesupport/test/core_ext/object/blank_test.rb
index 7fd3fed042..749e59ec00 100644
--- a/activesupport/test/core_ext/object/blank_test.rb
+++ b/activesupport/test/core_ext/object/blank_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/object/blank"
 
diff --git a/activesupport/test/core_ext/object/deep_dup_test.rb b/activesupport/test/core_ext/object/deep_dup_test.rb
index f247ee16de..2486592441 100644
--- a/activesupport/test/core_ext/object/deep_dup_test.rb
+++ b/activesupport/test/core_ext/object/deep_dup_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/object"
 
diff --git a/activesupport/test/core_ext/object/duplicable_test.rb b/activesupport/test/core_ext/object/duplicable_test.rb
index e6f3c8aef2..93f39b00bb 100644
--- a/activesupport/test/core_ext/object/duplicable_test.rb
+++ b/activesupport/test/core_ext/object/duplicable_test.rb
@@ -1,10 +1,15 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "bigdecimal"
 require "active_support/core_ext/object/duplicable"
 require "active_support/core_ext/numeric/time"
 
 class DuplicableTest < ActiveSupport::TestCase
-  if RUBY_VERSION >= "2.4.1"
+  if RUBY_VERSION >= "2.5.0"
+    RAISE_DUP = [method(:puts)]
+    ALLOW_DUP = ["1", "symbol_from_string".to_sym, Object.new, /foo/, [], {}, Time.now, Class.new, Module.new, BigDecimal.new("4.56"), nil, false, true, 1, 2.3, Complex(1), Rational(1)]
+  elsif RUBY_VERSION >= "2.4.1"
     RAISE_DUP = [method(:puts), Complex(1), Rational(1)]
     ALLOW_DUP = ["1", "symbol_from_string".to_sym, Object.new, /foo/, [], {}, Time.now, Class.new, Module.new, BigDecimal.new("4.56"), nil, false, true, 1, 2.3]
   elsif RUBY_VERSION >= "2.4.0"  # Due to 2.4.0 bug. This elsif cannot be removed unless we drop 2.4.0 support...
diff --git a/activesupport/test/core_ext/object/inclusion_test.rb b/activesupport/test/core_ext/object/inclusion_test.rb
index 955686d6aa..52c21f2e8e 100644
--- a/activesupport/test/core_ext/object/inclusion_test.rb
+++ b/activesupport/test/core_ext/object/inclusion_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/object/inclusion"
 
diff --git a/activesupport/test/core_ext/object/instance_variables_test.rb b/activesupport/test/core_ext/object/instance_variables_test.rb
index 5bdb2fbc35..b9ec827954 100644
--- a/activesupport/test/core_ext/object/instance_variables_test.rb
+++ b/activesupport/test/core_ext/object/instance_variables_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/object"
 
diff --git a/activesupport/test/core_ext/object/json_cherry_pick_test.rb b/activesupport/test/core_ext/object/json_cherry_pick_test.rb
index dd4e90918e..22659a4050 100644
--- a/activesupport/test/core_ext/object/json_cherry_pick_test.rb
+++ b/activesupport/test/core_ext/object/json_cherry_pick_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 # These test cases were added to test that cherry-picking the json extensions
diff --git a/activesupport/test/core_ext/object/json_gem_encoding_test.rb b/activesupport/test/core_ext/object/json_gem_encoding_test.rb
index f5016d0c2a..4cdb6ed09f 100644
--- a/activesupport/test/core_ext/object/json_gem_encoding_test.rb
+++ b/activesupport/test/core_ext/object/json_gem_encoding_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "json"
 require "json/encoding_test_cases"
diff --git a/activesupport/test/core_ext/object/to_param_test.rb b/activesupport/test/core_ext/object/to_param_test.rb
index 56246b24f3..612156bd99 100644
--- a/activesupport/test/core_ext/object/to_param_test.rb
+++ b/activesupport/test/core_ext/object/to_param_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/object/to_param"
 
diff --git a/activesupport/test/core_ext/object/to_query_test.rb b/activesupport/test/core_ext/object/to_query_test.rb
index 298c8bf373..7593bcfa4d 100644
--- a/activesupport/test/core_ext/object/to_query_test.rb
+++ b/activesupport/test/core_ext/object/to_query_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/ordered_hash"
 require "active_support/core_ext/object/to_query"
diff --git a/activesupport/test/core_ext/object/try_test.rb b/activesupport/test/core_ext/object/try_test.rb
index 5c8bf59952..fe68b24bf5 100644
--- a/activesupport/test/core_ext/object/try_test.rb
+++ b/activesupport/test/core_ext/object/try_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/object"
 
diff --git a/activesupport/test/core_ext/range_ext_test.rb b/activesupport/test/core_ext/range_ext_test.rb
index d166c7309c..a96e3d62e8 100644
--- a/activesupport/test/core_ext/range_ext_test.rb
+++ b/activesupport/test/core_ext/range_ext_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/time"
 require "active_support/core_ext/numeric"
diff --git a/activesupport/test/core_ext/regexp_ext_test.rb b/activesupport/test/core_ext/regexp_ext_test.rb
index e569a9f234..5737bdafda 100644
--- a/activesupport/test/core_ext/regexp_ext_test.rb
+++ b/activesupport/test/core_ext/regexp_ext_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/regexp"
 
diff --git a/activesupport/test/core_ext/secure_random_test.rb b/activesupport/test/core_ext/secure_random_test.rb
index fc25f6ab41..7067fb524c 100644
--- a/activesupport/test/core_ext/secure_random_test.rb
+++ b/activesupport/test/core_ext/secure_random_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/securerandom"
 
diff --git a/activesupport/test/core_ext/string_ext_test.rb b/activesupport/test/core_ext/string_ext_test.rb
index 41cc9888c6..0afff5aa50 100644
--- a/activesupport/test/core_ext/string_ext_test.rb
+++ b/activesupport/test/core_ext/string_ext_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "date"
 require "abstract_unit"
 require "timeout"
@@ -78,6 +80,12 @@ class StringInflectionsTest < ActiveSupport::TestCase
     end
   end
 
+  def test_titleize_with_keep_id_suffix
+    MixtureToTitleCaseWithKeepIdSuffix.each do |before, titleized|
+      assert_equal(titleized, before.titleize(keep_id_suffix: true))
+    end
+  end
+
   def test_upcase_first
     assert_equal "What a Lovely Day", "what a Lovely Day".upcase_first
   end
@@ -199,6 +207,12 @@ class StringInflectionsTest < ActiveSupport::TestCase
     end
   end
 
+  def test_humanize_with_keep_id_suffix
+    UnderscoreToHumanWithKeepIdSuffix.each do |underscore, human|
+      assert_equal(human, underscore.humanize(keep_id_suffix: true))
+    end
+  end
+
   def test_humanize_with_html_escape
     assert_equal "Hello", ERB::Util.html_escape("hello").humanize
   end
@@ -221,7 +235,7 @@ class StringInflectionsTest < ActiveSupport::TestCase
 
   def test_string_squish
     original = %{\u205f\u3000 A string surrounded by various unicode spaces,
-      with tabs(\t\t), newlines(\n\n), unicode nextlines(\u0085\u0085) and many spaces(  ). \u00a0\u2007}
+      with tabs(\t\t), newlines(\n\n), unicode nextlines(\u0085\u0085) and many spaces(  ). \u00a0\u2007}.dup
 
     expected = "A string surrounded by various unicode spaces, " \
       "with tabs( ), newlines( ), unicode nextlines( ) and many spaces( )."
@@ -291,8 +305,8 @@ class StringInflectionsTest < ActiveSupport::TestCase
   end
 
   def test_truncate_multibyte
-    assert_equal "\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 ...".force_encoding(Encoding::UTF_8),
-      "\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 \354\225\204\353\235\274\353\246\254\354\230\244".force_encoding(Encoding::UTF_8).truncate(10)
+    assert_equal "\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 ...".dup.force_encoding(Encoding::UTF_8),
+      "\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 \354\225\204\353\235\274\353\246\254\354\230\244".dup.force_encoding(Encoding::UTF_8).truncate(10)
   end
 
   def test_truncate_should_not_be_html_safe
@@ -313,7 +327,7 @@ class StringInflectionsTest < ActiveSupport::TestCase
   end
 
   def test_remove!
-    original = "This is a very good day to die"
+    original = "This is a very good day to die".dup
     assert_equal "This is a good day to die", original.remove!(" very")
     assert_equal "This is a good day to die", original
     assert_equal "This is a good day", original.remove!(" to ", /die/)
@@ -646,7 +660,7 @@ end
 
 class OutputSafetyTest < ActiveSupport::TestCase
   def setup
-    @string = "hello"
+    @string = "hello".dup
     @object = Class.new(Object) do
       def to_s
         "other"
@@ -722,7 +736,7 @@ class OutputSafetyTest < ActiveSupport::TestCase
   end
 
   test "Concatting safe onto unsafe yields unsafe" do
-    @other_string = "other"
+    @other_string = "other".dup
 
     string = @string.html_safe
     @other_string.concat(string)
@@ -745,7 +759,7 @@ class OutputSafetyTest < ActiveSupport::TestCase
   end
 
   test "Concatting safe onto unsafe with << yields unsafe" do
-    @other_string = "other"
+    @other_string = "other".dup
     string = @string.html_safe
 
     @other_string << string
@@ -801,7 +815,7 @@ class OutputSafetyTest < ActiveSupport::TestCase
   test "Concatting an integer to safe always yields safe" do
     string = @string.html_safe
     string = string.concat(13)
-    assert_equal "hello".concat(13), string
+    assert_equal "hello".dup.concat(13), string
     assert string.html_safe?
   end
 
@@ -856,7 +870,8 @@ end
 
 class StringIndentTest < ActiveSupport::TestCase
   test "does not indent strings that only contain newlines (edge cases)" do
-    ["", "\n", "\n" * 7].each do |str|
+    ["", "\n", "\n" * 7].each do |string|
+      str = string.dup
       assert_nil str.indent!(8)
       assert_equal str, str.indent(8)
       assert_equal str, str.indent(1, "\t")
diff --git a/activesupport/test/core_ext/time_ext_test.rb b/activesupport/test/core_ext/time_ext_test.rb
index bd644c8457..dc2f4c5ac7 100644
--- a/activesupport/test/core_ext/time_ext_test.rb
+++ b/activesupport/test/core_ext/time_ext_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/time"
 require "core_ext/date_and_time_behavior"
@@ -433,6 +435,13 @@ class TimeExtCalculationsTest < ActiveSupport::TestCase
     assert_raise(ArgumentError) { Time.new(2005, 2, 22, 15, 15, 45, "-08:00").change(nsec: 1000000000) }
   end
 
+  def test_change_offset
+    assert_equal Time.new(2006, 2, 22, 15, 15, 10, "-08:00"), Time.new(2006, 2, 22, 15, 15, 10, "+01:00").change(offset: "-08:00")
+    assert_equal Time.new(2006, 2, 22, 15, 15, 10, -28800), Time.new(2006, 2, 22, 15, 15, 10, 3600).change(offset: -28800)
+    assert_raise(ArgumentError) { Time.new(2005, 2, 22, 15, 15, 45, "+01:00").change(usec: 1000000, offset: "-08:00") }
+    assert_raise(ArgumentError) { Time.new(2005, 2, 22, 15, 15, 45, "+01:00").change(nsec: 1000000000, offset: -28800) }
+  end
+
   def test_advance
     assert_equal Time.local(2006, 2, 28, 15, 15, 10), Time.local(2005, 2, 28, 15, 15, 10).advance(years: 1)
     assert_equal Time.local(2005, 6, 28, 15, 15, 10), Time.local(2005, 2, 28, 15, 15, 10).advance(months: 4)
diff --git a/activesupport/test/core_ext/time_with_zone_test.rb b/activesupport/test/core_ext/time_with_zone_test.rb
index 3cc29ca040..0f80a24758 100644
--- a/activesupport/test/core_ext/time_with_zone_test.rb
+++ b/activesupport/test/core_ext/time_with_zone_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/time"
 require "time_zone_test_helpers"
@@ -431,11 +433,29 @@ class TimeWithZoneTest < ActiveSupport::TestCase
     assert_equal time, Time.at(time)
   end
 
-  def test_to_time
-    with_env_tz "US/Eastern" do
-      assert_equal Time, @twz.to_time.class
-      assert_equal Time.local(1999, 12, 31, 19), @twz.to_time
-      assert_equal Time.local(1999, 12, 31, 19).utc_offset, @twz.to_time.utc_offset
+  def test_to_time_with_preserve_timezone
+    with_preserve_timezone(true) do
+      with_env_tz "US/Eastern" do
+        time = @twz.to_time
+
+        assert_equal Time, time.class
+        assert_equal time.object_id, @twz.to_time.object_id
+        assert_equal Time.local(1999, 12, 31, 19), time
+        assert_equal Time.local(1999, 12, 31, 19).utc_offset, time.utc_offset
+      end
+    end
+  end
+
+  def test_to_time_without_preserve_timezone
+    with_preserve_timezone(false) do
+      with_env_tz "US/Eastern" do
+        time = @twz.to_time
+
+        assert_equal Time, time.class
+        assert_equal time.object_id, @twz.to_time.object_id
+        assert_equal Time.local(1999, 12, 31, 19), time
+        assert_equal Time.local(1999, 12, 31, 19).utc_offset, time.utc_offset
+      end
     end
   end
 
@@ -518,6 +538,7 @@ class TimeWithZoneTest < ActiveSupport::TestCase
       @twz.period
       @twz.time
       @twz.to_datetime
+      @twz.to_time
     end
   end
 
@@ -606,6 +627,12 @@ class TimeWithZoneTest < ActiveSupport::TestCase
     assert_equal "Fri, 31 Dec 1999 06:00:00 EST -05:00", @twz.change(hour: 6).inspect
     assert_equal "Fri, 31 Dec 1999 19:15:00 EST -05:00", @twz.change(min: 15).inspect
     assert_equal "Fri, 31 Dec 1999 19:00:30 EST -05:00", @twz.change(sec: 30).inspect
+    assert_equal "Fri, 31 Dec 1999 19:00:00 HST -10:00", @twz.change(offset: "-10:00").inspect
+    assert_equal "Fri, 31 Dec 1999 19:00:00 HST -10:00", @twz.change(offset: -36000).inspect
+    assert_equal "Fri, 31 Dec 1999 19:00:00 HST -10:00", @twz.change(zone: "Hawaii").inspect
+    assert_equal "Fri, 31 Dec 1999 19:00:00 HST -10:00", @twz.change(zone: -10).inspect
+    assert_equal "Fri, 31 Dec 1999 19:00:00 HST -10:00", @twz.change(zone: -36000).inspect
+    assert_equal "Fri, 31 Dec 1999 19:00:00 HST -10:00", @twz.change(zone: "Pacific/Honolulu").inspect
   end
 
   def test_change_at_dst_boundary
diff --git a/activesupport/test/core_ext/uri_ext_test.rb b/activesupport/test/core_ext/uri_ext_test.rb
index 0f13ca9c0e..8816b0d392 100644
--- a/activesupport/test/core_ext/uri_ext_test.rb
+++ b/activesupport/test/core_ext/uri_ext_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "uri"
 require "active_support/core_ext/uri"
diff --git a/activesupport/test/current_attributes_test.rb b/activesupport/test/current_attributes_test.rb
new file mode 100644
index 0000000000..d333ffc8f5
--- /dev/null
+++ b/activesupport/test/current_attributes_test.rb
@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class CurrentAttributesTest < ActiveSupport::TestCase
+  Person = Struct.new(:name, :time_zone)
+
+  class Current < ActiveSupport::CurrentAttributes
+    attribute :world, :account, :person, :request
+    delegate :time_zone, to: :person
+
+    resets { Time.zone = "UTC" }
+
+    def account=(account)
+      super
+      self.person = "#{account}'s person"
+    end
+
+    def person=(person)
+      super
+      Time.zone = person.try(:time_zone)
+    end
+
+    def request
+      "#{super} something"
+    end
+
+    def intro
+      "#{person.name}, in #{time_zone}"
+    end
+  end
+
+  setup { Current.reset }
+
+  test "read and write attribute" do
+    Current.world = "world/1"
+    assert_equal "world/1", Current.world
+  end
+
+  test "read overwritten attribute method" do
+    Current.request = "request/1"
+    assert_equal "request/1 something", Current.request
+  end
+
+  test "set attribute via overwritten method" do
+    Current.account = "account/1"
+    assert_equal "account/1", Current.account
+    assert_equal "account/1's person", Current.person
+  end
+
+  test "set auxiliary class via overwritten method" do
+    Current.person = Person.new("David", "Central Time (US & Canada)")
+    assert_equal "Central Time (US & Canada)", Time.zone.name
+  end
+
+  test "resets auxiliary class via callback" do
+    Current.person = Person.new("David", "Central Time (US & Canada)")
+    assert_equal "Central Time (US & Canada)", Time.zone.name
+
+    Current.reset
+    assert_equal "UTC", Time.zone.name
+  end
+
+  test "set attribute only via scope" do
+    Current.world = "world/1"
+
+    Current.set(world: "world/2") do
+      assert_equal "world/2", Current.world
+    end
+
+    assert_equal "world/1", Current.world
+  end
+
+  test "set multiple attributes" do
+    Current.world = "world/1"
+    Current.account = "account/1"
+
+    Current.set(world: "world/2", account: "account/2") do
+      assert_equal "world/2", Current.world
+      assert_equal "account/2", Current.account
+    end
+
+    assert_equal "world/1", Current.world
+    assert_equal "account/1", Current.account
+  end
+
+  test "delegation" do
+    Current.person = Person.new("David", "Central Time (US & Canada)")
+    assert_equal "Central Time (US & Canada)", Current.time_zone
+    assert_equal "Central Time (US & Canada)", Current.instance.time_zone
+  end
+
+  test "all methods forward to the instance" do
+    Current.person = Person.new("David", "Central Time (US & Canada)")
+    assert_equal "David, in Central Time (US & Canada)", Current.intro
+    assert_equal "David, in Central Time (US & Canada)", Current.instance.intro
+  end
+end
diff --git a/activesupport/test/dependencies/check_warnings.rb b/activesupport/test/dependencies/check_warnings.rb
index 03c3dca1d6..f7d7d2dbc7 100644
--- a/activesupport/test/dependencies/check_warnings.rb
+++ b/activesupport/test/dependencies/check_warnings.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 $check_warnings_load_count += 1
 $checked_verbose = $VERBOSE
diff --git a/activesupport/test/dependencies/conflict.rb b/activesupport/test/dependencies/conflict.rb
index 7eff49bbfa..aa22ec0b09 100644
--- a/activesupport/test/dependencies/conflict.rb
+++ b/activesupport/test/dependencies/conflict.rb
@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 Conflict = 1
diff --git a/activesupport/test/dependencies/cross_site_depender.rb b/activesupport/test/dependencies/cross_site_depender.rb
index fbc3b64f56..3ddea7fc4b 100644
--- a/activesupport/test/dependencies/cross_site_depender.rb
+++ b/activesupport/test/dependencies/cross_site_depender.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class CrossSiteDepender
   CrossSiteDependency
 end
diff --git a/activesupport/test/dependencies/mutual_one.rb b/activesupport/test/dependencies/mutual_one.rb
index 05f08f82d3..bb48fddd4d 100644
--- a/activesupport/test/dependencies/mutual_one.rb
+++ b/activesupport/test/dependencies/mutual_one.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 $mutual_dependencies_count += 1
 require_dependency "mutual_two"
 require_dependency "mutual_two.rb"
diff --git a/activesupport/test/dependencies/mutual_two.rb b/activesupport/test/dependencies/mutual_two.rb
index 1d87d334af..ed354ed75e 100644
--- a/activesupport/test/dependencies/mutual_two.rb
+++ b/activesupport/test/dependencies/mutual_two.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 $mutual_dependencies_count += 1
 require_dependency "mutual_one.rb"
 require_dependency "mutual_one"
diff --git a/activesupport/test/dependencies/raises_exception.rb b/activesupport/test/dependencies/raises_exception.rb
index 0a56680fe3..67bfaabb3e 100644
--- a/activesupport/test/dependencies/raises_exception.rb
+++ b/activesupport/test/dependencies/raises_exception.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 $raises_exception_load_count += 1
 raise Exception, "Loading me failed, so do not add to loaded or history."
 $raises_exception_load_count += 1
diff --git a/activesupport/test/dependencies/raises_exception_without_blame_file.rb b/activesupport/test/dependencies/raises_exception_without_blame_file.rb
index 7c3856b1e6..3a6533cd3a 100644
--- a/activesupport/test/dependencies/raises_exception_without_blame_file.rb
+++ b/activesupport/test/dependencies/raises_exception_without_blame_file.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 exception = Exception.new("I am not blamable!")
 class << exception
   undef_method(:blame_file!)
diff --git a/activesupport/test/dependencies/requires_nonexistent0.rb b/activesupport/test/dependencies/requires_nonexistent0.rb
index 7f8a0d8419..d09dbd2485 100644
--- a/activesupport/test/dependencies/requires_nonexistent0.rb
+++ b/activesupport/test/dependencies/requires_nonexistent0.rb
@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require "RMagickDontExistDude"
diff --git a/activesupport/test/dependencies/requires_nonexistent1.rb b/activesupport/test/dependencies/requires_nonexistent1.rb
index 0055177d67..ce96229172 100644
--- a/activesupport/test/dependencies/requires_nonexistent1.rb
+++ b/activesupport/test/dependencies/requires_nonexistent1.rb
@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require_dependency "requires_nonexistent0"
diff --git a/activesupport/test/dependencies/service_one.rb b/activesupport/test/dependencies/service_one.rb
index afc3042269..2a4a39144d 100644
--- a/activesupport/test/dependencies/service_one.rb
+++ b/activesupport/test/dependencies/service_one.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 $loaded_service_one ||= 0
 $loaded_service_one += 1
 
diff --git a/activesupport/test/dependencies/service_two.rb b/activesupport/test/dependencies/service_two.rb
index aabfc3c553..29cd73cbcd 100644
--- a/activesupport/test/dependencies/service_two.rb
+++ b/activesupport/test/dependencies/service_two.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class ServiceTwo
 end
diff --git a/activesupport/test/dependencies_test.rb b/activesupport/test/dependencies_test.rb
index e38d4e83e5..d636da46d2 100644
--- a/activesupport/test/dependencies_test.rb
+++ b/activesupport/test/dependencies_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "pp"
 require "active_support/dependencies"
@@ -104,7 +106,7 @@ class DependenciesTest < ActiveSupport::TestCase
     with_loading "dependencies" do
       old_warnings, ActiveSupport::Dependencies.warnings_on_first_load = ActiveSupport::Dependencies.warnings_on_first_load, true
       filename = "check_warnings"
-      expanded = File.expand_path("#{File.dirname(__FILE__)}/dependencies/#{filename}")
+      expanded = File.expand_path("dependencies/#{filename}", __dir__)
       $check_warnings_load_count = 0
 
       assert_not ActiveSupport::Dependencies.loaded.include?(expanded)
@@ -293,7 +295,7 @@ class DependenciesTest < ActiveSupport::TestCase
   end
 
   def test_doesnt_break_normal_require
-    path = File.expand_path("../autoloading_fixtures/load_path", __FILE__)
+    path = File.expand_path("autoloading_fixtures/load_path", __dir__)
     original_path = $:.dup
     $:.push(path)
     with_autoloading_fixtures do
@@ -312,7 +314,7 @@ class DependenciesTest < ActiveSupport::TestCase
   end
 
   def test_doesnt_break_normal_require_nested
-    path = File.expand_path("../autoloading_fixtures/load_path", __FILE__)
+    path = File.expand_path("autoloading_fixtures/load_path", __dir__)
     original_path = $:.dup
     $:.push(path)
 
@@ -332,7 +334,7 @@ class DependenciesTest < ActiveSupport::TestCase
   end
 
   def test_require_returns_true_when_file_not_yet_required
-    path = File.expand_path("../autoloading_fixtures/load_path", __FILE__)
+    path = File.expand_path("autoloading_fixtures/load_path", __dir__)
     original_path = $:.dup
     $:.push(path)
 
@@ -345,7 +347,7 @@ class DependenciesTest < ActiveSupport::TestCase
   end
 
   def test_require_returns_true_when_file_not_yet_required_even_when_no_new_constants_added
-    path = File.expand_path("../autoloading_fixtures/load_path", __FILE__)
+    path = File.expand_path("autoloading_fixtures/load_path", __dir__)
     original_path = $:.dup
     $:.push(path)
 
@@ -359,7 +361,7 @@ class DependenciesTest < ActiveSupport::TestCase
   end
 
   def test_require_returns_false_when_file_already_required
-    path = File.expand_path("../autoloading_fixtures/load_path", __FILE__)
+    path = File.expand_path("autoloading_fixtures/load_path", __dir__)
     original_path = $:.dup
     $:.push(path)
 
@@ -379,7 +381,7 @@ class DependenciesTest < ActiveSupport::TestCase
   end
 
   def test_load_returns_true_when_file_found
-    path = File.expand_path("../autoloading_fixtures/load_path", __FILE__)
+    path = File.expand_path("autoloading_fixtures/load_path", __dir__)
     original_path = $:.dup
     $:.push(path)
 
@@ -438,7 +440,7 @@ class DependenciesTest < ActiveSupport::TestCase
 
   def test_loadable_constants_for_path_should_handle_relative_paths
     fake_root = "dependencies"
-    relative_root = File.dirname(__FILE__) + "/dependencies"
+    relative_root = File.expand_path("dependencies", __dir__)
     ["", "/"].each do |suffix|
       with_loading fake_root + suffix do
         assert_equal ["A::B"], ActiveSupport::Dependencies.loadable_constants_for_path(relative_root + "/a/b")
@@ -463,7 +465,7 @@ class DependenciesTest < ActiveSupport::TestCase
   end
 
   def test_loadable_constants_with_load_path_without_trailing_slash
-    path = File.dirname(__FILE__) + "/autoloading_fixtures/class_folder/inline_class.rb"
+    path = File.expand_path("autoloading_fixtures/class_folder/inline_class.rb", __dir__)
     with_loading "autoloading_fixtures/class/" do
       assert_equal [], ActiveSupport::Dependencies.loadable_constants_for_path(path)
     end
@@ -991,7 +993,7 @@ class DependenciesTest < ActiveSupport::TestCase
   def test_remove_constant_does_not_trigger_loading_autoloads
     constant = "ShouldNotBeAutoloaded"
     Object.class_eval do
-      autoload constant, File.expand_path("../autoloading_fixtures/should_not_be_required", __FILE__)
+      autoload constant, File.expand_path("autoloading_fixtures/should_not_be_required", __dir__)
     end
 
     assert_nil ActiveSupport::Dependencies.remove_constant(constant), "Kernel#autoload has been triggered by remove_constant"
diff --git a/activesupport/test/dependencies_test_helpers.rb b/activesupport/test/dependencies_test_helpers.rb
index 9bc63ed89e..b54a7e70c8 100644
--- a/activesupport/test/dependencies_test_helpers.rb
+++ b/activesupport/test/dependencies_test_helpers.rb
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module DependenciesTestHelpers
   def with_loading(*from)
     old_mechanism, ActiveSupport::Dependencies.mechanism = ActiveSupport::Dependencies.mechanism, :load
-    this_dir = File.dirname(__FILE__)
+    this_dir = __dir__
     parent_dir = File.dirname(this_dir)
     path_copy = $LOAD_PATH.dup
     $LOAD_PATH.unshift(parent_dir) unless $LOAD_PATH.include?(parent_dir)
diff --git a/activesupport/test/deprecation/method_wrappers_test.rb b/activesupport/test/deprecation/method_wrappers_test.rb
index 85d057bb02..04e2325754 100644
--- a/activesupport/test/deprecation/method_wrappers_test.rb
+++ b/activesupport/test/deprecation/method_wrappers_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/deprecation"
 
diff --git a/activesupport/test/deprecation/proxy_wrappers_test.rb b/activesupport/test/deprecation/proxy_wrappers_test.rb
index 67afd75c44..2f866775f6 100644
--- a/activesupport/test/deprecation/proxy_wrappers_test.rb
+++ b/activesupport/test/deprecation/proxy_wrappers_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/deprecation"
 
diff --git a/activesupport/test/deprecation_test.rb b/activesupport/test/deprecation_test.rb
index 5f72fbf662..f2267a822f 100644
--- a/activesupport/test/deprecation_test.rb
+++ b/activesupport/test/deprecation_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/testing/stream"
 
@@ -35,6 +37,18 @@ class Deprecatee
   A = ActiveSupport::Deprecation::DeprecatedConstantProxy.new("Deprecatee::A", "Deprecatee::B::C")
 end
 
+class DeprecateeWithAccessor
+  include ActiveSupport::Deprecation::DeprecatedConstantAccessor
+
+  module B
+    C = 1
+  end
+  deprecate_constant "A", "DeprecateeWithAccessor::B::C"
+
+  class NewException < StandardError; end
+  deprecate_constant "OldException", "DeprecateeWithAccessor::NewException"
+end
+
 class DeprecationTest < ActiveSupport::TestCase
   include ActiveSupport::Testing::Stream
 
@@ -88,16 +102,18 @@ class DeprecationTest < ActiveSupport::TestCase
   end
 
   def test_several_behaviors
-    @a, @b = nil, nil
+    @a, @b, @c = nil, nil, nil
 
     ActiveSupport::Deprecation.behavior = [
-      Proc.new { |msg, callstack| @a = msg },
-      Proc.new { |msg, callstack| @b = msg }
+      lambda { |msg, callstack, horizon, gem| @a = msg },
+      lambda { |msg, callstack| @b = msg },
+      lambda { |*args| @c = args },
     ]
 
     @dtc.partially
     assert_match(/foo=nil/, @a)
     assert_match(/foo=nil/, @b)
+    assert_equal 4, @c.size
   end
 
   def test_raise_behaviour
@@ -107,7 +123,7 @@ class DeprecationTest < ActiveSupport::TestCase
     callstack = caller_locations
 
     e = assert_raise ActiveSupport::DeprecationException do
-      ActiveSupport::Deprecation.behavior.first.call(message, callstack)
+      ActiveSupport::Deprecation.behavior.first.call(message, callstack, "horizon", "gem")
     end
     assert_equal message, e.message
     assert_equal callstack.map(&:to_s), e.backtrace.map(&:to_s)
@@ -118,7 +134,7 @@ class DeprecationTest < ActiveSupport::TestCase
     behavior = ActiveSupport::Deprecation.behavior.first
 
     content = capture(:stderr) {
-      assert_nil behavior.call("Some error!", ["call stack!"])
+      assert_nil behavior.call("Some error!", ["call stack!"], "horizon", "gem")
     }
     assert_match(/Some error!/, content)
     assert_match(/call stack!/, content)
@@ -140,11 +156,32 @@ class DeprecationTest < ActiveSupport::TestCase
     behavior = ActiveSupport::Deprecation.behavior.first
 
     stderr_output = capture(:stderr) {
-      assert_nil behavior.call("Some error!", ["call stack!"])
+      assert_nil behavior.call("Some error!", ["call stack!"], "horizon", "gem")
     }
     assert stderr_output.empty?
   end
 
+  def test_default_notify_behavior
+    ActiveSupport::Deprecation.behavior = :notify
+    behavior = ActiveSupport::Deprecation.behavior.first
+
+    begin
+      events = []
+      ActiveSupport::Notifications.subscribe("deprecation.my_gem_custom") { |_, **args|
+        events << args
+      }
+
+      assert_nil behavior.call("Some error!", ["call stack!"], "horizon", "MyGem::Custom")
+      assert_equal 1, events.size
+      assert_equal "Some error!", events.first[:message]
+      assert_equal ["call stack!"], events.first[:callstack]
+      assert_equal "horizon", events.first[:deprecation_horizon]
+      assert_equal "MyGem::Custom", events.first[:gem_name]
+    ensure
+      ActiveSupport::Notifications.unsubscribe("deprecation.my_gem_custom")
+    end
+  end
+
   def test_deprecated_instance_variable_proxy
     assert_not_deprecated { @dtc.request.size }
 
@@ -162,6 +199,17 @@ class DeprecationTest < ActiveSupport::TestCase
     assert_not_deprecated { assert_equal Deprecatee::B::C.class, Deprecatee::A.class }
   end
 
+  def test_deprecated_constant_accessor
+    assert_not_deprecated { DeprecateeWithAccessor::B::C }
+    assert_deprecated("DeprecateeWithAccessor::A") { assert_equal DeprecateeWithAccessor::B::C, DeprecateeWithAccessor::A }
+  end
+
+  def test_deprecated_constant_accessor_exception
+    raise DeprecateeWithAccessor::NewException.new("Test")
+  rescue DeprecateeWithAccessor::OldException => e
+    assert_kind_of DeprecateeWithAccessor::NewException, e
+  end
+
   def test_assert_deprecated_raises_when_method_not_deprecated
     assert_raises(Minitest::Assertion) { assert_deprecated { @dtc.not } }
   end
diff --git a/activesupport/test/descendants_tracker_test_cases.rb b/activesupport/test/descendants_tracker_test_cases.rb
index cf349d53ee..1f8b4a8605 100644
--- a/activesupport/test/descendants_tracker_test_cases.rb
+++ b/activesupport/test/descendants_tracker_test_cases.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "set"
 
 module DescendantsTrackerTestCases
diff --git a/activesupport/test/descendants_tracker_with_autoloading_test.rb b/activesupport/test/descendants_tracker_with_autoloading_test.rb
index e202667a8a..7c396b7c8e 100644
--- a/activesupport/test/descendants_tracker_with_autoloading_test.rb
+++ b/activesupport/test/descendants_tracker_with_autoloading_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/descendants_tracker"
 require "active_support/dependencies"
diff --git a/activesupport/test/descendants_tracker_without_autoloading_test.rb b/activesupport/test/descendants_tracker_without_autoloading_test.rb
index 72adc30ace..f5c6a3045d 100644
--- a/activesupport/test/descendants_tracker_without_autoloading_test.rb
+++ b/activesupport/test/descendants_tracker_without_autoloading_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/descendants_tracker"
 require "descendants_tracker_test_cases"
diff --git a/activesupport/test/evented_file_update_checker_test.rb b/activesupport/test/evented_file_update_checker_test.rb
index f33a5f5764..9b560f7f42 100644
--- a/activesupport/test/evented_file_update_checker_test.rb
+++ b/activesupport/test/evented_file_update_checker_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "pathname"
 require "file_update_checker_shared_tests"
diff --git a/activesupport/test/executor_test.rb b/activesupport/test/executor_test.rb
index 7fefc066b3..af441064dd 100644
--- a/activesupport/test/executor_test.rb
+++ b/activesupport/test/executor_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class ExecutorTest < ActiveSupport::TestCase
diff --git a/activesupport/test/file_update_checker_shared_tests.rb b/activesupport/test/file_update_checker_shared_tests.rb
index 361e7e2349..f8266dac06 100644
--- a/activesupport/test/file_update_checker_shared_tests.rb
+++ b/activesupport/test/file_update_checker_shared_tests.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "fileutils"
 
 module FileUpdateCheckerSharedTests
diff --git a/activesupport/test/file_update_checker_test.rb b/activesupport/test/file_update_checker_test.rb
index 55b0b46644..ec1df0df67 100644
--- a/activesupport/test/file_update_checker_test.rb
+++ b/activesupport/test/file_update_checker_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "file_update_checker_shared_tests"
 
diff --git a/activesupport/test/fixtures/autoload/another_class.rb b/activesupport/test/fixtures/autoload/another_class.rb
index ab6e075ab4..cf38336cf8 100644
--- a/activesupport/test/fixtures/autoload/another_class.rb
+++ b/activesupport/test/fixtures/autoload/another_class.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class Fixtures::AnotherClass
 end
diff --git a/activesupport/test/fixtures/autoload/some_class.rb b/activesupport/test/fixtures/autoload/some_class.rb
index 30d41eb0bf..ff25eb995e 100644
--- a/activesupport/test/fixtures/autoload/some_class.rb
+++ b/activesupport/test/fixtures/autoload/some_class.rb
@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class Fixtures::Autoload::SomeClass
 end
diff --git a/activesupport/test/gzip_test.rb b/activesupport/test/gzip_test.rb
index 33e0cd2a04..05ce12fe86 100644
--- a/activesupport/test/gzip_test.rb
+++ b/activesupport/test/gzip_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/object/blank"
 
diff --git a/activesupport/test/hash_with_indifferent_access_test.rb b/activesupport/test/hash_with_indifferent_access_test.rb
new file mode 100644
index 0000000000..4acdd10de6
--- /dev/null
+++ b/activesupport/test/hash_with_indifferent_access_test.rb
@@ -0,0 +1,747 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "active_support/core_ext/hash"
+require "bigdecimal"
+require "active_support/core_ext/string/access"
+require "active_support/ordered_hash"
+require "active_support/core_ext/object/conversions"
+require "active_support/core_ext/object/deep_dup"
+require "active_support/inflections"
+
+class HashWithIndifferentAccessTest < ActiveSupport::TestCase
+  HashWithIndifferentAccess = ActiveSupport::HashWithIndifferentAccess
+
+  class IndifferentHash < ActiveSupport::HashWithIndifferentAccess
+  end
+
+  class SubclassingArray < Array
+  end
+
+  class SubclassingHash < Hash
+  end
+
+  class NonIndifferentHash < Hash
+    def nested_under_indifferent_access
+      self
+    end
+  end
+
+  class HashByConversion
+    def initialize(hash)
+      @hash = hash
+    end
+
+    def to_hash
+      @hash
+    end
+  end
+
+  def setup
+    @strings = { "a" => 1, "b" => 2 }
+    @nested_strings = { "a" => { "b" => { "c" => 3 } } }
+    @symbols = { a: 1, b: 2 }
+    @nested_symbols = { a: { b: { c: 3 } } }
+    @mixed = { :a => 1, "b" => 2 }
+    @nested_mixed = { "a" => { b: { "c" => 3 } } }
+    @integers = { 0 => 1, 1 => 2 }
+    @nested_integers = { 0 => { 1 => { 2 => 3 } } }
+    @illegal_symbols = { [] => 3 }
+    @nested_illegal_symbols = { [] => { [] => 3 } }
+  end
+
+  def test_symbolize_keys_for_hash_with_indifferent_access
+    assert_instance_of Hash, @symbols.with_indifferent_access.symbolize_keys
+    assert_equal @symbols, @symbols.with_indifferent_access.symbolize_keys
+    assert_equal @symbols, @strings.with_indifferent_access.symbolize_keys
+    assert_equal @symbols, @mixed.with_indifferent_access.symbolize_keys
+  end
+
+  def test_deep_symbolize_keys_for_hash_with_indifferent_access
+    assert_instance_of Hash, @nested_symbols.with_indifferent_access.deep_symbolize_keys
+    assert_equal @nested_symbols, @nested_symbols.with_indifferent_access.deep_symbolize_keys
+    assert_equal @nested_symbols, @nested_strings.with_indifferent_access.deep_symbolize_keys
+    assert_equal @nested_symbols, @nested_mixed.with_indifferent_access.deep_symbolize_keys
+  end
+
+  def test_symbolize_keys_bang_for_hash_with_indifferent_access
+    assert_raise(NoMethodError) { @symbols.with_indifferent_access.dup.symbolize_keys! }
+    assert_raise(NoMethodError) { @strings.with_indifferent_access.dup.symbolize_keys! }
+    assert_raise(NoMethodError) { @mixed.with_indifferent_access.dup.symbolize_keys! }
+  end
+
+  def test_deep_symbolize_keys_bang_for_hash_with_indifferent_access
+    assert_raise(NoMethodError) { @nested_symbols.with_indifferent_access.deep_dup.deep_symbolize_keys! }
+    assert_raise(NoMethodError) { @nested_strings.with_indifferent_access.deep_dup.deep_symbolize_keys! }
+    assert_raise(NoMethodError) { @nested_mixed.with_indifferent_access.deep_dup.deep_symbolize_keys! }
+  end
+
+  def test_symbolize_keys_preserves_keys_that_cant_be_symbolized_for_hash_with_indifferent_access
+    assert_equal @illegal_symbols, @illegal_symbols.with_indifferent_access.symbolize_keys
+    assert_raise(NoMethodError) { @illegal_symbols.with_indifferent_access.dup.symbolize_keys! }
+  end
+
+  def test_deep_symbolize_keys_preserves_keys_that_cant_be_symbolized_for_hash_with_indifferent_access
+    assert_equal @nested_illegal_symbols, @nested_illegal_symbols.with_indifferent_access.deep_symbolize_keys
+    assert_raise(NoMethodError) { @nested_illegal_symbols.with_indifferent_access.deep_dup.deep_symbolize_keys! }
+  end
+
+  def test_symbolize_keys_preserves_integer_keys_for_hash_with_indifferent_access
+    assert_equal @integers, @integers.with_indifferent_access.symbolize_keys
+    assert_raise(NoMethodError) { @integers.with_indifferent_access.dup.symbolize_keys! }
+  end
+
+  def test_deep_symbolize_keys_preserves_integer_keys_for_hash_with_indifferent_access
+    assert_equal @nested_integers, @nested_integers.with_indifferent_access.deep_symbolize_keys
+    assert_raise(NoMethodError) { @nested_integers.with_indifferent_access.deep_dup.deep_symbolize_keys! }
+  end
+
+  def test_stringify_keys_for_hash_with_indifferent_access
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, @symbols.with_indifferent_access.stringify_keys
+    assert_equal @strings, @symbols.with_indifferent_access.stringify_keys
+    assert_equal @strings, @strings.with_indifferent_access.stringify_keys
+    assert_equal @strings, @mixed.with_indifferent_access.stringify_keys
+  end
+
+  def test_deep_stringify_keys_for_hash_with_indifferent_access
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, @nested_symbols.with_indifferent_access.deep_stringify_keys
+    assert_equal @nested_strings, @nested_symbols.with_indifferent_access.deep_stringify_keys
+    assert_equal @nested_strings, @nested_strings.with_indifferent_access.deep_stringify_keys
+    assert_equal @nested_strings, @nested_mixed.with_indifferent_access.deep_stringify_keys
+  end
+
+  def test_stringify_keys_bang_for_hash_with_indifferent_access
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, @symbols.with_indifferent_access.dup.stringify_keys!
+    assert_equal @strings, @symbols.with_indifferent_access.dup.stringify_keys!
+    assert_equal @strings, @strings.with_indifferent_access.dup.stringify_keys!
+    assert_equal @strings, @mixed.with_indifferent_access.dup.stringify_keys!
+  end
+
+  def test_deep_stringify_keys_bang_for_hash_with_indifferent_access
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, @nested_symbols.with_indifferent_access.dup.deep_stringify_keys!
+    assert_equal @nested_strings, @nested_symbols.with_indifferent_access.deep_dup.deep_stringify_keys!
+    assert_equal @nested_strings, @nested_strings.with_indifferent_access.deep_dup.deep_stringify_keys!
+    assert_equal @nested_strings, @nested_mixed.with_indifferent_access.deep_dup.deep_stringify_keys!
+  end
+
+  def test_nested_under_indifferent_access
+    foo = { "foo" => SubclassingHash.new.tap { |h| h["bar"] = "baz" } }.with_indifferent_access
+    assert_kind_of ActiveSupport::HashWithIndifferentAccess, foo["foo"]
+
+    foo = { "foo" => NonIndifferentHash.new.tap { |h| h["bar"] = "baz" } }.with_indifferent_access
+    assert_kind_of NonIndifferentHash, foo["foo"]
+
+    foo = { "foo" => IndifferentHash.new.tap { |h| h["bar"] = "baz" } }.with_indifferent_access
+    assert_kind_of IndifferentHash, foo["foo"]
+  end
+
+  def test_indifferent_assorted
+    @strings = @strings.with_indifferent_access
+    @symbols = @symbols.with_indifferent_access
+    @mixed   = @mixed.with_indifferent_access
+
+    assert_equal "a", @strings.__send__(:convert_key, :a)
+
+    assert_equal 1, @strings.fetch("a")
+    assert_equal 1, @strings.fetch(:a.to_s)
+    assert_equal 1, @strings.fetch(:a)
+
+    hashes = { :@strings => @strings, :@symbols => @symbols, :@mixed => @mixed }
+    method_map = { '[]': 1, fetch: 1, values_at: [1],
+                   has_key?: true, include?: true, key?: true,
+                   member?: true }
+
+    hashes.each do |name, hash|
+      method_map.sort_by(&:to_s).each do |meth, expected|
+        assert_equal(expected, hash.__send__(meth, "a"),
+                     "Calling #{name}.#{meth} 'a'")
+        assert_equal(expected, hash.__send__(meth, :a),
+                     "Calling #{name}.#{meth} :a")
+      end
+    end
+
+    assert_equal [1, 2], @strings.values_at("a", "b")
+    assert_equal [1, 2], @strings.values_at(:a, :b)
+    assert_equal [1, 2], @symbols.values_at("a", "b")
+    assert_equal [1, 2], @symbols.values_at(:a, :b)
+    assert_equal [1, 2], @mixed.values_at("a", "b")
+    assert_equal [1, 2], @mixed.values_at(:a, :b)
+  end
+
+  def test_indifferent_fetch_values
+    skip unless Hash.method_defined?(:fetch_values)
+
+    @mixed = @mixed.with_indifferent_access
+
+    assert_equal [1, 2], @mixed.fetch_values("a", "b")
+    assert_equal [1, 2], @mixed.fetch_values(:a, :b)
+    assert_equal [1, 2], @mixed.fetch_values(:a, "b")
+    assert_equal [1, "c"], @mixed.fetch_values(:a, :c) { |key| key }
+    assert_raise(KeyError) { @mixed.fetch_values(:a, :c) }
+  end
+
+  def test_indifferent_reading
+    hash = HashWithIndifferentAccess.new
+    hash["a"] = 1
+    hash["b"] = true
+    hash["c"] = false
+    hash["d"] = nil
+
+    assert_equal 1, hash[:a]
+    assert_equal true, hash[:b]
+    assert_equal false, hash[:c]
+    assert_nil hash[:d]
+    assert_nil hash[:e]
+  end
+
+  def test_indifferent_reading_with_nonnil_default
+    hash = HashWithIndifferentAccess.new(1)
+    hash["a"] = 1
+    hash["b"] = true
+    hash["c"] = false
+    hash["d"] = nil
+
+    assert_equal 1, hash[:a]
+    assert_equal true, hash[:b]
+    assert_equal false, hash[:c]
+    assert_nil hash[:d]
+    assert_equal 1, hash[:e]
+  end
+
+  def test_indifferent_writing
+    hash = HashWithIndifferentAccess.new
+    hash[:a] = 1
+    hash["b"] = 2
+    hash[3] = 3
+
+    assert_equal 1, hash["a"]
+    assert_equal 2, hash["b"]
+    assert_equal 1, hash[:a]
+    assert_equal 2, hash[:b]
+    assert_equal 3, hash[3]
+  end
+
+  def test_indifferent_update
+    hash = HashWithIndifferentAccess.new
+    hash[:a] = "a"
+    hash["b"] = "b"
+
+    updated_with_strings = hash.update(@strings)
+    updated_with_symbols = hash.update(@symbols)
+    updated_with_mixed = hash.update(@mixed)
+
+    assert_equal 1, updated_with_strings[:a]
+    assert_equal 1, updated_with_strings["a"]
+    assert_equal 2, updated_with_strings["b"]
+
+    assert_equal 1, updated_with_symbols[:a]
+    assert_equal 2, updated_with_symbols["b"]
+    assert_equal 2, updated_with_symbols[:b]
+
+    assert_equal 1, updated_with_mixed[:a]
+    assert_equal 2, updated_with_mixed["b"]
+
+    assert [updated_with_strings, updated_with_symbols, updated_with_mixed].all? { |h| h.keys.size == 2 }
+  end
+
+  def test_update_with_to_hash_conversion
+    hash = HashWithIndifferentAccess.new
+    hash.update HashByConversion.new(a: 1)
+    assert_equal 1, hash["a"]
+  end
+
+  def test_indifferent_merging
+    hash = HashWithIndifferentAccess.new
+    hash[:a] = "failure"
+    hash["b"] = "failure"
+
+    other = { "a" => 1, :b => 2 }
+
+    merged = hash.merge(other)
+
+    assert_equal HashWithIndifferentAccess, merged.class
+    assert_equal 1, merged[:a]
+    assert_equal 2, merged["b"]
+
+    hash.update(other)
+
+    assert_equal 1, hash[:a]
+    assert_equal 2, hash["b"]
+  end
+
+  def test_merge_with_to_hash_conversion
+    hash = HashWithIndifferentAccess.new
+    merged = hash.merge HashByConversion.new(a: 1)
+    assert_equal 1, merged["a"]
+  end
+
+  def test_indifferent_replace
+    hash = HashWithIndifferentAccess.new
+    hash[:a] = 42
+
+    replaced = hash.replace(b: 12)
+
+    assert hash.key?("b")
+    assert !hash.key?(:a)
+    assert_equal 12, hash[:b]
+    assert_same hash, replaced
+  end
+
+  def test_replace_with_to_hash_conversion
+    hash = HashWithIndifferentAccess.new
+    hash[:a] = 42
+
+    replaced = hash.replace(HashByConversion.new(b: 12))
+
+    assert hash.key?("b")
+    assert !hash.key?(:a)
+    assert_equal 12, hash[:b]
+    assert_same hash, replaced
+  end
+
+  def test_indifferent_merging_with_block
+    hash = HashWithIndifferentAccess.new
+    hash[:a] = 1
+    hash["b"] = 3
+
+    other = { "a" => 4, :b => 2, "c" => 10 }
+
+    merged = hash.merge(other) { |key, old, new| old > new ? old : new }
+
+    assert_equal HashWithIndifferentAccess, merged.class
+    assert_equal 4, merged[:a]
+    assert_equal 3, merged["b"]
+    assert_equal 10, merged[:c]
+
+    other_indifferent = HashWithIndifferentAccess.new("a" => 9, :b => 2)
+
+    merged = hash.merge(other_indifferent) { |key, old, new| old + new }
+
+    assert_equal HashWithIndifferentAccess, merged.class
+    assert_equal 10, merged[:a]
+    assert_equal 5, merged[:b]
+  end
+
+  def test_indifferent_reverse_merging
+    hash = HashWithIndifferentAccess.new key: :old_value
+    hash.reverse_merge! key: :new_value
+    assert_equal :old_value, hash[:key]
+
+    hash = HashWithIndifferentAccess.new("some" => "value", "other" => "value")
+    hash.reverse_merge!(some: "noclobber", another: "clobber")
+    assert_equal "value", hash[:some]
+    assert_equal "clobber", hash[:another]
+  end
+
+  def test_indifferent_with_defaults_aliases_reverse_merge
+    hash = HashWithIndifferentAccess.new key: :old_value
+    actual = hash.with_defaults key: :new_value
+    assert_equal :old_value, actual[:key]
+
+    hash = HashWithIndifferentAccess.new key: :old_value
+    hash.with_defaults! key: :new_value
+    assert_equal :old_value, hash[:key]
+  end
+
+  def test_indifferent_deleting
+    get_hash = proc { { a: "foo" }.with_indifferent_access }
+    hash = get_hash.call
+    assert_equal "foo", hash.delete(:a)
+    assert_nil hash.delete(:a)
+    hash = get_hash.call
+    assert_equal "foo", hash.delete("a")
+    assert_nil hash.delete("a")
+  end
+
+  def test_indifferent_select
+    hash = ActiveSupport::HashWithIndifferentAccess.new(@strings).select { |k, v| v == 1 }
+
+    assert_equal({ "a" => 1 }, hash)
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
+  end
+
+  def test_indifferent_select_returns_enumerator
+    enum = ActiveSupport::HashWithIndifferentAccess.new(@strings).select
+    assert_instance_of Enumerator, enum
+  end
+
+  def test_indifferent_select_returns_a_hash_when_unchanged
+    hash = ActiveSupport::HashWithIndifferentAccess.new(@strings).select { |k, v| true }
+
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
+  end
+
+  def test_indifferent_select_bang
+    indifferent_strings = ActiveSupport::HashWithIndifferentAccess.new(@strings)
+    indifferent_strings.select! { |k, v| v == 1 }
+
+    assert_equal({ "a" => 1 }, indifferent_strings)
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, indifferent_strings
+  end
+
+  def test_indifferent_reject
+    hash = ActiveSupport::HashWithIndifferentAccess.new(@strings).reject { |k, v| v != 1 }
+
+    assert_equal({ "a" => 1 }, hash)
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
+  end
+
+  def test_indifferent_reject_returns_enumerator
+    enum = ActiveSupport::HashWithIndifferentAccess.new(@strings).reject
+    assert_instance_of Enumerator, enum
+  end
+
+  def test_indifferent_reject_bang
+    indifferent_strings = ActiveSupport::HashWithIndifferentAccess.new(@strings)
+    indifferent_strings.reject! { |k, v| v != 1 }
+
+    assert_equal({ "a" => 1 }, indifferent_strings)
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, indifferent_strings
+  end
+
+  def test_indifferent_compact
+    hash_contain_nil_value = @strings.merge("z" => nil)
+    hash = ActiveSupport::HashWithIndifferentAccess.new(hash_contain_nil_value)
+    compacted_hash = hash.compact
+
+    assert_equal(@strings, compacted_hash)
+    assert_equal(hash_contain_nil_value, hash)
+    assert_instance_of ActiveSupport::HashWithIndifferentAccess, compacted_hash
+
+    empty_hash = ActiveSupport::HashWithIndifferentAccess.new
+    compacted_hash = empty_hash.compact
+
+    assert_equal compacted_hash, empty_hash
+
+    non_empty_hash = ActiveSupport::HashWithIndifferentAccess.new(foo: :bar)
+    compacted_hash = non_empty_hash.compact
+
+    assert_equal compacted_hash, non_empty_hash
+  end
+
+  def test_indifferent_to_hash
+    # Should convert to a Hash with String keys.
+    assert_equal @strings, @mixed.with_indifferent_access.to_hash
+
+    # Should preserve the default value.
+    mixed_with_default = @mixed.dup
+    mixed_with_default.default = "1234"
+    roundtrip = mixed_with_default.with_indifferent_access.to_hash
+    assert_equal @strings, roundtrip
+    assert_equal "1234", roundtrip.default
+
+    # Ensure nested hashes are not HashWithIndiffereneAccess
+    new_to_hash = @nested_mixed.with_indifferent_access.to_hash
+    assert_not new_to_hash.instance_of?(HashWithIndifferentAccess)
+    assert_not new_to_hash["a"].instance_of?(HashWithIndifferentAccess)
+    assert_not new_to_hash["a"]["b"].instance_of?(HashWithIndifferentAccess)
+  end
+
+  def test_lookup_returns_the_same_object_that_is_stored_in_hash_indifferent_access
+    hash = HashWithIndifferentAccess.new { |h, k| h[k] = [] }
+    hash[:a] << 1
+
+    assert_equal [1], hash[:a]
+  end
+
+  def test_with_indifferent_access_has_no_side_effects_on_existing_hash
+    hash = { content: [{ :foo => :bar, "bar" => "baz" }] }
+    hash.with_indifferent_access
+
+    assert_equal [:foo, "bar"], hash[:content].first.keys
+  end
+
+  def test_indifferent_hash_with_array_of_hashes
+    hash = { "urls" => { "url" => [ { "address" => "1" }, { "address" => "2" } ] } }.with_indifferent_access
+    assert_equal "1", hash[:urls][:url].first[:address]
+
+    hash = hash.to_hash
+    assert_not hash.instance_of?(HashWithIndifferentAccess)
+    assert_not hash["urls"].instance_of?(HashWithIndifferentAccess)
+    assert_not hash["urls"]["url"].first.instance_of?(HashWithIndifferentAccess)
+  end
+
+  def test_should_preserve_array_subclass_when_value_is_array
+    array = SubclassingArray.new
+    array << { "address" => "1" }
+    hash = { "urls" => { "url" => array } }.with_indifferent_access
+    assert_equal SubclassingArray, hash[:urls][:url].class
+  end
+
+  def test_should_preserve_array_class_when_hash_value_is_frozen_array
+    array = SubclassingArray.new
+    array << { "address" => "1" }
+    hash = { "urls" => { "url" => array.freeze } }.with_indifferent_access
+    assert_equal SubclassingArray, hash[:urls][:url].class
+  end
+
+  def test_stringify_and_symbolize_keys_on_indifferent_preserves_hash
+    h = HashWithIndifferentAccess.new
+    h[:first] = 1
+    h = h.stringify_keys
+    assert_equal 1, h["first"]
+    h = HashWithIndifferentAccess.new
+    h["first"] = 1
+    h = h.symbolize_keys
+    assert_equal 1, h[:first]
+  end
+
+  def test_deep_stringify_and_deep_symbolize_keys_on_indifferent_preserves_hash
+    h = HashWithIndifferentAccess.new
+    h[:first] = 1
+    h = h.deep_stringify_keys
+    assert_equal 1, h["first"]
+    h = HashWithIndifferentAccess.new
+    h["first"] = 1
+    h = h.deep_symbolize_keys
+    assert_equal 1, h[:first]
+  end
+
+  def test_to_options_on_indifferent_preserves_hash
+    h = HashWithIndifferentAccess.new
+    h["first"] = 1
+    h.to_options!
+    assert_equal 1, h["first"]
+  end
+
+  def test_to_options_on_indifferent_preserves_works_as_hash_with_dup
+    h = HashWithIndifferentAccess.new(a: { b: "b" })
+    dup = h.dup
+
+    dup[:a][:c] = "c"
+    assert_equal "c", h[:a][:c]
+  end
+
+  def test_indifferent_sub_hashes
+    h = { "user" => { "id" => 5 } }.with_indifferent_access
+    ["user", :user].each { |user| [:id, "id"].each { |id| assert_equal 5, h[user][id], "h[#{user.inspect}][#{id.inspect}] should be 5" } }
+
+    h = { user: { id: 5 } }.with_indifferent_access
+    ["user", :user].each { |user| [:id, "id"].each { |id| assert_equal 5, h[user][id], "h[#{user.inspect}][#{id.inspect}] should be 5" } }
+  end
+
+  def test_indifferent_duplication
+    # Should preserve default value
+    h = HashWithIndifferentAccess.new
+    h.default = "1234"
+    assert_equal h.default, h.dup.default
+
+    # Should preserve class for subclasses
+    h = IndifferentHash.new
+    assert_equal h.class, h.dup.class
+  end
+
+  def test_nested_dig_indifferent_access
+    skip if RUBY_VERSION < "2.3.0"
+    data = { "this" => { "views" => 1234 } }.with_indifferent_access
+    assert_equal 1234, data.dig(:this, :views)
+  end
+
+  def test_assorted_keys_not_stringified
+    original = { Object.new => 2, 1 => 2, [] => true }
+    indiff = original.with_indifferent_access
+    assert(!indiff.keys.any? { |k| k.kind_of? String }, "A key was converted to a string!")
+  end
+
+  def test_deep_merge_on_indifferent_access
+    hash_1 = HashWithIndifferentAccess.new(a: "a", b: "b", c: { c1: "c1", c2: "c2", c3: { d1: "d1" } })
+    hash_2 = HashWithIndifferentAccess.new(a: 1, c: { c1: 2, c3: { d2: "d2" } })
+    hash_3 = { a: 1, c: { c1: 2, c3: { d2: "d2" } } }
+    expected = { "a" => 1, "b" => "b", "c" => { "c1" => 2, "c2" => "c2", "c3" => { "d1" => "d1", "d2" => "d2" } } }
+    assert_equal expected, hash_1.deep_merge(hash_2)
+    assert_equal expected, hash_1.deep_merge(hash_3)
+
+    hash_1.deep_merge!(hash_2)
+    assert_equal expected, hash_1
+  end
+
+  def test_store_on_indifferent_access
+    hash = HashWithIndifferentAccess.new
+    hash.store(:test1, 1)
+    hash.store("test1", 11)
+    hash[:test2] = 2
+    hash["test2"] = 22
+    expected = { "test1" => 11, "test2" => 22 }
+    assert_equal expected, hash
+  end
+
+  def test_constructor_on_indifferent_access
+    hash = HashWithIndifferentAccess[:foo, 1]
+    assert_equal 1, hash[:foo]
+    assert_equal 1, hash["foo"]
+    hash[:foo] = 3
+    assert_equal 3, hash[:foo]
+    assert_equal 3, hash["foo"]
+  end
+
+  def test_indifferent_slice
+    original = { a: "x", b: "y", c: 10 }.with_indifferent_access
+    expected = { a: "x", b: "y" }.with_indifferent_access
+
+    [["a", "b"], [:a, :b]].each do |keys|
+      # Should return a new hash with only the given keys.
+      assert_equal expected, original.slice(*keys), keys.inspect
+      assert_not_equal expected, original
+    end
+  end
+
+  def test_indifferent_slice_inplace
+    original = { a: "x", b: "y", c: 10 }.with_indifferent_access
+    expected = { c: 10 }.with_indifferent_access
+
+    [["a", "b"], [:a, :b]].each do |keys|
+      # Should replace the hash with only the given keys.
+      copy = original.dup
+      assert_equal expected, copy.slice!(*keys)
+    end
+  end
+
+  def test_indifferent_slice_access_with_symbols
+    original = { "login" => "bender", "password" => "shiny", "stuff" => "foo" }
+    original = original.with_indifferent_access
+
+    slice = original.slice(:login, :password)
+
+    assert_equal "bender", slice[:login]
+    assert_equal "bender", slice["login"]
+  end
+
+  def test_indifferent_extract
+    original = { :a => 1, "b" => 2, :c => 3, "d" => 4 }.with_indifferent_access
+    expected = { a: 1, b: 2 }.with_indifferent_access
+    remaining = { c: 3, d: 4 }.with_indifferent_access
+
+    [["a", "b"], [:a, :b]].each do |keys|
+      copy = original.dup
+      assert_equal expected, copy.extract!(*keys)
+      assert_equal remaining, copy
+    end
+  end
+
+  def test_new_with_to_hash_conversion
+    hash = HashWithIndifferentAccess.new(HashByConversion.new(a: 1))
+    assert hash.key?("a")
+    assert_equal 1, hash[:a]
+  end
+
+  def test_dup_with_default_proc
+    hash = HashWithIndifferentAccess.new
+    hash.default_proc = proc { |h, v| raise "walrus" }
+    assert_nothing_raised { hash.dup }
+  end
+
+  def test_dup_with_default_proc_sets_proc
+    hash = HashWithIndifferentAccess.new
+    hash.default_proc = proc { |h, k| k + 1 }
+    new_hash = hash.dup
+
+    assert_equal 3, new_hash[2]
+
+    new_hash.default = 2
+    assert_equal 2, new_hash[:non_existent]
+  end
+
+  def test_to_hash_with_raising_default_proc
+    hash = HashWithIndifferentAccess.new
+    hash.default_proc = proc { |h, k| raise "walrus" }
+
+    assert_nothing_raised { hash.to_hash }
+  end
+
+  def test_new_with_to_hash_conversion_copies_default
+    normal_hash = Hash.new(3)
+    normal_hash[:a] = 1
+
+    hash = HashWithIndifferentAccess.new(HashByConversion.new(normal_hash))
+    assert_equal 1, hash[:a]
+    assert_equal 3, hash[:b]
+  end
+
+  def test_new_with_to_hash_conversion_copies_default_proc
+    normal_hash = Hash.new { 1 + 2 }
+    normal_hash[:a] = 1
+
+    hash = HashWithIndifferentAccess.new(HashByConversion.new(normal_hash))
+    assert_equal 1, hash[:a]
+    assert_equal 3, hash[:b]
+  end
+
+  def test_inheriting_from_top_level_hash_with_indifferent_access_preserves_ancestors_chain
+    klass = Class.new(::HashWithIndifferentAccess)
+    assert_equal ActiveSupport::HashWithIndifferentAccess, klass.ancestors[1]
+  end
+
+  def test_inheriting_from_hash_with_indifferent_access_properly_dumps_ivars
+    klass = Class.new(::HashWithIndifferentAccess) do
+      def initialize(*)
+        @foo = "bar"
+        super
+      end
+    end
+
+    yaml_output = klass.new.to_yaml
+
+    # `hash-with-ivars` was introduced in 2.0.9 (https://git.io/vyUQW)
+    if Gem::Version.new(Psych::VERSION) >= Gem::Version.new("2.0.9")
+      assert_includes yaml_output, "hash-with-ivars"
+      assert_includes yaml_output, "@foo: bar"
+    else
+      assert_includes yaml_output, "hash"
+    end
+  end
+
+  def test_should_use_default_proc_for_unknown_key
+    hash_wia = HashWithIndifferentAccess.new { 1 + 2 }
+    assert_equal 3, hash_wia[:new_key]
+  end
+
+  def test_should_return_nil_if_no_key_is_supplied
+    hash_wia = HashWithIndifferentAccess.new { 1 + 2 }
+    assert_nil hash_wia.default
+  end
+
+  def test_should_use_default_value_for_unknown_key
+    hash_wia = HashWithIndifferentAccess.new(3)
+    assert_equal 3, hash_wia[:new_key]
+  end
+
+  def test_should_use_default_value_if_no_key_is_supplied
+    hash_wia = HashWithIndifferentAccess.new(3)
+    assert_equal 3, hash_wia.default
+  end
+
+  def test_should_nil_if_no_default_value_is_supplied
+    hash_wia = HashWithIndifferentAccess.new
+    assert_nil hash_wia.default
+  end
+
+  def test_should_return_dup_for_with_indifferent_access
+    hash_wia = HashWithIndifferentAccess.new
+    assert_equal hash_wia, hash_wia.with_indifferent_access
+    assert_not_same hash_wia, hash_wia.with_indifferent_access
+  end
+
+  def test_allows_setting_frozen_array_values_with_indifferent_access
+    value = [1, 2, 3].freeze
+    hash = HashWithIndifferentAccess.new
+    hash[:key] = value
+    assert_equal hash[:key], value
+  end
+
+  def test_should_copy_the_default_value_when_converting_to_hash_with_indifferent_access
+    hash = Hash.new(3)
+    hash_wia = hash.with_indifferent_access
+    assert_equal 3, hash_wia.default
+  end
+
+  def test_should_copy_the_default_proc_when_converting_to_hash_with_indifferent_access
+    hash = Hash.new do
+      2 + 1
+    end
+    assert_equal 3, hash[:foo]
+
+    hash_wia = hash.with_indifferent_access
+    assert_equal 3, hash_wia[:foo]
+    assert_equal 3, hash_wia[:bar]
+  end
+end
diff --git a/activesupport/test/i18n_test.rb b/activesupport/test/i18n_test.rb
index 7d88d2dc6b..8ad9441f9d 100644
--- a/activesupport/test/i18n_test.rb
+++ b/activesupport/test/i18n_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/time"
 require "active_support/core_ext/array/conversions"
diff --git a/activesupport/test/inflector_test.rb b/activesupport/test/inflector_test.rb
index 03d7b3fe94..eeec0ab1a5 100644
--- a/activesupport/test/inflector_test.rb
+++ b/activesupport/test/inflector_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/inflector"
 
@@ -119,6 +121,13 @@ class InflectorTest < ActiveSupport::TestCase
     end
   end
 
+  MixtureToTitleCaseWithKeepIdSuffix.each_with_index do |(before, titleized), index|
+    define_method "test_titleize_with_keep_id_suffix_mixture_to_title_case_#{index}" do
+      assert_equal(titleized, ActiveSupport::Inflector.titleize(before, keep_id_suffix: true),
+        "mixture to TitleCase with keep_id_suffix failed for #{before}")
+    end
+  end
+
   def test_camelize
     CamelToUnderscore.each do |camel, underscore|
       assert_equal(camel, ActiveSupport::Inflector.camelize(underscore))
@@ -324,6 +333,12 @@ class InflectorTest < ActiveSupport::TestCase
     end
   end
 
+  def test_humanize_with_keep_id_suffix
+    UnderscoreToHumanWithKeepIdSuffix.each do |underscore, human|
+      assert_equal(human, ActiveSupport::Inflector.humanize(underscore, keep_id_suffix: true))
+    end
+  end
+
   def test_humanize_by_rule
     ActiveSupport::Inflector.inflections do |inflect|
       inflect.human(/_cnt$/i, '\1_count')
@@ -407,6 +422,8 @@ class InflectorTest < ActiveSupport::TestCase
       inflect.singular(/es$/, "")
 
       inflect.irregular("el", "los")
+
+      inflect.uncountable("agua")
     end
 
     assert_equal("hijos", "hijo".pluralize(:es))
@@ -419,12 +436,17 @@ class InflectorTest < ActiveSupport::TestCase
     assert_equal("los", "el".pluralize(:es))
     assert_equal("els", "el".pluralize)
 
+    assert_equal("agua", "agua".pluralize(:es))
+    assert_equal("aguas", "agua".pluralize)
+
     ActiveSupport::Inflector.inflections(:es) { |inflect| inflect.clear }
 
     assert ActiveSupport::Inflector.inflections(:es).plurals.empty?
     assert ActiveSupport::Inflector.inflections(:es).singulars.empty?
+    assert ActiveSupport::Inflector.inflections(:es).uncountables.empty?
     assert !ActiveSupport::Inflector.inflections.plurals.empty?
     assert !ActiveSupport::Inflector.inflections.singulars.empty?
+    assert !ActiveSupport::Inflector.inflections.uncountables.empty?
   end
 
   def test_clear_all
diff --git a/activesupport/test/inflector_test_cases.rb b/activesupport/test/inflector_test_cases.rb
index b660987d92..f1214671ce 100644
--- a/activesupport/test/inflector_test_cases.rb
+++ b/activesupport/test/inflector_test_cases.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module InflectorTestCases
   SingularToPlural = {
     "search"      => "searches",
@@ -248,12 +250,27 @@ module InflectorTestCases
     "_external_id"    => "External"
   }
 
+  UnderscoreToHumanWithKeepIdSuffix = {
+    "this_is_a_string_ending_with_id" => "This is a string ending with id",
+    "employee_id"                => "Employee id",
+    "employee_id_something_else" => "Employee id something else",
+    "underground"               => "Underground",
+    "_id"                       => "Id",
+    "_external_id"              => "External id"
+  }
+
   UnderscoreToHumanWithoutCapitalize = {
     "employee_salary" => "employee salary",
     "employee_id"     => "employee",
     "underground"     => "underground"
   }
 
+  MixtureToTitleCaseWithKeepIdSuffix = {
+    "this_is_a_string_ending_with_id" => "This Is A String Ending With Id",
+    "EmployeeId"                      => "Employee Id",
+    "Author Id"                       => "Author Id"
+  }
+
   MixtureToTitleCase = {
     "active_record"         => "Active Record",
     "ActiveRecord"          => "Active Record",
@@ -271,6 +288,7 @@ module InflectorTestCases
     "¿por qué?"             => "¿Por Qué?",
     "Fred’s"                => "Fred’s",
     "Fred`s"                => "Fred`s",
+    "this was 'fake news'"  => "This Was 'Fake News'",
     ActiveSupport::SafeBuffer.new("confirmation num") => "Confirmation Num"
   }
 
diff --git a/activesupport/test/json/decoding_test.rb b/activesupport/test/json/decoding_test.rb
index 6f5051c312..8d9587f248 100644
--- a/activesupport/test/json/decoding_test.rb
+++ b/activesupport/test/json/decoding_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/json"
 require "active_support/time"
diff --git a/activesupport/test/json/encoding_test.rb b/activesupport/test/json/encoding_test.rb
index 6d8f7cfbd0..80d03ec9d6 100644
--- a/activesupport/test/json/encoding_test.rb
+++ b/activesupport/test/json/encoding_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "securerandom"
 require "abstract_unit"
 require "active_support/core_ext/string/inflections"
diff --git a/activesupport/test/json/encoding_test_cases.rb b/activesupport/test/json/encoding_test_cases.rb
index 7e4775cec8..5a4700459f 100644
--- a/activesupport/test/json/encoding_test_cases.rb
+++ b/activesupport/test/json/encoding_test_cases.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "bigdecimal"
 require "date"
 require "time"
diff --git a/activesupport/test/key_generator_test.rb b/activesupport/test/key_generator_test.rb
index 89db9563ac..a948cfbd8e 100644
--- a/activesupport/test/key_generator_test.rb
+++ b/activesupport/test/key_generator_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 begin
diff --git a/activesupport/test/lazy_load_hooks_test.rb b/activesupport/test/lazy_load_hooks_test.rb
index 3b1959a1c9..9c9264e8fc 100644
--- a/activesupport/test/lazy_load_hooks_test.rb
+++ b/activesupport/test/lazy_load_hooks_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class LazyLoadHooksTest < ActiveSupport::TestCase
diff --git a/activesupport/test/log_subscriber_test.rb b/activesupport/test/log_subscriber_test.rb
index f6496ef7d6..2af9b1de30 100644
--- a/activesupport/test/log_subscriber_test.rb
+++ b/activesupport/test/log_subscriber_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/log_subscriber/test_helper"
 
diff --git a/activesupport/test/logger_test.rb b/activesupport/test/logger_test.rb
index 3f04783401..5efbd10a7d 100644
--- a/activesupport/test/logger_test.rb
+++ b/activesupport/test/logger_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "multibyte_test_helpers"
 require "stringio"
@@ -37,7 +39,7 @@ class LoggerTest < ActiveSupport::TestCase
     logger = Logger.new f
     logger.level = Logger::DEBUG
 
-    str = "\x80"
+    str = "\x80".dup
     str.force_encoding("ASCII-8BIT")
 
     logger.add Logger::DEBUG, str
@@ -55,7 +57,7 @@ class LoggerTest < ActiveSupport::TestCase
     logger = Logger.new f
     logger.level = Logger::DEBUG
 
-    str = "\x80"
+    str = "\x80".dup
     str.force_encoding("ASCII-8BIT")
 
     logger.add Logger::DEBUG, str
diff --git a/activesupport/test/message_encryptor_test.rb b/activesupport/test/message_encryptor_test.rb
index 56a436f751..832841597f 100644
--- a/activesupport/test/message_encryptor_test.rb
+++ b/activesupport/test/message_encryptor_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "openssl"
 require "active_support/time"
@@ -86,20 +88,32 @@ class MessageEncryptorTest < ActiveSupport::TestCase
     assert_equal @data, encryptor.decrypt_and_verify(message)
   end
 
+  def test_aead_mode_with_hmac_cbc_cipher_text
+    encryptor = ActiveSupport::MessageEncryptor.new(@secret, cipher: "aes-256-gcm")
+
+    assert_aead_not_decrypted(encryptor, "eHdGeExnZEwvMSt3U3dKaFl1WFo0TjVvYzA0eGpjbm5WSkt5MXlsNzhpZ0ZnbWhBWFlQZTRwaXE1bVJCS2oxMDZhYVp2dVN3V0lNZUlWQ3c2eVhQbnhnVjFmeVVubmhRKzF3WnZyWHVNMDg9LS1HSisyakJVSFlPb05ISzRMaXRzcFdBPT0=--831a1d54a3cda8a0658dc668a03dedcbce13b5ca")
+  end
+
   def test_messing_with_aead_values_causes_failures
     encryptor = ActiveSupport::MessageEncryptor.new(@secret, cipher: "aes-256-gcm")
     text, iv, auth_tag = encryptor.encrypt_and_sign(@data).split("--")
-    assert_not_decrypted([iv, text, auth_tag] * "--")
-    assert_not_decrypted([munge(text), iv, auth_tag] * "--")
-    assert_not_decrypted([text, munge(iv), auth_tag] * "--")
-    assert_not_decrypted([text, iv, munge(auth_tag)] * "--")
-    assert_not_decrypted([munge(text), munge(iv), munge(auth_tag)] * "--")
-    assert_not_decrypted([text, iv] * "--")
-    assert_not_decrypted([text, iv, auth_tag[0..-2]] * "--")
+    assert_aead_not_decrypted(encryptor, [iv, text, auth_tag] * "--")
+    assert_aead_not_decrypted(encryptor, [munge(text), iv, auth_tag] * "--")
+    assert_aead_not_decrypted(encryptor, [text, munge(iv), auth_tag] * "--")
+    assert_aead_not_decrypted(encryptor, [text, iv, munge(auth_tag)] * "--")
+    assert_aead_not_decrypted(encryptor, [munge(text), munge(iv), munge(auth_tag)] * "--")
+    assert_aead_not_decrypted(encryptor, [text, iv] * "--")
+    assert_aead_not_decrypted(encryptor, [text, iv, auth_tag[0..-2]] * "--")
   end
 
   private
 
+    def assert_aead_not_decrypted(encryptor, value)
+      assert_raise(ActiveSupport::MessageEncryptor::InvalidMessage) do
+        encryptor.decrypt_and_verify(value)
+      end
+    end
+
     def assert_not_decrypted(value)
       assert_raise(ActiveSupport::MessageEncryptor::InvalidMessage) do
         @encryptor.decrypt_and_verify(@verifier.generate(value))
diff --git a/activesupport/test/message_verifier_test.rb b/activesupport/test/message_verifier_test.rb
index d6109c761d..ba886f9fb4 100644
--- a/activesupport/test/message_verifier_test.rb
+++ b/activesupport/test/message_verifier_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "openssl"
 require "active_support/time"
diff --git a/activesupport/test/multibyte_chars_test.rb b/activesupport/test/multibyte_chars_test.rb
index d80d340986..f51fbe2671 100644
--- a/activesupport/test/multibyte_chars_test.rb
+++ b/activesupport/test/multibyte_chars_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "multibyte_test_helpers"
 require "active_support/core_ext/string/multibyte"
@@ -51,7 +53,7 @@ class MultibyteCharsTest < ActiveSupport::TestCase
   end
 
   def test_forwarded_method_with_non_string_result_should_be_returned_verbatim
-    str = ""
+    str = "".dup
     str.singleton_class.class_eval { def __method_for_multibyte_testing_with_integer_result; 1; end }
     @chars.wrapped_string.singleton_class.class_eval { def __method_for_multibyte_testing_with_integer_result; 1; end }
 
@@ -59,14 +61,14 @@ class MultibyteCharsTest < ActiveSupport::TestCase
   end
 
   def test_should_concatenate
-    mb_a = "a".mb_chars
-    mb_b = "b".mb_chars
+    mb_a = "a".dup.mb_chars
+    mb_b = "b".dup.mb_chars
     assert_equal "ab", mb_a + "b"
     assert_equal "ab", "a" + mb_b
     assert_equal "ab", mb_a + mb_b
 
     assert_equal "ab", mb_a << "b"
-    assert_equal "ab", "a" << mb_b
+    assert_equal "ab", "a".dup << mb_b
     assert_equal "abb", mb_a << mb_b
   end
 
@@ -78,7 +80,7 @@ class MultibyteCharsTest < ActiveSupport::TestCase
 
   def test_concatenation_should_return_a_proxy_class_instance
     assert_equal ActiveSupport::Multibyte.proxy_class, ("a".mb_chars + "b").class
-    assert_equal ActiveSupport::Multibyte.proxy_class, ("a".mb_chars << "b").class
+    assert_equal ActiveSupport::Multibyte.proxy_class, ("a".dup.mb_chars << "b").class
   end
 
   def test_ascii_strings_are_treated_at_utf8_strings
@@ -88,8 +90,8 @@ class MultibyteCharsTest < ActiveSupport::TestCase
   def test_concatenate_should_return_proxy_instance
     assert(("a".mb_chars + "b").kind_of?(@proxy_class))
     assert(("a".mb_chars + "b".mb_chars).kind_of?(@proxy_class))
-    assert(("a".mb_chars << "b").kind_of?(@proxy_class))
-    assert(("a".mb_chars << "b".mb_chars).kind_of?(@proxy_class))
+    assert(("a".dup.mb_chars << "b").kind_of?(@proxy_class))
+    assert(("a".dup.mb_chars << "b".mb_chars).kind_of?(@proxy_class))
   end
 
   def test_should_return_string_as_json
@@ -115,12 +117,12 @@ class MultibyteCharsUTF8BehaviourTest < ActiveSupport::TestCase
   %w{capitalize downcase lstrip reverse rstrip swapcase upcase}.each do |method|
     class_eval(<<-EOTESTS, __FILE__, __LINE__ + 1)
       def test_#{method}_bang_should_return_self_when_modifying_wrapped_string
-        chars = ' él piDió Un bUen café '
+        chars = ' él piDió Un bUen café '.dup
         assert_equal chars.object_id, chars.send("#{method}!").object_id
       end
 
       def test_#{method}_bang_should_change_wrapped_string
-        original = ' él piDió Un bUen café '
+        original = ' él piDió Un bUen café '.dup
         proxy = chars(original.dup)
         proxy.send("#{method}!")
         assert_not_equal original, proxy.to_s
@@ -133,7 +135,7 @@ class MultibyteCharsUTF8BehaviourTest < ActiveSupport::TestCase
   end
 
   def test_tidy_bytes_bang_should_change_wrapped_string
-    original = " Un bUen café \x92"
+    original = " Un bUen café \x92".dup
     proxy = chars(original.dup)
     proxy.tidy_bytes!
     assert_not_equal original, proxy.to_s
@@ -150,7 +152,7 @@ class MultibyteCharsUTF8BehaviourTest < ActiveSupport::TestCase
   end
 
   def test_string_methods_are_chainable
-    assert chars("").insert(0, "").kind_of?(ActiveSupport::Multibyte.proxy_class)
+    assert chars("".dup).insert(0, "").kind_of?(ActiveSupport::Multibyte.proxy_class)
     assert chars("").rjust(1).kind_of?(ActiveSupport::Multibyte.proxy_class)
     assert chars("").ljust(1).kind_of?(ActiveSupport::Multibyte.proxy_class)
     assert chars("").center(1).kind_of?(ActiveSupport::Multibyte.proxy_class)
@@ -195,7 +197,7 @@ class MultibyteCharsUTF8BehaviourTest < ActiveSupport::TestCase
   end
 
   def test_should_use_character_offsets_for_insert_offsets
-    assert_equal "", "".mb_chars.insert(0, "")
+    assert_equal "", "".dup.mb_chars.insert(0, "")
     assert_equal "こわにちわ", @chars.insert(1, "わ")
     assert_equal "こわわわにちわ", @chars.insert(2, "わわ")
     assert_equal "わこわわわにちわ", @chars.insert(0, "わ")
@@ -418,13 +420,13 @@ class MultibyteCharsUTF8BehaviourTest < ActiveSupport::TestCase
   end
 
   def test_slice_bang_removes_the_slice_from_the_receiver
-    chars = "úüù".mb_chars
+    chars = "úüù".dup.mb_chars
     chars.slice!(0, 2)
     assert_equal "ù", chars
   end
 
   def test_slice_bang_returns_nil_and_does_not_modify_receiver_if_out_of_bounds
-    string = "úüù"
+    string = "úüù".dup
     chars = string.mb_chars
     assert_nil chars.slice!(4, 5)
     assert_equal "úüù", chars
diff --git a/activesupport/test/multibyte_conformance_test.rb b/activesupport/test/multibyte_conformance_test.rb
index ef1a26135f..748e8d16e1 100644
--- a/activesupport/test/multibyte_conformance_test.rb
+++ b/activesupport/test/multibyte_conformance_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "multibyte_test_helpers"
 
diff --git a/activesupport/test/multibyte_grapheme_break_conformance_test.rb b/activesupport/test/multibyte_grapheme_break_conformance_test.rb
index b3328987ae..fac74cd80f 100644
--- a/activesupport/test/multibyte_grapheme_break_conformance_test.rb
+++ b/activesupport/test/multibyte_grapheme_break_conformance_test.rb
@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 require "abstract_unit"
 require "multibyte_test_helpers"
diff --git a/activesupport/test/multibyte_normalization_conformance_test.rb b/activesupport/test/multibyte_normalization_conformance_test.rb
index ebc9f92d23..1173a94e81 100644
--- a/activesupport/test/multibyte_normalization_conformance_test.rb
+++ b/activesupport/test/multibyte_normalization_conformance_test.rb
@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 require "abstract_unit"
 require "multibyte_test_helpers"
diff --git a/activesupport/test/multibyte_proxy_test.rb b/activesupport/test/multibyte_proxy_test.rb
index c303097f80..ecedab2569 100644
--- a/activesupport/test/multibyte_proxy_test.rb
+++ b/activesupport/test/multibyte_proxy_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class MultibyteProxyText < ActiveSupport::TestCase
diff --git a/activesupport/test/multibyte_test_helpers.rb b/activesupport/test/multibyte_test_helpers.rb
index a70516bb08..f7cf993100 100644
--- a/activesupport/test/multibyte_test_helpers.rb
+++ b/activesupport/test/multibyte_test_helpers.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MultibyteTestHelpers
   class Downloader
     def self.download(from, to)
@@ -23,7 +25,7 @@ module MultibyteTestHelpers
 
   UNICODE_STRING = "こにちわ".freeze
   ASCII_STRING = "ohayo".freeze
-  BYTE_STRING = "\270\236\010\210\245".force_encoding("ASCII-8BIT").freeze
+  BYTE_STRING = "\270\236\010\210\245".dup.force_encoding("ASCII-8BIT").freeze
 
   def chars(str)
     ActiveSupport::Multibyte::Chars.new(str)
diff --git a/activesupport/test/multibyte_unicode_database_test.rb b/activesupport/test/multibyte_unicode_database_test.rb
index 3724782930..540a34493d 100644
--- a/activesupport/test/multibyte_unicode_database_test.rb
+++ b/activesupport/test/multibyte_unicode_database_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class MultibyteUnicodeDatabaseTest < ActiveSupport::TestCase
diff --git a/activesupport/test/notifications/evented_notification_test.rb b/activesupport/test/notifications/evented_notification_test.rb
index 24c5befec3..4beb8194b9 100644
--- a/activesupport/test/notifications/evented_notification_test.rb
+++ b/activesupport/test/notifications/evented_notification_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 module ActiveSupport
diff --git a/activesupport/test/notifications/instrumenter_test.rb b/activesupport/test/notifications/instrumenter_test.rb
index 7eacc5cbe7..1d76c91d30 100644
--- a/activesupport/test/notifications/instrumenter_test.rb
+++ b/activesupport/test/notifications/instrumenter_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/notifications/instrumenter"
 
diff --git a/activesupport/test/notifications_test.rb b/activesupport/test/notifications_test.rb
index 11f743519f..5cfbd60131 100644
--- a/activesupport/test/notifications_test.rb
+++ b/activesupport/test/notifications_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/module/delegation"
 
diff --git a/activesupport/test/number_helper_i18n_test.rb b/activesupport/test/number_helper_i18n_test.rb
index a1d1c41dc2..6d6958be49 100644
--- a/activesupport/test/number_helper_i18n_test.rb
+++ b/activesupport/test/number_helper_i18n_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/number_helper"
 require "active_support/core_ext/hash/keys"
diff --git a/activesupport/test/number_helper_test.rb b/activesupport/test/number_helper_test.rb
index dc0c34d4e2..b4795b6ee1 100644
--- a/activesupport/test/number_helper_test.rb
+++ b/activesupport/test/number_helper_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/number_helper"
 require "active_support/core_ext/string/output_safety"
@@ -321,12 +323,18 @@ module ActiveSupport
           gangster = { hundred: "hundred bucks", million: "thousand quids" }
           assert_equal "1 hundred bucks", number_helper.number_to_human(100, units: gangster)
           assert_equal "25 hundred bucks", number_helper.number_to_human(2500, units: gangster)
+          assert_equal "1000 hundred bucks", number_helper.number_to_human(100_000, units: gangster)
+          assert_equal "1 thousand quids", number_helper.number_to_human(999_999, units: gangster)
+          assert_equal "1 thousand quids", number_helper.number_to_human(1_000_000, units: gangster)
           assert_equal "25 thousand quids", number_helper.number_to_human(25000000, units: gangster)
           assert_equal "12300 thousand quids", number_helper.number_to_human(12345000000, units: gangster)
 
           #Spaces are stripped from the resulting string
           assert_equal "4", number_helper.number_to_human(4, units: { unit: "", ten: "tens " })
           assert_equal "4.5  tens", number_helper.number_to_human(45, units: { unit: "", ten: " tens   " })
+
+          #Uses only the provided units and does not try to use larger ones
+          assert_equal "1000 kilometers", number_helper.number_to_human(1_000_000, units: { unit: "meter", thousand: "kilometers" })
         end
       end
 
diff --git a/activesupport/test/option_merger_test.rb b/activesupport/test/option_merger_test.rb
index c5a6d304ee..935e2aee63 100644
--- a/activesupport/test/option_merger_test.rb
+++ b/activesupport/test/option_merger_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/object/with_options"
 
diff --git a/activesupport/test/ordered_hash_test.rb b/activesupport/test/ordered_hash_test.rb
index 2cefab3832..c70d3b4c37 100644
--- a/activesupport/test/ordered_hash_test.rb
+++ b/activesupport/test/ordered_hash_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/json"
 require "active_support/core_ext/object/json"
diff --git a/activesupport/test/ordered_options_test.rb b/activesupport/test/ordered_options_test.rb
index 0417911289..7f2e774c02 100644
--- a/activesupport/test/ordered_options_test.rb
+++ b/activesupport/test/ordered_options_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/ordered_options"
 
diff --git a/activesupport/test/reloader_test.rb b/activesupport/test/reloader_test.rb
index bdd80307c7..3e4229eaf7 100644
--- a/activesupport/test/reloader_test.rb
+++ b/activesupport/test/reloader_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class ReloaderTest < ActiveSupport::TestCase
diff --git a/activesupport/test/rescuable_test.rb b/activesupport/test/rescuable_test.rb
index f7eb047d44..b1b8a25c5b 100644
--- a/activesupport/test/rescuable_test.rb
+++ b/activesupport/test/rescuable_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class WraithAttack < StandardError
@@ -43,7 +45,9 @@ class Stargate
   def dispatch(method)
     send(method)
   rescue Exception => e
-    rescue_with_handler(e)
+    unless rescue_with_handler(e)
+      @result = "unhandled"
+    end
   end
 
   def attack
@@ -58,6 +62,26 @@ class Stargate
     raise MadRonon.new("dex")
   end
 
+  def crash
+    raise "unhandled RuntimeError"
+  end
+
+  def looped_crash
+    ex1 = StandardError.new("error 1")
+    ex2 = StandardError.new("error 2")
+    begin
+      begin
+        raise ex1
+      rescue
+        # sets the cause on ex2 to be ex1
+        raise ex2
+      end
+    rescue
+      # sets the cause on ex1 to be ex2
+      raise ex1
+    end
+  end
+
   def fall_back_to_cause
     # This exception is the cause and has a handler.
     ronanize
@@ -139,4 +163,14 @@ class RescuableTest < ActiveSupport::TestCase
     @stargate.dispatch :fall_back_to_cause
     assert_equal "dex", @stargate.result
   end
+
+  def test_unhandled_exceptions
+    @stargate.dispatch(:crash)
+    assert_equal "unhandled", @stargate.result
+  end
+
+  def test_rescue_handles_loops_in_exception_cause_chain
+    @stargate.dispatch :looped_crash
+    assert_equal "unhandled", @stargate.result
+  end
 end
diff --git a/activesupport/test/safe_buffer_test.rb b/activesupport/test/safe_buffer_test.rb
index 36c068b91f..05c2fb59be 100644
--- a/activesupport/test/safe_buffer_test.rb
+++ b/activesupport/test/safe_buffer_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/string/inflections"
 require "yaml"
diff --git a/activesupport/test/security_utils_test.rb b/activesupport/test/security_utils_test.rb
index e8f762da22..efd2bcfa0f 100644
--- a/activesupport/test/security_utils_test.rb
+++ b/activesupport/test/security_utils_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/security_utils"
 
diff --git a/activesupport/test/share_lock_test.rb b/activesupport/test/share_lock_test.rb
index a5970591fa..42fd5eefc1 100644
--- a/activesupport/test/share_lock_test.rb
+++ b/activesupport/test/share_lock_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "concurrent/atomic/count_down_latch"
 require "active_support/concurrency/share_lock"
diff --git a/activesupport/test/string_inquirer_test.rb b/activesupport/test/string_inquirer_test.rb
index 79a715349c..bf8f878a32 100644
--- a/activesupport/test/string_inquirer_test.rb
+++ b/activesupport/test/string_inquirer_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class StringInquirerTest < ActiveSupport::TestCase
diff --git a/activesupport/test/subscriber_test.rb b/activesupport/test/subscriber_test.rb
index 9127da35d4..6b012e43af 100644
--- a/activesupport/test/subscriber_test.rb
+++ b/activesupport/test/subscriber_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/subscriber"
 
diff --git a/activesupport/test/tagged_logging_test.rb b/activesupport/test/tagged_logging_test.rb
index 2469e827d4..5fd6a6b316 100644
--- a/activesupport/test/tagged_logging_test.rb
+++ b/activesupport/test/tagged_logging_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/logger"
 require "active_support/tagged_logging"
diff --git a/activesupport/test/test_case_test.rb b/activesupport/test/test_case_test.rb
index af7fc44d66..8830c9b348 100644
--- a/activesupport/test/test_case_test.rb
+++ b/activesupport/test/test_case_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 class AssertDifferenceTest < ActiveSupport::TestCase
@@ -237,9 +239,6 @@ class AssertDifferenceTest < ActiveSupport::TestCase
   end
 end
 
-class AlsoDoingNothingTest < ActiveSupport::TestCase
-end
-
 # Setup and teardown callbacks.
 class SetupAndTeardownTest < ActiveSupport::TestCase
   setup :reset_callback_record, :foo
diff --git a/activesupport/test/testing/constant_lookup_test.rb b/activesupport/test/testing/constant_lookup_test.rb
index 00e69fcdb5..37b7822950 100644
--- a/activesupport/test/testing/constant_lookup_test.rb
+++ b/activesupport/test/testing/constant_lookup_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "dependencies_test_helpers"
 
diff --git a/activesupport/test/testing/file_fixtures_test.rb b/activesupport/test/testing/file_fixtures_test.rb
index e44fe58ce9..35be8f5206 100644
--- a/activesupport/test/testing/file_fixtures_test.rb
+++ b/activesupport/test/testing/file_fixtures_test.rb
@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 
 require "pathname"
 
 class FileFixturesTest < ActiveSupport::TestCase
-  self.file_fixture_path = File.expand_path("../../file_fixtures", __FILE__)
+  self.file_fixture_path = File.expand_path("../file_fixtures", __dir__)
 
   test "#file_fixture returns Pathname to file fixture" do
     path = file_fixture("sample.txt")
     assert_kind_of Pathname, path
-    assert_match %r{.*/test/file_fixtures/sample.txt$}, path.to_s
+    assert_match %r{.*/test/file_fixtures/sample\.txt$}, path.to_s
   end
 
   test "raises an exception when the fixture file does not exist" do
@@ -20,11 +22,11 @@ class FileFixturesTest < ActiveSupport::TestCase
 end
 
 class FileFixturesPathnameDirectoryTest < ActiveSupport::TestCase
-  self.file_fixture_path = Pathname.new(File.expand_path("../../file_fixtures", __FILE__))
+  self.file_fixture_path = Pathname.new(File.expand_path("../file_fixtures", __dir__))
 
   test "#file_fixture_path returns Pathname to file fixture" do
     path = file_fixture("sample.txt")
     assert_kind_of Pathname, path
-    assert_match %r{.*/test/file_fixtures/sample.txt$}, path.to_s
+    assert_match %r{.*/test/file_fixtures/sample\.txt$}, path.to_s
   end
 end
diff --git a/activesupport/test/testing/method_call_assertions_test.rb b/activesupport/test/testing/method_call_assertions_test.rb
index 7887933b15..4af000bb7e 100644
--- a/activesupport/test/testing/method_call_assertions_test.rb
+++ b/activesupport/test/testing/method_call_assertions_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/testing/method_call_assertions"
 
diff --git a/activesupport/test/time_travel_test.rb b/activesupport/test/time_travel_test.rb
index e0d3fb0cf5..4172c18ead 100644
--- a/activesupport/test/time_travel_test.rb
+++ b/activesupport/test/time_travel_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/core_ext/date_time"
 require "active_support/core_ext/numeric/time"
@@ -99,7 +101,7 @@ class TimeTravelTest < ActiveSupport::TestCase
             #noop
           end
         end
-        assert_match(/Calling `travel_to` with a block, when we have previously already made a call to `travel_to`, can lead to confusing time stubbing./, e.message)
+        assert_match(/Calling `travel_to` with a block, when we have previously already made a call to `travel_to`, can lead to confusing time stubbing\./, e.message)
       end
     end
   end
@@ -162,4 +164,26 @@ class TimeTravelTest < ActiveSupport::TestCase
       assert_equal DateTime.now.to_s, DateTimeSubclass.now.to_s
     end
   end
+
+  def test_time_helper_freeze_time
+    expected_time = Time.now
+    freeze_time
+    sleep(1)
+
+    assert_equal expected_time.to_s(:db), Time.now.to_s(:db)
+  ensure
+    travel_back
+  end
+
+  def test_time_helper_freeze_time_with_block
+    expected_time = Time.now
+
+    freeze_time do
+      sleep(1)
+
+      assert_equal expected_time.to_s(:db), Time.now.to_s(:db)
+    end
+
+    assert_operator expected_time.to_s(:db), :<, Time.now.to_s(:db)
+  end
 end
diff --git a/activesupport/test/time_zone_test.rb b/activesupport/test/time_zone_test.rb
index 1615d8fdb2..04f1a53dd9 100644
--- a/activesupport/test/time_zone_test.rb
+++ b/activesupport/test/time_zone_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/time"
 require "time_zone_test_helpers"
@@ -403,6 +405,16 @@ class TimeZoneTest < ActiveSupport::TestCase
     end
   end
 
+  def test_parse_with_invalid_date
+    zone = ActiveSupport::TimeZone["UTC"]
+
+    exception = assert_raises(ArgumentError) do
+      zone.parse("9000")
+    end
+
+    assert_equal "argument out of range", exception.message
+  end
+
   def test_rfc3339
     zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
     twz = zone.rfc3339("1999-12-31T14:00:00-10:00")
@@ -714,6 +726,10 @@ class TimeZoneTest < ActiveSupport::TestCase
     assert_not_includes ActiveSupport::TimeZone.country_zones(:ru), ActiveSupport::TimeZone["Kuala Lumpur"]
   end
 
+  def test_country_zones_without_mappings
+    assert_includes ActiveSupport::TimeZone.country_zones(:sv), ActiveSupport::TimeZone["America/El_Salvador"]
+  end
+
   def test_to_yaml
     assert_equal("--- !ruby/object:ActiveSupport::TimeZone\nname: Pacific/Honolulu\n", ActiveSupport::TimeZone["Hawaii"].to_yaml)
     assert_equal("--- !ruby/object:ActiveSupport::TimeZone\nname: Europe/London\n", ActiveSupport::TimeZone["Europe/London"].to_yaml)
diff --git a/activesupport/test/time_zone_test_helpers.rb b/activesupport/test/time_zone_test_helpers.rb
index e1d615d154..051703a781 100644
--- a/activesupport/test/time_zone_test_helpers.rb
+++ b/activesupport/test/time_zone_test_helpers.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module TimeZoneTestHelpers
   def with_tz_default(tz = nil)
     old_tz = Time.zone
diff --git a/activesupport/test/transliterate_test.rb b/activesupport/test/transliterate_test.rb
index 466b69bcef..7d19447598 100644
--- a/activesupport/test/transliterate_test.rb
+++ b/activesupport/test/transliterate_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/inflector/transliterate"
 
diff --git a/activesupport/test/xml_mini/jdom_engine_test.rb b/activesupport/test/xml_mini/jdom_engine_test.rb
index e783cea67c..97a533aafb 100644
--- a/activesupport/test/xml_mini/jdom_engine_test.rb
+++ b/activesupport/test/xml_mini/jdom_engine_test.rb
@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require_relative "xml_mini_engine_test"
 
 XMLMiniEngineTest.run_with_platform("java") do
   class JDOMEngineTest < XMLMiniEngineTest
-    FILES_DIR = File.dirname(__FILE__) + "/../fixtures/xml"
+    FILES_DIR = File.expand_path("../fixtures/xml", __dir__)
 
     def test_not_allowed_to_expand_entities_to_files
       attack_xml = <<-EOT
diff --git a/activesupport/test/xml_mini/libxml_engine_test.rb b/activesupport/test/xml_mini/libxml_engine_test.rb
index f3394ad7f2..5c13f493f1 100644
--- a/activesupport/test/xml_mini/libxml_engine_test.rb
+++ b/activesupport/test/xml_mini/libxml_engine_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "xml_mini_engine_test"
 
 XMLMiniEngineTest.run_with_gem("libxml") do
diff --git a/activesupport/test/xml_mini/libxmlsax_engine_test.rb b/activesupport/test/xml_mini/libxmlsax_engine_test.rb
index f457e160d6..8e4a30a48e 100644
--- a/activesupport/test/xml_mini/libxmlsax_engine_test.rb
+++ b/activesupport/test/xml_mini/libxmlsax_engine_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "xml_mini_engine_test"
 
 XMLMiniEngineTest.run_with_gem("libxml") do
diff --git a/activesupport/test/xml_mini/nokogiri_engine_test.rb b/activesupport/test/xml_mini/nokogiri_engine_test.rb
index 3151e75fc0..f1584bcedf 100644
--- a/activesupport/test/xml_mini/nokogiri_engine_test.rb
+++ b/activesupport/test/xml_mini/nokogiri_engine_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "xml_mini_engine_test"
 
 XMLMiniEngineTest.run_with_gem("nokogiri") do
diff --git a/activesupport/test/xml_mini/nokogirisax_engine_test.rb b/activesupport/test/xml_mini/nokogirisax_engine_test.rb
index 7dafbdaf48..f38a56e83b 100644
--- a/activesupport/test/xml_mini/nokogirisax_engine_test.rb
+++ b/activesupport/test/xml_mini/nokogirisax_engine_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "xml_mini_engine_test"
 
 XMLMiniEngineTest.run_with_gem("nokogiri") do
diff --git a/activesupport/test/xml_mini/rexml_engine_test.rb b/activesupport/test/xml_mini/rexml_engine_test.rb
index c51f0d3c20..34bf81fa75 100644
--- a/activesupport/test/xml_mini/rexml_engine_test.rb
+++ b/activesupport/test/xml_mini/rexml_engine_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "xml_mini_engine_test"
 
 class REXMLEngineTest < XMLMiniEngineTest
diff --git a/activesupport/test/xml_mini/xml_mini_engine_test.rb b/activesupport/test/xml_mini/xml_mini_engine_test.rb
index 5be9084c9d..5c4c28d9b7 100644
--- a/activesupport/test/xml_mini/xml_mini_engine_test.rb
+++ b/activesupport/test/xml_mini/xml_mini_engine_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/xml_mini"
 require "active_support/core_ext/hash/conversions"
@@ -75,6 +77,11 @@ class XMLMiniEngineTest < ActiveSupport::TestCase
       assert_equal({}, ActiveSupport::XmlMini.parse(""))
     end
 
+    def test_parse_from_frozen_string
+      xml_string = "<root/>".freeze
+      assert_equal({ "root" => {} }, ActiveSupport::XmlMini.parse(xml_string))
+    end
+
     def test_array_type_makes_an_array
       assert_equal_rexml(<<-eoxml)
         <blog>
diff --git a/activesupport/test/xml_mini_test.rb b/activesupport/test/xml_mini_test.rb
index b8caa1d74c..5e46406a7b 100644
--- a/activesupport/test/xml_mini_test.rb
+++ b/activesupport/test/xml_mini_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "abstract_unit"
 require "active_support/xml_mini"
 require "active_support/builder"