Merge branch 'master' into feature/reselect-method

35 files changed, 505 insertions, 155 deletions

diff --git a/activesupport/test/abstract_unit.rb b/activesupport/test/abstract_unit.rb
index f214898145..168d3655d3 100644
--- a/activesupport/test/abstract_unit.rb
+++ b/activesupport/test/abstract_unit.rb
@@ -29,17 +29,18 @@ I18n.enforce_available_locales = false
 class ActiveSupport::TestCase
   include ActiveSupport::Testing::MethodCallAssertions
 
-  # Skips the current run on Rubinius using Minitest::Assertions#skip
-  private def rubinius_skip(message = "")
-    skip message if RUBY_ENGINE == "rbx"
-  end
-
-  # Skips the current run on JRuby using Minitest::Assertions#skip
-  private def jruby_skip(message = "")
-    skip message if defined?(JRUBY_VERSION)
-  end
-
-  def frozen_error_class
-    Object.const_defined?(:FrozenError) ? FrozenError : RuntimeError
-  end
+  private
+    # Skips the current run on Rubinius using Minitest::Assertions#skip
+    def rubinius_skip(message = "")
+      skip message if RUBY_ENGINE == "rbx"
+    end
+
+    # Skips the current run on JRuby using Minitest::Assertions#skip
+    def jruby_skip(message = "")
+      skip message if defined?(JRUBY_VERSION)
+    end
+
+    def frozen_error_class
+      Object.const_defined?(:FrozenError) ? FrozenError : RuntimeError
+    end
 end
diff --git a/activesupport/test/benchmarkable_test.rb b/activesupport/test/benchmarkable_test.rb
index cb7a69cccf..59a71d99be 100644
--- a/activesupport/test/benchmarkable_test.rb
+++ b/activesupport/test/benchmarkable_test.rb
@@ -59,13 +59,13 @@ class BenchmarkableTest < ActiveSupport::TestCase
 
   def test_within_level
     logger.level = ActiveSupport::Logger::DEBUG
-    benchmark("included_debug_run", level: :debug) {}
+    benchmark("included_debug_run", level: :debug) { }
     assert_last_logged "included_debug_run"
   end
 
   def test_outside_level
     logger.level = ActiveSupport::Logger::ERROR
-    benchmark("skipped_debug_run", level: :debug) {}
+    benchmark("skipped_debug_run", level: :debug) { }
     assert_no_match(/skipped_debug_run/, buffer.last)
   ensure
     logger.level = ActiveSupport::Logger::DEBUG
diff --git a/activesupport/test/cache/behaviors/cache_store_behavior.rb b/activesupport/test/cache/behaviors/cache_store_behavior.rb
index e17c09ba39..30735eb0eb 100644
--- a/activesupport/test/cache/behaviors/cache_store_behavior.rb
+++ b/activesupport/test/cache/behaviors/cache_store_behavior.rb
@@ -319,7 +319,7 @@ module CacheStoreBehavior
   end
 
   def test_original_store_objects_should_not_be_immutable
-    bar = "bar".dup
+    bar = +"bar"
     @cache.write("foo", bar)
     assert_nothing_raised { bar.gsub!(/.*/, "baz") }
   end
@@ -424,7 +424,7 @@ module CacheStoreBehavior
       @events << ActiveSupport::Notifications::Event.new(*args)
     end
     assert @cache.write(key, "1", raw: true)
-    assert @cache.fetch(key) {}
+    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]
@@ -438,7 +438,7 @@ module CacheStoreBehavior
     ActiveSupport::Notifications.subscribe(/^cache_(.*)\.active_support$/) do |*args|
       @events << ActiveSupport::Notifications::Event.new(*args)
     end
-    assert_not @cache.fetch("bad_key") {}
+    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
diff --git a/activesupport/test/cache/behaviors/encoded_key_cache_behavior.rb b/activesupport/test/cache/behaviors/encoded_key_cache_behavior.rb
index da16142496..842400f4a3 100644
--- a/activesupport/test/cache/behaviors/encoded_key_cache_behavior.rb
+++ b/activesupport/test/cache/behaviors/encoded_key_cache_behavior.rb
@@ -6,7 +6,7 @@
 module EncodedKeyCacheBehavior
   Encoding.list.each do |encoding|
     define_method "test_#{encoding.name.underscore}_encoded_values" do
-      key = "foo".dup.force_encoding(encoding)
+      key = (+"foo").force_encoding(encoding)
       assert @cache.write(key, "1", raw: true)
       assert_equal "1", @cache.read(key)
       assert_equal "1", @cache.fetch(key)
@@ -18,7 +18,7 @@ module EncodedKeyCacheBehavior
   end
 
   def test_common_utf8_values
-    key = "\xC3\xBCmlaut".dup.force_encoding(Encoding::UTF_8)
+    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)
@@ -29,7 +29,7 @@ module EncodedKeyCacheBehavior
   end
 
   def test_retains_encoding
-    key = "\xC3\xBCmlaut".dup.force_encoding(Encoding::UTF_8)
+    key = (+"\xC3\xBCmlaut").force_encoding(Encoding::UTF_8)
     assert @cache.write(key, "1", raw: true)
     assert_equal Encoding::UTF_8, key.encoding
   end
diff --git a/activesupport/test/cache/cache_key_test.rb b/activesupport/test/cache/cache_key_test.rb
index 84e656f504..c2240d03c2 100644
--- a/activesupport/test/cache/cache_key_test.rb
+++ b/activesupport/test/cache/cache_key_test.rb
@@ -47,7 +47,7 @@ class CacheKeyTest < ActiveSupport::TestCase
   end
 
   def test_expand_cache_key_respond_to_cache_key
-    key = "foo".dup
+    key = +"foo"
     def key.cache_key
       :foo_key
     end
@@ -55,7 +55,7 @@ class CacheKeyTest < ActiveSupport::TestCase
   end
 
   def test_expand_cache_key_array_with_something_that_responds_to_cache_key
-    key = "foo".dup
+    key = +"foo"
     def key.cache_key
       :foo_key
     end
diff --git a/activesupport/test/cache/local_cache_middleware_test.rb b/activesupport/test/cache/local_cache_middleware_test.rb
index e59fae0b4c..e46fa59784 100644
--- a/activesupport/test/cache/local_cache_middleware_test.rb
+++ b/activesupport/test/cache/local_cache_middleware_test.rb
@@ -17,7 +17,7 @@ module ActiveSupport
             })
             _, _, body = middleware.call({})
             assert LocalCacheRegistry.cache_for(key), "should still have a cache"
-            body.each {}
+            body.each { }
             assert LocalCacheRegistry.cache_for(key), "should still have a cache"
             body.close
             assert_nil LocalCacheRegistry.cache_for(key)
diff --git a/activesupport/test/callbacks_test.rb b/activesupport/test/callbacks_test.rb
index 5c9a3b29e7..466b364e9d 100644
--- a/activesupport/test/callbacks_test.rb
+++ b/activesupport/test/callbacks_test.rb
@@ -953,7 +953,7 @@ module CallbacksTest
 
     def test_proc_arity_2
       assert_raises(ArgumentError) do
-        klass = build_class(->(x, y) {})
+        klass = build_class(->(x, y) { })
         klass.new.run
       end
     end
@@ -1032,7 +1032,7 @@ module CallbacksTest
 
     def test_proc_arity2
       assert_raises(ArgumentError) do
-        object = build_class(->(a, b) {}).new
+        object = build_class(->(a, b) { }).new
         object.run
       end
     end
