Merge branch 'master' into feature/reselect-method

86 files changed, 855 insertions, 260 deletions

diff --git a/activesupport/CHANGELOG.md b/activesupport/CHANGELOG.md
index 5423d59984..fd96c46814 100644
--- a/activesupport/CHANGELOG.md
+++ b/activesupport/CHANGELOG.md
@@ -1,3 +1,55 @@
+*   Deprecate using negative limits in `String#first` and `String#last`.
+
+    *Gannon McGibbon*, *Eric Turner*
+
+*   Fix bug where `#without` for `ActiveSupport::HashWithIndifferentAccess` would fail
+    with symbol arguments
+
+    *Abraham Chan*
+
+*   Treat `#delete_prefix`, `#delete_suffix` and `#unicode_normalize` results as non-`html_safe`.
+    Ensure safety of arguments for `#insert`, `#[]=` and `#replace` calls on `html_safe` Strings.
+
+    *Janosch Müller*
+
+*   Changed `ActiveSupport::TaggedLogging.new` to return a new logger instance instead
+    of mutating the one received as parameter.
+
+    *Thierry Joyal*
+
+*   Define `unfreeze_time` as an alias of `travel_back` in `ActiveSupport::Testing::TimeHelpers`.
+
+    The alias is provided for symmetry with `freeze_time`.
+
+    *Ryan Davidson*
+
+*   Add support for tracing constant autoloads. Just throw
+
+        ActiveSupport::Dependencies.logger = Rails.logger
+        ActiveSupport::Dependencies.verbose = true
+
+    in an initializer.
+
+    *Xavier Noria*
+
+*   Maintain `html_safe?` on html_safe strings when sliced.
+
+        string = "<div>test</div>".html_safe
+        string[-1..1].html_safe? # => true
+
+    *Elom Gomez*, *Yumin Wong*
+
+*   Add `Array#extract!`.
+
+    The method removes and returns the elements for which the block returns a true value.
+    If no block is given, an Enumerator is returned instead.
+
+        numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+        odd_numbers = numbers.extract! { |number| number.odd? } # => [1, 3, 5, 7, 9]
+        numbers # => [0, 2, 4, 6, 8]
+
+    *bogdanvlviv*
+
 *   Support not to cache `nil` for `ActiveSupport::Cache#fetch`.
 
         cache.fetch('bar', skip_nil: true) { nil }
@@ -39,7 +91,7 @@
 
     *Aaron "t.lo" Patterson*
 
-*   Add cpu_time, idle_time, and allocations to Event
+*   Add cpu_time, idle_time, and allocations to Event.
 
     *Eileen M. Uchitelle*, *Aaron Patterson*
 
@@ -53,7 +105,7 @@
 
     *Jason Lee*
 
-*   Allow Range#=== and Range#cover? on Range
+*   Allow `Range#===` and `Range#cover?` on Range.
 
     `Range#cover?` can now accept a range argument like `Range#include?` and
     `Range#===`. `Range#===` works correctly on Ruby 2.6. `Range#include?` is moved
@@ -96,7 +148,7 @@
 
     *Godfrey Chan*
 
-*   Fix bug where `URI.unscape` would fail with mixed Unicode/escaped character input:
+*   Fix bug where `URI.unescape` would fail with mixed Unicode/escaped character input:
 
         URI.unescape("\xe3\x83\x90")  # => "バ"
         URI.unescape("%E3%83%90")  # => "バ"
diff --git a/activesupport/lib/active_support/backtrace_cleaner.rb b/activesupport/lib/active_support/backtrace_cleaner.rb
index 16dd733ddb..62973eca58 100644
--- a/activesupport/lib/active_support/backtrace_cleaner.rb
+++ b/activesupport/lib/active_support/backtrace_cleaner.rb
@@ -31,6 +31,9 @@ module ActiveSupport
   class BacktraceCleaner
     def initialize
       @filters, @silencers = [], []
+      add_gem_filter
+      add_gem_silencer
+      add_stdlib_silencer
     end
 
     # Returns the backtrace after all filters and silencers have been run
@@ -82,6 +85,26 @@ module ActiveSupport
     end
 
     private
