12 files changed, 536 insertions, 536 deletions

diff --git a/activesupport/test/core_ext/class/attribute_test.rb b/activesupport/test/core_ext/class/attribute_test.rb
index b1a10a007e..5a9ec78cc1 100644
--- a/activesupport/test/core_ext/class/attribute_test.rb
+++ b/activesupport/test/core_ext/class/attribute_test.rb
@@ -56,18 +56,18 @@ class ClassAttributeTest < ActiveSupport::TestCase
   end
 
   test "disabling instance writer" do
-    object = Class.new { class_attribute :setting, :instance_writer => false }.new
+    object = Class.new { class_attribute :setting, instance_writer: false }.new
     assert_raise(NoMethodError) { object.setting = "boom" }
   end
 
   test "disabling instance reader" do
-    object = Class.new { class_attribute :setting, :instance_reader => false }.new
+    object = Class.new { class_attribute :setting, instance_reader: false }.new
     assert_raise(NoMethodError) { object.setting }
     assert_raise(NoMethodError) { object.setting? }
   end
 
   test "disabling both instance writer and reader" do
-    object = Class.new { class_attribute :setting, :instance_accessor => false }.new
+    object = Class.new { class_attribute :setting, instance_accessor: false }.new
     assert_raise(NoMethodError) { object.setting }
     assert_raise(NoMethodError) { object.setting? }
     assert_raise(NoMethodError) { object.setting = "boom" }
diff --git a/activesupport/test/core_ext/date_ext_test.rb b/activesupport/test/core_ext/date_ext_test.rb
index 9368820a8e..0c9b88d861 100644
--- a/activesupport/test/core_ext/date_ext_test.rb
+++ b/activesupport/test/core_ext/date_ext_test.rb
@@ -81,10 +81,10 @@ class DateExtCalculationsTest < ActiveSupport::TestCase
   end
 
   def test_change
-    assert_equal Date.new(2005, 2, 21), Date.new(2005, 2, 11).change(:day => 21)
-    assert_equal Date.new(2007, 5, 11), Date.new(2005, 2, 11).change(:year => 2007, :month => 5)
-    assert_equal Date.new(2006,2,22), Date.new(2005,2,22).change(:year => 2006)
-    assert_equal Date.new(2005,6,22), Date.new(2005,2,22).change(:month => 6)
+    assert_equal Date.new(2005, 2, 21), Date.new(2005, 2, 11).change(day: 21)
+    assert_equal Date.new(2007, 5, 11), Date.new(2005, 2, 11).change(year: 2007, month: 5)
+    assert_equal Date.new(2006,2,22), Date.new(2005,2,22).change(year: 2006)
+    assert_equal Date.new(2005,6,22), Date.new(2005,2,22).change(month: 6)
   end
 
   def test_sunday
@@ -139,34 +139,34 @@ class DateExtCalculationsTest < ActiveSupport::TestCase
   end
 
   def test_advance
-    assert_equal Date.new(2006,2,28), Date.new(2005,2,28).advance(:years => 1)
-    assert_equal Date.new(2005,6,28), Date.new(2005,2,28).advance(:months => 4)
-    assert_equal Date.new(2005,3,21), Date.new(2005,2,28).advance(:weeks => 3)
-    assert_equal Date.new(2005,3,5), Date.new(2005,2,28).advance(:days => 5)
-    assert_equal Date.new(2012,9,28), Date.new(2005,2,28).advance(:years => 7, :months => 7)
-    assert_equal Date.new(2013,10,3), Date.new(2005,2,28).advance(:years => 7, :months => 19, :days => 5)
-    assert_equal Date.new(2013,10,17), Date.new(2005,2,28).advance(:years => 7, :months => 19, :weeks => 2, :days => 5)
-    assert_equal Date.new(2005,2,28), Date.new(2004,2,29).advance(:years => 1) #leap day plus one year
+    assert_equal Date.new(2006,2,28), Date.new(2005,2,28).advance(years: 1)
+    assert_equal Date.new(2005,6,28), Date.new(2005,2,28).advance(months: 4)
+    assert_equal Date.new(2005,3,21), Date.new(2005,2,28).advance(weeks: 3)
+    assert_equal Date.new(2005,3,5), Date.new(2005,2,28).advance(days: 5)
+    assert_equal Date.new(2012,9,28), Date.new(2005,2,28).advance(years: 7, months: 7)
+    assert_equal Date.new(2013,10,3), Date.new(2005,2,28).advance(years: 7, months: 19, days: 5)
+    assert_equal Date.new(2013,10,17), Date.new(2005,2,28).advance(years: 7, months: 19, weeks: 2, days: 5)
+    assert_equal Date.new(2005,2,28), Date.new(2004,2,29).advance(years: 1) #leap day plus one year
   end
 
   def test_advance_does_first_years_and_then_days
-    assert_equal Date.new(2012, 2, 29), Date.new(2011, 2, 28).advance(:years => 1, :days => 1)
+    assert_equal Date.new(2012, 2, 29), Date.new(2011, 2, 28).advance(years: 1, days: 1)
     # If day was done first we would jump to 2012-03-01 instead.
   end
 
   def test_advance_does_first_months_and_then_days
-    assert_equal Date.new(2010, 3, 29), Date.new(2010, 2, 28).advance(:months => 1, :days => 1)
+    assert_equal Date.new(2010, 3, 29), Date.new(2010, 2, 28).advance(months: 1, days: 1)
     # If day was done first we would jump to 2010-04-01 instead.
   end
 
   def test_advance_in_calendar_reform
-    assert_equal Date.new(1582,10,15), Date.new(1582,10,4).advance(:days => 1)
-    assert_equal Date.new(1582,10,4), Date.new(1582,10,15).advance(:days => -1)
+    assert_equal Date.new(1582,10,15), Date.new(1582,10,4).advance(days: 1)
+    assert_equal Date.new(1582,10,4), Date.new(1582,10,15).advance(days: -1)
     5.upto(14) do |day|
-      assert_equal Date.new(1582,10,4), Date.new(1582,9,day).advance(:months => 1)
-      assert_equal Date.new(1582,10,4), Date.new(1582,11,day).advance(:months => -1)
-      assert_equal Date.new(1582,10,4), Date.new(1581,10,day).advance(:years => 1)
-      assert_equal Date.new(1582,10,4), Date.new(1583,10,day).advance(:years => -1)
+      assert_equal Date.new(1582,10,4), Date.new(1582,9,day).advance(months: 1)
+      assert_equal Date.new(1582,10,4), Date.new(1582,11,day).advance(months: -1)
+      assert_equal Date.new(1582,10,4), Date.new(1581,10,day).advance(years: 1)
+      assert_equal Date.new(1582,10,4), Date.new(1583,10,day).advance(years: -1)
     end
   end
 
@@ -384,9 +384,9 @@ class DateExtCalculationsTest < ActiveSupport::TestCase
   end
 
   def test_date_advance_should_not_change_passed_options_hash
-    options = { :years => 3, :months => 11, :days => 2 }
+    options = { years: 3, months: 11, days: 2 }
     Date.new(2005,2,28).advance(options)
-    assert_equal({ :years => 3, :months => 11, :days => 2 }, options)
+    assert_equal({ years: 3, months: 11, days: 2 }, options)
   end
 end
 
diff --git a/activesupport/test/core_ext/date_time_ext_test.rb b/activesupport/test/core_ext/date_time_ext_test.rb
index 222a43f1b2..f2a50f4693 100644
--- a/activesupport/test/core_ext/date_time_ext_test.rb
+++ b/activesupport/test/core_ext/date_time_ext_test.rb
@@ -159,47 +159,47 @@ class DateTimeExtCalculationsTest < ActiveSupport::TestCase
   end
 
   def test_change
-    assert_equal DateTime.civil(2006,2,22,15,15,10), DateTime.civil(2005,2,22,15,15,10).change(:year => 2006)
-    assert_equal DateTime.civil(2005,6,22,15,15,10), DateTime.civil(2005,2,22,15,15,10).change(:month => 6)
-    assert_equal DateTime.civil(2012,9,22,15,15,10), DateTime.civil(2005,2,22,15,15,10).change(:year => 2012, :month => 9)
-    assert_equal DateTime.civil(2005,2,22,16),       DateTime.civil(2005,2,22,15,15,10).change(:hour => 16)
-    assert_equal DateTime.civil(2005,2,22,16,45),    DateTime.civil(2005,2,22,15,15,10).change(:hour => 16, :min => 45)
-    assert_equal DateTime.civil(2005,2,22,15,45),    DateTime.civil(2005,2,22,15,15,10).change(:min => 45)
+    assert_equal DateTime.civil(2006,2,22,15,15,10), DateTime.civil(2005,2,22,15,15,10).change(year: 2006)
+    assert_equal DateTime.civil(2005,6,22,15,15,10), DateTime.civil(2005,2,22,15,15,10).change(month: 6)
+    assert_equal DateTime.civil(2012,9,22,15,15,10), DateTime.civil(2005,2,22,15,15,10).change(year: 2012, month: 9)
+    assert_equal DateTime.civil(2005,2,22,16),       DateTime.civil(2005,2,22,15,15,10).change(hour: 16)
+    assert_equal DateTime.civil(2005,2,22,16,45),    DateTime.civil(2005,2,22,15,15,10).change(hour: 16, min: 45)
+    assert_equal DateTime.civil(2005,2,22,15,45),    DateTime.civil(2005,2,22,15,15,10).change(min: 45)
 
     # datetime with fractions of a second
-    assert_equal DateTime.civil(2005,2,1,15,15,10.7), DateTime.civil(2005,2,22,15,15,10.7).change(:day => 1)
+    assert_equal DateTime.civil(2005,2,1,15,15,10.7), DateTime.civil(2005,2,22,15,15,10.7).change(day: 1)
   end
 
   def test_advance
-    assert_equal DateTime.civil(2006,2,28,15,15,10),  DateTime.civil(2005,2,28,15,15,10).advance(:years => 1)
-    assert_equal DateTime.civil(2005,6,28,15,15,10),  DateTime.civil(2005,2,28,15,15,10).advance(:months => 4)
-    assert_equal DateTime.civil(2005,3,21,15,15,10),  DateTime.civil(2005,2,28,15,15,10).advance(:weeks => 3)
-    assert_equal DateTime.civil(2005,3,5,15,15,10),   DateTime.civil(2005,2,28,15,15,10).advance(:days => 5)
-    assert_equal DateTime.civil(2012,9,28,15,15,10),  DateTime.civil(2005,2,28,15,15,10).advance(:years => 7, :months => 7)
-    assert_equal DateTime.civil(2013,10,3,15,15,10),  DateTime.civil(2005,2,28,15,15,10).advance(:years => 7, :months => 19, :days => 5)
-    assert_equal DateTime.civil(2013,10,17,15,15,10), DateTime.civil(2005,2,28,15,15,10).advance(:years => 7, :months => 19, :weeks => 2, :days => 5)
-    assert_equal DateTime.civil(2001,12,27,15,15,10), DateTime.civil(2005,2,28,15,15,10).advance(:years => -3, :months => -2, :days => -1)
-    assert_equal DateTime.civil(2005,2,28,15,15,10),  DateTime.civil(2004,2,29,15,15,10).advance(:years => 1) #leap day plus one year
-    assert_equal DateTime.civil(2005,2,28,20,15,10),  DateTime.civil(2005,2,28,15,15,10).advance(:hours => 5)
-    assert_equal DateTime.civil(2005,2,28,15,22,10),  DateTime.civil(2005,2,28,15,15,10).advance(:minutes => 7)
-    assert_equal DateTime.civil(2005,2,28,15,15,19),  DateTime.civil(2005,2,28,15,15,10).advance(:seconds => 9)
-    assert_equal DateTime.civil(2005,2,28,20,22,19),  DateTime.civil(2005,2,28,15,15,10).advance(:hours => 5, :minutes => 7, :seconds => 9)
-    assert_equal DateTime.civil(2005,2,28,10,8,1),    DateTime.civil(2005,2,28,15,15,10).advance(:hours => -5, :minutes => -7, :seconds => -9)
-    assert_equal DateTime.civil(2013,10,17,20,22,19), DateTime.civil(2005,2,28,15,15,10).advance(:years => 7, :months => 19, :weeks => 2, :days => 5, :hours => 5, :minutes => 7, :seconds => 9)
+    assert_equal DateTime.civil(2006,2,28,15,15,10),  DateTime.civil(2005,2,28,15,15,10).advance(years: 1)
+    assert_equal DateTime.civil(2005,6,28,15,15,10),  DateTime.civil(2005,2,28,15,15,10).advance(months: 4)
+    assert_equal DateTime.civil(2005,3,21,15,15,10),  DateTime.civil(2005,2,28,15,15,10).advance(weeks: 3)
+    assert_equal DateTime.civil(2005,3,5,15,15,10),   DateTime.civil(2005,2,28,15,15,10).advance(days: 5)
+    assert_equal DateTime.civil(2012,9,28,15,15,10),  DateTime.civil(2005,2,28,15,15,10).advance(years: 7, months: 7)
+    assert_equal DateTime.civil(2013,10,3,15,15,10),  DateTime.civil(2005,2,28,15,15,10).advance(years: 7, months: 19, days: 5)
+    assert_equal DateTime.civil(2013,10,17,15,15,10), DateTime.civil(2005,2,28,15,15,10).advance(years: 7, months: 19, weeks: 2, days: 5)
+    assert_equal DateTime.civil(2001,12,27,15,15,10), DateTime.civil(2005,2,28,15,15,10).advance(years: -3, months: -2, days: -1)
+    assert_equal DateTime.civil(2005,2,28,15,15,10),  DateTime.civil(2004,2,29,15,15,10).advance(years: 1) #leap day plus one year
+    assert_equal DateTime.civil(2005,2,28,20,15,10),  DateTime.civil(2005,2,28,15,15,10).advance(hours: 5)
+    assert_equal DateTime.civil(2005,2,28,15,22,10),  DateTime.civil(2005,2,28,15,15,10).advance(minutes: 7)
+    assert_equal DateTime.civil(2005,2,28,15,15,19),  DateTime.civil(2005,2,28,15,15,10).advance(seconds: 9)
+    assert_equal DateTime.civil(2005,2,28,20,22,19),  DateTime.civil(2005,2,28,15,15,10).advance(hours: 5, minutes: 7, seconds: 9)
+    assert_equal DateTime.civil(2005,2,28,10,8,1),    DateTime.civil(2005,2,28,15,15,10).advance(hours: -5, minutes: -7, seconds: -9)
+    assert_equal DateTime.civil(2013,10,17,20,22,19), DateTime.civil(2005,2,28,15,15,10).advance(years: 7, months: 19, weeks: 2, days: 5, hours: 5, minutes: 7, seconds: 9)
   end
 
   def test_advance_partial_days
-    assert_equal DateTime.civil(2012,9,29,13,15,10),  DateTime.civil(2012,9,28,1,15,10).advance(:days => 1.5)
-    assert_equal DateTime.civil(2012,9,28,13,15,10),  DateTime.civil(2012,9,28,1,15,10).advance(:days => 0.5)
-    assert_equal DateTime.civil(2012,10,29,13,15,10), DateTime.civil(2012,9,28,1,15,10).advance(:days => 1.5, :months => 1)
+    assert_equal DateTime.civil(2012,9,29,13,15,10),  DateTime.civil(2012,9,28,1,15,10).advance(days: 1.5)
+    assert_equal DateTime.civil(2012,9,28,13,15,10),  DateTime.civil(2012,9,28,1,15,10).advance(days: 0.5)
+    assert_equal DateTime.civil(2012,10,29,13,15,10), DateTime.civil(2012,9,28,1,15,10).advance(days: 1.5, months: 1)
   end
 
   def test_advanced_processes_first_the_date_deltas_and_then_the_time_deltas
     # If the time deltas were processed first, the following datetimes would be advanced to 2010/04/01 instead.
-    assert_equal DateTime.civil(2010, 3, 29), DateTime.civil(2010, 2, 28, 23, 59, 59).advance(:months => 1, :seconds => 1)
-    assert_equal DateTime.civil(2010, 3, 29), DateTime.civil(2010, 2, 28, 23, 59).advance(:months => 1, :minutes => 1)
-    assert_equal DateTime.civil(2010, 3, 29), DateTime.civil(2010, 2, 28, 23).advance(:months => 1, :hours => 1)
-    assert_equal DateTime.civil(2010, 3, 29), DateTime.civil(2010, 2, 28, 22, 58, 59).advance(:months => 1, :hours => 1, :minutes => 1, :seconds => 1)
+    assert_equal DateTime.civil(2010, 3, 29), DateTime.civil(2010, 2, 28, 23, 59, 59).advance(months: 1, seconds: 1)
+    assert_equal DateTime.civil(2010, 3, 29), DateTime.civil(2010, 2, 28, 23, 59).advance(months: 1, minutes: 1)
+    assert_equal DateTime.civil(2010, 3, 29), DateTime.civil(2010, 2, 28, 23).advance(months: 1, hours: 1)
+    assert_equal DateTime.civil(2010, 3, 29), DateTime.civil(2010, 2, 28, 22, 58, 59).advance(months: 1, hours: 1, minutes: 1, seconds: 1)
   end
 
   def test_last_week
diff --git a/activesupport/test/core_ext/hash_ext_test.rb b/activesupport/test/core_ext/hash_ext_test.rb
index 6c1a6b1ed4..1253c13c5a 100644
--- a/activesupport/test/core_ext/hash_ext_test.rb
+++ b/activesupport/test/core_ext/hash_ext_test.rb
@@ -36,10 +36,10 @@ class HashExtTest < ActiveSupport::TestCase
   def setup
     @strings = { "a" => 1, "b" => 2 }
     @nested_strings = { "a" => { "b" => { "c" => 3 } } }
-    @symbols = { :a => 1, :b => 2 }
-    @nested_symbols = { :a => { :b => { :c => 3 } } }
+    @symbols = { a: 1, b: 2 }
+    @nested_symbols = { a: { b: { c: 3 } } }
     @mixed = { :a => 1, "b" => 2 }
-    @nested_mixed = { "a" => { :b => { "c" => 3 } } }
+    @nested_mixed = { "a" => { b: { "c" => 3 } } }
     @integers = { 0 => 1, 1 => 2 }
     @nested_integers = { 0 => { 1 => { 2 => 3} } }
     @illegal_symbols = { [] => 3 }