diff --git a/activesupport/test/clean_backtrace_test.rb b/activesupport/test/clean_backtrace_test.rb
index 1b44c7c9bf..a0a7056952 100644
--- a/activesupport/test/clean_backtrace_test.rb
+++ b/activesupport/test/clean_backtrace_test.rb
@@ -74,3 +74,43 @@ class BacktraceCleanerFilterAndSilencerTest < ActiveSupport::TestCase
     assert_equal [ "/class.rb" ], @bc.clean([ "/mongrel/class.rb" ])
   end
 end
+
+class BacktraceCleanerDefaultFilterAndSilencerTest < ActiveSupport::TestCase
+  def setup
+    @bc = ActiveSupport::BacktraceCleaner.new
+  end
+
+  test "should format installed gems correctly" do
+    backtrace = [ "#{Gem.default_dir}/gems/nosuchgem-1.2.3/lib/foo.rb" ]
+    result = @bc.clean(backtrace, :all)
+    assert_equal "nosuchgem (1.2.3) lib/foo.rb", result[0]
+  end
+
+  test "should format installed gems not in Gem.default_dir correctly" do
+    target_dir = Gem.path.detect { |p| p != Gem.default_dir }
+    # skip this test if default_dir is the only directory on Gem.path
+    if target_dir
+      backtrace = [ "#{target_dir}/gems/nosuchgem-1.2.3/lib/foo.rb" ]
+      result = @bc.clean(backtrace, :all)
+      assert_equal "nosuchgem (1.2.3) lib/foo.rb", result[0]
+    end
+  end
+
+  test "should format gems installed by bundler" do
+    backtrace = [ "#{Gem.default_dir}/bundler/gems/nosuchgem-1.2.3/lib/foo.rb" ]
+    result = @bc.clean(backtrace, :all)
+    assert_equal "nosuchgem (1.2.3) lib/foo.rb", result[0]
+  end
+
+  test "should silence gems from the backtrace" do
+    backtrace = [ "#{Gem.path[0]}/gems/nosuchgem-1.2.3/lib/foo.rb" ]
+    result = @bc.clean(backtrace)
+    assert_empty result
+  end
+
+  test "should silence stdlib" do
+    backtrace = ["#{RbConfig::CONFIG["rubylibdir"]}/lib/foo.rb"]
+    result = @bc.clean(backtrace)
+    assert_empty result
+  end
+end
diff --git a/activesupport/test/core_ext/array/extract_test.rb b/activesupport/test/core_ext/array/extract_test.rb
new file mode 100644
index 0000000000..f26e055033
--- /dev/null
+++ b/activesupport/test/core_ext/array/extract_test.rb
@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "active_support/core_ext/array"
+
+class ExtractTest < ActiveSupport::TestCase
+  def test_extract
+    numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    array_id = numbers.object_id
+
+    odd_numbers = numbers.extract!(&:odd?)
+
+    assert_equal [1, 3, 5, 7, 9], odd_numbers
+    assert_equal [0, 2, 4, 6, 8], numbers
+    assert_equal array_id, numbers.object_id
+  end
+
+  def test_extract_without_block
+    numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    array_id = numbers.object_id
+
+    extract_enumerator = numbers.extract!
+
+    assert_instance_of Enumerator, extract_enumerator
+    assert_equal numbers.size, extract_enumerator.size
+
+    odd_numbers = extract_enumerator.each(&:odd?)
+
+    assert_equal [1, 3, 5, 7, 9], odd_numbers
+    assert_equal [0, 2, 4, 6, 8], numbers
+    assert_equal array_id, numbers.object_id
+  end
+
+  def test_extract_on_empty_array
+    empty_array = []
+    array_id = empty_array.object_id
+
+    new_empty_array = empty_array.extract! { }
+
+    assert_equal [], new_empty_array
+    assert_equal [], empty_array
+    assert_equal array_id, empty_array.object_id
+  end
+end
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 266829a452..58a24b60b6 100644
--- a/activesupport/test/core_ext/date_and_time_compatibility_test.rb
+++ b/activesupport/test/core_ext/date_and_time_compatibility_test.rb
@@ -248,7 +248,7 @@ class DateAndTimeCompatibilityTest < ActiveSupport::TestCase
   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
+        source = "2016-04-23T15:11:12+01:00"
         time = source.to_time
 
         assert_instance_of Time, time
@@ -262,7 +262,7 @@ class DateAndTimeCompatibilityTest < ActiveSupport::TestCase
   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
+        source = "2016-04-23T15:11:12+01:00"
         time = source.to_time
 
         assert_instance_of Time, time
diff --git a/activesupport/test/core_ext/module/concerning_test.rb b/activesupport/test/core_ext/module/concerning_test.rb
index 374114c11b..38fd60463d 100644
--- a/activesupport/test/core_ext/module/concerning_test.rb
+++ b/activesupport/test/core_ext/module/concerning_test.rb
@@ -5,7 +5,7 @@ require "active_support/core_ext/module/concerning"
 
 class ModuleConcerningTest < ActiveSupport::TestCase
   def test_concerning_declares_a_concern_and_includes_it_immediately
-    klass = Class.new { concerning(:Foo) {} }
+    klass = Class.new { concerning(:Foo) { } }
     assert_includes klass.ancestors, klass::Foo, klass.ancestors.inspect
   end
 end
diff --git a/activesupport/test/core_ext/object/instance_variables_test.rb b/activesupport/test/core_ext/object/instance_variables_test.rb
index a3d8daab5b..9052d209a3 100644
--- a/activesupport/test/core_ext/object/instance_variables_test.rb
+++ b/activesupport/test/core_ext/object/instance_variables_test.rb
@@ -19,15 +19,15 @@ class ObjectInstanceVariableTest < ActiveSupport::TestCase
   end
 
   def test_instance_exec_passes_arguments_to_block
-    assert_equal %w(hello goodbye), "hello".dup.instance_exec("goodbye") { |v| [self, v] }
+    assert_equal %w(hello goodbye), (+"hello").instance_exec("goodbye") { |v| [self, v] }
   end
 
   def test_instance_exec_with_frozen_obj
-    assert_equal %w(olleh goodbye), "hello".freeze.instance_exec("goodbye") { |v| [reverse, v] }
+    assert_equal %w(olleh goodbye), "hello".instance_exec("goodbye") { |v| [reverse, v] }
   end
 
   def test_instance_exec_nested
-    assert_equal %w(goodbye olleh bar), "hello".dup.instance_exec("goodbye") { |arg|
+    assert_equal %w(goodbye olleh bar), (+"hello").instance_exec("goodbye") { |arg|
       [arg] + instance_exec("bar") { |v| [reverse, v] } }
   end
 end
diff --git a/activesupport/test/core_ext/object/to_query_test.rb b/activesupport/test/core_ext/object/to_query_test.rb
index b0b7ef0913..561dadbbcf 100644
--- a/activesupport/test/core_ext/object/to_query_test.rb
+++ b/activesupport/test/core_ext/object/to_query_test.rb
@@ -88,7 +88,7 @@ class ToQueryTest < ActiveSupport::TestCase
     }
     expected = "foo[contents][][name]=gorby&foo[contents][][id]=123&foo[contents][][name]=puff&foo[contents][][d]=true"
 
-    assert_equal expected, URI.decode(params.to_query)
+    assert_equal expected, URI.decode_www_form_component(params.to_query)
   end
 
   private