+
+      FORMATTED_GEMS_PATTERN = /\A[^\/]+ \([\w.]+\) /
+
+      def add_gem_filter
+        gems_paths = (Gem.path | [Gem.default_dir]).map { |p| Regexp.escape(p) }
+        return if gems_paths.empty?
+
+        gems_regexp = %r{(#{gems_paths.join('|')})/(bundler/)?gems/([^/]+)-([\w.]+)/(.*)}
+        gems_result = '\3 (\4) \5'
+        add_filter { |line| line.sub(gems_regexp, gems_result) }
+      end
+
+      def add_gem_silencer
+        add_silencer { |line| FORMATTED_GEMS_PATTERN.match?(line) }
+      end
+
+      def add_stdlib_silencer
+        add_silencer { |line| line.start_with?(RbConfig::CONFIG["rubylibdir"]) }
+      end
+
       def filter_backtrace(backtrace)
         @filters.each do |f|
           backtrace = backtrace.map { |line| f.call(line) }
diff --git a/activesupport/lib/active_support/cache.rb b/activesupport/lib/active_support/cache.rb
index 8e516de4c9..a5d0c52b13 100644
--- a/activesupport/lib/active_support/cache.rb
+++ b/activesupport/lib/active_support/cache.rb
@@ -694,7 +694,7 @@ module ActiveSupport
         end
 
         def get_entry_value(entry, name, options)
-          instrument(:fetch_hit, name, options) {}
+          instrument(:fetch_hit, name, options) { }
           entry.value
         end
 
diff --git a/activesupport/lib/active_support/cache/file_store.rb b/activesupport/lib/active_support/cache/file_store.rb
index a0f44aac0f..53a2b07536 100644
--- a/activesupport/lib/active_support/cache/file_store.rb
+++ b/activesupport/lib/active_support/cache/file_store.rb
@@ -26,6 +26,11 @@ module ActiveSupport
         @cache_path = cache_path.to_s
       end
 
+      # Advertise cache versioning support.
+      def self.supports_cache_versioning?
+        true
+      end
+
       # Deletes all items from the cache. In this case it deletes all the entries in the specified
       # file store directory except for .keep or .gitkeep. Be careful which directory is specified in your
       # config file when using +FileStore+ because everything in that directory will be deleted.
@@ -127,15 +132,19 @@ module ActiveSupport
           hash = Zlib.adler32(fname)
           hash, dir_1 = hash.divmod(0x1000)
           dir_2 = hash.modulo(0x1000)
-          fname_paths = []
 
           # Make sure file name doesn't exceed file system limits.
-          begin
-            fname_paths << fname[0, FILENAME_MAX_SIZE]
-            fname = fname[FILENAME_MAX_SIZE..-1]
-          end until fname.blank?
+          if fname.length < FILENAME_MAX_SIZE
+            fname_paths = fname
+          else
+            fname_paths = []
+            begin
+              fname_paths << fname[0, FILENAME_MAX_SIZE]
+              fname = fname[FILENAME_MAX_SIZE..-1]
+            end until fname.blank?
+          end
 
-          File.join(cache_path, DIR_FORMATTER % dir_1, DIR_FORMATTER % dir_2, *fname_paths)
+          File.join(cache_path, DIR_FORMATTER % dir_1, DIR_FORMATTER % dir_2, fname_paths)
         end
 
         # Translate a file path into a key.
diff --git a/activesupport/lib/active_support/cache/mem_cache_store.rb b/activesupport/lib/active_support/cache/mem_cache_store.rb
index 2840781dde..174c784deb 100644
--- a/activesupport/lib/active_support/cache/mem_cache_store.rb
+++ b/activesupport/lib/active_support/cache/mem_cache_store.rb
@@ -47,6 +47,11 @@ module ActiveSupport
           end
       end
 
+      # Advertise cache versioning support.
+      def self.supports_cache_versioning?
+        true
+      end
+
       prepend Strategy::LocalCache
       prepend LocalCacheWithRaw
 
diff --git a/activesupport/lib/active_support/cache/memory_store.rb b/activesupport/lib/active_support/cache/memory_store.rb
index 564ac17241..106b616529 100644
--- a/activesupport/lib/active_support/cache/memory_store.rb
+++ b/activesupport/lib/active_support/cache/memory_store.rb
@@ -30,6 +30,11 @@ module ActiveSupport
         @pruning = false
       end
 
+      # Advertise cache versioning support.
+      def self.supports_cache_versioning?
+        true
+      end
+
       # Delete all data stored in a given cache store.
       def clear(options = nil)
         synchronize do
diff --git a/activesupport/lib/active_support/cache/null_store.rb b/activesupport/lib/active_support/cache/null_store.rb
index 1a5983db43..8452a28fd8 100644
--- a/activesupport/lib/active_support/cache/null_store.rb
+++ b/activesupport/lib/active_support/cache/null_store.rb
@@ -12,6 +12,11 @@ module ActiveSupport
     class NullStore < Store
       prepend Strategy::LocalCache
 
+      # Advertise cache versioning support.
+      def self.supports_cache_versioning?
+        true
+      end
+
       def clear(options = nil)
       end
 
diff --git a/activesupport/lib/active_support/cache/redis_cache_store.rb b/activesupport/lib/active_support/cache/redis_cache_store.rb
index 5737450b4a..9a55e49e27 100644
--- a/activesupport/lib/active_support/cache/redis_cache_store.rb
+++ b/activesupport/lib/active_support/cache/redis_cache_store.rb
@@ -66,6 +66,11 @@ module ActiveSupport
       SCAN_BATCH_SIZE = 1000
       private_constant :SCAN_BATCH_SIZE
 
+      # Advertise cache versioning support.
+      def self.supports_cache_versioning?
+        true
+      end
+
       # Support raw values in the local cache strategy.
       module LocalCacheWithRaw # :nodoc:
         private
diff --git a/activesupport/lib/active_support/callbacks.rb b/activesupport/lib/active_support/callbacks.rb
index c266b432c0..487fe79f41 100644
--- a/activesupport/lib/active_support/callbacks.rb
+++ b/activesupport/lib/active_support/callbacks.rb
@@ -657,9 +657,17 @@ module ActiveSupport
         # * <tt>:if</tt> - A symbol or an array of symbols, each naming an instance
         #   method or a proc; the callback will be called only when they all return
         #   a true value.
+        #
+        #   If a proc is given, its body is evaluated in the context of the
+        #   current object. It can also optionally accept the current object as
+        #   an argument.
         # * <tt>:unless</tt> - A symbol or an array of symbols, each naming an
         #   instance method or a proc; the callback will be called only when they
         #   all return a false value.
+        #
+        #   If a proc is given, its body is evaluated in the context of the
+        #   current object. It can also optionally accept the current object as
+        #   an argument.
         # * <tt>:prepend</tt> - If +true+, the callback will be prepended to the
         #   existing chain rather than appended.
         def set_callback(name, *filter_list, &block)
diff --git a/activesupport/lib/active_support/core_ext/array.rb b/activesupport/lib/active_support/core_ext/array.rb
index 6d83b76882..a2569c798b 100644
--- a/activesupport/lib/active_support/core_ext/array.rb
+++ b/activesupport/lib/active_support/core_ext/array.rb
@@ -3,6 +3,7 @@
 require "active_support/core_ext/array/wrap"
 require "active_support/core_ext/array/access"
 require "active_support/core_ext/array/conversions"
+require "active_support/core_ext/array/extract"
 require "active_support/core_ext/array/extract_options"
 require "active_support/core_ext/array/grouping"
 require "active_support/core_ext/array/prepend_and_append"
diff --git a/activesupport/lib/active_support/core_ext/array/extract.rb b/activesupport/lib/active_support/core_ext/array/extract.rb
new file mode 100644
index 0000000000..cc5a8a3f88
--- /dev/null
+++ b/activesupport/lib/active_support/core_ext/array/extract.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Array
+  # Removes and returns the elements for which the block returns a true value.
+  # If no block is given, an Enumerator is returned instead.
+  #
+  #   numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+  #   odd_numbers = numbers.extract! { |number| number.odd? } # => [1, 3, 5, 7, 9]
+  #   numbers # => [0, 2, 4, 6, 8]
+  def extract!
+    return to_enum(:extract!) { size } unless block_given?
+
+    extracted_elements = []
+
+    reject! do |element|
+      extracted_elements << element if yield(element)
+    end
+
+    extracted_elements
+  end
+end
diff --git a/activesupport/lib/active_support/core_ext/class/subclasses.rb b/activesupport/lib/active_support/core_ext/class/subclasses.rb
index 75e65337b7..56fb46a88d 100644
--- a/activesupport/lib/active_support/core_ext/class/subclasses.rb
+++ b/activesupport/lib/active_support/core_ext/class/subclasses.rb
@@ -3,7 +3,7 @@
 class Class
   begin
     # Test if this Ruby supports each_object against singleton_class
-    ObjectSpace.each_object(Numeric.singleton_class) {}
+    ObjectSpace.each_object(Numeric.singleton_class) { }
 
     # Returns an array with all classes that are < than its receiver.
     #
diff --git a/activesupport/lib/active_support/core_ext/integer/multiple.rb b/activesupport/lib/active_support/core_ext/integer/multiple.rb
index e7606662d3..bd57a909c5 100644
--- a/activesupport/lib/active_support/core_ext/integer/multiple.rb
+++ b/activesupport/lib/active_support/core_ext/integer/multiple.rb
@@ -7,6 +7,6 @@ class Integer
   #   6.multiple_of?(5)  # => false
   #   10.multiple_of?(2) # => true
   def multiple_of?(number)
-    number != 0 ? self % number == 0 : zero?
+    number == 0 ? self == 0 : self % number == 0
   end
 end
diff --git a/activesupport/lib/active_support/core_ext/load_error.rb b/activesupport/lib/active_support/core_ext/load_error.rb
index 6b0dcab905..b81ed0605e 100644
--- a/activesupport/lib/active_support/core_ext/load_error.rb
+++ b/activesupport/lib/active_support/core_ext/load_error.rb
@@ -4,6 +4,6 @@ class LoadError
   # Returns true if the given path name (except perhaps for the ".rb"
   # extension) is the missing file which caused the exception to be raised.
   def is_missing?(location)
-    location.sub(/\.rb$/, "".freeze) == path.to_s.sub(/\.rb$/, "".freeze)
+    location.sub(/\.rb$/, "") == path.to_s.sub(/\.rb$/, "")
   end
 end
diff --git a/activesupport/lib/active_support/core_ext/object/blank.rb b/activesupport/lib/active_support/core_ext/object/blank.rb
index ad6a9c6146..f36fef6cc9 100644
--- a/activesupport/lib/active_support/core_ext/object/blank.rb
+++ b/activesupport/lib/active_support/core_ext/object/blank.rb
@@ -4,7 +4,7 @@ require "concurrent/map"
 
 class Object
   # An object is blank if it's false, empty, or a whitespace string.
-  # For example, +false+, '', '   ', +nil+, [], and {} are all blank.
+  # For example, +nil+, '', '   ', [], {}, and +false+ are all blank.
   #
   # This simplifies
   #
diff --git a/activesupport/lib/active_support/core_ext/object/try.rb b/activesupport/lib/active_support/core_ext/object/try.rb
index c874691629..aa6896af32 100644
--- a/activesupport/lib/active_support/core_ext/object/try.rb
+++ b/activesupport/lib/active_support/core_ext/object/try.rb
@@ -4,19 +4,27 @@ require "delegate"
 
 module ActiveSupport
   module Tryable #:nodoc:
-    def try(*a, &b)
-      try!(*a, &b) if a.empty? || respond_to?(a.first)
+    def try(method_name = nil, *args, &b)
+      if method_name.nil? && block_given?
+        if b.arity == 0
+          instance_eval(&b)
+        else
+          yield self
+        end
+      elsif respond_to?(method_name)
+        public_send(method_name, *args, &b)
+      end
     end
 
-    def try!(*a, &b)
-      if a.empty? && block_given?
+    def try!(method_name = nil, *args, &b)
+      if method_name.nil? && block_given?
         if b.arity == 0
           instance_eval(&b)
         else
           yield self
         end
       else
-        public_send(*a, &b)
+        public_send(method_name, *args, &b)
       end
     end
   end
diff --git a/activesupport/lib/active_support/core_ext/string/access.rb b/activesupport/lib/active_support/core_ext/string/access.rb
index 58591bbaaf..4ca24028b0 100644
--- a/activesupport/lib/active_support/core_ext/string/access.rb
+++ b/activesupport/lib/active_support/core_ext/string/access.rb
@@ -75,6 +75,10 @@ class String
   #   str.first(0) # => ""
   #   str.first(6) # => "hello"
   def first(limit = 1)
+    ActiveSupport::Deprecation.warn(
+      "Calling String#first with a negative integer limit " \
+      "will raise an ArgumentError in Rails 6.1."
+    ) if limit < 0
     if limit == 0
       ""
     elsif limit >= size
@@ -95,6 +99,10 @@ class String
   #   str.last(0) # => ""
   #   str.last(6) # => "hello"
   def last(limit = 1)
+    ActiveSupport::Deprecation.warn(
+      "Calling String#last with a negative integer limit " \
+      "will raise an ArgumentError in Rails 6.1."
+    ) if limit < 0
     if limit == 0
       ""
     elsif limit >= size
diff --git a/activesupport/lib/active_support/core_ext/string/output_safety.rb b/activesupport/lib/active_support/core_ext/string/output_safety.rb
index f3bdc2977e..3a80de4617 100644
--- a/activesupport/lib/active_support/core_ext/string/output_safety.rb
+++ b/activesupport/lib/active_support/core_ext/string/output_safety.rb
@@ -134,8 +134,9 @@ end
 module ActiveSupport #:nodoc:
   class SafeBuffer < String
     UNSAFE_STRING_METHODS = %w(
-      capitalize chomp chop delete downcase gsub lstrip next reverse rstrip
-      slice squeeze strip sub succ swapcase tr tr_s upcase
+      capitalize chomp chop delete delete_prefix delete_suffix
+      downcase gsub lstrip next reverse rstrip slice squeeze strip
+      sub succ swapcase tr tr_s unicode_normalize upcase
     )
 
     alias_method :original_concat, :concat
@@ -149,9 +150,7 @@ module ActiveSupport #:nodoc:
     end
 
     def [](*args)
-      if args.size < 2
-        super
-      elsif html_safe?
+      if html_safe?
         new_safe_buffer = super
 
         if new_safe_buffer
@@ -188,10 +187,22 @@ module ActiveSupport #:nodoc:
     end
     alias << concat
 
+    def insert(index, value)
+      super(index, html_escape_interpolated_argument(value))
+    end
+
     def prepend(value)
       super(html_escape_interpolated_argument(value))
     end
 
+    def replace(value)
+      super(html_escape_interpolated_argument(value))
+    end
+
+    def []=(index, value)
+      super(index, html_escape_interpolated_argument(value))
+    end
+
     def +(other)
       dup.concat(other)
     end
diff --git a/activesupport/lib/active_support/core_ext/string/strip.rb b/activesupport/lib/active_support/core_ext/string/strip.rb
index 6f9834bb16..60e9952ee6 100644
--- a/activesupport/lib/active_support/core_ext/string/strip.rb
+++ b/activesupport/lib/active_support/core_ext/string/strip.rb
@@ -20,7 +20,7 @@ class String
   # Technically, it looks for the least indented non-empty line
   # in the whole string, and removes that amount of leading whitespace.
   def strip_heredoc
-    gsub(/^#{scan(/^[ \t]*(?=\S)/).min}/, "".freeze).tap do |stripped|
+    gsub(/^#{scan(/^[ \t]*(?=\S)/).min}/, "").tap do |stripped|
       stripped.freeze if frozen?
     end
   end
diff --git a/activesupport/lib/active_support/dependencies.rb b/activesupport/lib/active_support/dependencies.rb
index 9dc2c46880..063d8d1587 100644
--- a/activesupport/lib/active_support/dependencies.rb
+++ b/activesupport/lib/active_support/dependencies.rb
@@ -79,6 +79,12 @@ module ActiveSupport #:nodoc:
     # to allow arbitrary constants to be marked for unloading.
     mattr_accessor :explicitly_unloadable_constants, default: []
 
+    # The logger used when tracing autoloads.
+    mattr_accessor :logger
+
+    # If true, trace autoloads with +logger.debug+.
+    mattr_accessor :verbose, default: false
+
     # The WatchStack keeps a stack of the modules being watched as files are
     # loaded. If a file in the process of being loaded (parent.rb) triggers the
     # load of another file (child.rb) the stack will ensure that child.rb
@@ -138,7 +144,7 @@ module ActiveSupport #:nodoc:
 
           # Normalize the list of new constants, and add them to the list we will return
           new_constants.each do |suffix|
-            constants << ([namespace, suffix] - ["Object"]).join("::".freeze)
+            constants << ([namespace, suffix] - ["Object"]).join("::")
           end
         end
         constants
@@ -404,7 +410,7 @@ module ActiveSupport #:nodoc:
         next unless expanded_path.start_with?(expanded_root)
 
         root_size = expanded_root.size
-        next if expanded_path[root_size] != ?/.freeze
+        next if expanded_path[root_size] != ?/
 
         nesting = expanded_path[(root_size + 1)..-1]
         paths << nesting.camelize unless nesting.blank?
@@ -416,7 +422,7 @@ module ActiveSupport #:nodoc:
 
     # Search for a file in autoload_paths matching the provided suffix.
     def search_for_file(path_suffix)
-      path_suffix = path_suffix.sub(/(\.rb)?$/, ".rb".freeze)
+      path_suffix += ".rb" unless path_suffix.ends_with?(".rb")
 
       autoload_paths.each do |root|
         path = File.join(root, path_suffix)
@@ -450,6 +456,7 @@ module ActiveSupport #:nodoc:
       return nil unless base_path = autoloadable_module?(path_suffix)
       mod = Module.new
       into.const_set const_name, mod
+      log("constant #{qualified_name} autoloaded (module autovivified from #{File.join(base_path, path_suffix)})")
       autoloaded_constants << qualified_name unless autoload_once_paths.include?(base_path)
       autoloaded_constants.uniq!
       mod
@@ -491,21 +498,26 @@ module ActiveSupport #:nodoc:
         raise ArgumentError, "A copy of #{from_mod} has been removed from the module tree but is still active!"
       end
 
-      qualified_name = qualified_name_for from_mod, const_name
+      qualified_name = qualified_name_for(from_mod, const_name)
       path_suffix = qualified_name.underscore
 
       file_path = search_for_file(path_suffix)
 
       if file_path
         expanded = File.expand_path(file_path)
-        expanded.sub!(/\.rb\z/, "".freeze)
+        expanded.sub!(/\.rb\z/, "")
 
         if loading.include?(expanded)
           raise "Circular dependency detected while autoloading constant #{qualified_name}"
         else
           require_or_load(expanded, qualified_name)
-          raise LoadError, "Unable to autoload constant #{qualified_name}, expected #{file_path} to define it" unless from_mod.const_defined?(const_name, false)
-          return from_mod.const_get(const_name)
+
+          if from_mod.const_defined?(const_name, false)
+            log("constant #{qualified_name} autoloaded from #{expanded}.rb")
+            return from_mod.const_get(const_name)
+          else
+            raise LoadError, "Unable to autoload constant #{qualified_name}, expected #{file_path} to define it"
+          end
         end
       elsif mod = autoload_module!(from_mod, const_name, qualified_name, path_suffix)
         return mod
@@ -554,6 +566,7 @@ module ActiveSupport #:nodoc:
     # as the environment will be in an inconsistent state, e.g. other constants
     # may have already been unloaded and not accessible.
     def remove_unloadable_constants!
+      log("removing unloadable constants")
       autoloaded_constants.each { |const| remove_constant const }
       autoloaded_constants.clear
       Reference.clear!
@@ -743,6 +756,10 @@ module ActiveSupport #:nodoc:
         # The constant is no longer reachable, just skip it.
       end
     end
+
+    def log(message)
+      logger.debug("autoloading: #{message}") if logger && verbose
+    end
   end
 end
 
diff --git a/activesupport/lib/active_support/deprecation/behaviors.rb b/activesupport/lib/active_support/deprecation/behaviors.rb
index 3abd25aa85..725667d139 100644
--- a/activesupport/lib/active_support/deprecation/behaviors.rb
+++ b/activesupport/lib/active_support/deprecation/behaviors.rb
@@ -43,7 +43,7 @@ module ActiveSupport
                                                 deprecation_horizon: deprecation_horizon)
       },
 
-      silence: ->(message, callstack, deprecation_horizon, gem_name) {},
+      silence: ->(message, callstack, deprecation_horizon, gem_name) { },
     }
 
     # Behavior module allows to determine how to display deprecation messages.
diff --git a/activesupport/lib/active_support/duration/iso8601_parser.rb b/activesupport/lib/active_support/duration/iso8601_parser.rb
index 414f727705..d3233e6111 100644
--- a/activesupport/lib/active_support/duration/iso8601_parser.rb
+++ b/activesupport/lib/active_support/duration/iso8601_parser.rb
@@ -13,8 +13,8 @@ module ActiveSupport
       class ParsingError < ::ArgumentError; end
 
       PERIOD_OR_COMMA = /\.|,/
-      PERIOD = ".".freeze
-      COMMA = ",".freeze
+      PERIOD = "."
+      COMMA = ","
 
       SIGN_MARKER = /\A\-|\+|/
       DATE_MARKER = /P/
diff --git a/activesupport/lib/active_support/duration/iso8601_serializer.rb b/activesupport/lib/active_support/duration/iso8601_serializer.rb
index 84ae29c1ec..1125454919 100644
--- a/activesupport/lib/active_support/duration/iso8601_serializer.rb
+++ b/activesupport/lib/active_support/duration/iso8601_serializer.rb
@@ -14,14 +14,14 @@ module ActiveSupport
       # Builds and returns output string.
       def serialize
         parts, sign = normalize
-        return "PT0S".freeze if parts.empty?
+        return "PT0S" if parts.empty?
 
-        output = "P".dup
+        output = +"P"
         output << "#{parts[:years]}Y"   if parts.key?(:years)
         output << "#{parts[:months]}M"  if parts.key?(:months)
         output << "#{parts[:weeks]}W"   if parts.key?(:weeks)
         output << "#{parts[:days]}D"    if parts.key?(:days)
-        time = "".dup
+        time = +""
         time << "#{parts[:hours]}H"     if parts.key?(:hours)
         time << "#{parts[:minutes]}M"   if parts.key?(:minutes)
         if parts.key?(:seconds)
diff --git a/activesupport/lib/active_support/hash_with_indifferent_access.rb b/activesupport/lib/active_support/hash_with_indifferent_access.rb
index e4afc8af93..2fac579469 100644
--- a/activesupport/lib/active_support/hash_with_indifferent_access.rb
+++ b/activesupport/lib/active_support/hash_with_indifferent_access.rb
@@ -2,6 +2,7 @@
 
 require "active_support/core_ext/hash/keys"
 require "active_support/core_ext/hash/reverse_merge"
+require "active_support/core_ext/hash/except"
 
 module ActiveSupport
   # Implements a hash where keys <tt>:foo</tt> and <tt>"foo"</tt> are considered
@@ -279,6 +280,8 @@ module ActiveSupport
       super(convert_key(key))
     end
 
+    alias_method :without, :except
+
     def stringify_keys!; self end
     def deep_stringify_keys!; self end
     def stringify_keys; dup end
diff --git a/activesupport/lib/active_support/i18n_railtie.rb b/activesupport/lib/active_support/i18n_railtie.rb
index 93bde57f6a..584930e413 100644
--- a/activesupport/lib/active_support/i18n_railtie.rb
+++ b/activesupport/lib/active_support/i18n_railtie.rb
@@ -87,9 +87,21 @@ module I18n
         when Hash, Array
           Array.wrap(fallbacks)
         else # TrueClass
-          []
+          [I18n.default_locale]
         end
 
+      if args.empty? || args.first.is_a?(Hash)
+        ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          Using I18n fallbacks with an empty `defaults` sets the defaults to
+          include the `default_locale`. This behavior will change in Rails 6.1.
+          If you desire the default locale to be included in the defaults, please
+          explicitly configure it with `config.i18n.fallbacks.defaults =
+          [I18n.default_locale]` or `config.i18n.fallbacks = [I18n.default_locale,
+          {...}]`
+        MSG
+        args.unshift I18n.default_locale
+      end
+
       I18n.fallbacks = I18n::Locale::Fallbacks.new(*args)
     end
 
diff --git a/activesupport/lib/active_support/inflector/methods.rb b/activesupport/lib/active_support/inflector/methods.rb
index 7359de762a..1af9833d46 100644
--- a/activesupport/lib/active_support/inflector/methods.rb
+++ b/activesupport/lib/active_support/inflector/methods.rb
@@ -73,7 +73,7 @@ module ActiveSupport
         string = string.sub(inflections.acronyms_camelize_regex) { |match| match.downcase }
       end
       string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{inflections.acronyms[$2] || $2.capitalize}" }
-      string.gsub!("/".freeze, "::".freeze)
+      string.gsub!("/", "::")
       string
     end
 
@@ -90,11 +90,11 @@ module ActiveSupport
     #   camelize(underscore('SSLError'))  # => "SslError"
     def underscore(camel_cased_word)
       return camel_cased_word unless /[A-Z-]|::/.match?(camel_cased_word)
-      word = camel_cased_word.to_s.gsub("::".freeze, "/".freeze)
-      word.gsub!(inflections.acronyms_underscore_regex) { "#{$1 && '_'.freeze }#{$2.downcase}" }
-      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2'.freeze)
-      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2'.freeze)
-      word.tr!("-".freeze, "_".freeze)
+      word = camel_cased_word.to_s.gsub("::", "/")
+      word.gsub!(inflections.acronyms_underscore_regex) { "#{$1 && '_' }#{$2.downcase}" }
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+      word.tr!("-", "_")
       word.downcase!
       word
     end
@@ -130,11 +130,11 @@ module ActiveSupport
 
       inflections.humans.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
 
-      result.sub!(/\A_+/, "".freeze)
+      result.sub!(/\A_+/, "")
       unless keep_id_suffix
-        result.sub!(/_id\z/, "".freeze)
+        result.sub!(/_id\z/, "")
       end
-      result.tr!("_".freeze, " ".freeze)
+      result.tr!("_", " ")
 
       result.gsub!(/([a-z\d]*)/i) do |match|
         "#{inflections.acronyms[match.downcase] || match.downcase}"
@@ -199,14 +199,14 @@ module ActiveSupport
     #   classify('calculus')     # => "Calculus"
     def classify(table_name)
       # strip out any leading schema name
-      camelize(singularize(table_name.to_s.sub(/.*\./, "".freeze)))
+      camelize(singularize(table_name.to_s.sub(/.*\./, "")))
     end
 
     # Replaces underscores with dashes in the string.
     #
     #   dasherize('puni_puni') # => "puni-puni"
     def dasherize(underscored_word)
-      underscored_word.tr("_".freeze, "-".freeze)
+      underscored_word.tr("_", "-")
     end
 
     # Removes the module part from the expression in the string.
@@ -269,7 +269,7 @@ module ActiveSupport
     # NameError is raised when the name is not in CamelCase or the constant is
     # unknown.
     def constantize(camel_cased_word)
-      names = camel_cased_word.split("::".freeze)
+      names = camel_cased_word.split("::")
 
       # Trigger a built-in NameError exception including the ill-formed constant in the message.
       Object.const_get(camel_cased_word) if names.empty?
@@ -364,7 +364,7 @@ module ActiveSupport
       #   const_regexp("Foo::Bar::Baz") # => "Foo(::Bar(::Baz)?)?"
       #   const_regexp("::")            # => "::"
       def const_regexp(camel_cased_word)
-        parts = camel_cased_word.split("::".freeze)
+        parts = camel_cased_word.split("::")
 
         return Regexp.escape(camel_cased_word) if parts.blank?
 
diff --git a/activesupport/lib/active_support/inflector/transliterate.rb b/activesupport/lib/active_support/inflector/transliterate.rb
index 6f2ca4999c..dbc8b8a2fa 100644
--- a/activesupport/lib/active_support/inflector/transliterate.rb
+++ b/activesupport/lib/active_support/inflector/transliterate.rb
@@ -58,7 +58,7 @@ module ActiveSupport
     #   I18n.locale = :de
     #   transliterate('Jürgen')
     #   # => "Juergen"
-    def transliterate(string, replacement = "?".freeze)
+    def transliterate(string, replacement = "?")
       raise ArgumentError, "Can only transliterate strings. Received #{string.class.name}" unless string.is_a?(String)
 
       I18n.transliterate(
@@ -97,7 +97,7 @@ module ActiveSupport
       parameterized_string.gsub!(/[^a-z0-9\-_]+/i, separator)
 
       unless separator.nil? || separator.empty?
-        if separator == "-".freeze
+        if separator == "-"
           re_duplicate_separator        = /-{2,}/
           re_leading_trailing_separator = /^-|-$/i
         else
@@ -108,7 +108,7 @@ module ActiveSupport
         # No more than one of the separator in a row.
         parameterized_string.gsub!(re_duplicate_separator, separator)
         # Remove leading/trailing separator.
-        parameterized_string.gsub!(re_leading_trailing_separator, "".freeze)
+        parameterized_string.gsub!(re_leading_trailing_separator, "")
       end
 
       parameterized_string.downcase! unless preserve_case
diff --git a/activesupport/lib/active_support/logger_silence.rb b/activesupport/lib/active_support/logger_silence.rb
index 89f32b6782..4344ca0429 100644
--- a/activesupport/lib/active_support/logger_silence.rb
+++ b/activesupport/lib/active_support/logger_silence.rb
@@ -2,7 +2,6 @@
 
 require "active_support/concern"
 require "active_support/core_ext/module/attribute_accessors"
-require "concurrent"
 
 module LoggerSilence
   extend ActiveSupport::Concern
diff --git a/activesupport/lib/active_support/logger_thread_safe_level.rb b/activesupport/lib/active_support/logger_thread_safe_level.rb
index ba32813d3d..22ab4cc28c 100644
--- a/activesupport/lib/active_support/logger_thread_safe_level.rb
+++ b/activesupport/lib/active_support/logger_thread_safe_level.rb
@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/concern"
+require "concurrent"
 
 module ActiveSupport
   module LoggerThreadSafeLevel # :nodoc:
diff --git a/activesupport/lib/active_support/message_encryptor.rb b/activesupport/lib/active_support/message_encryptor.rb
index 404404cad1..6f7302e732 100644
--- a/activesupport/lib/active_support/message_encryptor.rb
+++ b/activesupport/lib/active_support/message_encryptor.rb
@@ -182,7 +182,7 @@ module ActiveSupport
 
       def _decrypt(encrypted_message, purpose)
         cipher = new_cipher
-        encrypted_data, iv, auth_tag = encrypted_message.split("--".freeze).map { |v| ::Base64.strict_decode64(v) }
+        encrypted_data, iv, auth_tag = encrypted_message.split("--").map { |v| ::Base64.strict_decode64(v) }
 
         # Currently the OpenSSL bindings do not raise an error if auth_tag is
         # truncated, which would allow an attacker to easily forge it. See
diff --git a/activesupport/lib/active_support/message_verifier.rb b/activesupport/lib/active_support/message_verifier.rb
index 83c39c0a86..64c557bec6 100644
--- a/activesupport/lib/active_support/message_verifier.rb
+++ b/activesupport/lib/active_support/message_verifier.rb
@@ -122,7 +122,7 @@ module ActiveSupport
     def valid_message?(signed_message)
       return if signed_message.nil? || !signed_message.valid_encoding? || signed_message.blank?
 
-      data, digest = signed_message.split("--".freeze)
+      data, digest = signed_message.split("--")
       data.present? && digest.present? && ActiveSupport::SecurityUtils.secure_compare(digest, generate_digest(data))
     end
 
@@ -150,7 +150,7 @@ module ActiveSupport
     def verified(signed_message, purpose: nil, **)
       if valid_message?(signed_message)
         begin
-          data = signed_message.split("--".freeze)[0]
+          data = signed_message.split("--")[0]
           message = Messages::Metadata.verify(decode(data), purpose)
           @serializer.load(message) if message
         rescue ArgumentError => argument_error
diff --git a/activesupport/lib/active_support/number_helper.rb b/activesupport/lib/active_support/number_helper.rb
index 8fd6e932f1..c75ad52b0c 100644
--- a/activesupport/lib/active_support/number_helper.rb
+++ b/activesupport/lib/active_support/number_helper.rb
@@ -85,6 +85,9 @@ module ActiveSupport
     #   number given by <tt>:format</tt>).  Accepts the same fields
     #   than <tt>:format</tt>, except <tt>%n</tt> is here the
     #   absolute value of the number.
+    # * <tt>:strip_insignificant_zeros</tt> - If +true+ removes
+    #   insignificant zeros after the decimal separator (defaults to
+    #   +false+).
     #
     # ==== Examples
     #
@@ -100,6 +103,8 @@ module ActiveSupport
     #   # => "&pound;1234567890,50"
     #   number_to_currency(1234567890.50, unit: '&pound;', separator: ',', delimiter: '', format: '%n %u')
     #   # => "1234567890,50 &pound;"
+    #   number_to_currency(1234567890.50, strip_insignificant_zeros: true)
+    #   # => "$1,234,567,890.5"
     def number_to_currency(number, options = {})
       NumberToCurrencyConverter.convert(number, options)
     end
diff --git a/activesupport/lib/active_support/number_helper/number_to_currency_converter.rb b/activesupport/lib/active_support/number_helper/number_to_currency_converter.rb
index a25e22cbd3..aef5b62aed 100644
--- a/activesupport/lib/active_support/number_helper/number_to_currency_converter.rb
+++ b/activesupport/lib/active_support/number_helper/number_to_currency_converter.rb
@@ -15,7 +15,7 @@ module ActiveSupport
         end
 
         rounded_number = NumberToRoundedConverter.convert(number, options)
-        format.gsub("%n".freeze, rounded_number).gsub("%u".freeze, options[:unit])
+        format.gsub("%n", rounded_number).gsub("%u", options[:unit])
       end
 
       private
diff --git a/activesupport/lib/active_support/number_helper/number_to_delimited_converter.rb b/activesupport/lib/active_support/number_helper/number_to_delimited_converter.rb
index d5b5706705..05427fef53 100644
--- a/activesupport/lib/active_support/number_helper/number_to_delimited_converter.rb
+++ b/activesupport/lib/active_support/number_helper/number_to_delimited_converter.rb
@@ -14,7 +14,7 @@ module ActiveSupport
       private
 
         def parts
-          left, right = number.to_s.split(".".freeze)
+          left, right = number.to_s.split(".")
           left.gsub!(delimiter_pattern) do |digit_to_delimit|
             "#{digit_to_delimit}#{options[:delimiter]}"
           end
diff --git a/activesupport/lib/active_support/number_helper/number_to_human_converter.rb b/activesupport/lib/active_support/number_helper/number_to_human_converter.rb
index 03eb6671ec..908f788ee3 100644
--- a/activesupport/lib/active_support/number_helper/number_to_human_converter.rb
+++ b/activesupport/lib/active_support/number_helper/number_to_human_converter.rb
@@ -25,7 +25,7 @@ module ActiveSupport
 
         rounded_number = NumberToRoundedConverter.convert(number, options)
         unit = determine_unit(units, exponent)
-        format.gsub("%n".freeze, rounded_number).gsub("%u".freeze, unit).strip
+        format.gsub("%n", rounded_number).gsub("%u", unit).strip
       end
 
       private
diff --git a/activesupport/lib/active_support/number_helper/number_to_human_size_converter.rb b/activesupport/lib/active_support/number_helper/number_to_human_size_converter.rb
index 842f2fc8df..0c72096b72 100644
--- a/activesupport/lib/active_support/number_helper/number_to_human_size_converter.rb
+++ b/activesupport/lib/active_support/number_helper/number_to_human_size_converter.rb
@@ -22,7 +22,7 @@ module ActiveSupport
           human_size = number / (base**exponent)
           number_to_format = NumberToRoundedConverter.convert(human_size, options)
         end
-        conversion_format.gsub("%n".freeze, number_to_format).gsub("%u".freeze, unit)
+        conversion_format.gsub("%n", number_to_format).gsub("%u", unit)
       end
 
       private
diff --git a/activesupport/lib/active_support/number_helper/number_to_percentage_converter.rb b/activesupport/lib/active_support/number_helper/number_to_percentage_converter.rb
index 4dcdad2e2c..6618ecffd5 100644
--- a/activesupport/lib/active_support/number_helper/number_to_percentage_converter.rb
+++ b/activesupport/lib/active_support/number_helper/number_to_percentage_converter.rb
@@ -7,7 +7,7 @@ module ActiveSupport
 
       def convert
         rounded_number = NumberToRoundedConverter.convert(number, options)
-        options[:format].gsub("%n".freeze, rounded_number)
+        options[:format].gsub("%n", rounded_number)
       end
     end
   end
diff --git a/activesupport/lib/active_support/number_helper/number_to_rounded_converter.rb b/activesupport/lib/active_support/number_helper/number_to_rounded_converter.rb
index eb528a0583..0ee5ef92dd 100644
--- a/activesupport/lib/active_support/number_helper/number_to_rounded_converter.rb
+++ b/activesupport/lib/active_support/number_helper/number_to_rounded_converter.rb
@@ -20,9 +20,9 @@ module ActiveSupport
           formatted_string =
             if BigDecimal === rounded_number && rounded_number.finite?
               s = rounded_number.to_s("F")
-              s << "0".freeze * precision
-              a, b = s.split(".".freeze, 2)
-              a << ".".freeze
+              s << "0" * precision
+              a, b = s.split(".", 2)
+              a << "."
               a << b[0, precision]
             else
               "%00.#{precision}f" % rounded_number
diff --git a/activesupport/lib/active_support/subscriber.rb b/activesupport/lib/active_support/subscriber.rb
index 5a4c3d74af..9562149f8d 100644
--- a/activesupport/lib/active_support/subscriber.rb
+++ b/activesupport/lib/active_support/subscriber.rb
@@ -92,7 +92,7 @@ module ActiveSupport
       event.finish!
       event.payload.merge!(payload)
 
-      method = name.split(".".freeze).first
+      method = name.split(".").first
       send(method, event)
     end
 
diff --git a/activesupport/lib/active_support/tagged_logging.rb b/activesupport/lib/active_support/tagged_logging.rb
index b069ac94d4..d8a86d997e 100644
--- a/activesupport/lib/active_support/tagged_logging.rb
+++ b/activesupport/lib/active_support/tagged_logging.rb
@@ -46,7 +46,7 @@ module ActiveSupport
 
       def current_tags
         # We use our object ID here to avoid conflicting with other instances
-        thread_key = @thread_key ||= "activesupport_tagged_logging_tags:#{object_id}".freeze
+        thread_key = @thread_key ||= "activesupport_tagged_logging_tags:#{object_id}"
         Thread.current[thread_key] ||= []
       end
 
@@ -61,8 +61,15 @@ module ActiveSupport
     end
 
     def self.new(logger)
-      # Ensure we set a default formatter so we aren't extending nil!
-      logger.formatter ||= ActiveSupport::Logger::SimpleFormatter.new
+      logger = logger.dup
+
+      if logger.formatter
+        logger.formatter = logger.formatter.dup
+      else
+        # Ensure we set a default formatter so we aren't extending nil!
+        logger.formatter = ActiveSupport::Logger::SimpleFormatter.new
+      end
+
       logger.formatter.extend Formatter
       logger.extend(self)
     end
diff --git a/activesupport/lib/active_support/test_case.rb b/activesupport/lib/active_support/test_case.rb
index f17743b6db..ef12c6b9b0 100644
--- a/activesupport/lib/active_support/test_case.rb
+++ b/activesupport/lib/active_support/test_case.rb
@@ -65,8 +65,8 @@ module ActiveSupport
       #
       #   parallelize(workers: 2, with: :threads)
       #
-      # The threaded parallelization uses Minitest's parallel executor directly.
-      # The processes parallelization uses a Ruby Drb server.
+      # The threaded parallelization uses minitest's parallel executor directly.
+      # The processes parallelization uses a Ruby DRb server.
       def parallelize(workers: 2, with: :processes)
         workers = ENV["PARALLEL_WORKERS"].to_i if ENV["PARALLEL_WORKERS"]
 
diff --git a/activesupport/lib/active_support/testing/method_call_assertions.rb b/activesupport/lib/active_support/testing/method_call_assertions.rb
index c6358002ea..fdc70e1cd3 100644
--- a/activesupport/lib/active_support/testing/method_call_assertions.rb
+++ b/activesupport/lib/active_support/testing/method_call_assertions.rb
@@ -35,6 +35,35 @@ module ActiveSupport
           assert_called(object, method_name, message, times: 0, &block)
         end
 
+        # TODO: No need to resort to #send once support for Ruby 2.4 is
+        # dropped.
+        def assert_called_on_instance_of(klass, method_name, message = nil, times: 1, returns: nil)
+          times_called = 0
+          klass.send(:define_method, "stubbed_#{method_name}") do |*|
+            times_called += 1
+
+            returns
+          end
+
+          klass.send(:alias_method, "original_#{method_name}", method_name)
+          klass.send(:alias_method, method_name, "stubbed_#{method_name}")
+
+          yield
+
+          error = "Expected #{method_name} to be called #{times} times, but was called #{times_called} times"
+          error = "#{message}.\n#{error}" if message
+
+          assert_equal times, times_called, error
+        ensure
+          klass.send(:alias_method, method_name, "original_#{method_name}")
+          klass.send(:undef_method, "original_#{method_name}")
+          klass.send(:undef_method, "stubbed_#{method_name}")
+        end
+
+        def assert_not_called_on_instance_of(klass, method_name, message = nil, &block)
+          assert_called_on_instance_of(klass, method_name, message, times: 0, &block)
+        end
+
         def stub_any_instance(klass, instance: klass.new)
           klass.stub(:new, instance) { yield instance }
         end
diff --git a/activesupport/lib/active_support/testing/parallelization.rb b/activesupport/lib/active_support/testing/parallelization.rb
index 1caac1feb3..beeb470659 100644
--- a/activesupport/lib/active_support/testing/parallelization.rb
+++ b/activesupport/lib/active_support/testing/parallelization.rb
@@ -65,22 +65,24 @@ module ActiveSupport
       def start
         @pool = @queue_size.times.map do |worker|
           fork do
-            DRb.stop_service
+            begin
+              DRb.stop_service
 
-            after_fork(worker)
+              after_fork(worker)
 
-            queue = DRbObject.new_with_uri(@url)
+              queue = DRbObject.new_with_uri(@url)
 
-            while job = queue.pop
-              klass    = job[0]
-              method   = job[1]
-              reporter = job[2]
-              result   = Minitest.run_one_method(klass, method)
+              while job = queue.pop
+                klass    = job[0]
+                method   = job[1]
+                reporter = job[2]
+                result   = Minitest.run_one_method(klass, method)
 
-              queue.record(reporter, result)
+                queue.record(reporter, result)
+              end
+            ensure
+              run_cleanup(worker)
             end
-
-            run_cleanup(worker)
           end
         end
       end
diff --git a/activesupport/lib/active_support/testing/time_helpers.rb b/activesupport/lib/active_support/testing/time_helpers.rb
index 801ea2909b..f160e66971 100644
--- a/activesupport/lib/active_support/testing/time_helpers.rb
+++ b/activesupport/lib/active_support/testing/time_helpers.rb
@@ -158,7 +158,7 @@ module ActiveSupport
       end
 
       # Returns the current time back to its original state, by removing the stubs added by
-      # +travel+ and +travel_to+.
+      # +travel+, +travel_to+, and +freeze_time+.
       #
       #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
       #   travel_to Time.zone.local(2004, 11, 24, 01, 04, 44)
@@ -168,6 +168,7 @@ module ActiveSupport
       def travel_back
         simple_stubs.unstub_all!
       end
+      alias_method :unfreeze_time, :travel_back
 
       # Calls +travel_to+ with +Time.now+.
       #
diff --git a/activesupport/lib/active_support/time_with_zone.rb b/activesupport/lib/active_support/time_with_zone.rb
index 7e71318404..3be5f6f7b5 100644
--- a/activesupport/lib/active_support/time_with_zone.rb
+++ b/activesupport/lib/active_support/time_with_zone.rb
@@ -43,8 +43,8 @@ module ActiveSupport
       "Time"
     end
 
-    PRECISIONS = Hash.new { |h, n| h[n] = "%FT%T.%#{n}N".freeze }
-    PRECISIONS[0] = "%FT%T".freeze
+    PRECISIONS = Hash.new { |h, n| h[n] = "%FT%T.%#{n}N" }
+    PRECISIONS[0] = "%FT%T"
 
     include Comparable, DateAndTime::Compatibility
     attr_reader :time_zone
@@ -147,7 +147,7 @@ module ActiveSupport
     #
     #   Time.zone.now.xmlschema  # => "2014-12-04T11:02:37-05:00"
     def xmlschema(fraction_digits = 0)
-      "#{time.strftime(PRECISIONS[fraction_digits.to_i])}#{formatted_offset(true, 'Z'.freeze)}"
+      "#{time.strftime(PRECISIONS[fraction_digits.to_i])}#{formatted_offset(true, 'Z')}"
     end
     alias_method :iso8601, :xmlschema
     alias_method :rfc3339, :xmlschema
@@ -286,8 +286,10 @@ module ActiveSupport
     alias_method :since, :+
     alias_method :in, :+
 
-    # Returns a new TimeWithZone object that represents the difference between
-    # the current object's time and the +other+ time.
+    # Subtracts an interval of time and returns a new TimeWithZone object unless
+    # the other value `acts_like?` time. Then it will return a Float of the difference
+    # between the two times that represents the difference between the current
+    # object's time and the +other+ time.
     #
     #   Time.zone = 'Eastern Time (US & Canada)' # => 'Eastern Time (US & Canada)'
     #   now = Time.zone.now # => Mon, 03 Nov 2014 00:26:28 EST -05:00
@@ -302,6 +304,12 @@ module ActiveSupport
     #
     #   now - 24.hours      # => Sun, 02 Nov 2014 01:26:28 EDT -04:00
     #   now - 1.day         # => Sun, 02 Nov 2014 00:26:28 EDT -04:00
+    #
+    # If both the TimeWithZone object and the other value act like Time, a Float
+    # will be returned.
+    #
+    #   Time.zone.now - 1.day.ago # => 86399.999967
+    #
     def -(other)
       if other.acts_like?(:time)
         to_time - other.to_time
diff --git a/activesupport/lib/active_support/xml_mini/jdom.rb b/activesupport/lib/active_support/xml_mini/jdom.rb
index 7f94a64016..32fe6ade28 100644
--- a/activesupport/lib/active_support/xml_mini/jdom.rb
+++ b/activesupport/lib/active_support/xml_mini/jdom.rb
@@ -18,7 +18,7 @@ module ActiveSupport
   module XmlMini_JDOM #:nodoc:
     extend self
 
-    CONTENT_KEY = "__content__".freeze
+    CONTENT_KEY = "__content__"
 
     NODE_TYPE_NAMES = %w{ATTRIBUTE_NODE CDATA_SECTION_NODE COMMENT_NODE DOCUMENT_FRAGMENT_NODE
     DOCUMENT_NODE DOCUMENT_TYPE_NODE ELEMENT_NODE ENTITY_NODE ENTITY_REFERENCE_NODE NOTATION_NODE
@@ -169,7 +169,7 @@ module ActiveSupport
       # element::
       #   XML element to be checked.
       def empty_content?(element)
-        text = "".dup
+        text = +""
         child_nodes = element.child_nodes
         (0...child_nodes.length).each do |i|
           item = child_nodes.item(i)
diff --git a/activesupport/lib/active_support/xml_mini/libxml.rb b/activesupport/lib/active_support/xml_mini/libxml.rb
index 0b000fea60..c2e999ef6c 100644
--- a/activesupport/lib/active_support/xml_mini/libxml.rb
+++ b/activesupport/lib/active_support/xml_mini/libxml.rb
@@ -34,7 +34,7 @@ module LibXML #:nodoc:
     end
 
     module Node #:nodoc:
-      CONTENT_ROOT = "__content__".freeze
+      CONTENT_ROOT = "__content__"
 
       # Convert XML document to hash.
       #
@@ -55,7 +55,7 @@ module LibXML #:nodoc:
           if c.element?
             c.to_hash(node_hash)
           elsif c.text? || c.cdata?
-            node_hash[CONTENT_ROOT] ||= "".dup
+            node_hash[CONTENT_ROOT] ||= +""
             node_hash[CONTENT_ROOT] << c.content
           end
         end
diff --git a/activesupport/lib/active_support/xml_mini/libxmlsax.rb b/activesupport/lib/active_support/xml_mini/libxmlsax.rb
index dcf16e6084..ac8acdfc3c 100644
--- a/activesupport/lib/active_support/xml_mini/libxmlsax.rb
+++ b/activesupport/lib/active_support/xml_mini/libxmlsax.rb
@@ -13,8 +13,8 @@ module ActiveSupport
     class HashBuilder
       include LibXML::XML::SaxParser::Callbacks
 
-      CONTENT_KEY   = "__content__".freeze
-      HASH_SIZE_KEY = "__hash_size__".freeze
+      CONTENT_KEY   = "__content__"
+      HASH_SIZE_KEY = "__hash_size__"
 
       attr_reader :hash
 
@@ -23,7 +23,7 @@ module ActiveSupport
       end
 
       def on_start_document
-        @hash = { CONTENT_KEY => "".dup }
+        @hash = { CONTENT_KEY => +"" }
         @hash_stack = [@hash]
       end
 
@@ -33,7 +33,7 @@ module ActiveSupport
       end
 
       def on_start_element(name, attrs = {})
-        new_hash = { CONTENT_KEY => "".dup }.merge!(attrs)
+        new_hash = { CONTENT_KEY => +"" }.merge!(attrs)
         new_hash[HASH_SIZE_KEY] = new_hash.size + 1
 
         case current_hash[name]
diff --git a/activesupport/lib/active_support/xml_mini/nokogiri.rb b/activesupport/lib/active_support/xml_mini/nokogiri.rb
index 5ee6fc8159..f76513f48b 100644
--- a/activesupport/lib/active_support/xml_mini/nokogiri.rb
+++ b/activesupport/lib/active_support/xml_mini/nokogiri.rb
@@ -38,7 +38,7 @@ module ActiveSupport
       end
 
       module Node #:nodoc:
-        CONTENT_ROOT = "__content__".freeze
+        CONTENT_ROOT = "__content__"
 
         # Convert XML document to hash.
         #
@@ -59,7 +59,7 @@ module ActiveSupport
             if c.element?
               c.to_hash(node_hash)
             elsif c.text? || c.cdata?
-              node_hash[CONTENT_ROOT] ||= "".dup
+              node_hash[CONTENT_ROOT] ||= +""
               node_hash[CONTENT_ROOT] << c.content
             end
           end
diff --git a/activesupport/lib/active_support/xml_mini/nokogirisax.rb b/activesupport/lib/active_support/xml_mini/nokogirisax.rb
index b01ed00a14..55cd72e093 100644
--- a/activesupport/lib/active_support/xml_mini/nokogirisax.rb
+++ b/activesupport/lib/active_support/xml_mini/nokogirisax.rb
@@ -16,8 +16,8 @@ module ActiveSupport
     # Class that will build the hash while the XML document
     # is being parsed using SAX events.
     class HashBuilder < Nokogiri::XML::SAX::Document
-      CONTENT_KEY   = "__content__".freeze
-      HASH_SIZE_KEY = "__hash_size__".freeze
+      CONTENT_KEY   = "__content__"
+      HASH_SIZE_KEY = "__hash_size__"
 
       attr_reader :hash
 
@@ -39,7 +39,7 @@ module ActiveSupport
       end
 
       def start_element(name, attrs = [])
-        new_hash = { CONTENT_KEY => "".dup }.merge!(Hash[attrs])
+        new_hash = { CONTENT_KEY => +"" }.merge!(Hash[attrs])
         new_hash[HASH_SIZE_KEY] = new_hash.size + 1
 
         case current_hash[name]
diff --git a/activesupport/lib/active_support/xml_mini/rexml.rb b/activesupport/lib/active_support/xml_mini/rexml.rb
index 32458d5b0d..8d6e3af066 100644
--- a/activesupport/lib/active_support/xml_mini/rexml.rb
+++ b/activesupport/lib/active_support/xml_mini/rexml.rb
@@ -8,7 +8,7 @@ module ActiveSupport
   module XmlMini_REXML #:nodoc:
     extend self
 
-    CONTENT_KEY = "__content__".freeze
+    CONTENT_KEY = "__content__"
 
     # Parse an XML Document string or IO into a simple hash.
     #
@@ -76,7 +76,7 @@ module ActiveSupport
           hash
         else
           # must use value to prevent double-escaping
-          texts = "".dup
+          texts = +""
           element.texts.each { |t| texts << t.value }
           merge!(hash, CONTENT_KEY, texts)
         end
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