@@ -47,8 +47,8 @@ class HashExtTest < ActiveSupport::TestCase
     @upcase_strings = { "A" => 1, "B" => 2 }
     @nested_upcase_strings = { "A" => { "B" => { "C" => 3 } } }
     @string_array_of_hashes = { "a" => [ { "b" => 2 }, { "c" => 3 }, 4 ] }
-    @symbol_array_of_hashes = { :a => [ { :b => 2 }, { :c => 3 }, 4 ] }
-    @mixed_array_of_hashes = { :a => [ { :b => 2 }, { "c" => 3 }, 4 ] }
+    @symbol_array_of_hashes = { a: [ { b: 2 }, { c: 3 }, 4 ] }
+    @mixed_array_of_hashes = { a: [ { b: 2 }, { "c" => 3 }, 4 ] }
     @upcase_array_of_hashes = { "A" => [ { "B" => 2 }, { "C" => 3 }, 4 ] }
   end
 
@@ -127,7 +127,7 @@ class HashExtTest < ActiveSupport::TestCase
     transformed_hash = @nested_mixed.deep_dup
     transformed_hash.deep_transform_keys!{ |key| key.to_s.upcase }
     assert_equal @nested_upcase_strings, transformed_hash
-    assert_equal @nested_mixed, { "a" => { :b => { "c" => 3 } } }
+    assert_equal @nested_mixed, { "a" => { b: { "c" => 3 } } }
   end
 
   def test_symbolize_keys
@@ -183,7 +183,7 @@ class HashExtTest < ActiveSupport::TestCase
     transformed_hash = @nested_mixed.deep_dup
     transformed_hash.deep_symbolize_keys!
     assert_equal @nested_symbols, transformed_hash
-    assert_equal @nested_mixed, { "a" => { :b => { "c" => 3 } } }
+    assert_equal @nested_mixed, { "a" => { b: { "c" => 3 } } }
   end
 
   def test_symbolize_keys_preserves_keys_that_cant_be_symbolized
@@ -259,7 +259,7 @@ class HashExtTest < ActiveSupport::TestCase
     transformed_hash = @nested_mixed.deep_dup
     transformed_hash.deep_stringify_keys!
     assert_equal @nested_strings, transformed_hash
-    assert_equal @nested_mixed, { "a" => { :b => { "c" => 3 } } }
+    assert_equal @nested_mixed, { "a" => { b: { "c" => 3 } } }
   end
 
   def test_symbolize_keys_for_hash_with_indifferent_access
@@ -360,9 +360,9 @@ class HashExtTest < ActiveSupport::TestCase
     assert_equal 1, @strings.fetch(:a)
 
     hashes = { :@strings => @strings, :@symbols => @symbols, :@mixed => @mixed }
-    method_map = { :'[]' => 1, :fetch => 1, :values_at => [1],
-      :has_key? => true, :include? => true, :key? => true,
-      :member? => true }
+    method_map = { '[]': 1, fetch: 1, values_at: [1],
+      has_key?: true, include?: true, key?: true,
+      member?: true }
 
     hashes.each do |name, hash|
       method_map.sort_by(&:to_s).each do |meth, expected|
@@ -447,7 +447,7 @@ class HashExtTest < ActiveSupport::TestCase
 
   def test_update_with_to_hash_conversion
     hash = HashWithIndifferentAccess.new
-    hash.update HashByConversion.new({ :a => 1 })
+    hash.update HashByConversion.new({ a: 1 })
     assert_equal hash["a"], 1
   end
 
@@ -472,7 +472,7 @@ class HashExtTest < ActiveSupport::TestCase
 
   def test_merge_with_to_hash_conversion
     hash = HashWithIndifferentAccess.new
-    merged = hash.merge HashByConversion.new({ :a => 1 })
+    merged = hash.merge HashByConversion.new({ a: 1 })
     assert_equal merged["a"], 1
   end
 
@@ -529,13 +529,13 @@ class HashExtTest < ActiveSupport::TestCase
     assert_equal :old_value, hash[:key]
 
     hash = HashWithIndifferentAccess.new("some" => "value", "other" => "value")
-    hash.reverse_merge!(:some => "noclobber", :another => "clobber")
+    hash.reverse_merge!(some: "noclobber", another: "clobber")
     assert_equal "value", hash[:some]
     assert_equal "clobber", hash[:another]
   end
 
   def test_indifferent_deleting
-    get_hash = proc{ { :a => "foo" }.with_indifferent_access }
+    get_hash = proc{ { a: "foo" }.with_indifferent_access }
     hash = get_hash.call
     assert_equal hash.delete(:a), "foo"
     assert_equal hash.delete(:a), nil
@@ -687,7 +687,7 @@ class HashExtTest < ActiveSupport::TestCase
     h = {"user" => {"id" => 5}}.with_indifferent_access
     ["user", :user].each {|user| [:id, "id"].each {|id| assert_equal 5, h[user][id], "h[#{user.inspect}][#{id.inspect}] should be 5"}}
 
-    h = {:user => {:id => 5}}.with_indifferent_access
+    h = {user: {id: 5}}.with_indifferent_access
     ["user", :user].each {|user| [:id, "id"].each {|id| assert_equal 5, h[user][id], "h[#{user.inspect}][#{id.inspect}] should be 5"}}
   end
 
@@ -710,32 +710,32 @@ class HashExtTest < ActiveSupport::TestCase
 
   def test_assert_valid_keys
     assert_nothing_raised do
-      { :failure => "stuff", :funny => "business" }.assert_valid_keys([ :failure, :funny ])
-      { :failure => "stuff", :funny => "business" }.assert_valid_keys(:failure, :funny)
+      { failure: "stuff", funny: "business" }.assert_valid_keys([ :failure, :funny ])
+      { failure: "stuff", funny: "business" }.assert_valid_keys(:failure, :funny)
     end
     # not all valid keys are required to be present
     assert_nothing_raised do
-      { :failure => "stuff", :funny => "business" }.assert_valid_keys([ :failure, :funny, :sunny ])
-      { :failure => "stuff", :funny => "business" }.assert_valid_keys(:failure, :funny, :sunny)
+      { failure: "stuff", funny: "business" }.assert_valid_keys([ :failure, :funny, :sunny ])
+      { failure: "stuff", funny: "business" }.assert_valid_keys(:failure, :funny, :sunny)
     end
 
     exception = assert_raise ArgumentError do
-      { :failore => "stuff", :funny => "business" }.assert_valid_keys([ :failure, :funny ])
+      { failore: "stuff", funny: "business" }.assert_valid_keys([ :failure, :funny ])
     end
     assert_equal "Unknown key: :failore. Valid keys are: :failure, :funny", exception.message
 
     exception = assert_raise ArgumentError do
-      { :failore => "stuff", :funny => "business" }.assert_valid_keys(:failure, :funny)
+      { failore: "stuff", funny: "business" }.assert_valid_keys(:failure, :funny)
     end
     assert_equal "Unknown key: :failore. Valid keys are: :failure, :funny", exception.message
 
     exception = assert_raise ArgumentError do
-      { :failore => "stuff", :funny => "business" }.assert_valid_keys([ :failure ])
+      { failore: "stuff", funny: "business" }.assert_valid_keys([ :failure ])
     end
     assert_equal "Unknown key: :failore. Valid keys are: :failure", exception.message
 
     exception = assert_raise ArgumentError do
-      { :failore => "stuff", :funny => "business" }.assert_valid_keys(:failure)
+      { failore: "stuff", funny: "business" }.assert_valid_keys(:failure)
     end
     assert_equal "Unknown key: :failore. Valid keys are: :failure", exception.message
   end
@@ -747,9 +747,9 @@ class HashExtTest < ActiveSupport::TestCase
   end
 
   def test_deep_merge
-    hash_1 = { :a => "a", :b => "b", :c => { :c1 => "c1", :c2 => "c2", :c3 => { :d1 => "d1" } } }
-    hash_2 = { :a => 1, :c => { :c1 => 2, :c3 => { :d2 => "d2" } } }
-    expected = { :a => 1, :b => "b", :c => { :c1 => 2, :c2 => "c2", :c3 => { :d1 => "d1", :d2 => "d2" } } }
+    hash_1 = { a: "a", b: "b", c: { c1: "c1", c2: "c2", c3: { d1: "d1" } } }
+    hash_2 = { a: 1, c: { c1: 2, c3: { d2: "d2" } } }
+    expected = { a: 1, b: "b", c: { c1: 2, c2: "c2", c3: { d1: "d1", d2: "d2" } } }
     assert_equal expected, hash_1.deep_merge(hash_2)
 
     hash_1.deep_merge!(hash_2)
@@ -757,9 +757,9 @@ class HashExtTest < ActiveSupport::TestCase
   end
 
   def test_deep_merge_with_block
-    hash_1 = { :a => "a", :b => "b", :c => { :c1 => "c1", :c2 => "c2", :c3 => { :d1 => "d1" } } }
-    hash_2 = { :a => 1, :c => { :c1 => 2, :c3 => { :d2 => "d2" } } }
-    expected = { :a => [:a, "a", 1], :b => "b", :c => { :c1 => [:c1, "c1", 2], :c2 => "c2", :c3 => { :d1 => "d1", :d2 => "d2" } } }
+    hash_1 = { a: "a", b: "b", c: { c1: "c1", c2: "c2", c3: { d1: "d1" } } }
+    hash_2 = { a: 1, c: { c1: 2, c3: { d2: "d2" } } }
+    expected = { a: [:a, "a", 1], b: "b", c: { c1: [:c1, "c1", 2], c2: "c2", c3: { d1: "d1", d2: "d2" } } }
     assert_equal(expected, hash_1.deep_merge(hash_2) { |k,o,n| [k, o, n] })
 
     hash_1.deep_merge!(hash_2) { |k,o,n| [k, o, n] }
@@ -777,9 +777,9 @@ class HashExtTest < ActiveSupport::TestCase
   end
 
   def test_deep_merge_on_indifferent_access
-    hash_1 = HashWithIndifferentAccess.new({ :a => "a", :b => "b", :c => { :c1 => "c1", :c2 => "c2", :c3 => { :d1 => "d1" } } })
-    hash_2 = HashWithIndifferentAccess.new({ :a => 1, :c => { :c1 => 2, :c3 => { :d2 => "d2" } } })
-    hash_3 = { :a => 1, :c => { :c1 => 2, :c3 => { :d2 => "d2" } } }
+    hash_1 = HashWithIndifferentAccess.new({ a: "a", b: "b", c: { c1: "c1", c2: "c2", c3: { d1: "d1" } } })
+    hash_2 = HashWithIndifferentAccess.new({ a: 1, c: { c1: 2, c3: { d2: "d2" } } })
+    hash_3 = { a: 1, c: { c1: 2, c3: { d2: "d2" } } }
     expected = { "a" => 1, "b" => "b", "c" => { "c1" => 2, "c2" => "c2", "c3" => { "d1" => "d1", "d2" => "d2" } } }
     assert_equal expected, hash_1.deep_merge(hash_2)
     assert_equal expected, hash_1.deep_merge(hash_3)
@@ -808,9 +808,9 @@ class HashExtTest < ActiveSupport::TestCase
   end
 
   def test_reverse_merge
-    defaults = { :a => "x", :b => "y", :c => 10 }.freeze
-    options  = { :a => 1, :b => 2 }
-    expected = { :a => 1, :b => 2, :c => 10 }
+    defaults = { a: "x", b: "y", c: 10 }.freeze
+    options  = { a: 1, b: 2 }
+    expected = { a: 1, b: 2, c: 10 }
 
     # Should merge defaults into options, creating a new hash.
     assert_equal expected, options.reverse_merge(defaults)
@@ -828,8 +828,8 @@ class HashExtTest < ActiveSupport::TestCase
   end
 
   def test_slice
-    original = { :a => "x", :b => "y", :c => 10 }
-    expected = { :a => "x", :b => "y" }
+    original = { a: "x", b: "y", c: 10 }
+    expected = { a: "x", b: "y" }
 
     # Should return a new hash with only the given keys.
     assert_equal expected, original.slice(:a, :b)
@@ -837,8 +837,8 @@ class HashExtTest < ActiveSupport::TestCase
   end
 
   def test_slice_inplace
-    original = { :a => "x", :b => "y", :c => 10 }
-    expected = { :c => 10 }
+    original = { a: "x", b: "y", c: 10 }
+    expected = { c: 10 }
 
     # Should replace the hash with only the given keys.
     assert_equal expected, original.slice!(:a, :b)
@@ -855,7 +855,7 @@ class HashExtTest < ActiveSupport::TestCase
 
   def test_slice_inplace_with_an_array_key
     original = { :a => "x", :b => "y", :c => 10, [:a, :b] => "an array key" }
-    expected = { :a => "x", :b => "y" }
+    expected = { a: "x", b: "y" }
 
     # Should replace the hash with only the given keys when given an array key.
     assert_equal expected, original.slice!([:a, :b], :c)
@@ -863,15 +863,15 @@ class HashExtTest < ActiveSupport::TestCase
 
   def test_slice_with_splatted_keys
     original = { :a => "x", :b => "y", :c => 10, [:a, :b] => "an array key" }
-    expected = { :a => "x", :b => "y" }
+    expected = { a: "x", b: "y" }
 
     # Should grab each of the splatted keys.
     assert_equal expected, original.slice(*[:a, :b])
   end
 
   def test_indifferent_slice
-    original = { :a => "x", :b => "y", :c => 10 }.with_indifferent_access
-    expected = { :a => "x", :b => "y" }.with_indifferent_access
+    original = { a: "x", b: "y", c: 10 }.with_indifferent_access
+    expected = { a: "x", b: "y" }.with_indifferent_access
 
     [["a", "b"], [:a, :b]].each do |keys|
       # Should return a new hash with only the given keys.
@@ -881,8 +881,8 @@ class HashExtTest < ActiveSupport::TestCase
   end
 
   def test_indifferent_slice_inplace
-    original = { :a => "x", :b => "y", :c => 10 }.with_indifferent_access
-    expected = { :c => 10 }.with_indifferent_access
+    original = { a: "x", b: "y", c: 10 }.with_indifferent_access
+    expected = { c: 10 }.with_indifferent_access
 
     [["a", "b"], [:a, :b]].each do |keys|
       # Should replace the hash with only the given keys.
@@ -920,17 +920,17 @@ class HashExtTest < ActiveSupport::TestCase
   end
 
   def test_extract
-    original = {:a => 1, :b => 2, :c => 3, :d => 4}
-    expected = {:a => 1, :b => 2}
-    remaining = {:c => 3, :d => 4}
+    original = {a: 1, b: 2, c: 3, d: 4}
+    expected = {a: 1, b: 2}
+    remaining = {c: 3, d: 4}
 
     assert_equal expected, original.extract!(:a, :b, :x)
     assert_equal remaining, original
   end
 
   def test_extract_nils
-    original = {:a => nil, :b => nil}
-    expected = {:a => nil}
+    original = {a: nil, b: nil}
+    expected = {a: nil}
     extracted = original.extract!(:a, :x)
 
     assert_equal expected, extracted
@@ -940,8 +940,8 @@ class HashExtTest < ActiveSupport::TestCase
 
   def test_indifferent_extract
     original = {:a => 1, "b" => 2, :c => 3, "d" => 4}.with_indifferent_access
-    expected = {:a => 1, :b => 2}.with_indifferent_access
-    remaining = {:c => 3, :d => 4}.with_indifferent_access
+    expected = {a: 1, b: 2}.with_indifferent_access
+    remaining = {c: 3, d: 4}.with_indifferent_access
 
     [["a", "b"], [:a, :b]].each do |keys|
       copy = original.dup
@@ -951,8 +951,8 @@ class HashExtTest < ActiveSupport::TestCase
   end
 
   def test_except
-    original = { :a => "x", :b => "y", :c => 10 }
-    expected = { :a => "x", :b => "y" }
+    original = { a: "x", b: "y", c: 10 }
+    expected = { a: "x", b: "y" }
 
     # Should return a new hash without the given keys.
     assert_equal expected, original.except(:c)
@@ -964,8 +964,8 @@ class HashExtTest < ActiveSupport::TestCase
   end
 
   def test_except_with_more_than_one_argument
-    original = { :a => "x", :b => "y", :c => 10 }
-    expected = { :a => "x" }
+    original = { a: "x", b: "y", c: 10 }
+    expected = { a: "x" }
 
     assert_equal expected, original.except(:b, :c)
 
@@ -974,7 +974,7 @@ class HashExtTest < ActiveSupport::TestCase
   end
 
   def test_except_with_original_frozen
-    original = { :a => "x", :b => "y" }
+    original = { a: "x", b: "y" }
     original.freeze
     assert_nothing_raised { original.except(:a) }
 
@@ -982,7 +982,7 @@ class HashExtTest < ActiveSupport::TestCase
   end
 
   def test_except_does_not_delete_values_in_original
-    original = { :a => "x", :b => "y" }
+    original = { a: "x", b: "y" }
     assert_not_called(original, :delete) do
       original.except(:a)
     end
@@ -1081,7 +1081,7 @@ end
 class IWriteMyOwnXML
   def to_xml(options = {})
     options[:indent] ||= 2
-    xml = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+    xml = options[:builder] ||= Builder::XmlMarkup.new(indent: options[:indent])
     xml.instruct! unless options[:skip_instruct]
     xml.level_one do
       xml.tag!(:second_level, "content")
@@ -1098,7 +1098,7 @@ class HashExtToParamTests < ActiveSupport::TestCase
 
   def test_string_hash
     assert_equal "", {}.to_param
-    assert_equal "hello=world", { :hello => "world" }.to_param
+    assert_equal "hello=world", { hello: "world" }.to_param
     assert_equal "hello=10", { "hello" => 10 }.to_param
     assert_equal "hello=world&say_bye=true", {:hello => "world", "say_bye" => true}.to_param
   end
@@ -1122,46 +1122,46 @@ end
 
 class HashToXmlTest < ActiveSupport::TestCase
   def setup
-    @xml_options = { :root => :person, :skip_instruct => true, :indent => 0 }
+    @xml_options = { root: :person, skip_instruct: true, indent: 0 }
   end
 
   def test_one_level