diff --git a/activesupport/test/core_ext/range_ext_test.rb b/activesupport/test/core_ext/range_ext_test.rb
index 7c7a78f461..4b8efb8a93 100644
--- a/activesupport/test/core_ext/range_ext_test.rb
+++ b/activesupport/test/core_ext/range_ext_test.rb
@@ -108,14 +108,14 @@ class RangeTest < ActiveSupport::TestCase
   def test_each_on_time_with_zone
     twz = ActiveSupport::TimeWithZone.new(nil, ActiveSupport::TimeZone["Eastern Time (US & Canada)"], Time.utc(2006, 11, 28, 10, 30))
     assert_raises TypeError do
-      ((twz - 1.hour)..twz).each {}
+      ((twz - 1.hour)..twz).each { }
     end
   end
 
   def test_step_on_time_with_zone
     twz = ActiveSupport::TimeWithZone.new(nil, ActiveSupport::TimeZone["Eastern Time (US & Canada)"], Time.utc(2006, 11, 28, 10, 30))
     assert_raises TypeError do
-      ((twz - 1.hour)..twz).step(1) {}
+      ((twz - 1.hour)..twz).step(1) { }
     end
   end
 
@@ -131,11 +131,11 @@ class RangeTest < ActiveSupport::TestCase
 
   def test_date_time_with_each
     datetime = DateTime.now
-    assert(((datetime - 1.hour)..datetime).each {})
+    assert(((datetime - 1.hour)..datetime).each { })
   end
 
   def test_date_time_with_step
     datetime = DateTime.now
-    assert(((datetime - 1.hour)..datetime).step(1) {})
+    assert(((datetime - 1.hour)..datetime).step(1) { })
   end
 end
diff --git a/activesupport/test/core_ext/string_ext_test.rb b/activesupport/test/core_ext/string_ext_test.rb
index b8de16cc5e..2468fe3603 100644
--- a/activesupport/test/core_ext/string_ext_test.rb
+++ b/activesupport/test/core_ext/string_ext_test.rb
@@ -25,7 +25,7 @@ class StringInflectionsTest < ActiveSupport::TestCase
   end
 
   def test_strip_heredoc_on_a_frozen_string
-    assert "".freeze.strip_heredoc.frozen?
+    assert "".strip_heredoc.frozen?
   end
 
   def test_strip_heredoc_on_a_string_with_no_lines
@@ -245,8 +245,8 @@ class StringInflectionsTest < ActiveSupport::TestCase
   end
 
   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}.dup
+    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}
 
     expected = "A string surrounded by various unicode spaces, " \
       "with tabs( ), newlines( ), unicode nextlines( ) and many spaces( )."
@@ -378,8 +378,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 ...".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)
+    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)
   end
 
   def test_truncate_should_not_be_html_safe
@@ -400,7 +400,7 @@ class StringInflectionsTest < ActiveSupport::TestCase
   end
 
   def test_remove!
-    original = "This is a very good day to die".dup
+    original = +"This is a very good day to die"
     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/)
@@ -469,6 +469,15 @@ class StringAccessTest < ActiveSupport::TestCase
     assert_not_same different_string, string
   end
 
+  test "#first with negative Integer is deprecated" do
+    string = "hello"
+    message = "Calling String#first with a negative integer limit " \
+              "will raise an ArgumentError in Rails 6.1."
+    assert_deprecated(message) do
+      string.first(-1)
+    end
+  end
+
   test "#last returns the last character" do
     assert_equal "o", "hello".last
     assert_equal "x", "x".last
@@ -487,6 +496,15 @@ class StringAccessTest < ActiveSupport::TestCase
     assert_not_same different_string, string
   end
 
+  test "#last with negative Integer is deprecated" do
+    string = "hello"
+    message = "Calling String#last with a negative integer limit " \
+              "will raise an ArgumentError in Rails 6.1."
+    assert_deprecated(message) do
+      string.last(-1)
+    end
+  end
+
   test "access returns a real string" do
     hash = {}
     hash["h"] = true
@@ -733,7 +751,7 @@ end
 
 class OutputSafetyTest < ActiveSupport::TestCase
   def setup
-    @string = "hello".dup
+    @string = +"hello"
     @object = Class.new(Object) do
       def to_s
         "other"
@@ -809,7 +827,7 @@ class OutputSafetyTest < ActiveSupport::TestCase
   end
 
   test "Concatting safe onto unsafe yields unsafe" do
-    @other_string = "other".dup
+    @other_string = +"other"
 
     string = @string.html_safe
     @other_string.concat(string)
@@ -832,7 +850,7 @@ class OutputSafetyTest < ActiveSupport::TestCase
   end
 
   test "Concatting safe onto unsafe with << yields unsafe" do
-    @other_string = "other".dup
+    @other_string = +"other"
     string = @string.html_safe
 
     @other_string << string
@@ -888,7 +906,55 @@ 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".dup.concat(13), string
+    assert_equal (+"hello").concat(13), string
+    assert_predicate string, :html_safe?
+  end
+
+  test "Inserting safe into safe yields safe" do
+    string = "foo".html_safe
+    string.insert(0, "<b>".html_safe)
+
+    assert_equal "<b>foo", string
+    assert_predicate string, :html_safe?
+  end
+
+  test "Inserting unsafe into safe yields escaped safe" do
+    string = "foo".html_safe
+    string.insert(0, "<b>")
+
+    assert_equal "&lt;b&gt;foo", string
+    assert_predicate string, :html_safe?
+  end
+
+  test "Replacing safe with safe yields safe" do
+    string = "foo".html_safe
+    string.replace("<b>".html_safe)
+
+    assert_equal "<b>", string
+    assert_predicate string, :html_safe?
+  end
+
+  test "Replacing safe with unsafe yields escaped safe" do
+    string = "foo".html_safe
+    string.replace("<b>")
+
+    assert_equal "&lt;b&gt;", string
+    assert_predicate string, :html_safe?
+  end
+
+  test "Replacing index of safe with safe yields safe" do
+    string = "foo".html_safe
+    string[0] = "<b>".html_safe
+
+    assert_equal "<b>oo", string
+    assert_predicate string, :html_safe?
+  end
+
+  test "Replacing index of safe with unsafe yields escaped safe" do
+    string = "foo".html_safe
+    string[0] = "<b>"
+
+    assert_equal "&lt;b&gt;oo", string
     assert_predicate string, :html_safe?
   end
 
diff --git a/activesupport/test/core_ext/time_ext_test.rb b/activesupport/test/core_ext/time_ext_test.rb
index e1cb22fda8..7078f3506d 100644
--- a/activesupport/test/core_ext/time_ext_test.rb
+++ b/activesupport/test/core_ext/time_ext_test.rb
@@ -950,39 +950,39 @@ class TimeExtCalculationsTest < ActiveSupport::TestCase
 end
 
 class TimeExtMarshalingTest < ActiveSupport::TestCase
-  def test_marshaling_with_utc_instance
+  def test_marshalling_with_utc_instance
     t = Time.utc(2000)
-    unmarshaled = Marshal.load(Marshal.dump(t))
-    assert_equal "UTC", unmarshaled.zone
-    assert_equal t, unmarshaled
+    unmarshalled = Marshal.load(Marshal.dump(t))
+    assert_equal "UTC", unmarshalled.zone
+    assert_equal t, unmarshalled
   end
 
-  def test_marshaling_with_local_instance
+  def test_marshalling_with_local_instance
     t = Time.local(2000)