-    xml = { :name => "David", :street => "Paulina" }.to_xml(@xml_options)
+    xml = { name: "David", street: "Paulina" }.to_xml(@xml_options)
     assert_equal "<person>", xml.first(8)
     assert xml.include?(%(<street>Paulina</street>))
     assert xml.include?(%(<name>David</name>))
   end
 
   def test_one_level_dasherize_false
-    xml = { :name => "David", :street_name => "Paulina" }.to_xml(@xml_options.merge(:dasherize => false))
+    xml = { name: "David", street_name: "Paulina" }.to_xml(@xml_options.merge(dasherize: false))
     assert_equal "<person>", xml.first(8)
     assert xml.include?(%(<street_name>Paulina</street_name>))
     assert xml.include?(%(<name>David</name>))
   end
 
   def test_one_level_dasherize_true
-    xml = { :name => "David", :street_name => "Paulina" }.to_xml(@xml_options.merge(:dasherize => true))
+    xml = { name: "David", street_name: "Paulina" }.to_xml(@xml_options.merge(dasherize: true))
     assert_equal "<person>", xml.first(8)
     assert xml.include?(%(<street-name>Paulina</street-name>))
     assert xml.include?(%(<name>David</name>))
   end
 
   def test_one_level_camelize_true
-    xml = { :name => "David", :street_name => "Paulina" }.to_xml(@xml_options.merge(:camelize => true))
+    xml = { name: "David", street_name: "Paulina" }.to_xml(@xml_options.merge(camelize: true))
     assert_equal "<Person>", xml.first(8)
     assert xml.include?(%(<StreetName>Paulina</StreetName>))
     assert xml.include?(%(<Name>David</Name>))
   end
 
   def test_one_level_camelize_lower
-    xml = { :name => "David", :street_name => "Paulina" }.to_xml(@xml_options.merge(:camelize => :lower))
+    xml = { name: "David", street_name: "Paulina" }.to_xml(@xml_options.merge(camelize: :lower))
     assert_equal "<person>", xml.first(8)
     assert xml.include?(%(<streetName>Paulina</streetName>))
     assert xml.include?(%(<name>David</name>))
   end
 
   def test_one_level_with_types
-    xml = { :name => "David", :street => "Paulina", :age => 26, :age_in_millis => 820497600000, :moved_on => Date.new(2005, 11, 15), :resident => :yes }.to_xml(@xml_options)
+    xml = { name: "David", street: "Paulina", age: 26, age_in_millis: 820497600000, moved_on: Date.new(2005, 11, 15), resident: :yes }.to_xml(@xml_options)
     assert_equal "<person>", xml.first(8)
     assert xml.include?(%(<street>Paulina</street>))
     assert xml.include?(%(<name>David</name>))
@@ -1172,7 +1172,7 @@ class HashToXmlTest < ActiveSupport::TestCase
   end
 
   def test_one_level_with_nils
-    xml = { :name => "David", :street => "Paulina", :age => nil }.to_xml(@xml_options)
+    xml = { name: "David", street: "Paulina", age: nil }.to_xml(@xml_options)
     assert_equal "<person>", xml.first(8)
     assert xml.include?(%(<street>Paulina</street>))
     assert xml.include?(%(<name>David</name>))
@@ -1180,7 +1180,7 @@ class HashToXmlTest < ActiveSupport::TestCase
   end
 
   def test_one_level_with_skipping_types
-    xml = { :name => "David", :street => "Paulina", :age => nil }.to_xml(@xml_options.merge(:skip_types => true))
+    xml = { name: "David", street: "Paulina", age: nil }.to_xml(@xml_options.merge(skip_types: true))
     assert_equal "<person>", xml.first(8)
     assert xml.include?(%(<street>Paulina</street>))
     assert xml.include?(%(<name>David</name>))
@@ -1188,7 +1188,7 @@ class HashToXmlTest < ActiveSupport::TestCase
   end
 
   def test_one_level_with_yielding
-    xml = { :name => "David", :street => "Paulina" }.to_xml(@xml_options) do |x|
+    xml = { name: "David", street: "Paulina" }.to_xml(@xml_options) do |x|
       x.creator("Rails")
     end
 
@@ -1199,21 +1199,21 @@ class HashToXmlTest < ActiveSupport::TestCase
   end
 
   def test_two_levels
-    xml = { :name => "David", :address => { :street => "Paulina" } }.to_xml(@xml_options)
+    xml = { name: "David", address: { street: "Paulina" } }.to_xml(@xml_options)
     assert_equal "<person>", xml.first(8)
     assert xml.include?(%(<address><street>Paulina</street></address>))
     assert xml.include?(%(<name>David</name>))
   end
 
   def test_two_levels_with_second_level_overriding_to_xml
-    xml = { :name => "David", :address => { :street => "Paulina" }, :child => IWriteMyOwnXML.new }.to_xml(@xml_options)
+    xml = { name: "David", address: { street: "Paulina" }, child: IWriteMyOwnXML.new }.to_xml(@xml_options)
     assert_equal "<person>", xml.first(8)
     assert xml.include?(%(<address><street>Paulina</street></address>))
     assert xml.include?(%(<level_one><second_level>content</second_level></level_one>))
   end
 
   def test_two_levels_with_array
-    xml = { :name => "David", :addresses => [{ :street => "Paulina" }, { :street => "Evergreen" }] }.to_xml(@xml_options)
+    xml = { name: "David", addresses: [{ street: "Paulina" }, { street: "Evergreen" }] }.to_xml(@xml_options)
     assert_equal "<person>", xml.first(8)
     assert xml.include?(%(<addresses type="array"><address>))
     assert xml.include?(%(<address><street>Paulina</street></address>))
@@ -1222,14 +1222,14 @@ class HashToXmlTest < ActiveSupport::TestCase
   end
 
   def test_three_levels_with_array