-    unmarshaled = Marshal.load(Marshal.dump(t))
-    assert_equal t.zone, unmarshaled.zone
-    assert_equal t, unmarshaled
+    unmarshalled = Marshal.load(Marshal.dump(t))
+    assert_equal t.zone, unmarshalled.zone
+    assert_equal t, unmarshalled
   end
 
-  def test_marshaling_with_frozen_utc_instance
+  def test_marshalling_with_frozen_utc_instance
     t = Time.utc(2000).freeze
-    unmarshaled = Marshal.load(Marshal.dump(t))
-    assert_equal "UTC", unmarshaled.zone
-    assert_equal t, unmarshaled
+    unmarshalled = Marshal.load(Marshal.dump(t))
+    assert_equal "UTC", unmarshalled.zone
+    assert_equal t, unmarshalled
   end
 
-  def test_marshaling_with_frozen_local_instance
+  def test_marshalling_with_frozen_local_instance
     t = Time.local(2000).freeze
-    unmarshaled = Marshal.load(Marshal.dump(t))
-    assert_equal t.zone, unmarshaled.zone
-    assert_equal t, unmarshaled
+    unmarshalled = Marshal.load(Marshal.dump(t))
+    assert_equal t.zone, unmarshalled.zone
+    assert_equal t, unmarshalled
   end
 
   def test_marshalling_preserves_fractional_seconds
     t = Time.parse("00:00:00.500")
-    unmarshaled = Marshal.load(Marshal.dump(t))
-    assert_equal t.to_f, unmarshaled.to_f
-    assert_equal t, unmarshaled
+    unmarshalled = Marshal.load(Marshal.dump(t))
+    assert_equal t.to_f, unmarshalled.to_f
+    assert_equal t, unmarshalled
   end
 
   def test_last_quarter_on_31st
diff --git a/activesupport/test/core_ext/time_with_zone_test.rb b/activesupport/test/core_ext/time_with_zone_test.rb
index e650209268..f6e836e446 100644
--- a/activesupport/test/core_ext/time_with_zone_test.rb
+++ b/activesupport/test/core_ext/time_with_zone_test.rb
@@ -1105,7 +1105,7 @@ class TimeWithZoneMethodsForTimeAndDateTimeTest < ActiveSupport::TestCase
   def test_use_zone_raises_on_invalid_timezone
     Time.zone = "Alaska"
     assert_raise ArgumentError do
-      Time.use_zone("No such timezone exists") {}
+      Time.use_zone("No such timezone exists") { }
     end
     assert_equal ActiveSupport::TimeZone["Alaska"], Time.zone
   end
diff --git a/activesupport/test/dependencies_test.rb b/activesupport/test/dependencies_test.rb
index 84cb64a7c2..e144971e9f 100644
--- a/activesupport/test/dependencies_test.rb
+++ b/activesupport/test/dependencies_test.rb
@@ -816,7 +816,7 @@ class DependenciesTest < ActiveSupport::TestCase
   end
 
   def test_new_contants_in_without_constants
-    assert_equal [], (ActiveSupport::Dependencies.new_constants_in(Object) {})
+    assert_equal [], (ActiveSupport::Dependencies.new_constants_in(Object) { })
     assert ActiveSupport::Dependencies.constant_watch_stack.all? { |k, v| v.empty? }
   end
 
@@ -892,7 +892,7 @@ class DependenciesTest < ActiveSupport::TestCase
 
   def test_new_constants_in_with_illegal_module_name_raises_correct_error
     assert_raise(NameError) do
-      ActiveSupport::Dependencies.new_constants_in("Illegal-Name") {}
+      ActiveSupport::Dependencies.new_constants_in("Illegal-Name") { }
     end
   end
 
@@ -1130,3 +1130,52 @@ class DependenciesTest < ActiveSupport::TestCase
     ActiveSupport::Dependencies.hook!
   end
 end
+
+class DependenciesLogging < ActiveSupport::TestCase
+  MESSAGE = "message"
+
+  def with_settings(logger, verbose)
+    original_logger = ActiveSupport::Dependencies.logger
+    original_verbose = ActiveSupport::Dependencies.verbose
+
+    ActiveSupport::Dependencies.logger = logger
+    ActiveSupport::Dependencies.verbose = verbose
+
+    yield
+  ensure
+    ActiveSupport::Dependencies.logger = original_logger
+    ActiveSupport::Dependencies.verbose = original_verbose
+  end
+
+  def fake_logger
+    Class.new do
+      def self.debug(message)
+        message
+      end
+    end
+  end
+
+  test "does not log if the logger is nil and verbose is false" do
+    with_settings(nil, false) do
+      assert_nil ActiveSupport::Dependencies.log(MESSAGE)
+    end
+  end
+
+  test "does not log if the logger is nil and verbose is true" do
+    with_settings(nil, true) do
+      assert_nil ActiveSupport::Dependencies.log(MESSAGE)
+    end
+  end
+
+  test "does not log if the logger is set and verbose is false" do
+    with_settings(fake_logger, false) do
+      assert_nil ActiveSupport::Dependencies.log(MESSAGE)
+    end
+  end
+
+  test "logs if the logger is set and verbose is true" do
+    with_settings(fake_logger, true) do
+      assert_equal "autoloading: #{MESSAGE}", ActiveSupport::Dependencies.log(MESSAGE)
+    end
+  end
+end
diff --git a/activesupport/test/evented_file_update_checker_test.rb b/activesupport/test/evented_file_update_checker_test.rb
index d3af0dbef3..a557608986 100644
--- a/activesupport/test/evented_file_update_checker_test.rb
+++ b/activesupport/test/evented_file_update_checker_test.rb
@@ -38,7 +38,7 @@ class EventedFileUpdateCheckerTest < ActiveSupport::TestCase
 
     FileUtils.touch(tmpfiles)
 
-    checker = new_checker(tmpfiles) {}
+    checker = new_checker(tmpfiles) { }
     assert_not_predicate checker, :updated?
 
     # Pipes used for flow control across fork.
diff --git a/activesupport/test/executor_test.rb b/activesupport/test/executor_test.rb
index af441064dd..3026f002c3 100644
--- a/activesupport/test/executor_test.rb
+++ b/activesupport/test/executor_test.rb
@@ -23,7 +23,7 @@ class ExecutorTest < ActiveSupport::TestCase
     executor.to_run { @foo = true }
     executor.to_complete { result = @foo }
 
-    executor.wrap {}
+    executor.wrap { }
 
     assert result
   end
@@ -85,7 +85,7 @@ class ExecutorTest < ActiveSupport::TestCase
 
     executor.register_hook(hook)
 
-    executor.wrap {}
+    executor.wrap { }
 
     assert_equal :some_state, supplied_state
   end
@@ -105,7 +105,7 @@ class ExecutorTest < ActiveSupport::TestCase
 
     executor.register_hook(hook)
 
-    executor.wrap {}
+    executor.wrap { }
 
     assert_nil supplied_state
   end
@@ -129,7 +129,7 @@ class ExecutorTest < ActiveSupport::TestCase
     executor.register_hook(hook)
 
     assert_raises(DummyError) do
-      executor.wrap {}
+      executor.wrap { }
     end
 
     assert_equal :none, supplied_state
@@ -154,7 +154,7 @@ class ExecutorTest < ActiveSupport::TestCase
     end
 
     assert_raises(DummyError) do
-      executor.wrap {}
+      executor.wrap { }
     end
 
     assert_equal :some_state, supplied_state
@@ -187,7 +187,7 @@ class ExecutorTest < ActiveSupport::TestCase
     executor.register_hook(hook_class.new(:c), outer: true)
     executor.register_hook(hook_class.new(:d))
 
-    executor.wrap {}
+    executor.wrap { }
 
     assert_equal [:run_c, :run_a, :run_b, :run_d, :complete_a, :complete_b, :complete_d, :complete_c], invoked
     assert_equal [:state_a, :state_b, :state_d, :state_c], supplied_state
@@ -209,9 +209,9 @@ class ExecutorTest < ActiveSupport::TestCase
     executor.register_hook(hook)
 
     before = RubyVM.stat(:class_serial)
-    executor.wrap {}
-    executor.wrap {}
-    executor.wrap {}
+    executor.wrap { }
+    executor.wrap { }
+    executor.wrap { }
     after = RubyVM.stat(:class_serial)
 
     assert_equal before, after
diff --git a/activesupport/test/hash_with_indifferent_access_test.rb b/activesupport/test/hash_with_indifferent_access_test.rb
index eebff18ef1..af67ed21c8 100644
--- a/activesupport/test/hash_with_indifferent_access_test.rb
+++ b/activesupport/test/hash_with_indifferent_access_test.rb
@@ -672,6 +672,17 @@ class HashWithIndifferentAccessTest < ActiveSupport::TestCase
     assert_equal "bender", slice["login"]
   end
 
+  def test_indifferent_without
+    original = { a: "x", b: "y", c: 10 }.with_indifferent_access
+    expected = { c: 10 }.with_indifferent_access
+
+    [["a", "b"], [:a, :b]].each do |keys|
+      # Should return a new hash without the given keys.
+      assert_equal expected, original.without(*keys), keys.inspect
+      assert_not_equal expected, original
+    end
+  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
diff --git a/activesupport/test/key_generator_test.rb b/activesupport/test/key_generator_test.rb
index cdde2c573a..9dfc0b2154 100644
--- a/activesupport/test/key_generator_test.rb
+++ b/activesupport/test/key_generator_test.rb
@@ -9,9 +9,6 @@ rescue LoadError, NameError
   $stderr.puts "Skipping KeyGenerator test: broken OpenSSL install"
 else
 
-  require "active_support/time"
-  require "active_support/json"
-
   class KeyGeneratorTest < ActiveSupport::TestCase
     def setup
       @secret    = SecureRandom.hex(64)
diff --git a/activesupport/test/logger_test.rb b/activesupport/test/logger_test.rb
index 773b0daa1d..160e1156b6 100644
--- a/activesupport/test/logger_test.rb
+++ b/activesupport/test/logger_test.rb
@@ -40,7 +40,7 @@ class LoggerTest < ActiveSupport::TestCase
     logger = Logger.new f
     logger.level = Logger::DEBUG
 
-    str = "\x80".dup
+    str = +"\x80"
     str.force_encoding("ASCII-8BIT")
 
     logger.add Logger::DEBUG, str
@@ -58,7 +58,7 @@ class LoggerTest < ActiveSupport::TestCase
     logger = Logger.new f
     logger.level = Logger::DEBUG
 
-    str = "\x80".dup
+    str = +"\x80"
     str.force_encoding("ASCII-8BIT")
 
     logger.add Logger::DEBUG, str
diff --git a/activesupport/test/metadata/shared_metadata_tests.rb b/activesupport/test/metadata/shared_metadata_tests.rb
index 08bb0c648e..cf571223e5 100644
--- a/activesupport/test/metadata/shared_metadata_tests.rb
+++ b/activesupport/test/metadata/shared_metadata_tests.rb
@@ -1,11 +1,6 @@
 # frozen_string_literal: true
 
 module SharedMessageMetadataTests
-  def teardown
-    travel_back
-    super
-  end
-
   def null_serializing?
     false
   end
diff --git a/activesupport/test/multibyte_chars_test.rb b/activesupport/test/multibyte_chars_test.rb
index 061446c782..11c4822748 100644
--- a/activesupport/test/multibyte_chars_test.rb
+++ b/activesupport/test/multibyte_chars_test.rb
@@ -53,7 +53,7 @@ class MultibyteCharsTest < ActiveSupport::TestCase
   end
 
   def test_forwarded_method_with_non_string_result_should_be_returned_verbatim
-    str = "".dup
+    str = +""
     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 }
 
@@ -61,14 +61,14 @@ class MultibyteCharsTest < ActiveSupport::TestCase
   end
 
   def test_should_concatenate
-    mb_a = "a".dup.mb_chars
-    mb_b = "b".dup.mb_chars
+    mb_a = (+"a").mb_chars
+    mb_b = (+"b").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".dup << mb_b
+    assert_equal "ab", (+"a") << mb_b
     assert_equal "abb", mb_a << mb_b
   end
 
@@ -80,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".dup.mb_chars << "b").class
+    assert_equal ActiveSupport::Multibyte.proxy_class, ((+"a").mb_chars << "b").class
   end
 
   def test_ascii_strings_are_treated_at_utf8_strings
@@ -90,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".dup.mb_chars << "b").kind_of?(@proxy_class))
-    assert(("a".dup.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))
   end
 
   def test_should_return_string_as_json
@@ -135,7 +135,7 @@ class MultibyteCharsUTF8BehaviourTest < ActiveSupport::TestCase
   end
 
   def test_tidy_bytes_bang_should_change_wrapped_string
-    original = " Un bUen café \x92".dup
+    original = +" Un bUen café \x92"
     proxy = chars(original.dup)
     proxy.tidy_bytes!
     assert_not_equal original, proxy.to_s
@@ -152,7 +152,7 @@ class MultibyteCharsUTF8BehaviourTest < ActiveSupport::TestCase
   end
 
   def test_string_methods_are_chainable
-    assert chars("".dup).insert(0, "").kind_of?(ActiveSupport::Multibyte.proxy_class)
+    assert chars(+"").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)
@@ -197,7 +197,7 @@ class MultibyteCharsUTF8BehaviourTest < ActiveSupport::TestCase
   end
 
   def test_should_use_character_offsets_for_insert_offsets
-    assert_equal "", "".dup.mb_chars.insert(0, "")
+    assert_equal "", (+"").mb_chars.insert(0, "")
     assert_equal "こわにちわ", @chars.insert(1, "わ")
     assert_equal "こわわわにちわ", @chars.insert(2, "わわ")
     assert_equal "わこわわわにちわ", @chars.insert(0, "わ")
@@ -420,13 +420,13 @@ class MultibyteCharsUTF8BehaviourTest < ActiveSupport::TestCase
   end
 
   def test_slice_bang_removes_the_slice_from_the_receiver
-    chars = "úüù".dup.mb_chars
+    chars = (+"úüù").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 = "úüù".dup
+    string = +"úüù"
     chars = string.mb_chars
     assert_nil chars.slice!(4, 5)
     assert_equal "úüù", chars
diff --git a/activesupport/test/multibyte_test_helpers.rb b/activesupport/test/multibyte_test_helpers.rb
index 98f36aa939..7565655f25 100644
--- a/activesupport/test/multibyte_test_helpers.rb
+++ b/activesupport/test/multibyte_test_helpers.rb
@@ -27,9 +27,9 @@ module MultibyteTestHelpers
   CACHE_DIR = "#{Dir.tmpdir}/cache/unicode_conformance/#{ActiveSupport::Multibyte::Unicode::UNICODE_VERSION}"
   FileUtils.mkdir_p(CACHE_DIR)
 