-    xml = { :name => "David", :addresses => [{ :streets => [ { :name => "Paulina" }, { :name => "Paulina" } ] } ] }.to_xml(@xml_options)
+    xml = { name: "David", addresses: [{ streets: [ { name: "Paulina" }, { name: "Paulina" } ] } ] }.to_xml(@xml_options)
     assert xml.include?(%(<addresses type="array"><address><streets type="array"><street><name>))
   end
 
   def test_timezoned_attributes
     xml = {
-      :created_at => Time.utc(1999,2,2),
-      :local_created_at => Time.utc(1999,2,2).in_time_zone("Eastern Time (US & Canada)")
+      created_at: Time.utc(1999,2,2),
+      local_created_at: Time.utc(1999,2,2).in_time_zone("Eastern Time (US & Canada)")
     }.to_xml(@xml_options)
     assert_match %r{<created-at type=\"dateTime\">1999-02-02T00:00:00Z</created-at>}, xml
     assert_match %r{<local-created-at type=\"dateTime\">1999-02-01T19:00:00-05:00</local-created-at>}, xml
@@ -1268,17 +1268,17 @@ class HashToXmlTest < ActiveSupport::TestCase
     EOT
 
     expected_topic_hash = {
-      :title => "The First Topic",
-      :author_name => "David",
-      :id => 1,
-      :approved => false,
-      :replies_count => 0,
-      :replies_close_in => 2592000000,
-      :written_on => Date.new(2003, 7, 16),
-      :viewed_at => Time.utc(2003, 7, 16, 9, 28),
-      :content => "Have a nice day",
-      :author_email_address => "david@loudthinking.com",
-      :parent_id => nil
+      title: "The First Topic",
+      author_name: "David",
+      id: 1,
+      approved: false,
+      replies_count: 0,
+      replies_close_in: 2592000000,
+      written_on: Date.new(2003, 7, 16),
+      viewed_at: Time.utc(2003, 7, 16, 9, 28),
+      content: "Have a nice day",
+      author_email_address: "david@loudthinking.com",
+      parent_id: nil
     }.stringify_keys
 
     assert_equal expected_topic_hash, Hash.from_xml(topics_xml)["topics"].first
@@ -1303,18 +1303,18 @@ class HashToXmlTest < ActiveSupport::TestCase
     EOT
 
     expected_topic_hash = {
-      :title => "The First Topic",
-      :author_name => "David",
-      :id => 1,
-      :approved => true,
-      :replies_count => 0,
-      :replies_close_in => 2592000000,
-      :written_on => Date.new(2003, 7, 16),
-      :viewed_at => Time.utc(2003, 7, 16, 9, 28),
-      :author_email_address => "david@loudthinking.com",
-      :parent_id => nil,
-      :ad_revenue => BigDecimal("1.50"),
-      :optimum_viewing_angle => 135.0,
+      title: "The First Topic",
+      author_name: "David",
+      id: 1,
+      approved: true,
+      replies_count: 0,
+      replies_close_in: 2592000000,
+      written_on: Date.new(2003, 7, 16),
+      viewed_at: Time.utc(2003, 7, 16, 9, 28),
+      author_email_address: "david@loudthinking.com",
+      parent_id: nil,
+      ad_revenue: BigDecimal("1.50"),
+      optimum_viewing_angle: 135.0,
     }.stringify_keys
 
     assert_equal expected_topic_hash, Hash.from_xml(topic_xml)["topic"]
@@ -1333,12 +1333,12 @@ class HashToXmlTest < ActiveSupport::TestCase
     EOT
 
     expected_topic_hash = {
-      :title      => nil,
-      :id         => nil,
-      :approved   => nil,
-      :written_on => nil,
-      :viewed_at  => nil,
-      :parent_id  => nil
+      title: nil,
+      id: nil,
+      approved: nil,
+      written_on: nil,
+      viewed_at: nil,
+      parent_id: nil
     }.stringify_keys
 
     assert_equal expected_topic_hash, Hash.from_xml(topic_xml)["topic"]
@@ -1377,17 +1377,17 @@ class HashToXmlTest < ActiveSupport::TestCase
     EOT
 
     expected_topic_hash = {
-      :title => "The First Topic",
-      :author_name => "David",
-      :id => 1,
-      :approved => false,
-      :replies_count => 0,
-      :replies_close_in => 2592000000,
-      :written_on => Date.new(2003, 7, 16),
-      :viewed_at => Time.utc(2003, 7, 16, 9, 28),
-      :content => "Have a nice day",
-      :author_email_address => "david@loudthinking.com",
-      :parent_id => nil
+      title: "The First Topic",
+      author_name: "David",
+      id: 1,
+      approved: false,
+      replies_count: 0,
+      replies_close_in: 2592000000,
+      written_on: Date.new(2003, 7, 16),
+      viewed_at: Time.utc(2003, 7, 16, 9, 28),
+      content: "Have a nice day",
+      author_email_address: "david@loudthinking.com",
+      parent_id: nil
     }.stringify_keys
 
     assert_equal expected_topic_hash, Hash.from_xml(topics_xml)["topics"].first
@@ -1403,14 +1403,14 @@ class HashToXmlTest < ActiveSupport::TestCase
     EOT
 
     expected_topic_hash = {
-      :id => "175756086",
-      :owner => "55569174@N00",
-      :secret => "0279bf37a1",
-      :server => "76",
-      :title => "Colored Pencil PhotoBooth Fun",
-      :ispublic => "1",
-      :isfriend => "0",
-      :isfamily => "0",
+      id: "175756086",
+      owner: "55569174@N00",
+      secret: "0279bf37a1",
+      server: "76",
+      title: "Colored Pencil PhotoBooth Fun",
+      ispublic: "1",
+      isfriend: "0",
+      isfamily: "0",
     }.stringify_keys
 
     assert_equal expected_topic_hash, Hash.from_xml(topic_xml)["rsp"]["photos"]["photo"]
@@ -1535,13 +1535,13 @@ class HashToXmlTest < ActiveSupport::TestCase
     EOT
 
     expected_bacon_hash = {
-      :weight => 0.5,
-      :chunky => true,
-      :price => BigDecimal("12.50"),
-      :expires_at => Time.utc(2007,12,25,12,34,56),
-      :notes => "",
-      :illustration => "babe.png",
-      :caption => "That'll do, pig."
+      weight: 0.5,
+      chunky: true,
+      price: BigDecimal("12.50"),
+      expires_at: Time.utc(2007,12,25,12,34,56),
+      notes: "",
+      illustration: "babe.png",
+      caption: "That'll do, pig."
     }.stringify_keys
 
     assert_equal expected_bacon_hash, Hash.from_xml(bacon_xml)["bacon"]
@@ -1557,8 +1557,8 @@ class HashToXmlTest < ActiveSupport::TestCase
     EOT
 
     expected_product_hash = {
-      :weight => 0.5,
-      :image => {"type" => "ProductImage", "filename" => "image.gif" },
+      weight: 0.5,
+      image: {"type" => "ProductImage", "filename" => "image.gif" },
     }.stringify_keys
 
     assert_equal expected_product_hash, Hash.from_xml(product_xml)["product"]
@@ -1654,7 +1654,7 @@ class HashToXmlTest < ActiveSupport::TestCase
   # The XML builder seems to fail miserably when trying to tag something
   # with the same name as a Kernel method (throw, test, loop, select ...)
   def test_kernel_method_names_to_xml
-    hash     = { :throw => { :ball => "red" } }
+    hash     = { throw: { ball: "red" } }
     expected = "<person><throw><ball>red</ball></throw></person>"
 
     assert_nothing_raised do
@@ -1670,8 +1670,8 @@ class HashToXmlTest < ActiveSupport::TestCase
 
   def test_escaping_to_xml
     hash = {
-      :bare_string        => "First & Last Name",
-      :pre_escaped_string => "First &amp; Last Name"
+      bare_string: "First & Last Name",
+      pre_escaped_string: "First &amp; Last Name"
     }.stringify_keys
 
     expected_xml = "<person><bare-string>First &amp; Last Name</bare-string><pre-escaped-string>First &amp;amp; Last Name</pre-escaped-string></person>"
@@ -1681,16 +1681,16 @@ class HashToXmlTest < ActiveSupport::TestCase
   def test_unescaping_from_xml
     xml_string = "<person><bare-string>First &amp; Last Name</bare-string><pre-escaped-string>First &amp;amp; Last Name</pre-escaped-string></person>"
     expected_hash = {
-      :bare_string        => "First & Last Name",
-      :pre_escaped_string => "First &amp; Last Name"
+      bare_string: "First & Last Name",
+      pre_escaped_string: "First &amp; Last Name"
     }.stringify_keys
     assert_equal expected_hash, Hash.from_xml(xml_string)["person"]
   end
 
   def test_roundtrip_to_xml_from_xml
     hash = {
-      :bare_string        => "First & Last Name",
-      :pre_escaped_string => "First &amp; Last Name"
+      bare_string: "First & Last Name",
+      pre_escaped_string: "First &amp; Last Name"
     }.stringify_keys
 
     assert_equal hash, Hash.from_xml(hash.to_xml(@xml_options))["person"]
@@ -1735,10 +1735,10 @@ class HashToXmlTest < ActiveSupport::TestCase
   end
 
   def test_to_xml_dups_options
-    options = {:skip_instruct => true}
+    options = {skip_instruct: true}
     {}.to_xml(options)
     # :builder, etc, shouldn't be added to options
-    assert_equal({:skip_instruct => true}, options)
+    assert_equal({skip_instruct: true}, options)
   end
 
   def test_expansion_count_is_limited
diff --git a/activesupport/test/core_ext/module/attribute_accessor_test.rb b/activesupport/test/core_ext/module/attribute_accessor_test.rb
index 0c66e2c33c..fea6806b9b 100644
--- a/activesupport/test/core_ext/module/attribute_accessor_test.rb
+++ b/activesupport/test/core_ext/module/attribute_accessor_test.rb
@@ -5,9 +5,9 @@ class ModuleAttributeAccessorTest < ActiveSupport::TestCase
   def setup
     m = @module = Module.new do
       mattr_accessor :foo
-      mattr_accessor :bar, :instance_writer => false
-      mattr_reader   :shaq, :instance_reader => false
-      mattr_accessor :camp, :instance_accessor => false
+      mattr_accessor :bar, instance_writer: false
+      mattr_reader   :shaq, instance_reader: false
+      mattr_accessor :camp, instance_accessor: false
 
       cattr_accessor(:defa) { "default_accessor_value" }
       cattr_reader(:defr) { "default_reader_value" }
diff --git a/activesupport/test/core_ext/module_test.rb b/activesupport/test/core_ext/module_test.rb
index 3d7ec0ef91..9a2e52efa7 100644
--- a/activesupport/test/core_ext/module_test.rb
+++ b/activesupport/test/core_ext/module_test.rb
@@ -25,21 +25,21 @@ Somewhere = Struct.new(:street, :city) do
 end
 
 class Someone < Struct.new(:name, :place)
-  delegate :street, :city, :to_f, :to => :place
-  delegate :name=, :to => :place, :prefix => true
-  delegate :upcase, :to => "place.city"
-  delegate :table_name, :to => :class
-  delegate :table_name, :to => :class, :prefix => true
+  delegate :street, :city, :to_f, to: :place
+  delegate :name=, to: :place, prefix: true
+  delegate :upcase, to: "place.city"
+  delegate :table_name, to: :class
+  delegate :table_name, to: :class, prefix: true
 
   def self.table_name
     "some_table"
   end
 
   FAILED_DELEGATE_LINE = __LINE__ + 1
-  delegate :foo, :to => :place
+  delegate :foo, to: :place
 
   FAILED_DELEGATE_LINE_2 = __LINE__ + 1
-  delegate :bar, :to => :place, :allow_nil => true
+  delegate :bar, to: :place, allow_nil: true
 
   private
 
@@ -49,32 +49,32 @@ class Someone < Struct.new(:name, :place)
 end
 
 Invoice   = Struct.new(:client) do
-  delegate :street, :city, :name, :to => :client, :prefix => true
-  delegate :street, :city, :name, :to => :client, :prefix => :customer
+  delegate :street, :city, :name, to: :client, prefix: true
+  delegate :street, :city, :name, to: :client, prefix: :customer
 end
 
 Project   = Struct.new(:description, :person) do
-  delegate :name, :to => :person, :allow_nil => true
-  delegate :to_f, :to => :description, :allow_nil => true
+  delegate :name, to: :person, allow_nil: true
+  delegate :to_f, to: :description, allow_nil: true
 end
 
 Developer = Struct.new(:client) do
-  delegate :name, :to => :client, :prefix => nil
+  delegate :name, to: :client, prefix: nil
 end
 
 Event = Struct.new(:case) do
-  delegate :foo, :to => :case
+  delegate :foo, to: :case
 end
 
 Tester = Struct.new(:client) do
-  delegate :name, :to => :client, :prefix => false
+  delegate :name, to: :client, prefix: false
 
   def foo; 1; end
 end
 
 Product = Struct.new(:name) do
-  delegate :name, :to => :manufacturer, :prefix => true
-  delegate :name, :to => :type, :prefix => true
+  delegate :name, to: :manufacturer, prefix: true
+  delegate :name, to: :type, prefix: true
 
   def manufacturer
     @manufacturer ||= begin
@@ -114,15 +114,15 @@ HasBlock = Struct.new(:block) do
 end
 
 class ParameterSet
-  delegate :[], :[]=, :to => :@params
+  delegate :[], :[]=, to: :@params
 
   def initialize
-    @params = {:foo => "bar"}
+    @params = {foo: "bar"}
   end
 end
 
 class Name
-  delegate :upcase, :to => :@full_name
+  delegate :upcase, to: :@full_name
 
   def initialize(first, last)
     @full_name = "#{first} #{last}"
@@ -132,8 +132,8 @@ end
 class SideEffect
   attr_reader :ints
 
-  delegate :to_i, :to => :shift, :allow_nil => true
-  delegate :to_s, :to => :shift
+  delegate :to_i, to: :shift, allow_nil: true
+  delegate :to_s, to: :shift
 
   def initialize
     @ints = [1, 2, 3]
@@ -189,7 +189,7 @@ class ModuleTest < ActiveSupport::TestCase
       Name.send :delegate, :nowhere
     end
     assert_raise(ArgumentError) do
-      Name.send :delegate, :noplace, :tos => :hollywood
+      Name.send :delegate, :noplace, tos: :hollywood
     end
   end
 
@@ -233,7 +233,7 @@ class ModuleTest < ActiveSupport::TestCase
         def initialize(client)
           @client = client
         end
-        delegate :name, :address, :to => :@client, :prefix => true
+        delegate :name, :address, to: :@client, prefix: true
       end
     end
   end
@@ -261,7 +261,7 @@ class ModuleTest < ActiveSupport::TestCase
 
   def test_delegation_with_allow_nil_and_nil_value_and_prefix
     Project.class_eval do
-      delegate :name, :to => :person, :allow_nil => true, :prefix => true
+      delegate :name, to: :person, allow_nil: true, prefix: true
     end
     rails = Project.new("Rails")
     assert_nil rails.person_name
@@ -290,7 +290,7 @@ class ModuleTest < ActiveSupport::TestCase
     assert_nothing_raised do
       Class.new(parent) do
         class << self
-          delegate :parent_method, :to => :superclass
+          delegate :parent_method, to: :superclass
         end
       end
     end
diff --git a/activesupport/test/core_ext/numeric_ext_test.rb b/activesupport/test/core_ext/numeric_ext_test.rb
index 793f34897c..fc93a18ab1 100644
--- a/activesupport/test/core_ext/numeric_ext_test.rb
+++ b/activesupport/test/core_ext/numeric_ext_test.rb
@@ -23,41 +23,41 @@ class NumericExtTimeAndDateTimeTest < ActiveSupport::TestCase
   end
 
   def test_irregular_durations
-    assert_equal @now.advance(:days => 3000), 3000.days.since(@now)
-    assert_equal @now.advance(:months => 1), 1.month.since(@now)
-    assert_equal @now.advance(:months => -1), 1.month.until(@now)
-    assert_equal @now.advance(:years => 20), 20.years.since(@now)
-    assert_equal @dtnow.advance(:days => 3000), 3000.days.since(@dtnow)
-    assert_equal @dtnow.advance(:months => 1), 1.month.since(@dtnow)
-    assert_equal @dtnow.advance(:months => -1), 1.month.until(@dtnow)
-    assert_equal @dtnow.advance(:years => 20), 20.years.since(@dtnow)
+    assert_equal @now.advance(days: 3000), 3000.days.since(@now)
+    assert_equal @now.advance(months: 1), 1.month.since(@now)
+    assert_equal @now.advance(months: -1), 1.month.until(@now)
+    assert_equal @now.advance(years: 20), 20.years.since(@now)
+    assert_equal @dtnow.advance(days: 3000), 3000.days.since(@dtnow)
+    assert_equal @dtnow.advance(months: 1), 1.month.since(@dtnow)
+    assert_equal @dtnow.advance(months: -1), 1.month.until(@dtnow)
+    assert_equal @dtnow.advance(years: 20), 20.years.since(@dtnow)
   end
 
   def test_duration_addition
-    assert_equal @now.advance(:days => 1).advance(:months => 1), (1.day + 1.month).since(@now)
-    assert_equal @now.advance(:days => 7), (1.week + 5.seconds - 5.seconds).since(@now)
-    assert_equal @now.advance(:years => 2), (4.years - 2.years).since(@now)
-    assert_equal @dtnow.advance(:days => 1).advance(:months => 1), (1.day + 1.month).since(@dtnow)
-    assert_equal @dtnow.advance(:days => 7), (1.week + 5.seconds - 5.seconds).since(@dtnow)
-    assert_equal @dtnow.advance(:years => 2), (4.years - 2.years).since(@dtnow)
+    assert_equal @now.advance(days: 1).advance(months: 1), (1.day + 1.month).since(@now)
+    assert_equal @now.advance(days: 7), (1.week + 5.seconds - 5.seconds).since(@now)
+    assert_equal @now.advance(years: 2), (4.years - 2.years).since(@now)
+    assert_equal @dtnow.advance(days: 1).advance(months: 1), (1.day + 1.month).since(@dtnow)
+    assert_equal @dtnow.advance(days: 7), (1.week + 5.seconds - 5.seconds).since(@dtnow)
+    assert_equal @dtnow.advance(years: 2), (4.years - 2.years).since(@dtnow)
   end
 
   def test_time_plus_duration
     assert_equal @now + 8, @now + 8.seconds
     assert_equal @now + 22.9, @now + 22.9.seconds
-    assert_equal @now.advance(:days => 15), @now + 15.days
-    assert_equal @now.advance(:months => 1), @now + 1.month
+    assert_equal @now.advance(days: 15), @now + 15.days
+    assert_equal @now.advance(months: 1), @now + 1.month
     assert_equal @dtnow.since(8), @dtnow + 8.seconds
     assert_equal @dtnow.since(22.9), @dtnow + 22.9.seconds
-    assert_equal @dtnow.advance(:days => 15), @dtnow + 15.days
-    assert_equal @dtnow.advance(:months => 1), @dtnow + 1.month
+    assert_equal @dtnow.advance(days: 15), @dtnow + 15.days
+    assert_equal @dtnow.advance(months: 1), @dtnow + 1.month
   end
 
   def test_chaining_duration_operations
-    assert_equal @now.advance(:days => 2).advance(:months => -3), @now + 2.days - 3.months
-    assert_equal @now.advance(:days => 1).advance(:months => 2), @now + 1.day + 2.months
-    assert_equal @dtnow.advance(:days => 2).advance(:months => -3), @dtnow + 2.days - 3.months
-    assert_equal @dtnow.advance(:days => 1).advance(:months => 2), @dtnow + 1.day + 2.months
+    assert_equal @now.advance(days: 2).advance(months: -3), @now + 2.days - 3.months
+    assert_equal @now.advance(days: 1).advance(months: 2), @now + 1.day + 2.months
+    assert_equal @dtnow.advance(days: 2).advance(months: -3), @dtnow + 2.days - 3.months
+    assert_equal @dtnow.advance(days: 1).advance(months: 2), @dtnow + 1.day + 2.months
   end
 
   def test_duration_after_conversion_is_no_longer_accurate
@@ -87,8 +87,8 @@ class NumericExtDateTest < ActiveSupport::TestCase
   end
 
   def test_chaining_duration_operations
-    assert_equal @today.advance(:days => 2).advance(:months => -3), @today + 2.days - 3.months
-    assert_equal @today.advance(:days => 1).advance(:months => 2), @today + 1.day + 2.months
+    assert_equal @today.advance(days: 2).advance(months: -3), @today + 2.days - 3.months
+    assert_equal @today.advance(days: 1).advance(months: 2), @today + 1.day + 2.months
   end
 
   def test_add_one_year_to_leap_day
@@ -154,53 +154,53 @@ class NumericExtFormattingTest < ActiveSupport::TestCase
   def test_to_s__phone
     assert_equal("555-1234", 5551234.to_s(:phone))
     assert_equal("800-555-1212", 8005551212.to_s(:phone))
-    assert_equal("(800) 555-1212", 8005551212.to_s(:phone, :area_code => true))
-    assert_equal("800 555 1212", 8005551212.to_s(:phone, :delimiter => " "))
-    assert_equal("(800) 555-1212 x 123", 8005551212.to_s(:phone, :area_code => true, :extension => 123))
-    assert_equal("800-555-1212", 8005551212.to_s(:phone, :extension => "  "))
-    assert_equal("555.1212", 5551212.to_s(:phone, :delimiter => "."))
-    assert_equal("+1-800-555-1212", 8005551212.to_s(:phone, :country_code => 1))
-    assert_equal("+18005551212", 8005551212.to_s(:phone, :country_code => 1, :delimiter => ""))
+    assert_equal("(800) 555-1212", 8005551212.to_s(:phone, area_code: true))
+    assert_equal("800 555 1212", 8005551212.to_s(:phone, delimiter: " "))
+    assert_equal("(800) 555-1212 x 123", 8005551212.to_s(:phone, area_code: true, extension: 123))
+    assert_equal("800-555-1212", 8005551212.to_s(:phone, extension: "  "))
+    assert_equal("555.1212", 5551212.to_s(:phone, delimiter: "."))
+    assert_equal("+1-800-555-1212", 8005551212.to_s(:phone, country_code: 1))
+    assert_equal("+18005551212", 8005551212.to_s(:phone, country_code: 1, delimiter: ""))
     assert_equal("22-555-1212", 225551212.to_s(:phone))
-    assert_equal("+45-22-555-1212", 225551212.to_s(:phone, :country_code => 45))
+    assert_equal("+45-22-555-1212", 225551212.to_s(:phone, country_code: 45))
   end
 
   def test_to_s__currency
     assert_equal("$1,234,567,890.50", 1234567890.50.to_s(:currency))
     assert_equal("$1,234,567,890.51", 1234567890.506.to_s(:currency))
     assert_equal("-$1,234,567,890.50", -1234567890.50.to_s(:currency))
-    assert_equal("-$ 1,234,567,890.50", -1234567890.50.to_s(:currency, :format => "%u %n"))
-    assert_equal("($1,234,567,890.50)", -1234567890.50.to_s(:currency, :negative_format => "(%u%n)"))
-    assert_equal("$1,234,567,892", 1234567891.50.to_s(:currency, :precision => 0))
-    assert_equal("$1,234,567,890.5", 1234567890.50.to_s(:currency, :precision => 1))
-    assert_equal("&pound;1234567890,50", 1234567890.50.to_s(:currency, :unit => "&pound;", :separator => ",", :delimiter => ""))
+    assert_equal("-$ 1,234,567,890.50", -1234567890.50.to_s(:currency, format: "%u %n"))
+    assert_equal("($1,234,567,890.50)", -1234567890.50.to_s(:currency, negative_format: "(%u%n)"))
+    assert_equal("$1,234,567,892", 1234567891.50.to_s(:currency, precision: 0))
+    assert_equal("$1,234,567,890.5", 1234567890.50.to_s(:currency, precision: 1))
+    assert_equal("&pound;1234567890,50", 1234567890.50.to_s(:currency, unit: "&pound;", separator: ",", delimiter: ""))
   end
 
 
   def test_to_s__rounded
     assert_equal("-111.235", -111.2346.to_s(:rounded))
     assert_equal("111.235", 111.2346.to_s(:rounded))
-    assert_equal("31.83", 31.825.to_s(:rounded, :precision => 2))
-    assert_equal("111.23", 111.2346.to_s(:rounded, :precision => 2))
-    assert_equal("111.00", 111.to_s(:rounded, :precision => 2))
-    assert_equal("3268", (32.6751 * 100.00).to_s(:rounded, :precision => 0))
-    assert_equal("112", 111.50.to_s(:rounded, :precision => 0))
-    assert_equal("1234567892", 1234567891.50.to_s(:rounded, :precision => 0))
-    assert_equal("0", 0.to_s(:rounded, :precision => 0))
-    assert_equal("0.00100", 0.001.to_s(:rounded, :precision => 5))
-    assert_equal("0.001", 0.00111.to_s(:rounded, :precision => 3))
-    assert_equal("10.00", 9.995.to_s(:rounded, :precision => 2))
-    assert_equal("11.00", 10.995.to_s(:rounded, :precision => 2))
-    assert_equal("0.00", -0.001.to_s(:rounded, :precision => 2))
+    assert_equal("31.83", 31.825.to_s(:rounded, precision: 2))
+    assert_equal("111.23", 111.2346.to_s(:rounded, precision: 2))
+    assert_equal("111.00", 111.to_s(:rounded, precision: 2))
+    assert_equal("3268", (32.6751 * 100.00).to_s(:rounded, precision: 0))
+    assert_equal("112", 111.50.to_s(:rounded, precision: 0))
+    assert_equal("1234567892", 1234567891.50.to_s(:rounded, precision: 0))
+    assert_equal("0", 0.to_s(:rounded, precision: 0))
+    assert_equal("0.00100", 0.001.to_s(:rounded, precision: 5))
+    assert_equal("0.001", 0.00111.to_s(:rounded, precision: 3))
+    assert_equal("10.00", 9.995.to_s(:rounded, precision: 2))
+    assert_equal("11.00", 10.995.to_s(:rounded, precision: 2))
+    assert_equal("0.00", -0.001.to_s(:rounded, precision: 2))
   end
 
   def test_to_s__percentage
     assert_equal("100.000%", 100.to_s(:percentage))
-    assert_equal("100%", 100.to_s(:percentage, :precision => 0))
-    assert_equal("302.06%", 302.0574.to_s(:percentage, :precision => 2))
-    assert_equal("123.4%", 123.400.to_s(:percentage, :precision => 3, :strip_insignificant_zeros => true))
-    assert_equal("1.000,000%", 1000.to_s(:percentage, :delimiter => ".", :separator => ","))
-    assert_equal("1000.000  %", 1000.to_s(:percentage, :format => "%n  %"))
+    assert_equal("100%", 100.to_s(:percentage, precision: 0))
+    assert_equal("302.06%", 302.0574.to_s(:percentage, precision: 2))
+    assert_equal("123.4%", 123.400.to_s(:percentage, precision: 3, strip_insignificant_zeros: true))
+    assert_equal("1.000,000%", 1000.to_s(:percentage, delimiter: ".", separator: ","))
+    assert_equal("1000.000  %", 1000.to_s(:percentage, format: "%n  %"))
   end
 
   def test_to_s__delimited
@@ -216,51 +216,51 @@ class NumericExtFormattingTest < ActiveSupport::TestCase
   end
 
   def test_to_s__delimited__with_options_hash
-    assert_equal "12 345 678", 12345678.to_s(:delimited, :delimiter => " ")
-    assert_equal "12,345,678-05", 12345678.05.to_s(:delimited, :separator => "-")
-    assert_equal "12.345.678,05", 12345678.05.to_s(:delimited, :separator => ",", :delimiter => ".")
-    assert_equal "12.345.678,05", 12345678.05.to_s(:delimited, :delimiter => ".", :separator => ",")
+    assert_equal "12 345 678", 12345678.to_s(:delimited, delimiter: " ")
+    assert_equal "12,345,678-05", 12345678.05.to_s(:delimited, separator: "-")
+    assert_equal "12.345.678,05", 12345678.05.to_s(:delimited, separator: ",", delimiter: ".")
+    assert_equal "12.345.678,05", 12345678.05.to_s(:delimited, delimiter: ".", separator: ",")
   end
 
 
   def test_to_s__rounded_with_custom_delimiter_and_separator
-    assert_equal "31,83",       31.825.to_s(:rounded, :precision => 2, :separator => ",")
-    assert_equal "1.231,83",    1231.825.to_s(:rounded, :precision => 2, :separator => ",", :delimiter => ".")
+    assert_equal "31,83",       31.825.to_s(:rounded, precision: 2, separator: ",")
+    assert_equal "1.231,83",    1231.825.to_s(:rounded, precision: 2, separator: ",", delimiter: ".")
   end
 
   def test_to_s__rounded__with_significant_digits
-    assert_equal "124000", 123987.to_s(:rounded, :precision => 3, :significant => true)
-    assert_equal "120000000", 123987876.to_s(:rounded, :precision => 2, :significant => true )
-    assert_equal "9775", 9775.to_s(:rounded, :precision => 4, :significant => true )
-    assert_equal "5.4", 5.3923.to_s(:rounded, :precision => 2, :significant => true )
-    assert_equal "5", 5.3923.to_s(:rounded, :precision => 1, :significant => true )
-    assert_equal "1", 1.232.to_s(:rounded, :precision => 1, :significant => true )
-    assert_equal "7", 7.to_s(:rounded, :precision => 1, :significant => true )
-    assert_equal "1", 1.to_s(:rounded, :precision => 1, :significant => true )
-    assert_equal "53", 52.7923.to_s(:rounded, :precision => 2, :significant => true )
-    assert_equal "9775.00", 9775.to_s(:rounded, :precision => 6, :significant => true )
-    assert_equal "5.392900", 5.3929.to_s(:rounded, :precision => 7, :significant => true )
-    assert_equal "0.0", 0.to_s(:rounded, :precision => 2, :significant => true )
-    assert_equal "0", 0.to_s(:rounded, :precision => 1, :significant => true )
-    assert_equal "0.0001", 0.0001.to_s(:rounded, :precision => 1, :significant => true )
-    assert_equal "0.000100", 0.0001.to_s(:rounded, :precision => 3, :significant => true )
-    assert_equal "0.0001", 0.0001111.to_s(:rounded, :precision => 1, :significant => true )
-    assert_equal "10.0", 9.995.to_s(:rounded, :precision => 3, :significant => true)
-    assert_equal "9.99", 9.994.to_s(:rounded, :precision => 3, :significant => true)
-    assert_equal "11.0", 10.995.to_s(:rounded, :precision => 3, :significant => true)
+    assert_equal "124000", 123987.to_s(:rounded, precision: 3, significant: true)
+    assert_equal "120000000", 123987876.to_s(:rounded, precision: 2, significant: true )
+    assert_equal "9775", 9775.to_s(:rounded, precision: 4, significant: true )
+    assert_equal "5.4", 5.3923.to_s(:rounded, precision: 2, significant: true )
+    assert_equal "5", 5.3923.to_s(:rounded, precision: 1, significant: true )
+    assert_equal "1", 1.232.to_s(:rounded, precision: 1, significant: true )
+    assert_equal "7", 7.to_s(:rounded, precision: 1, significant: true )
+    assert_equal "1", 1.to_s(:rounded, precision: 1, significant: true )
+    assert_equal "53", 52.7923.to_s(:rounded, precision: 2, significant: true )
+    assert_equal "9775.00", 9775.to_s(:rounded, precision: 6, significant: true )
+    assert_equal "5.392900", 5.3929.to_s(:rounded, precision: 7, significant: true )
+    assert_equal "0.0", 0.to_s(:rounded, precision: 2, significant: true )
+    assert_equal "0", 0.to_s(:rounded, precision: 1, significant: true )
+    assert_equal "0.0001", 0.0001.to_s(:rounded, precision: 1, significant: true )
+    assert_equal "0.000100", 0.0001.to_s(:rounded, precision: 3, significant: true )
+    assert_equal "0.0001", 0.0001111.to_s(:rounded, precision: 1, significant: true )
+    assert_equal "10.0", 9.995.to_s(:rounded, precision: 3, significant: true)
+    assert_equal "9.99", 9.994.to_s(:rounded, precision: 3, significant: true)
+    assert_equal "11.0", 10.995.to_s(:rounded, precision: 3, significant: true)
   end
 
   def test_to_s__rounded__with_strip_insignificant_zeros
-    assert_equal "9775.43", 9775.43.to_s(:rounded, :precision => 4, :strip_insignificant_zeros => true )
-    assert_equal "9775.2", 9775.2.to_s(:rounded, :precision => 6, :significant => true, :strip_insignificant_zeros => true )
-    assert_equal "0", 0.to_s(:rounded, :precision => 6, :significant => true, :strip_insignificant_zeros => true )
+    assert_equal "9775.43", 9775.43.to_s(:rounded, precision: 4, strip_insignificant_zeros: true )
+    assert_equal "9775.2", 9775.2.to_s(:rounded, precision: 6, significant: true, strip_insignificant_zeros: true )
+    assert_equal "0", 0.to_s(:rounded, precision: 6, significant: true, strip_insignificant_zeros: true )
   end
 
   def test_to_s__rounded__with_significant_true_and_zero_precision
     # Zero precision with significant is a mistake (would always return zero),
     # so we treat it as if significant was false (increases backwards compatibility for number_to_human_size)
-    assert_equal "124", 123.987.to_s(:rounded, :precision => 0, :significant => true)
-    assert_equal "12", 12.to_s(:rounded, :precision => 0, :significant => true )
+    assert_equal "124", 123.987.to_s(:rounded, precision: 0, significant: true)
+    assert_equal "12", 12.to_s(:rounded, precision: 0, significant: true )
   end
 
   def test_to_s__human_size
@@ -280,50 +280,50 @@ class NumericExtFormattingTest < ActiveSupport::TestCase
     assert_equal "444 KB",    kilobytes(444).to_s(:human_size)
     assert_equal "1020 MB",   megabytes(1023).to_s(:human_size)
     assert_equal "3 TB",      terabytes(3).to_s(:human_size)
-    assert_equal "1.2 MB",    1234567.to_s(:human_size, :precision => 2)
-    assert_equal "3 Bytes",   3.14159265.to_s(:human_size, :precision => 4)
-    assert_equal "1 KB",      kilobytes(1.0123).to_s(:human_size, :precision => 2)
-    assert_equal "1.01 KB",   kilobytes(1.0100).to_s(:human_size, :precision => 4)
-    assert_equal "10 KB",     kilobytes(10.000).to_s(:human_size, :precision => 4)
+    assert_equal "1.2 MB",    1234567.to_s(:human_size, precision: 2)
+    assert_equal "3 Bytes",   3.14159265.to_s(:human_size, precision: 4)
+    assert_equal "1 KB",      kilobytes(1.0123).to_s(:human_size, precision: 2)
+    assert_equal "1.01 KB",   kilobytes(1.0100).to_s(:human_size, precision: 4)
+    assert_equal "10 KB",     kilobytes(10.000).to_s(:human_size, precision: 4)
     assert_equal "1 Byte",    1.1.to_s(:human_size)
     assert_equal "10 Bytes",  10.to_s(:human_size)
   end
 
   def test_to_s__human_size_with_si_prefix
     assert_deprecated do
-      assert_equal "3 Bytes",    3.14159265.to_s(:human_size, :prefix => :si)
-      assert_equal "123 Bytes",  123.0.to_s(:human_size, :prefix => :si)
-      assert_equal "123 Bytes",  123.to_s(:human_size, :prefix => :si)
-      assert_equal "1.23 KB",    1234.to_s(:human_size, :prefix => :si)
-      assert_equal "12.3 KB",    12345.to_s(:human_size, :prefix => :si)
-      assert_equal "1.23 MB",    1234567.to_s(:human_size, :prefix => :si)
-      assert_equal "1.23 GB",    1234567890.to_s(:human_size, :prefix => :si)
-      assert_equal "1.23 TB",    1234567890123.to_s(:human_size, :prefix => :si)
-      assert_equal "1.23 PB",    1234567890123456.to_s(:human_size, :prefix => :si)
-      assert_equal "1.23 EB",    1234567890123456789.to_s(:human_size, :prefix => :si)
+      assert_equal "3 Bytes",    3.14159265.to_s(:human_size, prefix: :si)
+      assert_equal "123 Bytes",  123.0.to_s(:human_size, prefix: :si)
+      assert_equal "123 Bytes",  123.to_s(:human_size, prefix: :si)
+      assert_equal "1.23 KB",    1234.to_s(:human_size, prefix: :si)
+      assert_equal "12.3 KB",    12345.to_s(:human_size, prefix: :si)
+      assert_equal "1.23 MB",    1234567.to_s(:human_size, prefix: :si)
+      assert_equal "1.23 GB",    1234567890.to_s(:human_size, prefix: :si)
+      assert_equal "1.23 TB",    1234567890123.to_s(:human_size, prefix: :si)
+      assert_equal "1.23 PB",    1234567890123456.to_s(:human_size, prefix: :si)
+      assert_equal "1.23 EB",    1234567890123456789.to_s(:human_size, prefix: :si)
     end
   end
 
   def test_to_s__human_size_with_options_hash
-    assert_equal "1.2 MB",   1234567.to_s(:human_size, :precision => 2)
-    assert_equal "3 Bytes",  3.14159265.to_s(:human_size, :precision => 4)
-    assert_equal "1 KB",     kilobytes(1.0123).to_s(:human_size, :precision => 2)
-    assert_equal "1.01 KB",  kilobytes(1.0100).to_s(:human_size, :precision => 4)
-    assert_equal "10 KB",    kilobytes(10.000).to_s(:human_size, :precision => 4)
-    assert_equal "1 TB",     1234567890123.to_s(:human_size, :precision => 1)
-    assert_equal "500 MB",   524288000.to_s(:human_size, :precision=>3)
-    assert_equal "10 MB",    9961472.to_s(:human_size, :precision=>0)
-    assert_equal "40 KB",    41010.to_s(:human_size, :precision => 1)
-    assert_equal "40 KB",    41100.to_s(:human_size, :precision => 2)
-    assert_equal "1.0 KB",   kilobytes(1.0123).to_s(:human_size, :precision => 2, :strip_insignificant_zeros => false)
-    assert_equal "1.012 KB", kilobytes(1.0123).to_s(:human_size, :precision => 3, :significant => false)
-    assert_equal "1 KB",     kilobytes(1.0123).to_s(:human_size, :precision => 0, :significant => true) #ignores significant it precision is 0
+    assert_equal "1.2 MB",   1234567.to_s(:human_size, precision: 2)
+    assert_equal "3 Bytes",  3.14159265.to_s(:human_size, precision: 4)
+    assert_equal "1 KB",     kilobytes(1.0123).to_s(:human_size, precision: 2)
+    assert_equal "1.01 KB",  kilobytes(1.0100).to_s(:human_size, precision: 4)
+    assert_equal "10 KB",    kilobytes(10.000).to_s(:human_size, precision: 4)
+    assert_equal "1 TB",     1234567890123.to_s(:human_size, precision: 1)
+    assert_equal "500 MB",   524288000.to_s(:human_size, precision: 3)
+    assert_equal "10 MB",    9961472.to_s(:human_size, precision: 0)
+    assert_equal "40 KB",    41010.to_s(:human_size, precision: 1)
+    assert_equal "40 KB",    41100.to_s(:human_size, precision: 2)
+    assert_equal "1.0 KB",   kilobytes(1.0123).to_s(:human_size, precision: 2, strip_insignificant_zeros: false)
+    assert_equal "1.012 KB", kilobytes(1.0123).to_s(:human_size, precision: 3, significant: false)
+    assert_equal "1 KB",     kilobytes(1.0123).to_s(:human_size, precision: 0, significant: true) #ignores significant it precision is 0
   end
 
   def test_to_s__human_size_with_custom_delimiter_and_separator
-    assert_equal "1,01 KB",     kilobytes(1.0123).to_s(:human_size, :precision => 3, :separator => ",")
-    assert_equal "1,01 KB",     kilobytes(1.0100).to_s(:human_size, :precision => 4, :separator => ",")
-    assert_equal "1.000,1 TB",  terabytes(1000.1).to_s(:human_size, :precision => 5, :delimiter => ".", :separator => ",")
+    assert_equal "1,01 KB",     kilobytes(1.0123).to_s(:human_size, precision: 3, separator: ",")
+    assert_equal "1,01 KB",     kilobytes(1.0100).to_s(:human_size, precision: 4, separator: ",")
+    assert_equal "1.000,1 TB",  terabytes(1000.1).to_s(:human_size, precision: 5, delimiter: ".", separator: ",")
   end
 
   def test_number_to_human
@@ -339,51 +339,51 @@ class NumericExtFormattingTest < ActiveSupport::TestCase
     assert_equal "1.23 Trillion", 1234567890123.to_s(:human)
     assert_equal "1.23 Quadrillion", 1234567890123456.to_s(:human)
     assert_equal "1230 Quadrillion", 1234567890123456789.to_s(:human)
-    assert_equal "490 Thousand", 489939.to_s(:human, :precision => 2)
-    assert_equal "489.9 Thousand", 489939.to_s(:human, :precision => 4)
-    assert_equal "489 Thousand", 489000.to_s(:human, :precision => 4)
-    assert_equal "489.0 Thousand", 489000.to_s(:human, :precision => 4, :strip_insignificant_zeros => false)
-    assert_equal "1.2346 Million", 1234567.to_s(:human, :precision => 4, :significant => false)
-    assert_equal "1,2 Million", 1234567.to_s(:human, :precision => 1, :significant => false, :separator => ",")
-    assert_equal "1 Million", 1234567.to_s(:human, :precision => 0, :significant => true, :separator => ",") #significant forced to false
+    assert_equal "490 Thousand", 489939.to_s(:human, precision: 2)
+    assert_equal "489.9 Thousand", 489939.to_s(:human, precision: 4)
+    assert_equal "489 Thousand", 489000.to_s(:human, precision: 4)
+    assert_equal "489.0 Thousand", 489000.to_s(:human, precision: 4, strip_insignificant_zeros: false)
+    assert_equal "1.2346 Million", 1234567.to_s(:human, precision: 4, significant: false)
+    assert_equal "1,2 Million", 1234567.to_s(:human, precision: 1, significant: false, separator: ",")
+    assert_equal "1 Million", 1234567.to_s(:human, precision: 0, significant: true, separator: ",") #significant forced to false
   end
 
   def test_number_to_human_with_custom_units
     #Only integers
-    volume = {:unit => "ml", :thousand => "lt", :million => "m3"}
-    assert_equal "123 lt", 123456.to_s(:human, :units => volume)
-    assert_equal "12 ml", 12.to_s(:human, :units => volume)
-    assert_equal "1.23 m3", 1234567.to_s(:human, :units => volume)
+    volume = {unit: "ml", thousand: "lt", million: "m3"}
+    assert_equal "123 lt", 123456.to_s(:human, units: volume)
+    assert_equal "12 ml", 12.to_s(:human, units: volume)
+    assert_equal "1.23 m3", 1234567.to_s(:human, units: volume)
 
     #Including fractionals
-    distance = {:mili => "mm", :centi => "cm", :deci => "dm", :unit => "m", :ten => "dam", :hundred => "hm", :thousand => "km"}
-    assert_equal "1.23 mm", 0.00123.to_s(:human, :units => distance)
-    assert_equal "1.23 cm", 0.0123.to_s(:human, :units => distance)
-    assert_equal "1.23 dm", 0.123.to_s(:human, :units => distance)
-    assert_equal "1.23 m",  1.23.to_s(:human, :units => distance)
-    assert_equal "1.23 dam", 12.3.to_s(:human, :units => distance)
-    assert_equal "1.23 hm", 123.to_s(:human, :units => distance)
-    assert_equal "1.23 km", 1230.to_s(:human, :units => distance)
-    assert_equal "1.23 km", 1230.to_s(:human, :units => distance)
-    assert_equal "1.23 km", 1230.to_s(:human, :units => distance)
-    assert_equal "12.3 km", 12300.to_s(:human, :units => distance)
+    distance = {mili: "mm", centi: "cm", deci: "dm", unit: "m", ten: "dam", hundred: "hm", thousand: "km"}
+    assert_equal "1.23 mm", 0.00123.to_s(:human, units: distance)
+    assert_equal "1.23 cm", 0.0123.to_s(:human, units: distance)
+    assert_equal "1.23 dm", 0.123.to_s(:human, units: distance)
+    assert_equal "1.23 m",  1.23.to_s(:human, units: distance)
+    assert_equal "1.23 dam", 12.3.to_s(:human, units: distance)
+    assert_equal "1.23 hm", 123.to_s(:human, units: distance)
+    assert_equal "1.23 km", 1230.to_s(:human, units: distance)
+    assert_equal "1.23 km", 1230.to_s(:human, units: distance)
+    assert_equal "1.23 km", 1230.to_s(:human, units: distance)
+    assert_equal "12.3 km", 12300.to_s(:human, units: distance)
 
     #The quantifiers don't need to be a continuous sequence
-    gangster = {:hundred => "hundred bucks", :million => "thousand quids"}
-    assert_equal "1 hundred bucks", 100.to_s(:human, :units => gangster)
-    assert_equal "25 hundred bucks", 2500.to_s(:human, :units => gangster)
-    assert_equal "25 thousand quids", 25000000.to_s(:human, :units => gangster)
-    assert_equal "12300 thousand quids", 12345000000.to_s(:human, :units => gangster)
+    gangster = {hundred: "hundred bucks", million: "thousand quids"}
+    assert_equal "1 hundred bucks", 100.to_s(:human, units: gangster)
+    assert_equal "25 hundred bucks", 2500.to_s(:human, units: gangster)
+    assert_equal "25 thousand quids", 25000000.to_s(:human, units: gangster)
+    assert_equal "12300 thousand quids", 12345000000.to_s(:human, units: gangster)
 
     #Spaces are stripped from the resulting string
-    assert_equal "4", 4.to_s(:human, :units => {:unit => "", :ten => "tens "})
-    assert_equal "4.5  tens", 45.to_s(:human, :units => {:unit => "", :ten => " tens   "})
+    assert_equal "4", 4.to_s(:human, units: {unit: "", ten: "tens "})
+    assert_equal "4.5  tens", 45.to_s(:human, units: {unit: "", ten: " tens   "})
   end
 
   def test_number_to_human_with_custom_format
-    assert_equal "123 times Thousand", 123456.to_s(:human, :format => "%n times %u")
-    volume = {:unit => "ml", :thousand => "lt", :million => "m3"}
-    assert_equal "123.lt", 123456.to_s(:human, :units => volume, :format => "%n.%u")
+    assert_equal "123 times Thousand", 123456.to_s(:human, format: "%n times %u")
+    volume = {unit: "ml", thousand: "lt", million: "m3"}
+    assert_equal "123.lt", 123456.to_s(:human, units: volume, format: "%n.%u")
   end
 
   def test_to_s__injected_on_proper_types
diff --git a/activesupport/test/core_ext/object/deep_dup_test.rb b/activesupport/test/core_ext/object/deep_dup_test.rb
index 38981f0497..2c0526eebf 100644
--- a/activesupport/test/core_ext/object/deep_dup_test.rb
+++ b/activesupport/test/core_ext/object/deep_dup_test.rb
@@ -12,7 +12,7 @@ class DeepDupTest < ActiveSupport::TestCase
   end
 
   def test_hash_deep_dup
-    hash = { :a => { :b => "b" } }
+    hash = { a: { b: "b" } }
     dup = hash.deep_dup
     dup[:a][:c] = "c"
     assert_equal nil, hash[:a][:c]
@@ -20,7 +20,7 @@ class DeepDupTest < ActiveSupport::TestCase
   end
 
   def test_array_deep_dup_with_hash_inside
-    array = [1, { :a => 2, :b => 3 } ]
+    array = [1, { a: 2, b: 3 } ]
     dup = array.deep_dup
     dup[1][:c] = 4
     assert_equal nil, array[1][:c]
@@ -28,7 +28,7 @@ class DeepDupTest < ActiveSupport::TestCase
   end
 
   def test_hash_deep_dup_with_array_inside
-    hash = { :a => [1, 2] }
+    hash = { a: [1, 2] }
     dup = hash.deep_dup
     dup[:a][2] = "c"
     assert_equal nil, hash[:a][2]
@@ -37,7 +37,7 @@ class DeepDupTest < ActiveSupport::TestCase
 
   def test_deep_dup_initialize
     zero_hash = Hash.new 0
-    hash = { :a => zero_hash }
+    hash = { a: zero_hash }
     dup = hash.deep_dup
     assert_equal 0, dup[:a][44]
   end
diff --git a/activesupport/test/core_ext/object/to_query_test.rb b/activesupport/test/core_ext/object/to_query_test.rb
index 42566d5374..aaa7e69acb 100644
--- a/activesupport/test/core_ext/object/to_query_test.rb
+++ b/activesupport/test/core_ext/object/to_query_test.rb
@@ -5,7 +5,7 @@ require "active_support/core_ext/string/output_safety"
 
 class ToQueryTest < ActiveSupport::TestCase
   def test_simple_conversion
-    assert_query_equal "a=10", :a => 10
+    assert_query_equal "a=10", a: 10
   end
 
   def test_cgi_escaping
@@ -28,22 +28,22 @@ class ToQueryTest < ActiveSupport::TestCase
 
   def test_nested_conversion
     assert_query_equal "person%5Blogin%5D=seckar&person%5Bname%5D=Nicholas",
-      :person => Hash[:login, "seckar", :name, "Nicholas"]
+      person: Hash[:login, "seckar", :name, "Nicholas"]
   end
 
   def test_multiple_nested
     assert_query_equal "account%5Bperson%5D%5Bid%5D=20&person%5Bid%5D=10",
-      Hash[:account, {:person => {:id => 20}}, :person, {:id => 10}]
+      Hash[:account, {person: {id: 20}}, :person, {id: 10}]
   end
 
   def test_array_values
     assert_query_equal "person%5Bid%5D%5B%5D=10&person%5Bid%5D%5B%5D=20",
-      :person => {:id => [10, 20]}
+      person: {id: [10, 20]}
   end
 
   def test_array_values_are_not_sorted
     assert_query_equal "person%5Bid%5D%5B%5D=20&person%5Bid%5D%5B%5D=10",
-      :person => {:id => [20, 10]}
+      person: {id: [20, 10]}
   end
 
   def test_empty_array
diff --git a/activesupport/test/core_ext/string_ext_test.rb b/activesupport/test/core_ext/string_ext_test.rb
index fceee698fc..4b40503d22 100644
--- a/activesupport/test/core_ext/string_ext_test.rb
+++ b/activesupport/test/core_ext/string_ext_test.rb
@@ -263,16 +263,16 @@ class StringInflectionsTest < ActiveSupport::TestCase
   end
 
   def test_truncate_with_omission_and_separator
-    assert_equal "Hello[...]", "Hello World!".truncate(10, :omission => "[...]")
-    assert_equal "Hello[...]", "Hello Big World!".truncate(13, :omission => "[...]", :separator => " ")
-    assert_equal "Hello Big[...]", "Hello Big World!".truncate(14, :omission => "[...]", :separator => " ")
-    assert_equal "Hello Big[...]", "Hello Big World!".truncate(15, :omission => "[...]", :separator => " ")
+    assert_equal "Hello[...]", "Hello World!".truncate(10, omission: "[...]")
+    assert_equal "Hello[...]", "Hello Big World!".truncate(13, omission: "[...]", separator: " ")
+    assert_equal "Hello Big[...]", "Hello Big World!".truncate(14, omission: "[...]", separator: " ")
+    assert_equal "Hello Big[...]", "Hello Big World!".truncate(15, omission: "[...]", separator: " ")
   end
 
   def test_truncate_with_omission_and_regexp_separator
-    assert_equal "Hello[...]", "Hello Big World!".truncate(13, :omission => "[...]", :separator => /\s/)
-    assert_equal "Hello Big[...]", "Hello Big World!".truncate(14, :omission => "[...]", :separator => /\s/)
-    assert_equal "Hello Big[...]", "Hello Big World!".truncate(15, :omission => "[...]", :separator => /\s/)
+    assert_equal "Hello[...]", "Hello Big World!".truncate(13, omission: "[...]", separator: /\s/)
+    assert_equal "Hello Big[...]", "Hello Big World!".truncate(14, omission: "[...]", separator: /\s/)
+    assert_equal "Hello Big[...]", "Hello Big World!".truncate(15, omission: "[...]", separator: /\s/)
   end
 
   def test_truncate_words
@@ -281,19 +281,19 @@ class StringInflectionsTest < ActiveSupport::TestCase
   end
 
   def test_truncate_words_with_omission
-    assert_equal "Hello Big World!", "Hello Big World!".truncate_words(3, :omission => "[...]")
-    assert_equal "Hello Big[...]", "Hello Big World!".truncate_words(2, :omission => "[...]")
+    assert_equal "Hello Big World!", "Hello Big World!".truncate_words(3, omission: "[...]")
+    assert_equal "Hello Big[...]", "Hello Big World!".truncate_words(2, omission: "[...]")
   end
 
   def test_truncate_words_with_separator
-    assert_equal "Hello<br>Big<br>World!...", "Hello<br>Big<br>World!<br>".truncate_words(3, :separator => "<br>")
-    assert_equal "Hello<br>Big<br>World!", "Hello<br>Big<br>World!".truncate_words(3, :separator => "<br>")
-    assert_equal "Hello\n<br>Big...", "Hello\n<br>Big<br>Wide<br>World!".truncate_words(2, :separator => "<br>")
+    assert_equal "Hello<br>Big<br>World!...", "Hello<br>Big<br>World!<br>".truncate_words(3, separator: "<br>")
+    assert_equal "Hello<br>Big<br>World!", "Hello<br>Big<br>World!".truncate_words(3, separator: "<br>")
+    assert_equal "Hello\n<br>Big...", "Hello\n<br>Big<br>Wide<br>World!".truncate_words(2, separator: "<br>")
   end
 
   def test_truncate_words_with_separator_and_omission
-    assert_equal "Hello<br>Big<br>World![...]", "Hello<br>Big<br>World!<br>".truncate_words(3, :omission => "[...]", :separator => "<br>")
-    assert_equal "Hello<br>Big<br>World!", "Hello<br>Big<br>World!".truncate_words(3, :omission => "[...]", :separator => "<br>")
+    assert_equal "Hello<br>Big<br>World![...]", "Hello<br>Big<br>World!<br>".truncate_words(3, omission: "[...]", separator: "<br>")
+    assert_equal "Hello<br>Big<br>World!", "Hello<br>Big<br>World!".truncate_words(3, omission: "[...]", separator: "<br>")
   end
 
   def test_truncate_words_with_complex_string
@@ -821,7 +821,7 @@ class OutputSafetyTest < ActiveSupport::TestCase
   end
 
   test "emits normal string yaml" do
-    assert_equal "foo".to_yaml, "foo".html_safe.to_yaml(:foo => 1)
+    assert_equal "foo".to_yaml, "foo".html_safe.to_yaml(foo: 1)
   end
 
   test "call to_param returns a normal string" do
diff --git a/activesupport/test/core_ext/time_ext_test.rb b/activesupport/test/core_ext/time_ext_test.rb
index 8fb85e3494..a6c9a7d5a8 100644
--- a/activesupport/test/core_ext/time_ext_test.rb
+++ b/activesupport/test/core_ext/time_ext_test.rb
@@ -393,122 +393,122 @@ class TimeExtCalculationsTest < ActiveSupport::TestCase
   end
 
   def test_change
-    assert_equal Time.local(2006,2,22,15,15,10), Time.local(2005,2,22,15,15,10).change(:year => 2006)
-    assert_equal Time.local(2005,6,22,15,15,10), Time.local(2005,2,22,15,15,10).change(:month => 6)
-    assert_equal Time.local(2012,9,22,15,15,10), Time.local(2005,2,22,15,15,10).change(:year => 2012, :month => 9)
-    assert_equal Time.local(2005,2,22,16),       Time.local(2005,2,22,15,15,10).change(:hour => 16)
-    assert_equal Time.local(2005,2,22,16,45),    Time.local(2005,2,22,15,15,10).change(:hour => 16, :min => 45)
-    assert_equal Time.local(2005,2,22,15,45),    Time.local(2005,2,22,15,15,10).change(:min => 45)
-
-    assert_equal Time.local(2005,1,2, 5, 0, 0, 0), Time.local(2005,1,2,11,22,33,44).change(:hour => 5)
-    assert_equal Time.local(2005,1,2,11, 6, 0, 0), Time.local(2005,1,2,11,22,33,44).change(:min  => 6)
-    assert_equal Time.local(2005,1,2,11,22, 7, 0), Time.local(2005,1,2,11,22,33,44).change(:sec  => 7)
-    assert_equal Time.local(2005,1,2,11,22,33, 8), Time.local(2005,1,2,11,22,33,44).change(:usec => 8)
-    assert_equal Time.local(2005,1,2,11,22,33, 8), Time.local(2005,1,2,11,22,33,2).change(:nsec => 8000)
-    assert_raise(ArgumentError) { Time.local(2005,1,2,11,22,33, 8).change(:usec => 1, :nsec => 1) }
+    assert_equal Time.local(2006,2,22,15,15,10), Time.local(2005,2,22,15,15,10).change(year: 2006)
+    assert_equal Time.local(2005,6,22,15,15,10), Time.local(2005,2,22,15,15,10).change(month: 6)
+    assert_equal Time.local(2012,9,22,15,15,10), Time.local(2005,2,22,15,15,10).change(year: 2012, month: 9)
+    assert_equal Time.local(2005,2,22,16),       Time.local(2005,2,22,15,15,10).change(hour: 16)
+    assert_equal Time.local(2005,2,22,16,45),    Time.local(2005,2,22,15,15,10).change(hour: 16, min: 45)
+    assert_equal Time.local(2005,2,22,15,45),    Time.local(2005,2,22,15,15,10).change(min: 45)
+
+    assert_equal Time.local(2005,1,2, 5, 0, 0, 0), Time.local(2005,1,2,11,22,33,44).change(hour: 5)
+    assert_equal Time.local(2005,1,2,11, 6, 0, 0), Time.local(2005,1,2,11,22,33,44).change(min: 6)
+    assert_equal Time.local(2005,1,2,11,22, 7, 0), Time.local(2005,1,2,11,22,33,44).change(sec: 7)
+    assert_equal Time.local(2005,1,2,11,22,33, 8), Time.local(2005,1,2,11,22,33,44).change(usec: 8)
+    assert_equal Time.local(2005,1,2,11,22,33, 8), Time.local(2005,1,2,11,22,33,2).change(nsec: 8000)
+    assert_raise(ArgumentError) { Time.local(2005,1,2,11,22,33, 8).change(usec: 1, nsec: 1) }
     assert_nothing_raised { Time.new(2015, 5, 9, 10, 00, 00, "+03:00").change(nsec: 999999999) }
   end
 
   def test_utc_change
-    assert_equal Time.utc(2006,2,22,15,15,10), Time.utc(2005,2,22,15,15,10).change(:year => 2006)
-    assert_equal Time.utc(2005,6,22,15,15,10), Time.utc(2005,2,22,15,15,10).change(:month => 6)
-    assert_equal Time.utc(2012,9,22,15,15,10), Time.utc(2005,2,22,15,15,10).change(:year => 2012, :month => 9)
-    assert_equal Time.utc(2005,2,22,16),       Time.utc(2005,2,22,15,15,10).change(:hour => 16)
-    assert_equal Time.utc(2005,2,22,16,45),    Time.utc(2005,2,22,15,15,10).change(:hour => 16, :min => 45)
-    assert_equal Time.utc(2005,2,22,15,45),    Time.utc(2005,2,22,15,15,10).change(:min => 45)
-    assert_equal Time.utc(2005,1,2,11,22,33,8), Time.utc(2005,1,2,11,22,33,2).change(:nsec => 8000)
+    assert_equal Time.utc(2006,2,22,15,15,10), Time.utc(2005,2,22,15,15,10).change(year: 2006)
+    assert_equal Time.utc(2005,6,22,15,15,10), Time.utc(2005,2,22,15,15,10).change(month: 6)
+    assert_equal Time.utc(2012,9,22,15,15,10), Time.utc(2005,2,22,15,15,10).change(year: 2012, month: 9)
+    assert_equal Time.utc(2005,2,22,16),       Time.utc(2005,2,22,15,15,10).change(hour: 16)
+    assert_equal Time.utc(2005,2,22,16,45),    Time.utc(2005,2,22,15,15,10).change(hour: 16, min: 45)
+    assert_equal Time.utc(2005,2,22,15,45),    Time.utc(2005,2,22,15,15,10).change(min: 45)
+    assert_equal Time.utc(2005,1,2,11,22,33,8), Time.utc(2005,1,2,11,22,33,2).change(nsec: 8000)
   end
 
   def test_offset_change
-    assert_equal Time.new(2006,2,22,15,15,10,"-08:00"), Time.new(2005,2,22,15,15,10,"-08:00").change(:year => 2006)
-    assert_equal Time.new(2005,6,22,15,15,10,"-08:00"), Time.new(2005,2,22,15,15,10,"-08:00").change(:month => 6)
-    assert_equal Time.new(2012,9,22,15,15,10,"-08:00"), Time.new(2005,2,22,15,15,10,"-08:00").change(:year => 2012, :month => 9)
-    assert_equal Time.new(2005,2,22,16,0,0,"-08:00"),   Time.new(2005,2,22,15,15,10,"-08:00").change(:hour => 16)
-    assert_equal Time.new(2005,2,22,16,45,0,"-08:00"),  Time.new(2005,2,22,15,15,10,"-08:00").change(:hour => 16, :min => 45)
-    assert_equal Time.new(2005,2,22,15,45,0,"-08:00"),  Time.new(2005,2,22,15,15,10,"-08:00").change(:min => 45)
-    assert_equal Time.new(2005,2,22,15,15,10,"-08:00"),  Time.new(2005,2,22,15,15,0,"-08:00").change(:sec => 10)
-    assert_equal 10, Time.new(2005,2,22,15,15,0,"-08:00").change(:usec => 10).usec
-    assert_equal 10, Time.new(2005,2,22,15,15,0,"-08:00").change(:nsec => 10).nsec
-    assert_raise(ArgumentError) { Time.new(2005, 2, 22, 15, 15, 45, "-08:00").change(:usec => 1000000) }
-    assert_raise(ArgumentError) { Time.new(2005, 2, 22, 15, 15, 45, "-08:00").change(:nsec => 1000000000) }
+    assert_equal Time.new(2006,2,22,15,15,10,"-08:00"), Time.new(2005,2,22,15,15,10,"-08:00").change(year: 2006)
+    assert_equal Time.new(2005,6,22,15,15,10,"-08:00"), Time.new(2005,2,22,15,15,10,"-08:00").change(month: 6)
+    assert_equal Time.new(2012,9,22,15,15,10,"-08:00"), Time.new(2005,2,22,15,15,10,"-08:00").change(year: 2012, month: 9)
+    assert_equal Time.new(2005,2,22,16,0,0,"-08:00"),   Time.new(2005,2,22,15,15,10,"-08:00").change(hour: 16)
+    assert_equal Time.new(2005,2,22,16,45,0,"-08:00"),  Time.new(2005,2,22,15,15,10,"-08:00").change(hour: 16, min: 45)
+    assert_equal Time.new(2005,2,22,15,45,0,"-08:00"),  Time.new(2005,2,22,15,15,10,"-08:00").change(min: 45)
+    assert_equal Time.new(2005,2,22,15,15,10,"-08:00"),  Time.new(2005,2,22,15,15,0,"-08:00").change(sec: 10)
+    assert_equal 10, Time.new(2005,2,22,15,15,0,"-08:00").change(usec: 10).usec
+    assert_equal 10, Time.new(2005,2,22,15,15,0,"-08:00").change(nsec: 10).nsec
+    assert_raise(ArgumentError) { Time.new(2005, 2, 22, 15, 15, 45, "-08:00").change(usec: 1000000) }
+    assert_raise(ArgumentError) { Time.new(2005, 2, 22, 15, 15, 45, "-08:00").change(nsec: 1000000000) }
   end
 
   def test_advance
-    assert_equal Time.local(2006,2,28,15,15,10), Time.local(2005,2,28,15,15,10).advance(:years => 1)
-    assert_equal Time.local(2005,6,28,15,15,10), Time.local(2005,2,28,15,15,10).advance(:months => 4)
-    assert_equal Time.local(2005,3,21,15,15,10), Time.local(2005,2,28,15,15,10).advance(:weeks => 3)
-    assert_equal Time.local(2005,3,25,3,15,10), Time.local(2005,2,28,15,15,10).advance(:weeks => 3.5)
-    assert_in_delta Time.local(2005,3,26,12,51,10), Time.local(2005,2,28,15,15,10).advance(:weeks => 3.7), 1
-    assert_equal Time.local(2005,3,5,15,15,10), Time.local(2005,2,28,15,15,10).advance(:days => 5)
-    assert_equal Time.local(2005,3,6,3,15,10), Time.local(2005,2,28,15,15,10).advance(:days => 5.5)
-    assert_in_delta Time.local(2005,3,6,8,3,10), Time.local(2005,2,28,15,15,10).advance(:days => 5.7), 1
-    assert_equal Time.local(2012,9,28,15,15,10), Time.local(2005,2,28,15,15,10).advance(:years => 7, :months => 7)
-    assert_equal Time.local(2013,10,3,15,15,10), Time.local(2005,2,28,15,15,10).advance(:years => 7, :months => 19, :days => 5)
-    assert_equal Time.local(2013,10,17,15,15,10), Time.local(2005,2,28,15,15,10).advance(:years => 7, :months => 19, :weeks => 2, :days => 5)
-    assert_equal Time.local(2001,12,27,15,15,10), Time.local(2005,2,28,15,15,10).advance(:years => -3, :months => -2, :days => -1)
-    assert_equal Time.local(2005,2,28,15,15,10), Time.local(2004,2,29,15,15,10).advance(:years => 1) #leap day plus one year
-    assert_equal Time.local(2005,2,28,20,15,10), Time.local(2005,2,28,15,15,10).advance(:hours => 5)
-    assert_equal Time.local(2005,2,28,15,22,10), Time.local(2005,2,28,15,15,10).advance(:minutes => 7)
-    assert_equal Time.local(2005,2,28,15,15,19), Time.local(2005,2,28,15,15,10).advance(:seconds => 9)
-    assert_equal Time.local(2005,2,28,20,22,19), Time.local(2005,2,28,15,15,10).advance(:hours => 5, :minutes => 7, :seconds => 9)
-    assert_equal Time.local(2005,2,28,10,8,1), Time.local(2005,2,28,15,15,10).advance(:hours => -5, :minutes => -7, :seconds => -9)
-    assert_equal Time.local(2013,10,17,20,22,19), Time.local(2005,2,28,15,15,10).advance(:years => 7, :months => 19, :weeks => 2, :days => 5, :hours => 5, :minutes => 7, :seconds => 9)
+    assert_equal Time.local(2006,2,28,15,15,10), Time.local(2005,2,28,15,15,10).advance(years: 1)
+    assert_equal Time.local(2005,6,28,15,15,10), Time.local(2005,2,28,15,15,10).advance(months: 4)
+    assert_equal Time.local(2005,3,21,15,15,10), Time.local(2005,2,28,15,15,10).advance(weeks: 3)
+    assert_equal Time.local(2005,3,25,3,15,10), Time.local(2005,2,28,15,15,10).advance(weeks: 3.5)
+    assert_in_delta Time.local(2005,3,26,12,51,10), Time.local(2005,2,28,15,15,10).advance(weeks: 3.7), 1
+    assert_equal Time.local(2005,3,5,15,15,10), Time.local(2005,2,28,15,15,10).advance(days: 5)
+    assert_equal Time.local(2005,3,6,3,15,10), Time.local(2005,2,28,15,15,10).advance(days: 5.5)
+    assert_in_delta Time.local(2005,3,6,8,3,10), Time.local(2005,2,28,15,15,10).advance(days: 5.7), 1
+    assert_equal Time.local(2012,9,28,15,15,10), Time.local(2005,2,28,15,15,10).advance(years: 7, months: 7)
+    assert_equal Time.local(2013,10,3,15,15,10), Time.local(2005,2,28,15,15,10).advance(years: 7, months: 19, days: 5)
+    assert_equal Time.local(2013,10,17,15,15,10), Time.local(2005,2,28,15,15,10).advance(years: 7, months: 19, weeks: 2, days: 5)
+    assert_equal Time.local(2001,12,27,15,15,10), Time.local(2005,2,28,15,15,10).advance(years: -3, months: -2, days: -1)
+    assert_equal Time.local(2005,2,28,15,15,10), Time.local(2004,2,29,15,15,10).advance(years: 1) #leap day plus one year
+    assert_equal Time.local(2005,2,28,20,15,10), Time.local(2005,2,28,15,15,10).advance(hours: 5)
+    assert_equal Time.local(2005,2,28,15,22,10), Time.local(2005,2,28,15,15,10).advance(minutes: 7)
+    assert_equal Time.local(2005,2,28,15,15,19), Time.local(2005,2,28,15,15,10).advance(seconds: 9)
+    assert_equal Time.local(2005,2,28,20,22,19), Time.local(2005,2,28,15,15,10).advance(hours: 5, minutes: 7, seconds: 9)
+    assert_equal Time.local(2005,2,28,10,8,1), Time.local(2005,2,28,15,15,10).advance(hours: -5, minutes: -7, seconds: -9)
+    assert_equal Time.local(2013,10,17,20,22,19), Time.local(2005,2,28,15,15,10).advance(years: 7, months: 19, weeks: 2, days: 5, hours: 5, minutes: 7, seconds: 9)
   end
 
   def test_utc_advance
-    assert_equal Time.utc(2006,2,22,15,15,10), Time.utc(2005,2,22,15,15,10).advance(:years => 1)
-    assert_equal Time.utc(2005,6,22,15,15,10), Time.utc(2005,2,22,15,15,10).advance(:months => 4)
-    assert_equal Time.utc(2005,3,21,15,15,10), Time.utc(2005,2,28,15,15,10).advance(:weeks => 3)
-    assert_equal Time.utc(2005,3,25,3,15,10), Time.utc(2005,2,28,15,15,10).advance(:weeks => 3.5)
-    assert_in_delta Time.utc(2005,3,26,12,51,10), Time.utc(2005,2,28,15,15,10).advance(:weeks => 3.7), 1
-    assert_equal Time.utc(2005,3,5,15,15,10), Time.utc(2005,2,28,15,15,10).advance(:days => 5)
-    assert_equal Time.utc(2005,3,6,3,15,10), Time.utc(2005,2,28,15,15,10).advance(:days => 5.5)
-    assert_in_delta Time.utc(2005,3,6,8,3,10), Time.utc(2005,2,28,15,15,10).advance(:days => 5.7), 1
-    assert_equal Time.utc(2012,9,22,15,15,10), Time.utc(2005,2,22,15,15,10).advance(:years => 7, :months => 7)
-    assert_equal Time.utc(2013,10,3,15,15,10), Time.utc(2005,2,22,15,15,10).advance(:years => 7, :months => 19, :days => 11)
-    assert_equal Time.utc(2013,10,17,15,15,10), Time.utc(2005,2,28,15,15,10).advance(:years => 7, :months => 19, :weeks => 2, :days => 5)
-    assert_equal Time.utc(2001,12,27,15,15,10), Time.utc(2005,2,28,15,15,10).advance(:years => -3, :months => -2, :days => -1)
-    assert_equal Time.utc(2005,2,28,15,15,10), Time.utc(2004,2,29,15,15,10).advance(:years => 1) #leap day plus one year
-    assert_equal Time.utc(2005,2,28,20,15,10), Time.utc(2005,2,28,15,15,10).advance(:hours => 5)
-    assert_equal Time.utc(2005,2,28,15,22,10), Time.utc(2005,2,28,15,15,10).advance(:minutes => 7)
-    assert_equal Time.utc(2005,2,28,15,15,19), Time.utc(2005,2,28,15,15,10).advance(:seconds => 9)
-    assert_equal Time.utc(2005,2,28,20,22,19), Time.utc(2005,2,28,15,15,10).advance(:hours => 5, :minutes => 7, :seconds => 9)
-    assert_equal Time.utc(2005,2,28,10,8,1), Time.utc(2005,2,28,15,15,10).advance(:hours => -5, :minutes => -7, :seconds => -9)
-    assert_equal Time.utc(2013,10,17,20,22,19), Time.utc(2005,2,28,15,15,10).advance(:years => 7, :months => 19, :weeks => 2, :days => 5, :hours => 5, :minutes => 7, :seconds => 9)
+    assert_equal Time.utc(2006,2,22,15,15,10), Time.utc(2005,2,22,15,15,10).advance(years: 1)
+    assert_equal Time.utc(2005,6,22,15,15,10), Time.utc(2005,2,22,15,15,10).advance(months: 4)
+    assert_equal Time.utc(2005,3,21,15,15,10), Time.utc(2005,2,28,15,15,10).advance(weeks: 3)
+    assert_equal Time.utc(2005,3,25,3,15,10), Time.utc(2005,2,28,15,15,10).advance(weeks: 3.5)
+    assert_in_delta Time.utc(2005,3,26,12,51,10), Time.utc(2005,2,28,15,15,10).advance(weeks: 3.7), 1
+    assert_equal Time.utc(2005,3,5,15,15,10), Time.utc(2005,2,28,15,15,10).advance(days: 5)
+    assert_equal Time.utc(2005,3,6,3,15,10), Time.utc(2005,2,28,15,15,10).advance(days: 5.5)
+    assert_in_delta Time.utc(2005,3,6,8,3,10), Time.utc(2005,2,28,15,15,10).advance(days: 5.7), 1
+    assert_equal Time.utc(2012,9,22,15,15,10), Time.utc(2005,2,22,15,15,10).advance(years: 7, months: 7)
+    assert_equal Time.utc(2013,10,3,15,15,10), Time.utc(2005,2,22,15,15,10).advance(years: 7, months: 19, days: 11)
+    assert_equal Time.utc(2013,10,17,15,15,10), Time.utc(2005,2,28,15,15,10).advance(years: 7, months: 19, weeks: 2, days: 5)
+    assert_equal Time.utc(2001,12,27,15,15,10), Time.utc(2005,2,28,15,15,10).advance(years: -3, months: -2, days: -1)
+    assert_equal Time.utc(2005,2,28,15,15,10), Time.utc(2004,2,29,15,15,10).advance(years: 1) #leap day plus one year
+    assert_equal Time.utc(2005,2,28,20,15,10), Time.utc(2005,2,28,15,15,10).advance(hours: 5)
+    assert_equal Time.utc(2005,2,28,15,22,10), Time.utc(2005,2,28,15,15,10).advance(minutes: 7)
+    assert_equal Time.utc(2005,2,28,15,15,19), Time.utc(2005,2,28,15,15,10).advance(seconds: 9)
+    assert_equal Time.utc(2005,2,28,20,22,19), Time.utc(2005,2,28,15,15,10).advance(hours: 5, minutes: 7, seconds: 9)
+    assert_equal Time.utc(2005,2,28,10,8,1), Time.utc(2005,2,28,15,15,10).advance(hours: -5, minutes: -7, seconds: -9)
+    assert_equal Time.utc(2013,10,17,20,22,19), Time.utc(2005,2,28,15,15,10).advance(years: 7, months: 19, weeks: 2, days: 5, hours: 5, minutes: 7, seconds: 9)
   end
 
   def test_offset_advance
-    assert_equal Time.new(2006,2,22,15,15,10,"-08:00"), Time.new(2005,2,22,15,15,10,"-08:00").advance(:years => 1)
-    assert_equal Time.new(2005,6,22,15,15,10,"-08:00"), Time.new(2005,2,22,15,15,10,"-08:00").advance(:months => 4)
-    assert_equal Time.new(2005,3,21,15,15,10,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(:weeks => 3)
-    assert_equal Time.new(2005,3,25,3,15,10,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(:weeks => 3.5)
-    assert_in_delta Time.new(2005,3,26,12,51,10,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(:weeks => 3.7), 1
-    assert_equal Time.new(2005,3,5,15,15,10,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(:days => 5)
-    assert_equal Time.new(2005,3,6,3,15,10,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(:days => 5.5)
-    assert_in_delta Time.new(2005,3,6,8,3,10,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(:days => 5.7), 1
-    assert_equal Time.new(2012,9,22,15,15,10,"-08:00"), Time.new(2005,2,22,15,15,10,"-08:00").advance(:years => 7, :months => 7)
-    assert_equal Time.new(2013,10,3,15,15,10,"-08:00"), Time.new(2005,2,22,15,15,10,"-08:00").advance(:years => 7, :months => 19, :days => 11)
-    assert_equal Time.new(2013,10,17,15,15,10,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(:years => 7, :months => 19, :weeks => 2, :days => 5)
-    assert_equal Time.new(2001,12,27,15,15,10,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(:years => -3, :months => -2, :days => -1)
-    assert_equal Time.new(2005,2,28,15,15,10,"-08:00"), Time.new(2004,2,29,15,15,10,"-08:00").advance(:years => 1) #leap day plus one year
-    assert_equal Time.new(2005,2,28,20,15,10,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(:hours => 5)
-    assert_equal Time.new(2005,2,28,15,22,10,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(:minutes => 7)
-    assert_equal Time.new(2005,2,28,15,15,19,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(:seconds => 9)
-    assert_equal Time.new(2005,2,28,20,22,19,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(:hours => 5, :minutes => 7, :seconds => 9)
-    assert_equal Time.new(2005,2,28,10,8,1,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(:hours => -5, :minutes => -7, :seconds => -9)
-    assert_equal Time.new(2013,10,17,20,22,19,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(:years => 7, :months => 19, :weeks => 2, :days => 5, :hours => 5, :minutes => 7, :seconds => 9)
+    assert_equal Time.new(2006,2,22,15,15,10,"-08:00"), Time.new(2005,2,22,15,15,10,"-08:00").advance(years: 1)
+    assert_equal Time.new(2005,6,22,15,15,10,"-08:00"), Time.new(2005,2,22,15,15,10,"-08:00").advance(months: 4)
+    assert_equal Time.new(2005,3,21,15,15,10,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(weeks: 3)
+    assert_equal Time.new(2005,3,25,3,15,10,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(weeks: 3.5)
+    assert_in_delta Time.new(2005,3,26,12,51,10,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(weeks: 3.7), 1
+    assert_equal Time.new(2005,3,5,15,15,10,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(days: 5)
+    assert_equal Time.new(2005,3,6,3,15,10,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(days: 5.5)
+    assert_in_delta Time.new(2005,3,6,8,3,10,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(days: 5.7), 1
+    assert_equal Time.new(2012,9,22,15,15,10,"-08:00"), Time.new(2005,2,22,15,15,10,"-08:00").advance(years: 7, months: 7)
+    assert_equal Time.new(2013,10,3,15,15,10,"-08:00"), Time.new(2005,2,22,15,15,10,"-08:00").advance(years: 7, months: 19, days: 11)
+    assert_equal Time.new(2013,10,17,15,15,10,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(years: 7, months: 19, weeks: 2, days: 5)
+    assert_equal Time.new(2001,12,27,15,15,10,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(years: -3, months: -2, days: -1)
+    assert_equal Time.new(2005,2,28,15,15,10,"-08:00"), Time.new(2004,2,29,15,15,10,"-08:00").advance(years: 1) #leap day plus one year
+    assert_equal Time.new(2005,2,28,20,15,10,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(hours: 5)
+    assert_equal Time.new(2005,2,28,15,22,10,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(minutes: 7)
+    assert_equal Time.new(2005,2,28,15,15,19,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(seconds: 9)
+    assert_equal Time.new(2005,2,28,20,22,19,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(hours: 5, minutes: 7, seconds: 9)
+    assert_equal Time.new(2005,2,28,10,8,1,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(hours: -5, minutes: -7, seconds: -9)
+    assert_equal Time.new(2013,10,17,20,22,19,"-08:00"), Time.new(2005,2,28,15,15,10,"-08:00").advance(years: 7, months: 19, weeks: 2, days: 5, hours: 5, minutes: 7, seconds: 9)
   end
 
   def test_advance_with_nsec
     t = Time.at(0, Rational(108635108, 1000))
-    assert_equal t, t.advance(:months => 0)
+    assert_equal t, t.advance(months: 0)
   end
 
   def test_advance_gregorian_proleptic
-    assert_equal Time.local(1582,10,14,15,15,10), Time.local(1582,10,15,15,15,10).advance(:days => -1)
-    assert_equal Time.local(1582,10,15,15,15,10), Time.local(1582,10,14,15,15,10).advance(:days => 1)
-    assert_equal Time.local(1582,10,5,15,15,10), Time.local(1582,10,4,15,15,10).advance(:days => 1)
-    assert_equal Time.local(1582,10,4,15,15,10), Time.local(1582,10,5,15,15,10).advance(:days => -1)
+    assert_equal Time.local(1582,10,14,15,15,10), Time.local(1582,10,15,15,15,10).advance(days: -1)
+    assert_equal Time.local(1582,10,15,15,15,10), Time.local(1582,10,14,15,15,10).advance(days: 1)
+    assert_equal Time.local(1582,10,5,15,15,10), Time.local(1582,10,4,15,15,10).advance(days: 1)
+    assert_equal Time.local(1582,10,4,15,15,10), Time.local(1582,10,5,15,15,10).advance(days: -1)
   end
 
   def test_last_week
diff --git a/activesupport/test/core_ext/time_with_zone_test.rb b/activesupport/test/core_ext/time_with_zone_test.rb
index 62235449bc..773d2c0fb7 100644
--- a/activesupport/test/core_ext/time_with_zone_test.rb
+++ b/activesupport/test/core_ext/time_with_zone_test.rb
@@ -584,18 +584,18 @@ class TimeWithZoneTest < ActiveSupport::TestCase
 
   def test_change
     assert_equal "Fri, 31 Dec 1999 19:00:00 EST -05:00", @twz.inspect
-    assert_equal "Mon, 31 Dec 2001 19:00:00 EST -05:00", @twz.change(:year => 2001).inspect
-    assert_equal "Wed, 31 Mar 1999 19:00:00 EST -05:00", @twz.change(:month => 3).inspect
-    assert_equal "Wed, 03 Mar 1999 19:00:00 EST -05:00", @twz.change(:month => 2).inspect
-    assert_equal "Wed, 15 Dec 1999 19:00:00 EST -05:00", @twz.change(:day => 15).inspect
-    assert_equal "Fri, 31 Dec 1999 06:00:00 EST -05:00", @twz.change(:hour => 6).inspect
-    assert_equal "Fri, 31 Dec 1999 19:15:00 EST -05:00", @twz.change(:min => 15).inspect
-    assert_equal "Fri, 31 Dec 1999 19:00:30 EST -05:00", @twz.change(:sec => 30).inspect
+    assert_equal "Mon, 31 Dec 2001 19:00:00 EST -05:00", @twz.change(year: 2001).inspect
+    assert_equal "Wed, 31 Mar 1999 19:00:00 EST -05:00", @twz.change(month: 3).inspect
+    assert_equal "Wed, 03 Mar 1999 19:00:00 EST -05:00", @twz.change(month: 2).inspect
+    assert_equal "Wed, 15 Dec 1999 19:00:00 EST -05:00", @twz.change(day: 15).inspect
+    assert_equal "Fri, 31 Dec 1999 06:00:00 EST -05:00", @twz.change(hour: 6).inspect
+    assert_equal "Fri, 31 Dec 1999 19:15:00 EST -05:00", @twz.change(min: 15).inspect
+    assert_equal "Fri, 31 Dec 1999 19:00:30 EST -05:00", @twz.change(sec: 30).inspect
   end
 
   def test_change_at_dst_boundary
     twz = ActiveSupport::TimeWithZone.new(Time.at(1319936400).getutc, ActiveSupport::TimeZone["Madrid"])
-    assert_equal twz, twz.change(:min => 0)
+    assert_equal twz, twz.change(min: 0)
   end
 
   def test_round_at_dst_boundary
@@ -605,12 +605,12 @@ class TimeWithZoneTest < ActiveSupport::TestCase
 
   def test_advance
     assert_equal "Fri, 31 Dec 1999 19:00:00 EST -05:00", @twz.inspect
-    assert_equal "Mon, 31 Dec 2001 19:00:00 EST -05:00", @twz.advance(:years => 2).inspect
-    assert_equal "Fri, 31 Mar 2000 19:00:00 EST -05:00", @twz.advance(:months => 3).inspect
-    assert_equal "Tue, 04 Jan 2000 19:00:00 EST -05:00", @twz.advance(:days => 4).inspect
-    assert_equal "Sat, 01 Jan 2000 01:00:00 EST -05:00", @twz.advance(:hours => 6).inspect
-    assert_equal "Fri, 31 Dec 1999 19:15:00 EST -05:00", @twz.advance(:minutes => 15).inspect
-    assert_equal "Fri, 31 Dec 1999 19:00:30 EST -05:00", @twz.advance(:seconds => 30).inspect
+    assert_equal "Mon, 31 Dec 2001 19:00:00 EST -05:00", @twz.advance(years: 2).inspect
+    assert_equal "Fri, 31 Mar 2000 19:00:00 EST -05:00", @twz.advance(months: 3).inspect
+    assert_equal "Tue, 04 Jan 2000 19:00:00 EST -05:00", @twz.advance(days: 4).inspect
+    assert_equal "Sat, 01 Jan 2000 01:00:00 EST -05:00", @twz.advance(hours: 6).inspect
+    assert_equal "Fri, 31 Dec 1999 19:15:00 EST -05:00", @twz.advance(minutes: 15).inspect
+    assert_equal "Fri, 31 Dec 1999 19:00:30 EST -05:00", @twz.advance(seconds: 30).inspect
   end
 
   def test_beginning_of_year
@@ -685,7 +685,7 @@ class TimeWithZoneTest < ActiveSupport::TestCase
 
   def test_advance_1_year_from_leap_day
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2004,2,29))
-    assert_equal "Mon, 28 Feb 2005 00:00:00 EST -05:00", twz.advance(:years => 1).inspect
+    assert_equal "Mon, 28 Feb 2005 00:00:00 EST -05:00", twz.advance(years: 1).inspect
     assert_equal "Mon, 28 Feb 2005 00:00:00 EST -05:00", twz.years_since(1).inspect
     assert_equal "Mon, 28 Feb 2005 00:00:00 EST -05:00", twz.since(1.year).inspect
     assert_equal "Mon, 28 Feb 2005 00:00:00 EST -05:00", (twz + 1.year).inspect
@@ -693,7 +693,7 @@ class TimeWithZoneTest < ActiveSupport::TestCase
 
   def test_advance_1_month_from_last_day_of_january
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2005,1,31))
-    assert_equal "Mon, 28 Feb 2005 00:00:00 EST -05:00", twz.advance(:months => 1).inspect
+    assert_equal "Mon, 28 Feb 2005 00:00:00 EST -05:00", twz.advance(months: 1).inspect
     assert_equal "Mon, 28 Feb 2005 00:00:00 EST -05:00", twz.months_since(1).inspect
     assert_equal "Mon, 28 Feb 2005 00:00:00 EST -05:00", twz.since(1.month).inspect
     assert_equal "Mon, 28 Feb 2005 00:00:00 EST -05:00", (twz + 1.month).inspect
@@ -701,7 +701,7 @@ class TimeWithZoneTest < ActiveSupport::TestCase
 
   def test_advance_1_month_from_last_day_of_january_during_leap_year
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2000,1,31))
-    assert_equal "Tue, 29 Feb 2000 00:00:00 EST -05:00", twz.advance(:months => 1).inspect
+    assert_equal "Tue, 29 Feb 2000 00:00:00 EST -05:00", twz.advance(months: 1).inspect
     assert_equal "Tue, 29 Feb 2000 00:00:00 EST -05:00", twz.months_since(1).inspect
     assert_equal "Tue, 29 Feb 2000 00:00:00 EST -05:00", twz.since(1.month).inspect
     assert_equal "Tue, 29 Feb 2000 00:00:00 EST -05:00", (twz + 1.month).inspect
@@ -709,7 +709,7 @@ class TimeWithZoneTest < ActiveSupport::TestCase
 
   def test_advance_1_month_into_spring_dst_gap
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006,3,2,2))
-    assert_equal "Sun, 02 Apr 2006 03:00:00 EDT -04:00", twz.advance(:months => 1).inspect
+    assert_equal "Sun, 02 Apr 2006 03:00:00 EDT -04:00", twz.advance(months: 1).inspect
     assert_equal "Sun, 02 Apr 2006 03:00:00 EDT -04:00", twz.months_since(1).inspect
     assert_equal "Sun, 02 Apr 2006 03:00:00 EDT -04:00", twz.since(1.month).inspect
     assert_equal "Sun, 02 Apr 2006 03:00:00 EDT -04:00", (twz + 1.month).inspect
@@ -717,7 +717,7 @@ class TimeWithZoneTest < ActiveSupport::TestCase
 
   def test_advance_1_second_into_spring_dst_gap
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006,4,2,1,59,59))
-    assert_equal "Sun, 02 Apr 2006 03:00:00 EDT -04:00", twz.advance(:seconds => 1).inspect
+    assert_equal "Sun, 02 Apr 2006 03:00:00 EDT -04:00", twz.advance(seconds: 1).inspect
     assert_equal "Sun, 02 Apr 2006 03:00:00 EDT -04:00", (twz + 1).inspect
     assert_equal "Sun, 02 Apr 2006 03:00:00 EDT -04:00", twz.since(1).inspect
     assert_equal "Sun, 02 Apr 2006 03:00:00 EDT -04:00", twz.since(1.second).inspect
@@ -728,7 +728,7 @@ class TimeWithZoneTest < ActiveSupport::TestCase
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006,4,1,10,30))
     # In 2006, spring DST transition occurred Apr 2 at 2AM; this day was only 23 hours long
     # When we advance 1 day, we want to end up at the same time on the next day
-    assert_equal "Sun, 02 Apr 2006 10:30:00 EDT -04:00", twz.advance(:days => 1).inspect
+    assert_equal "Sun, 02 Apr 2006 10:30:00 EDT -04:00", twz.advance(days: 1).inspect
     assert_equal "Sun, 02 Apr 2006 10:30:00 EDT -04:00", twz.since(1.days).inspect
     assert_equal "Sun, 02 Apr 2006 10:30:00 EDT -04:00", (twz + 1.days).inspect
     assert_equal "Sun, 02 Apr 2006 10:30:01 EDT -04:00", twz.since(1.days + 1.second).inspect
@@ -739,7 +739,7 @@ class TimeWithZoneTest < ActiveSupport::TestCase
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006,4,2,10,30))
     # In 2006, spring DST transition occurred Apr 2 at 2AM; this day was only 23 hours long
     # When we advance back 1 day, we want to end up at the same time on the previous day
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.advance(:days => -1).inspect
+    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.advance(days: -1).inspect
     assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.ago(1.days).inspect
     assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", (twz - 1.days).inspect
     assert_equal "Sat, 01 Apr 2006 10:30:01 EST -05:00", twz.ago(1.days - 1.second).inspect
@@ -753,13 +753,13 @@ class TimeWithZoneTest < ActiveSupport::TestCase
     assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", (twz + 86400.seconds).inspect
     assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", twz.since(86400).inspect
     assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", twz.since(86400.seconds).inspect
-    assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", twz.advance(:seconds => 86400).inspect
+    assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", twz.advance(seconds: 86400).inspect
     assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", (twz + 1440.minutes).inspect
     assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", twz.since(1440.minutes).inspect
-    assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", twz.advance(:minutes => 1440).inspect
+    assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", twz.advance(minutes: 1440).inspect
     assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", (twz + 24.hours).inspect
     assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", twz.since(24.hours).inspect
-    assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", twz.advance(:hours => 24).inspect
+    assert_equal "Sun, 02 Apr 2006 11:30:00 EDT -04:00", twz.advance(hours: 24).inspect
   end
 
   def test_advance_1_day_expressed_as_number_of_seconds_minutes_or_hours_across_spring_dst_transition_backwards
@@ -770,20 +770,20 @@ class TimeWithZoneTest < ActiveSupport::TestCase
     assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", (twz - 86400.seconds).inspect
     assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.ago(86400).inspect
     assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.ago(86400.seconds).inspect
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.advance(:seconds => -86400).inspect
+    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.advance(seconds: -86400).inspect
     assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", (twz - 1440.minutes).inspect
     assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.ago(1440.minutes).inspect
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.advance(:minutes => -1440).inspect
+    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.advance(minutes: -1440).inspect
     assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", (twz - 24.hours).inspect
     assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.ago(24.hours).inspect
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.advance(:hours => -24).inspect
+    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.advance(hours: -24).inspect
   end
 
   def test_advance_1_day_across_fall_dst_transition
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006,10,28,10,30))
     # In 2006, fall DST transition occurred Oct 29 at 2AM; this day was 25 hours long
     # When we advance 1 day, we want to end up at the same time on the next day
-    assert_equal "Sun, 29 Oct 2006 10:30:00 EST -05:00", twz.advance(:days => 1).inspect
+    assert_equal "Sun, 29 Oct 2006 10:30:00 EST -05:00", twz.advance(days: 1).inspect
     assert_equal "Sun, 29 Oct 2006 10:30:00 EST -05:00", twz.since(1.days).inspect
     assert_equal "Sun, 29 Oct 2006 10:30:00 EST -05:00", (twz + 1.days).inspect
     assert_equal "Sun, 29 Oct 2006 10:30:01 EST -05:00", twz.since(1.days + 1.second).inspect
@@ -794,7 +794,7 @@ class TimeWithZoneTest < ActiveSupport::TestCase
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006,10,29,10,30))
     # In 2006, fall DST transition occurred Oct 29 at 2AM; this day was 25 hours long
     # When we advance backwards 1 day, we want to end up at the same time on the previous day
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.advance(:days => -1).inspect
+    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.advance(days: -1).inspect
     assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.ago(1.days).inspect
     assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", (twz - 1.days).inspect
     assert_equal "Sat, 28 Oct 2006 10:30:01 EDT -04:00", twz.ago(1.days - 1.second).inspect
@@ -808,13 +808,13 @@ class TimeWithZoneTest < ActiveSupport::TestCase
     assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", (twz + 86400.seconds).inspect
     assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", twz.since(86400).inspect
     assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", twz.since(86400.seconds).inspect
-    assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", twz.advance(:seconds => 86400).inspect
+    assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", twz.advance(seconds: 86400).inspect
     assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", (twz + 1440.minutes).inspect
     assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", twz.since(1440.minutes).inspect
-    assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", twz.advance(:minutes => 1440).inspect
+    assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", twz.advance(minutes: 1440).inspect
     assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", (twz + 24.hours).inspect
     assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", twz.since(24.hours).inspect
-    assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", twz.advance(:hours => 24).inspect
+    assert_equal "Sun, 29 Oct 2006 09:30:00 EST -05:00", twz.advance(hours: 24).inspect
   end
 
   def test_advance_1_day_expressed_as_number_of_seconds_minutes_or_hours_across_fall_dst_transition_backwards
@@ -825,18 +825,18 @@ class TimeWithZoneTest < ActiveSupport::TestCase
     assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", (twz - 86400.seconds).inspect
     assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.ago(86400).inspect
     assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.ago(86400.seconds).inspect
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.advance(:seconds => -86400).inspect
+    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.advance(seconds: -86400).inspect
     assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", (twz - 1440.minutes).inspect
     assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.ago(1440.minutes).inspect
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.advance(:minutes => -1440).inspect
+    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.advance(minutes: -1440).inspect
     assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", (twz - 24.hours).inspect
     assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.ago(24.hours).inspect
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.advance(:hours => -24).inspect
+    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.advance(hours: -24).inspect
   end
 
   def test_advance_1_week_across_spring_dst_transition
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006,4,1,10,30))
-    assert_equal "Sat, 08 Apr 2006 10:30:00 EDT -04:00", twz.advance(:weeks => 1).inspect
+    assert_equal "Sat, 08 Apr 2006 10:30:00 EDT -04:00", twz.advance(weeks: 1).inspect
     assert_equal "Sat, 08 Apr 2006 10:30:00 EDT -04:00", twz.weeks_since(1).inspect
     assert_equal "Sat, 08 Apr 2006 10:30:00 EDT -04:00", twz.since(1.week).inspect
     assert_equal "Sat, 08 Apr 2006 10:30:00 EDT -04:00", (twz + 1.week).inspect
@@ -844,7 +844,7 @@ class TimeWithZoneTest < ActiveSupport::TestCase
 
   def test_advance_1_week_across_spring_dst_transition_backwards
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006,4,8,10,30))
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.advance(:weeks => -1).inspect
+    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.advance(weeks: -1).inspect
     assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.weeks_ago(1).inspect
     assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.ago(1.week).inspect
     assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", (twz - 1.week).inspect
@@ -852,7 +852,7 @@ class TimeWithZoneTest < ActiveSupport::TestCase
 
   def test_advance_1_week_across_fall_dst_transition
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006,10,28,10,30))
-    assert_equal "Sat, 04 Nov 2006 10:30:00 EST -05:00", twz.advance(:weeks => 1).inspect
+    assert_equal "Sat, 04 Nov 2006 10:30:00 EST -05:00", twz.advance(weeks: 1).inspect
     assert_equal "Sat, 04 Nov 2006 10:30:00 EST -05:00", twz.weeks_since(1).inspect
     assert_equal "Sat, 04 Nov 2006 10:30:00 EST -05:00", twz.since(1.week).inspect
     assert_equal "Sat, 04 Nov 2006 10:30:00 EST -05:00", (twz + 1.week).inspect
@@ -860,7 +860,7 @@ class TimeWithZoneTest < ActiveSupport::TestCase
 
   def test_advance_1_week_across_fall_dst_transition_backwards
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006,11,4,10,30))
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.advance(:weeks => -1).inspect
+    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.advance(weeks: -1).inspect
     assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.weeks_ago(1).inspect
     assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.ago(1.week).inspect
     assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", (twz - 1.week).inspect
@@ -868,7 +868,7 @@ class TimeWithZoneTest < ActiveSupport::TestCase
 
   def test_advance_1_month_across_spring_dst_transition
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006,4,1,10,30))
-    assert_equal "Mon, 01 May 2006 10:30:00 EDT -04:00", twz.advance(:months => 1).inspect
+    assert_equal "Mon, 01 May 2006 10:30:00 EDT -04:00", twz.advance(months: 1).inspect
     assert_equal "Mon, 01 May 2006 10:30:00 EDT -04:00", twz.months_since(1).inspect
     assert_equal "Mon, 01 May 2006 10:30:00 EDT -04:00", twz.since(1.month).inspect
     assert_equal "Mon, 01 May 2006 10:30:00 EDT -04:00", (twz + 1.month).inspect
@@ -876,7 +876,7 @@ class TimeWithZoneTest < ActiveSupport::TestCase
 
   def test_advance_1_month_across_spring_dst_transition_backwards
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006,5,1,10,30))
-    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.advance(:months => -1).inspect
+    assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.advance(months: -1).inspect
     assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.months_ago(1).inspect
     assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", twz.ago(1.month).inspect
     assert_equal "Sat, 01 Apr 2006 10:30:00 EST -05:00", (twz - 1.month).inspect
@@ -884,7 +884,7 @@ class TimeWithZoneTest < ActiveSupport::TestCase
 
   def test_advance_1_month_across_fall_dst_transition
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006,10,28,10,30))
-    assert_equal "Tue, 28 Nov 2006 10:30:00 EST -05:00", twz.advance(:months => 1).inspect
+    assert_equal "Tue, 28 Nov 2006 10:30:00 EST -05:00", twz.advance(months: 1).inspect
     assert_equal "Tue, 28 Nov 2006 10:30:00 EST -05:00", twz.months_since(1).inspect
     assert_equal "Tue, 28 Nov 2006 10:30:00 EST -05:00", twz.since(1.month).inspect
     assert_equal "Tue, 28 Nov 2006 10:30:00 EST -05:00", (twz + 1.month).inspect
@@ -892,7 +892,7 @@ class TimeWithZoneTest < ActiveSupport::TestCase
 
   def test_advance_1_month_across_fall_dst_transition_backwards
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2006,11,28,10,30))
-    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.advance(:months => -1).inspect
+    assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.advance(months: -1).inspect
     assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.months_ago(1).inspect
     assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", twz.ago(1.month).inspect
     assert_equal "Sat, 28 Oct 2006 10:30:00 EDT -04:00", (twz - 1.month).inspect