-  UNICODE_STRING = "こにちわ".freeze
-  ASCII_STRING = "ohayo".freeze
-  BYTE_STRING = "\270\236\010\210\245".dup.force_encoding("ASCII-8BIT").freeze
+  UNICODE_STRING = "こにちわ"
+  ASCII_STRING = "ohayo"
+  BYTE_STRING = (+"\270\236\010\210\245").force_encoding("ASCII-8BIT").freeze
 
   def chars(str)
     ActiveSupport::Multibyte::Chars.new(str)
diff --git a/activesupport/test/notifications_test.rb b/activesupport/test/notifications_test.rb
index 62817a839a..54fd4345fb 100644
--- a/activesupport/test/notifications_test.rb
+++ b/activesupport/test/notifications_test.rb
@@ -90,7 +90,7 @@ module Notifications
       ActiveSupport::Notifications.subscribe("foo", TestSubscriber.new)
 
       ActiveSupport::Notifications.instrument("foo") do
-        ActiveSupport::Notifications.subscribe("foo") {}
+        ActiveSupport::Notifications.subscribe("foo") { }
       end
     ensure
       ActiveSupport::Notifications.notifier = old_notifier
diff --git a/activesupport/test/reloader_test.rb b/activesupport/test/reloader_test.rb
index 976917c1a1..1b7cc253d9 100644
--- a/activesupport/test/reloader_test.rb
+++ b/activesupport/test/reloader_test.rb
@@ -35,13 +35,13 @@ class ReloaderTest < ActiveSupport::TestCase
     r = new_reloader { true }
     invoked = false
     r.to_run { invoked = true }
-    r.wrap {}
+    r.wrap { }
     assert invoked
 
     r = new_reloader { false }
     invoked = false
     r.to_run { invoked = true }
-    r.wrap {}
+    r.wrap { }
     assert_not invoked
   end
 
@@ -53,7 +53,7 @@ class ReloaderTest < ActiveSupport::TestCase
     reloader.executor.to_run { called << :executor_run }
     reloader.executor.to_complete { called << :executor_complete }
 
-    reloader.wrap {}
+    reloader.wrap { }
     assert_equal [:executor_run, :reloader_run, :prepare, :reloader_complete, :executor_complete], called
 
     called = []
@@ -63,7 +63,7 @@ class ReloaderTest < ActiveSupport::TestCase
     reloader.check = lambda { false }
 
     called = []
-    reloader.wrap {}
+    reloader.wrap { }
     assert_equal [:executor_run, :executor_complete], called
 
     called = []
diff --git a/activesupport/test/safe_buffer_test.rb b/activesupport/test/safe_buffer_test.rb
index 9456bb8753..49a3951623 100644
--- a/activesupport/test/safe_buffer_test.rb
+++ b/activesupport/test/safe_buffer_test.rb
@@ -75,16 +75,41 @@ class SafeBufferTest < ActiveSupport::TestCase
     assert_equal "my_test", str
   end
 
-  test "Should not return safe buffer from gsub" do
-    altered_buffer = @buffer.gsub("", "asdf")
-    assert_equal "asdf", altered_buffer
-    assert_not_predicate altered_buffer, :html_safe?
-  end
+  {
+    capitalize: nil,
+    chomp: nil,
+    chop: nil,
+    delete: "foo",
+    delete_prefix: "foo",
+    delete_suffix: "foo",
+    downcase: nil,
+    gsub: ["foo", "bar"],
+    lstrip: nil,
+    next: nil,
+    reverse: nil,
+    rstrip: nil,
+    slice: "foo",
+    squeeze: nil,
+    strip: nil,
+    sub: ["foo", "bar"],
+    succ: nil,
+    swapcase: nil,
+    tr: ["foo", "bar"],
+    tr_s: ["foo", "bar"],
+    unicode_normalize: nil,
+    upcase: nil,
+  }.each do |unsafe_method, dummy_args|
+    test "Should not return safe buffer from #{unsafe_method}" do
+      skip unless String.method_defined?(unsafe_method)
+      altered_buffer = @buffer.send(unsafe_method, *dummy_args)
+      assert_not_predicate altered_buffer, :html_safe?
+    end
 
-  test "Should not return safe buffer from gsub!" do
-    @buffer.gsub!("", "asdf")
-    assert_equal "asdf", @buffer
-    assert_not_predicate @buffer, :html_safe?
+    test "Should not return safe buffer from #{unsafe_method}!" do
+      skip unless String.method_defined?("#{unsafe_method}!")
+      @buffer.send("#{unsafe_method}!", *dummy_args)
+      assert_not_predicate @buffer, :html_safe?
+    end
   end
 
   test "Should escape dirty buffers on add" do
@@ -150,6 +175,18 @@ class SafeBufferTest < ActiveSupport::TestCase
     assert_not y.html_safe?, "should not be safe"
   end
 
+  test "Should continue safe on slice" do
+    x = "<div>foo</div>".html_safe
+
+    assert_predicate x, :html_safe?
+
+    # getting a slice of it
+    y = x[0..-1]
+
+    # should still be safe
+    assert_predicate y, :html_safe?
+  end
+
   test "Should work with interpolation (array argument)" do
     x = "foo %s bar".html_safe % ["qux"]
     assert_equal "foo qux bar", x
diff --git a/activesupport/test/share_lock_test.rb b/activesupport/test/share_lock_test.rb
index 42fd5eefc1..34479020e1 100644
--- a/activesupport/test/share_lock_test.rb
+++ b/activesupport/test/share_lock_test.rb
@@ -11,29 +11,29 @@ class ShareLockTest < ActiveSupport::TestCase
 
   def test_reentrancy
     thread = Thread.new do
-      @lock.sharing   { @lock.sharing   {} }
-      @lock.exclusive { @lock.exclusive {} }
+      @lock.sharing   { @lock.sharing   { } }
+      @lock.exclusive { @lock.exclusive { } }
     end
     assert_threads_not_stuck thread
   end
 
   def test_sharing_doesnt_block
     with_thread_waiting_in_lock_section(:sharing) do |sharing_thread_latch|
-      assert_threads_not_stuck(Thread.new { @lock.sharing {} })
+      assert_threads_not_stuck(Thread.new { @lock.sharing { } })
     end
   end
 
   def test_sharing_blocks_exclusive
     with_thread_waiting_in_lock_section(:sharing) do |sharing_thread_release_latch|
       @lock.exclusive(no_wait: true) { flunk } # polling should fail
-      exclusive_thread = Thread.new { @lock.exclusive {} }
+      exclusive_thread = Thread.new { @lock.exclusive { } }
       assert_threads_stuck_but_releasable_by_latch exclusive_thread, sharing_thread_release_latch
     end
   end
 
   def test_exclusive_blocks_sharing
     with_thread_waiting_in_lock_section(:exclusive) do |exclusive_thread_release_latch|
-      sharing_thread = Thread.new { @lock.sharing {} }
+      sharing_thread = Thread.new { @lock.sharing { } }
       assert_threads_stuck_but_releasable_by_latch sharing_thread, exclusive_thread_release_latch
     end
   end
@@ -42,7 +42,7 @@ class ShareLockTest < ActiveSupport::TestCase
     with_thread_waiting_in_lock_section(:sharing) do |sharing_thread_release_latch|
       exclusive_threads = (1..2).map do
         Thread.new do
-          @lock.exclusive {}
+          @lock.exclusive { }
         end
       end
 