@@ -900,20 +900,20 @@ class TimeWithZoneTest < ActiveSupport::TestCase
 
   def test_advance_1_year
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2008,2,15,10,30))
-    assert_equal "Sun, 15 Feb 2009 10:30:00 EST -05:00", twz.advance(:years => 1).inspect
+    assert_equal "Sun, 15 Feb 2009 10:30:00 EST -05:00", twz.advance(years: 1).inspect
     assert_equal "Sun, 15 Feb 2009 10:30:00 EST -05:00", twz.years_since(1).inspect
     assert_equal "Sun, 15 Feb 2009 10:30:00 EST -05:00", (twz + 1.year).inspect
-    assert_equal "Thu, 15 Feb 2007 10:30:00 EST -05:00", twz.advance(:years => -1).inspect
+    assert_equal "Thu, 15 Feb 2007 10:30:00 EST -05:00", twz.advance(years: -1).inspect
     assert_equal "Thu, 15 Feb 2007 10:30:00 EST -05:00", twz.years_ago(1).inspect
     assert_equal "Thu, 15 Feb 2007 10:30:00 EST -05:00", (twz - 1.year).inspect
   end
 
   def test_advance_1_year_during_dst
     twz = ActiveSupport::TimeWithZone.new(nil, @time_zone, Time.utc(2008,7,15,10,30))
-    assert_equal "Wed, 15 Jul 2009 10:30:00 EDT -04:00", twz.advance(:years => 1).inspect
+    assert_equal "Wed, 15 Jul 2009 10:30:00 EDT -04:00", twz.advance(years: 1).inspect
     assert_equal "Wed, 15 Jul 2009 10:30:00 EDT -04:00", twz.years_since(1).inspect
     assert_equal "Wed, 15 Jul 2009 10:30:00 EDT -04:00", (twz + 1.year).inspect
-    assert_equal "Sun, 15 Jul 2007 10:30:00 EDT -04:00", twz.advance(:years => -1).inspect
+    assert_equal "Sun, 15 Jul 2007 10:30:00 EDT -04:00", twz.advance(years: -1).inspect
     assert_equal "Sun, 15 Jul 2007 10:30:00 EDT -04:00", twz.years_ago(1).inspect
     assert_equal "Sun, 15 Jul 2007 10:30:00 EDT -04:00", (twz - 1.year).inspect
   end