@@ -53,7 +53,7 @@ class ShareLockTest < ActiveSupport::TestCase
   def test_sharing_is_upgradeable_to_exclusive
     upgrading_thread = Thread.new do
       @lock.sharing do
-        @lock.exclusive {}
+        @lock.exclusive { }
       end
     end
     assert_threads_not_stuck upgrading_thread
@@ -66,7 +66,7 @@ class ShareLockTest < ActiveSupport::TestCase
       upgrading_thread = Thread.new do
         @lock.sharing do
           in_sharing.count_down
-          @lock.exclusive {}
+          @lock.exclusive { }
         end
       end
 
@@ -81,7 +81,7 @@ class ShareLockTest < ActiveSupport::TestCase
         exclusive_threads = (1..2).map do
           Thread.new do
             @lock.send(use_upgrading ? :sharing : :tap) do
-              @lock.exclusive(purpose: :load, compatible: [:load, :unload]) {}
+              @lock.exclusive(purpose: :load, compatible: [:load, :unload]) { }
             end
           end
         end
@@ -95,7 +95,7 @@ class ShareLockTest < ActiveSupport::TestCase
     with_thread_waiting_in_lock_section(:sharing) do |sharing_thread_release_latch|
       thread = Thread.new do
         @lock.sharing do
-          @lock.exclusive {}
+          @lock.exclusive { }
         end
       end
 
@@ -105,7 +105,7 @@ class ShareLockTest < ActiveSupport::TestCase
       sharing_thread_release_latch.count_down
 
       thread = Thread.new do
-        @lock.exclusive {}
+        @lock.exclusive { }
       end
 
       assert_threads_not_stuck thread
@@ -121,13 +121,13 @@ class ShareLockTest < ActiveSupport::TestCase
             Thread.new do
               @lock.send(use_upgrading ? :sharing : :tap) do
                 together.wait
-                @lock.exclusive(purpose: :red, compatible: [:green, :purple]) {}
+                @lock.exclusive(purpose: :red, compatible: [:green, :purple]) { }
               end
             end,
             Thread.new do
               @lock.send(use_upgrading ? :sharing : :tap) do
                 together.wait
-                @lock.exclusive(purpose: :blue, compatible: [:green]) {}
+                @lock.exclusive(purpose: :blue, compatible: [:green]) { }
               end
             end
           ]
@@ -138,7 +138,7 @@ class ShareLockTest < ActiveSupport::TestCase
           # a sharing block. While it's blocked, it holds no lock, so it
           # doesn't interfere with any other attempts.
           no_purpose_thread = Thread.new do
-            @lock.exclusive {}
+            @lock.exclusive { }
           end
           assert_threads_stuck no_purpose_thread
 
@@ -147,7 +147,7 @@ class ShareLockTest < ActiveSupport::TestCase
           # lock, but as soon as that's released, it can run --
           # regardless of whether those threads hold share locks.
           compatible_thread = Thread.new do
-            @lock.exclusive(purpose: :green, compatible: []) {}
+            @lock.exclusive(purpose: :green, compatible: []) { }
           end
           assert_threads_stuck compatible_thread
 
@@ -231,7 +231,7 @@ class ShareLockTest < ActiveSupport::TestCase
       assert_threads_stuck waiting_exclusive
 
       late_share_attempt = Thread.new do
-        @lock.sharing {}
+        @lock.sharing { }
       end
       assert_threads_stuck late_share_attempt
 
@@ -252,14 +252,14 @@ class ShareLockTest < ActiveSupport::TestCase
         @lock.sharing do
           ready.wait
           attempt_reentrancy.wait
-          @lock.sharing {}
+          @lock.sharing { }
         end
       end
 
       exclusive = Thread.new do
         @lock.sharing do
           ready.wait
-          @lock.exclusive {}
+          @lock.exclusive { }
         end
       end
 
@@ -280,7 +280,7 @@ class ShareLockTest < ActiveSupport::TestCase
       Thread.new do
         @lock.sharing do
           ready.wait
-          @lock.exclusive(purpose: :x, compatible: [:x], after_compatible: [:x]) {}
+          @lock.exclusive(purpose: :x, compatible: [:x], after_compatible: [:x]) { }
           done.wait
         end
       end
@@ -297,7 +297,7 @@ class ShareLockTest < ActiveSupport::TestCase
       Thread.new do
         @lock.sharing do
           ready.wait
-          @lock.exclusive(purpose: :x) {}
+          @lock.exclusive(purpose: :x) { }
           done.wait
         end
       end,
@@ -323,7 +323,7 @@ class ShareLockTest < ActiveSupport::TestCase
       Thread.new do
         @lock.sharing do
           ready.wait
-          @lock.exclusive(purpose: :x) {}
+          @lock.exclusive(purpose: :x) { }
           done.wait
         end
       end,
@@ -352,7 +352,7 @@ class ShareLockTest < ActiveSupport::TestCase
       Thread.new do
         @lock.sharing do
           ready.wait
-          @lock.exclusive(purpose: :x) {}
+          @lock.exclusive(purpose: :x) { }
           done.wait
         end
       end,
@@ -386,7 +386,7 @@ class ShareLockTest < ActiveSupport::TestCase
     incompatible_thread = Thread.new do
       @lock.sharing do
         ready.wait
-        @lock.exclusive(purpose: :x) {}
+        @lock.exclusive(purpose: :x) { }
       end
     end
 
@@ -418,7 +418,7 @@ class ShareLockTest < ActiveSupport::TestCase
 
     incompatible_thread = Thread.new do
       ready.wait
-      @lock.exclusive(purpose: :z) {}
+      @lock.exclusive(purpose: :z) { }
     end
 
     recursive_yield_shares_thread = Thread.new do
@@ -427,7 +427,7 @@ class ShareLockTest < ActiveSupport::TestCase
         @lock.yield_shares(compatible: [:y]) do
           do_nesting.wait
           @lock.sharing do
-            @lock.yield_shares(compatible: [:x, :y]) {}
+            @lock.yield_shares(compatible: [:x, :y]) { }
           end
           after_nesting.wait
         end
@@ -439,12 +439,12 @@ class ShareLockTest < ActiveSupport::TestCase
     assert_threads_stuck incompatible_thread
 
     compatible_thread = Thread.new do
-      @lock.exclusive(purpose: :y) {}
+      @lock.exclusive(purpose: :y) { }
     end
     assert_threads_not_stuck compatible_thread
 
     post_nesting_incompatible_thread = Thread.new do
-      @lock.exclusive(purpose: :x) {}
+      @lock.exclusive(purpose: :x) { }
     end
     assert_threads_stuck post_nesting_incompatible_thread
 
diff --git a/activesupport/test/tagged_logging_test.rb b/activesupport/test/tagged_logging_test.rb
index e2b41cf8ee..cff73472c3 100644
--- a/activesupport/test/tagged_logging_test.rb
+++ b/activesupport/test/tagged_logging_test.rb
@@ -19,9 +19,10 @@ class TaggedLoggingTest < ActiveSupport::TestCase
   test "sets logger.formatter if missing and extends it with a tagging API" do
     logger = Logger.new(StringIO.new)
     assert_nil logger.formatter
-    ActiveSupport::TaggedLogging.new(logger)
-    assert_not_nil logger.formatter
-    assert_respond_to logger.formatter, :tagged
+
+    other_logger = ActiveSupport::TaggedLogging.new(logger)
+    assert_not_nil other_logger.formatter
+    assert_respond_to other_logger.formatter, :tagged
   end
 
   test "tagged once" do
@@ -83,16 +84,28 @@ class TaggedLoggingTest < ActiveSupport::TestCase
   end
 
   test "keeps each tag in their own instance" do
-    @other_output = StringIO.new
-    @other_logger = ActiveSupport::TaggedLogging.new(MyLogger.new(@other_output))
+    other_output = StringIO.new
+    other_logger = ActiveSupport::TaggedLogging.new(MyLogger.new(other_output))
     @logger.tagged("OMG") do
-      @other_logger.tagged("BCX") do
+      other_logger.tagged("BCX") do
         @logger.info "Cool story"
-        @other_logger.info "Funky time"
+        other_logger.info "Funky time"
       end
     end
     assert_equal "[OMG] Cool story\n", @output.string
-    assert_equal "[BCX] Funky time\n", @other_output.string
+    assert_equal "[BCX] Funky time\n", other_output.string
+  end
+
+  test "does not share the same formatter instance of the original logger" do
+    other_logger = ActiveSupport::TaggedLogging.new(@logger)
+
+    @logger.tagged("OMG") do
+      other_logger.tagged("BCX") do
+        @logger.info "Cool story"
+        other_logger.info "Funky time"
+      end
+    end
+    assert_equal "[OMG] Cool story\n[BCX] Funky time\n", @output.string
   end
 
   test "cleans up the taggings on flush" do
diff --git a/activesupport/test/testing/method_call_assertions_test.rb b/activesupport/test/testing/method_call_assertions_test.rb
index 0500e47def..7438a0490e 100644
--- a/activesupport/test/testing/method_call_assertions_test.rb
+++ b/activesupport/test/testing/method_call_assertions_test.rb
@@ -36,6 +36,8 @@ class MethodCallAssertionsTest < ActiveSupport::TestCase
     assert_called(@object, :increment, returns: 10) do
       assert_equal 10, @object.increment
     end
+
+    assert_equal 1, @object.increment
   end
 
   def test_assert_called_failure
@@ -70,6 +72,14 @@ class MethodCallAssertionsTest < ActiveSupport::TestCase
     end
   end
 
+  def test_assert_called_with_arguments_and_returns
+    assert_called_with(@object, :<<, [ 2 ], returns: 10) do
+      assert_equal(10, @object << 2)
+    end
+
+    assert_nil(@object << 2)
+  end
+
   def test_assert_called_with_failure
     assert_raises(MockExpectationError) do
       assert_called_with(@object, :<<, [ 4567 ]) do
@@ -91,6 +101,65 @@ class MethodCallAssertionsTest < ActiveSupport::TestCase
     end
   end
 
+  def test_assert_called_on_instance_of_with_defaults_to_expect_once
+    assert_called_on_instance_of Level, :increment do
+      @object.increment
+    end
+  end
+
+  def test_assert_called_on_instance_of_more_than_once
+    assert_called_on_instance_of(Level, :increment, times: 2) do
+      @object.increment
+      @object.increment
+    end
+  end
+
+  def test_assert_called_on_instance_of_with_arguments
+    assert_called_on_instance_of(Level, :<<) do
+      @object << 2
+    end
+  end
+
+  def test_assert_called_on_instance_of_returns
+    assert_called_on_instance_of(Level, :increment, returns: 10) do
+      assert_equal 10, @object.increment
+    end
+
+    assert_equal 1, @object.increment
+  end
+
+  def test_assert_called_on_instance_of_failure
+    error = assert_raises(Minitest::Assertion) do
+      assert_called_on_instance_of(Level, :increment) do
+        # Call nothing...
+      end
+    end
+
+    assert_equal "Expected increment to be called 1 times, but was called 0 times.\nExpected: 1\n  Actual: 0", error.message
+  end
+
+  def test_assert_called_on_instance_of_with_message
+    error = assert_raises(Minitest::Assertion) do
+      assert_called_on_instance_of(Level, :increment, "dang it") do
+        # Call nothing...
+      end
+    end
+
+    assert_match(/dang it.\nExpected increment/, error.message)
+  end
+
+  def test_assert_called_on_instance_of_nesting
+    assert_called_on_instance_of(Level, :increment, times: 3) do
+      assert_called_on_instance_of(Level, :decrement, times: 2) do
+        @object.increment
+        @object.decrement
+        @object.increment
+        @object.decrement
+        @object.increment
+      end
+    end
+  end
+
   def test_assert_not_called
     assert_not_called(@object, :decrement) do
       @object.increment
@@ -107,6 +176,30 @@ class MethodCallAssertionsTest < ActiveSupport::TestCase
     assert_equal "Expected increment to be called 0 times, but was called 1 times.\nExpected: 0\n  Actual: 1", error.message
   end
 
+  def test_assert_not_called_on_instance_of
+    assert_not_called_on_instance_of(Level, :decrement) do
+      @object.increment
+    end
+  end
+
+  def test_assert_not_called_on_instance_of_failure
+    error = assert_raises(Minitest::Assertion) do
+      assert_not_called_on_instance_of(Level, :increment) do
+        @object.increment
+      end
+    end
+
+    assert_equal "Expected increment to be called 0 times, but was called 1 times.\nExpected: 0\n  Actual: 1", error.message
+  end
+
+  def test_assert_not_called_on_instance_of_nesting
+    assert_not_called_on_instance_of(Level, :increment) do
+      assert_not_called_on_instance_of(Level, :decrement) do
+        # Call nothing...
+      end
+    end
+  end
+
   def test_stub_any_instance
     stub_any_instance(Level) do |instance|
       assert_equal instance, Level.new
diff --git a/activesupport/test/time_travel_test.rb b/activesupport/test/time_travel_test.rb
index 9c2c635f43..8c47f2cdc7 100644
--- a/activesupport/test/time_travel_test.rb
+++ b/activesupport/test/time_travel_test.rb
@@ -186,4 +186,8 @@ class TimeTravelTest < ActiveSupport::TestCase
 
     assert_operator expected_time.to_s(:db), :<, Time.now.to_s(:db)
   end
+
+  def test_time_helper_unfreeze_time
+    assert_equal method(:travel_back), method(:unfreeze_time)
+  end
 end
diff --git a/activesupport/test/xml_mini/rexml_engine_test.rb b/activesupport/test/xml_mini/rexml_engine_test.rb
index 34bf81fa75..b711619ba7 100644
--- a/activesupport/test/xml_mini/rexml_engine_test.rb
+++ b/activesupport/test/xml_mini/rexml_engine_test.rb
@@ -12,7 +12,7 @@ class REXMLEngineTest < XMLMiniEngineTest
   end
 
   def test_parse_from_frozen_string
-    xml_string = "<root></root>".freeze
+    xml_string = "<root></root>"
     assert_equal({ "root" => {} }, ActiveSupport::XmlMini.parse(xml_string))
   end
 
diff --git a/activesupport/test/xml_mini/xml_mini_engine_test.rb b/activesupport/test/xml_mini/xml_mini_engine_test.rb
index 5c4c28d9b7..c62e7e32c9 100644
--- a/activesupport/test/xml_mini/xml_mini_engine_test.rb
+++ b/activesupport/test/xml_mini/xml_mini_engine_test.rb
@@ -78,7 +78,7 @@ class XMLMiniEngineTest < ActiveSupport::TestCase
     end
 
     def test_parse_from_frozen_string
-      xml_string = "<root/>".freeze
+      xml_string = "<root/>"
       assert_equal({ "root" => {} }, ActiveSupport::XmlMini.parse(xml_string))
     end