16 files changed, 435 insertions, 110 deletions

diff --git a/activesupport/test/buffered_logger_test.rb b/activesupport/test/buffered_logger_test.rb
index 21049d685b..386006677b 100644
--- a/activesupport/test/buffered_logger_test.rb
+++ b/activesupport/test/buffered_logger_test.rb
@@ -198,4 +198,57 @@ class BufferedLoggerTest < Test::Unit::TestCase
     end
     assert byte_string.include?(BYTE_STRING)
   end
+
+  def test_silence_only_current_thread
+    @logger.auto_flushing = true
+    run_thread_a = false
+
+    a = Thread.new do
+      while !run_thread_a do
+        sleep(0.001)
+      end
+      @logger.info("x")
+      run_thread_a = false
+    end
+
+    @logger.silence do
+      run_thread_a = true
+      @logger.info("a")
+      while run_thread_a do
+        sleep(0.001)
+      end
+    end
+
+    a.join
+
+    assert @output.string.include?("x")
+    assert !@output.string.include?("a")
+  end
+
+  def test_flush_dead_buffers
+    @logger.auto_flushing = false
+
+    a = Thread.new do
+      @logger.info("a")
+    end
+    
+    keep_running = true
+    Thread.new do
+      @logger.info("b")
+      while keep_running
+        sleep(0.001)
+      end
+    end
+
+    @logger.info("x")
+    a.join
+    @logger.flush
+
+
+    assert @output.string.include?("x")
+    assert @output.string.include?("a")
+    assert !@output.string.include?("b")
+    
+    keep_running = false
+  end
 end
diff --git a/activesupport/test/caching_test.rb b/activesupport/test/caching_test.rb
index cb5362525f..5d7464c623 100644
--- a/activesupport/test/caching_test.rb
+++ b/activesupport/test/caching_test.rb
@@ -13,10 +13,10 @@ class CacheKeyTest < ActiveSupport::TestCase
       ENV['RAILS_CACHE_ID'] = 'c99'
       assert_equal 'c99/foo', ActiveSupport::Cache.expand_cache_key(:foo)
       assert_equal 'c99/foo', ActiveSupport::Cache.expand_cache_key([:foo])
-      assert_equal 'c99/c99/foo/c99/bar', ActiveSupport::Cache.expand_cache_key([:foo, :bar])
+      assert_equal 'c99/foo/bar', ActiveSupport::Cache.expand_cache_key([:foo, :bar])
       assert_equal 'nm/c99/foo', ActiveSupport::Cache.expand_cache_key(:foo, :nm)
       assert_equal 'nm/c99/foo', ActiveSupport::Cache.expand_cache_key([:foo], :nm)
-      assert_equal 'nm/c99/c99/foo/c99/bar', ActiveSupport::Cache.expand_cache_key([:foo, :bar], :nm)
+      assert_equal 'nm/c99/foo/bar', ActiveSupport::Cache.expand_cache_key([:foo, :bar], :nm)
     ensure
       ENV['RAILS_CACHE_ID'] = nil
     end
@@ -42,7 +42,7 @@ class CacheKeyTest < ActiveSupport::TestCase
     end
   end
 
-  def test_respond_to_cache_key
+  def test_expand_cache_key_respond_to_cache_key
     key = 'foo'
     def key.cache_key
       :foo_key
@@ -50,6 +50,25 @@ class CacheKeyTest < ActiveSupport::TestCase
     assert_equal 'foo_key', ActiveSupport::Cache.expand_cache_key(key)
   end
 
+  def test_expand_cache_key_array_with_something_that_responds_to_cache_key
+    key = 'foo'
+    def key.cache_key
+      :foo_key
+    end
+    assert_equal 'foo_key', ActiveSupport::Cache.expand_cache_key([key])
+  end
+
+  def test_expand_cache_key_of_nil
+    assert_equal '', ActiveSupport::Cache.expand_cache_key(nil)
+  end
+
+  def test_expand_cache_key_of_false
+    assert_equal 'false', ActiveSupport::Cache.expand_cache_key(false)
+  end
+
+  def test_expand_cache_key_of_true
+    assert_equal 'true', ActiveSupport::Cache.expand_cache_key(true)
+  end
 end
 
 class CacheStoreSettingTest < ActiveSupport::TestCase
@@ -122,8 +141,8 @@ class CacheStoreNamespaceTest < ActiveSupport::TestCase
     cache.write("foo", "bar")
     cache.write("fu", "baz")
     cache.delete_matched(/^fo/)
-    assert_equal false, cache.exist?("foo")
-    assert_equal true, cache.exist?("fu")
+    assert !cache.exist?("foo")
+    assert cache.exist?("fu")
   end
 
   def test_delete_matched_key
@@ -131,15 +150,15 @@ class CacheStoreNamespaceTest < ActiveSupport::TestCase
     cache.write("foo", "bar")
     cache.write("fu", "baz")
     cache.delete_matched(/OO/i)
-    assert_equal false, cache.exist?("foo")
-    assert_equal true, cache.exist?("fu")
+    assert !cache.exist?("foo")
+    assert cache.exist?("fu")
   end
 end
 
 # Tests the base functionality that should be identical across all cache stores.
 module CacheStoreBehavior
   def test_should_read_and_write_strings
-    assert_equal true, @cache.write('foo', 'bar')
+    assert @cache.write('foo', 'bar')
     assert_equal 'bar', @cache.read('foo')
   end
 
@@ -174,22 +193,22 @@ module CacheStoreBehavior
   end
 
   def test_should_read_and_write_hash
-    assert_equal true, @cache.write('foo', {:a => "b"})
+    assert @cache.write('foo', {:a => "b"})
     assert_equal({:a => "b"}, @cache.read('foo'))
   end
 
   def test_should_read_and_write_integer
-    assert_equal true, @cache.write('foo', 1)
+    assert @cache.write('foo', 1)
     assert_equal 1, @cache.read('foo')
   end
 
   def test_should_read_and_write_nil
-    assert_equal true, @cache.write('foo', nil)
+    assert @cache.write('foo', nil)
     assert_equal nil, @cache.read('foo')
   end
 
   def test_should_read_and_write_false
-    assert_equal true, @cache.write('foo', false)
+    assert @cache.write('foo', false)
     assert_equal false, @cache.read('foo')
   end
 
@@ -262,19 +281,19 @@ module CacheStoreBehavior
 
   def test_exist
     @cache.write('foo', 'bar')
-    assert_equal true, @cache.exist?('foo')
-    assert_equal false, @cache.exist?('bar')
+    assert @cache.exist?('foo')
+    assert !@cache.exist?('bar')
   end
 
   def test_nil_exist
     @cache.write('foo', nil)
-    assert_equal true, @cache.exist?('foo')
+    assert @cache.exist?('foo')
   end
 
   def test_delete
     @cache.write('foo', 'bar')
     assert @cache.exist?('foo')
-    assert_equal true, @cache.delete('foo')
+    assert @cache.delete('foo')
     assert !@cache.exist?('foo')
   end
 
@@ -346,10 +365,10 @@ module CacheStoreBehavior
 
   def test_crazy_key_characters
     crazy_key = "#/:*(<+=> )&$%@?;'\"\'`~-"
-    assert_equal true, @cache.write(crazy_key, "1", :raw => true)
+    assert @cache.write(crazy_key, "1", :raw => true)
     assert_equal "1", @cache.read(crazy_key)
     assert_equal "1", @cache.fetch(crazy_key)
-    assert_equal true, @cache.delete(crazy_key)
+    assert @cache.delete(crazy_key)
     assert_equal "2", @cache.fetch(crazy_key, :raw => true) { "2" }
     assert_equal 3, @cache.increment(crazy_key)
     assert_equal 2, @cache.decrement(crazy_key)
@@ -358,12 +377,12 @@ module CacheStoreBehavior
   def test_really_long_keys
     key = ""
     900.times{key << "x"}
-    assert_equal true, @cache.write(key, "bar")
+    assert @cache.write(key, "bar")
     assert_equal "bar", @cache.read(key)
     assert_equal "bar", @cache.fetch(key)
     assert_nil @cache.read("#{key}x")
     assert_equal({key => "bar"}, @cache.read_multi(key))
-    assert_equal true, @cache.delete(key)
+    assert @cache.delete(key)
   end
 end
 
@@ -375,10 +394,10 @@ module EncodedKeyCacheBehavior
     Encoding.list.each do |encoding|
       define_method "test_#{encoding.name.underscore}_encoded_values" do
         key = "foo".force_encoding(encoding)
-        assert_equal true, @cache.write(key, "1", :raw => true)
+        assert @cache.write(key, "1", :raw => true)
         assert_equal "1", @cache.read(key)
         assert_equal "1", @cache.fetch(key)
-        assert_equal true, @cache.delete(key)
+        assert @cache.delete(key)
         assert_equal "2", @cache.fetch(key, :raw => true) { "2" }
         assert_equal 3, @cache.increment(key)
         assert_equal 2, @cache.decrement(key)
@@ -387,10 +406,10 @@ module EncodedKeyCacheBehavior
 
     def test_common_utf8_values
       key = "\xC3\xBCmlaut".force_encoding(Encoding::UTF_8)
-      assert_equal true, @cache.write(key, "1", :raw => true)
+      assert @cache.write(key, "1", :raw => true)
       assert_equal "1", @cache.read(key)
       assert_equal "1", @cache.fetch(key)
-      assert_equal true, @cache.delete(key)
+      assert @cache.delete(key)
       assert_equal "2", @cache.fetch(key, :raw => true) { "2" }
       assert_equal 3, @cache.increment(key)
       assert_equal 2, @cache.decrement(key)
@@ -398,7 +417,7 @@ module EncodedKeyCacheBehavior
 
     def test_retains_encoding
       key = "\xC3\xBCmlaut".force_encoding(Encoding::UTF_8)
-      assert_equal true, @cache.write(key, "1", :raw => true)
+      assert @cache.write(key, "1", :raw => true)
       assert_equal Encoding::UTF_8, key.encoding
     end
   end
@@ -411,10 +430,10 @@ module CacheDeleteMatchedBehavior
     @cache.write("foo/bar", "baz")
     @cache.write("fu/baz", "bar")
     @cache.delete_matched(/oo/)
-    assert_equal false, @cache.exist?("foo")
-    assert_equal true, @cache.exist?("fu")
-    assert_equal false, @cache.exist?("foo/bar")
-    assert_equal true, @cache.exist?("fu/baz")
+    assert !@cache.exist?("foo")
+    assert @cache.exist?("fu")
+    assert !@cache.exist?("foo/bar")
+    assert @cache.exist?("fu/baz")
   end
 end
 
@@ -443,7 +462,7 @@ module LocalCacheBehavior
     retval = @cache.with_local_cache do
       @cache.write('foo', 'bar')
     end
-    assert_equal true, retval
+    assert retval
     assert_equal 'bar', @cache.read('foo')
   end
 
@@ -595,11 +614,11 @@ class MemoryStoreTest < ActiveSupport::TestCase
     @cache.read(2) && sleep(0.001)
     @cache.read(4)
     @cache.prune(@record_size * 3)
-    assert_equal true, @cache.exist?(5)
-    assert_equal true, @cache.exist?(4)
-    assert_equal false, @cache.exist?(3)
-    assert_equal true, @cache.exist?(2)
-    assert_equal false, @cache.exist?(1)
+    assert @cache.exist?(5)
+    assert @cache.exist?(4)
+    assert !@cache.exist?(3)
+    assert @cache.exist?(2)
+    assert !@cache.exist?(1)
   end
 
   def test_prune_size_on_write
@@ -616,17 +635,17 @@ class MemoryStoreTest < ActiveSupport::TestCase
     @cache.read(2) && sleep(0.001)
     @cache.read(4) && sleep(0.001)
     @cache.write(11, "llllllllll")
-    assert_equal true, @cache.exist?(11)
-    assert_equal true, @cache.exist?(10)
-    assert_equal true, @cache.exist?(9)
-    assert_equal true, @cache.exist?(8)
-    assert_equal true, @cache.exist?(7)
-    assert_equal false, @cache.exist?(6)
-    assert_equal false, @cache.exist?(5)
-    assert_equal true, @cache.exist?(4)
-    assert_equal false, @cache.exist?(3)
-    assert_equal true, @cache.exist?(2)
-    assert_equal false, @cache.exist?(1)
+    assert @cache.exist?(11)
+    assert @cache.exist?(10)
+    assert @cache.exist?(9)
+    assert @cache.exist?(8)
+    assert @cache.exist?(7)
+    assert !@cache.exist?(6)
+    assert !@cache.exist?(5)
+    assert @cache.exist?(4)
+    assert !@cache.exist?(3)
+    assert @cache.exist?(2)
+    assert !@cache.exist?(1)
   end
 
   def test_pruning_is_capped_at_a_max_time
@@ -640,11 +659,11 @@ class MemoryStoreTest < ActiveSupport::TestCase
     @cache.write(4, "dddddddddd") && sleep(0.001)
     @cache.write(5, "eeeeeeeeee") && sleep(0.001)
     @cache.prune(30, 0.001)
-    assert_equal true, @cache.exist?(5)
-    assert_equal true, @cache.exist?(4)
-    assert_equal true, @cache.exist?(3)
-    assert_equal true, @cache.exist?(2)
-    assert_equal false, @cache.exist?(1)
+    assert @cache.exist?(5)
+    assert @cache.exist?(4)
+    assert @cache.exist?(3)
+    assert @cache.exist?(2)
+    assert !@cache.exist?(1)
   end
 end
 
@@ -723,7 +742,7 @@ class CacheEntryTest < ActiveSupport::TestCase
     entry = ActiveSupport::Cache::Entry.create("raw", time, :compress => false, :expires_in => 300)
     assert_equal "raw", entry.raw_value
     assert_equal time.to_f, entry.created_at
-    assert_equal false, entry.compressed?
+    assert !entry.compressed?
     assert_equal 300, entry.expires_in
   end
 
@@ -740,7 +759,7 @@ class CacheEntryTest < ActiveSupport::TestCase
   def test_compress_values
     entry = ActiveSupport::Cache::Entry.new("value", :compress => true, :compress_threshold => 1)
     assert_equal "value", entry.value
-    assert_equal true, entry.compressed?
+    assert entry.compressed?
     assert_equal "value", Marshal.load(Zlib::Inflate.inflate(entry.raw_value))
   end
 
@@ -748,6 +767,6 @@ class CacheEntryTest < ActiveSupport::TestCase
     entry = ActiveSupport::Cache::Entry.new("value")
     assert_equal "value", entry.value
     assert_equal "value", Marshal.load(entry.raw_value)
-    assert_equal false, entry.compressed?
+    assert !entry.compressed?
   end
 end
diff --git a/activesupport/test/concern_test.rb b/activesupport/test/concern_test.rb
index 4cbe56a2d2..0b0920ee03 100644
--- a/activesupport/test/concern_test.rb
+++ b/activesupport/test/concern_test.rb
@@ -19,9 +19,6 @@ class ConcernTest < Test::Unit::TestCase
       end
     end
 
-    module InstanceMethods
-    end
-
     included do
       self.included_ran = true
     end
@@ -74,7 +71,7 @@ class ConcernTest < Test::Unit::TestCase
   def test_instance_methods_are_included
     @klass.send(:include, Baz)
     assert_equal "baz", @klass.new.baz
-    assert @klass.included_modules.include?(ConcernTest::Baz::InstanceMethods)
+    assert @klass.included_modules.include?(ConcernTest::Baz)
   end
 
   def test_included_block_is_ran
@@ -92,6 +89,6 @@ class ConcernTest < Test::Unit::TestCase
 
   def test_dependencies_with_multiple_modules
     @klass.send(:include, Foo)
-    assert_equal [ConcernTest::Foo, ConcernTest::Bar, ConcernTest::Baz::InstanceMethods, ConcernTest::Baz], @klass.included_modules[0..3]
+    assert_equal [ConcernTest::Foo, ConcernTest::Bar, ConcernTest::Baz], @klass.included_modules[0..2]
   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 456736cbad..9be28272f7 100644
--- a/activesupport/test/core_ext/date_time_ext_test.rb
+++ b/activesupport/test/core_ext/date_time_ext_test.rb
@@ -34,8 +34,8 @@ class DateTimeExtCalculationsTest < Test::Unit::TestCase
   end
 
   def test_to_time
-    assert_equal Time.utc(2005, 2, 21, 10, 11, 12), DateTime.new(2005, 2, 21, 10, 11, 12, 0, 0).to_time
-    assert_equal Time.utc_time(2039, 2, 21, 10, 11, 12), DateTime.new(2039, 2, 21, 10, 11, 12, 0, 0).to_time
+    assert_equal Time.utc(2005, 2, 21, 10, 11, 12), DateTime.new(2005, 2, 21, 10, 11, 12, 0).to_time
+    assert_equal Time.utc_time(2039, 2, 21, 10, 11, 12), DateTime.new(2039, 2, 21, 10, 11, 12, 0).to_time
     # DateTimes with offsets other than 0 are returned unaltered
     assert_equal DateTime.new(2005, 2, 21, 10, 11, 12, Rational(-5, 24)), DateTime.new(2005, 2, 21, 10, 11, 12, Rational(-5, 24)).to_time
     # Fractional seconds are preserved
@@ -99,7 +99,7 @@ class DateTimeExtCalculationsTest < Test::Unit::TestCase
     assert_equal DateTime.civil(2005,5,1,10), DateTime.civil(2005,6,5,10,0,0).weeks_ago(5)
     assert_equal DateTime.civil(2005,4,24,10), DateTime.civil(2005,6,5,10,0,0).weeks_ago(6)
     assert_equal DateTime.civil(2005,2,27,10),  DateTime.civil(2005,6,5,10,0,0).weeks_ago(14)
-    assert_equal DateTime.civil(2004,12,25,10),  DateTime.civil(2005,1,1,10,0,0).weeks_ago(1)    
+    assert_equal DateTime.civil(2004,12,25,10),  DateTime.civil(2005,1,1,10,0,0).weeks_ago(1)
   end
 
   def test_months_ago
diff --git a/activesupport/test/core_ext/integer_ext_test.rb b/activesupport/test/core_ext/integer_ext_test.rb
index fe8c7eb224..b1f5f70a70 100644
--- a/activesupport/test/core_ext/integer_ext_test.rb
+++ b/activesupport/test/core_ext/integer_ext_test.rb
@@ -2,6 +2,8 @@ require 'abstract_unit'
 require 'active_support/core_ext/integer'
 
 class IntegerExtTest < Test::Unit::TestCase
+  PRIME = 22953686867719691230002707821868552601124472329079
+
   def test_multiple_of
     [ -7, 0, 7, 14 ].each { |i| assert i.multiple_of?(7) }
     [ -7, 7, 14 ].each { |i| assert ! i.multiple_of?(6) }
@@ -11,10 +13,7 @@ class IntegerExtTest < Test::Unit::TestCase
     assert !5.multiple_of?(0)
 
     # test with a prime
-    assert !22953686867719691230002707821868552601124472329079.multiple_of?(2)
-    assert !22953686867719691230002707821868552601124472329079.multiple_of?(3)
-    assert !22953686867719691230002707821868552601124472329079.multiple_of?(5)
-    assert !22953686867719691230002707821868552601124472329079.multiple_of?(7)
+    [2, 3, 5, 7].each { |i| assert !PRIME.multiple_of?(i) }
   end
 
   def test_ordinalize
diff --git a/activesupport/test/core_ext/module/qualified_const_test.rb b/activesupport/test/core_ext/module/qualified_const_test.rb
new file mode 100644
index 0000000000..8af0b9a023
--- /dev/null
+++ b/activesupport/test/core_ext/module/qualified_const_test.rb
@@ -0,0 +1,94 @@
+require 'abstract_unit'
+require 'active_support/core_ext/module/qualified_const'
+
+module QualifiedConstTestMod
+  X = false
+
+  module M
+    X = 1
+
+    class C
+      X = 2
+    end
+  end
+
+  module N
+    include M
+  end
+end
+
+class QualifiedConstTest < ActiveSupport::TestCase
+  test "Object.qualified_const_defined?" do
+    assert Object.qualified_const_defined?("QualifiedConstTestMod")
+    assert !Object.qualified_const_defined?("NonExistingQualifiedConstTestMod")
+
+    assert Object.qualified_const_defined?("QualifiedConstTestMod::X")
+    assert !Object.qualified_const_defined?("QualifiedConstTestMod::Y")
+
+    assert Object.qualified_const_defined?("QualifiedConstTestMod::M::X")
+    assert !Object.qualified_const_defined?("QualifiedConstTestMod::M::Y")
+
+    if Module.method(:const_defined?).arity == 1
+      assert !Object.qualified_const_defined?("QualifiedConstTestMod::N::X")
+    else
+      assert Object.qualified_const_defined?("QualifiedConstTestMod::N::X")
+      assert !Object.qualified_const_defined?("QualifiedConstTestMod::N::X", false)
+      assert Object.qualified_const_defined?("QualifiedConstTestMod::N::X", true)
+    end
+  end
+
+  test "mod.qualified_const_defined?" do
+    assert QualifiedConstTestMod.qualified_const_defined?("M")
+    assert !QualifiedConstTestMod.qualified_const_defined?("NonExistingM")
+
+    assert QualifiedConstTestMod.qualified_const_defined?("M::X")
+    assert !QualifiedConstTestMod.qualified_const_defined?("M::Y")
+
+    assert QualifiedConstTestMod.qualified_const_defined?("M::C::X")
+    assert !QualifiedConstTestMod.qualified_const_defined?("M::C::Y")
+
+    if Module.method(:const_defined?).arity == 1
+      assert !QualifiedConstTestMod.qualified_const_defined?("QualifiedConstTestMod::N::X")
+    else
+      assert QualifiedConstTestMod.qualified_const_defined?("N::X")
+      assert !QualifiedConstTestMod.qualified_const_defined?("N::X", false)
+      assert QualifiedConstTestMod.qualified_const_defined?("N::X", true)
+    end
+  end
+
+  test "qualified_const_get" do
+    assert_equal false, Object.qualified_const_get("QualifiedConstTestMod::X")
+    assert_equal false, QualifiedConstTestMod.qualified_const_get("X")
+    assert_equal 1, QualifiedConstTestMod.qualified_const_get("M::X")
+    assert_equal 1, QualifiedConstTestMod.qualified_const_get("N::X")
+    assert_equal 2, QualifiedConstTestMod.qualified_const_get("M::C::X")
+
+    assert_raise(NameError) { QualifiedConstTestMod.qualified_const_get("M::C::Y")}
+  end
+
+  test "qualified_const_set" do
+    m = Module.new
+    assert_equal m, Object.qualified_const_set("QualifiedConstTestMod2", m)
+    assert_equal m, ::QualifiedConstTestMod2
+
+    # We are going to assign to existing constants on purpose, so silence warnings.
+    silence_warnings do
+      assert_equal true, QualifiedConstTestMod.qualified_const_set("QualifiedConstTestMod::X", true)
+      assert_equal true, QualifiedConstTestMod::X
+
+      assert_equal 10, QualifiedConstTestMod::M.qualified_const_set("X", 10)
+      assert_equal 10, QualifiedConstTestMod::M::X
+    end
+  end
+
+  test "reject absolute paths" do
+    assert_raise(NameError, "wrong constant name ::X") { Object.qualified_const_defined?("::X")}
+    assert_raise(NameError, "wrong constant name ::X") { Object.qualified_const_defined?("::X::Y")}
+
+    assert_raise(NameError, "wrong constant name ::X") { Object.qualified_const_get("::X")}
+    assert_raise(NameError, "wrong constant name ::X") { Object.qualified_const_get("::X::Y")}
+
+    assert_raise(NameError, "wrong constant name ::X") { Object.qualified_const_set("::X", nil)}
+    assert_raise(NameError, "wrong constant name ::X") { Object.qualified_const_set("::X::Y", nil)}
+  end
+end
diff --git a/activesupport/test/core_ext/module/remove_method_test.rb b/activesupport/test/core_ext/module/remove_method_test.rb
new file mode 100644
index 0000000000..4657f0c175
--- /dev/null
+++ b/activesupport/test/core_ext/module/remove_method_test.rb
@@ -0,0 +1,29 @@
+require 'abstract_unit'
+require 'active_support/core_ext/module/remove_method'
+
+module RemoveMethodTests
+  class A
+    def do_something
+      return 1
+    end
+    
+  end
+end
+
+class RemoveMethodTest < ActiveSupport::TestCase
+  
+  def test_remove_method_from_an_object
+    RemoveMethodTests::A.class_eval{
+      self.remove_possible_method(:do_something)
+    }
+    assert !RemoveMethodTests::A.new.respond_to?(:do_something)
+  end
+  
+  def test_redefine_method_in_an_object
+    RemoveMethodTests::A.class_eval{
+      self.redefine_method(:do_something) { return 100 }
+    }
+    assert_equal 100, RemoveMethodTests::A.new.do_something
+  end
+
+end
\ No newline at end of file
diff --git a/activesupport/test/core_ext/string_ext_test.rb b/activesupport/test/core_ext/string_ext_test.rb
index 5c1dddaf96..ade09efc56 100644
--- a/activesupport/test/core_ext/string_ext_test.rb
+++ b/activesupport/test/core_ext/string_ext_test.rb
@@ -20,7 +20,7 @@ end
 class StringInflectionsTest < Test::Unit::TestCase
   include InflectorTestCases
   include ConstantizeTestCases
-  
+
   def test_erb_escape
     string = [192, 60].pack('CC')
     expected = 192.chr + "&lt;"
@@ -64,6 +64,10 @@ class StringInflectionsTest < Test::Unit::TestCase
     end
 
     assert_equal("plurals", "plurals".pluralize)
+
+    assert_equal("blargles", "blargle".pluralize(0))
+    assert_equal("blargle", "blargle".pluralize(1))
+    assert_equal("blargles", "blargle".pluralize(2))
   end
 
   def test_singularize
@@ -107,6 +111,10 @@ class StringInflectionsTest < Test::Unit::TestCase
     assert_equal "Account", "MyApplication::Billing::Account".demodulize
   end
 
+  def test_deconstantize
+    assert_equal "MyApplication::Billing", "MyApplication::Billing::Account".deconstantize
+  end
+
   def test_foreign_key
     ClassNameToForeignKeyWithUnderscore.each do |klass, foreign_key|
       assert_equal(foreign_key, klass.foreign_key)
@@ -301,13 +309,13 @@ class StringInflectionsTest < Test::Unit::TestCase
         "\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 \354\225\204\353\235\274\353\246\254\354\230\244".force_encoding('UTF-8').truncate(10)
     end
   end
-  
+
   def test_constantize
     run_constantize_tests_on do |string|
       string.constantize
     end
   end
-  
+
   def test_safe_constantize
     run_safe_constantize_tests_on do |string|
       string.safe_constantize
@@ -381,7 +389,7 @@ class OutputSafetyTest < ActiveSupport::TestCase
   test "A fixnum is safe by default" do
     assert 5.html_safe?
   end
-  
+
   test "a float is safe by default" do
     assert 5.7.html_safe?
   end
diff --git a/activesupport/test/core_ext/time_ext_test.rb b/activesupport/test/core_ext/time_ext_test.rb
index ab9be4b18b..d2ff44e1b4 100644
--- a/activesupport/test/core_ext/time_ext_test.rb
+++ b/activesupport/test/core_ext/time_ext_test.rb
@@ -135,7 +135,7 @@ class TimeExtCalculationsTest < ActiveSupport::TestCase
     assert_equal Time.local(2005,5,1,10), Time.local(2005,6,5,10,0,0).weeks_ago(5)
     assert_equal Time.local(2005,4,24,10), Time.local(2005,6,5,10,0,0).weeks_ago(6)
     assert_equal Time.local(2005,2,27,10),  Time.local(2005,6,5,10,0,0).weeks_ago(14)
-    assert_equal Time.local(2004,12,25,10),  Time.local(2005,1,1,10,0,0).weeks_ago(1)    
+    assert_equal Time.local(2004,12,25,10),  Time.local(2005,1,1,10,0,0).weeks_ago(1)
   end
 
   def test_months_ago
@@ -479,7 +479,7 @@ class TimeExtCalculationsTest < ActiveSupport::TestCase
       assert_equal Time.local(2006,10,30), Time.local(2006,11,6,0,0,0).prev_week
       assert_equal Time.local(2006,11,15), Time.local(2006,11,23,0,0,0).prev_week(:wednesday)
     end
-  end    
+  end
 
   def test_next_week
     with_env_tz 'US/Eastern' do
@@ -538,12 +538,12 @@ class TimeExtCalculationsTest < ActiveSupport::TestCase
   end
 
   def test_to_datetime
-    assert_equal Time.utc(2005, 2, 21, 17, 44, 30).to_datetime, DateTime.civil(2005, 2, 21, 17, 44, 30, 0, 0)
+    assert_equal Time.utc(2005, 2, 21, 17, 44, 30).to_datetime, DateTime.civil(2005, 2, 21, 17, 44, 30, 0)
     with_env_tz 'US/Eastern' do
-      assert_equal Time.local(2005, 2, 21, 17, 44, 30).to_datetime, DateTime.civil(2005, 2, 21, 17, 44, 30, Rational(Time.local(2005, 2, 21, 17, 44, 30).utc_offset, 86400), 0)
+      assert_equal Time.local(2005, 2, 21, 17, 44, 30).to_datetime, DateTime.civil(2005, 2, 21, 17, 44, 30, Rational(Time.local(2005, 2, 21, 17, 44, 30).utc_offset, 86400))
     end
     with_env_tz 'NZ' do
-      assert_equal Time.local(2005, 2, 21, 17, 44, 30).to_datetime, DateTime.civil(2005, 2, 21, 17, 44, 30, Rational(Time.local(2005, 2, 21, 17, 44, 30).utc_offset, 86400), 0)
+      assert_equal Time.local(2005, 2, 21, 17, 44, 30).to_datetime, DateTime.civil(2005, 2, 21, 17, 44, 30, Rational(Time.local(2005, 2, 21, 17, 44, 30).utc_offset, 86400))
     end
     assert_equal ::Date::ITALY, Time.utc(2005, 2, 21, 17, 44, 30).to_datetime.start # use Ruby's default start value
   end
@@ -592,11 +592,11 @@ class TimeExtCalculationsTest < ActiveSupport::TestCase
   def test_time_with_datetime_fallback
     assert_equal Time.time_with_datetime_fallback(:utc, 2005, 2, 21, 17, 44, 30), Time.utc(2005, 2, 21, 17, 44, 30)
     assert_equal Time.time_with_datetime_fallback(:local, 2005, 2, 21, 17, 44, 30), Time.local(2005, 2, 21, 17, 44, 30)
-    assert_equal Time.time_with_datetime_fallback(:utc, 2039, 2, 21, 17, 44, 30), DateTime.civil(2039, 2, 21, 17, 44, 30, 0, 0)
-    assert_equal Time.time_with_datetime_fallback(:local, 2039, 2, 21, 17, 44, 30), DateTime.civil(2039, 2, 21, 17, 44, 30, DateTime.local_offset, 0)
-    assert_equal Time.time_with_datetime_fallback(:utc, 1900, 2, 21, 17, 44, 30), DateTime.civil(1900, 2, 21, 17, 44, 30, 0, 0)
+    assert_equal Time.time_with_datetime_fallback(:utc, 2039, 2, 21, 17, 44, 30), DateTime.civil(2039, 2, 21, 17, 44, 30, 0)
+    assert_equal Time.time_with_datetime_fallback(:local, 2039, 2, 21, 17, 44, 30), DateTime.civil(2039, 2, 21, 17, 44, 30, DateTime.local_offset)
+    assert_equal Time.time_with_datetime_fallback(:utc, 1900, 2, 21, 17, 44, 30), DateTime.civil(1900, 2, 21, 17, 44, 30, 0)
     assert_equal Time.time_with_datetime_fallback(:utc, 2005), Time.utc(2005)
-    assert_equal Time.time_with_datetime_fallback(:utc, 2039), DateTime.civil(2039, 1, 1, 0, 0, 0, 0, 0)
+    assert_equal Time.time_with_datetime_fallback(:utc, 2039), DateTime.civil(2039, 1, 1, 0, 0, 0, 0)
     assert_equal Time.time_with_datetime_fallback(:utc, 2005, 2, 21, 17, 44, 30, 1), Time.utc(2005, 2, 21, 17, 44, 30, 1) #with usec
     # This won't overflow on 64bit linux
     unless time_is_64bits?
@@ -616,16 +616,16 @@ class TimeExtCalculationsTest < ActiveSupport::TestCase
 
   def test_utc_time
     assert_equal Time.utc_time(2005, 2, 21, 17, 44, 30), Time.utc(2005, 2, 21, 17, 44, 30)
-    assert_equal Time.utc_time(2039, 2, 21, 17, 44, 30), DateTime.civil(2039, 2, 21, 17, 44, 30, 0, 0)
-    assert_equal Time.utc_time(1901, 2, 21, 17, 44, 30), DateTime.civil(1901, 2, 21, 17, 44, 30, 0, 0)
+    assert_equal Time.utc_time(2039, 2, 21, 17, 44, 30), DateTime.civil(2039, 2, 21, 17, 44, 30, 0)
+    assert_equal Time.utc_time(1901, 2, 21, 17, 44, 30), DateTime.civil(1901, 2, 21, 17, 44, 30, 0)
   end
 
   def test_local_time
     assert_equal Time.local_time(2005, 2, 21, 17, 44, 30), Time.local(2005, 2, 21, 17, 44, 30)
-    assert_equal Time.local_time(2039, 2, 21, 17, 44, 30), DateTime.civil(2039, 2, 21, 17, 44, 30, DateTime.local_offset, 0)
+    assert_equal Time.local_time(2039, 2, 21, 17, 44, 30), DateTime.civil(2039, 2, 21, 17, 44, 30, DateTime.local_offset)
 
     unless time_is_64bits?
-      assert_equal Time.local_time(1901, 2, 21, 17, 44, 30), DateTime.civil(1901, 2, 21, 17, 44, 30, DateTime.local_offset, 0)
+      assert_equal Time.local_time(1901, 2, 21, 17, 44, 30), DateTime.civil(1901, 2, 21, 17, 44, 30, DateTime.local_offset)
     end
   end
 
@@ -744,6 +744,12 @@ class TimeExtCalculationsTest < ActiveSupport::TestCase
     assert_equal(-1, Time.utc(2000) <=> ActiveSupport::TimeWithZone.new( Time.utc(2000, 1, 1, 0, 0, 1), ActiveSupport::TimeZone['UTC'] ))
   end
 
+  def test_eql?
+    assert_equal true, Time.utc(2000).eql?( ActiveSupport::TimeWithZone.new(Time.utc(2000), ActiveSupport::TimeZone['UTC']) )
+    assert_equal true, Time.utc(2000).eql?( ActiveSupport::TimeWithZone.new(Time.utc(2000), ActiveSupport::TimeZone["Hawaii"]) )
+    assert_equal false,Time.utc(2000, 1, 1, 0, 0, 1).eql?( ActiveSupport::TimeWithZone.new(Time.utc(2000), ActiveSupport::TimeZone['UTC']) )
+  end
+
   def test_minus_with_time_with_zone
     assert_equal  86_400.0, Time.utc(2000, 1, 2) - ActiveSupport::TimeWithZone.new( Time.utc(2000, 1, 1), ActiveSupport::TimeZone['UTC'] )
   end
diff --git a/activesupport/test/core_ext/time_with_zone_test.rb b/activesupport/test/core_ext/time_with_zone_test.rb
index b2309ae806..9d9e411c28 100644
--- a/activesupport/test/core_ext/time_with_zone_test.rb
+++ b/activesupport/test/core_ext/time_with_zone_test.rb
@@ -200,8 +200,15 @@ class TimeWithZoneTest < Test::Unit::TestCase
   end
 
   def test_eql?
-    assert @twz.eql?(Time.utc(2000))
-    assert @twz.eql?( ActiveSupport::TimeWithZone.new(Time.utc(2000), ActiveSupport::TimeZone["Hawaii"]) )
+    assert_equal true, @twz.eql?(Time.utc(2000))
+    assert_equal true, @twz.eql?( ActiveSupport::TimeWithZone.new(Time.utc(2000), ActiveSupport::TimeZone["Hawaii"]) )
+    assert_equal false, @twz.eql?( Time.utc(2000, 1, 1, 0, 0, 1) )
+    assert_equal false, @twz.eql?( DateTime.civil(1999, 12, 31, 23, 59, 59) )
+  end
+
+  def test_hash
+    assert_equal Time.utc(2000).hash, @twz.hash
+    assert_equal Time.utc(2000).hash, ActiveSupport::TimeWithZone.new(Time.utc(2000), ActiveSupport::TimeZone["Hawaii"]).hash
   end
 
   def test_plus_with_integer
diff --git a/activesupport/test/flush_cache_on_private_memoization_test.rb b/activesupport/test/flush_cache_on_private_memoization_test.rb
index 20768b777a..bc488cc743 100644
--- a/activesupport/test/flush_cache_on_private_memoization_test.rb
+++ b/activesupport/test/flush_cache_on_private_memoization_test.rb
@@ -1,7 +1,7 @@
 require 'abstract_unit'
 require 'test/unit'
 
-class FlashCacheOnPrivateMemoizationTest < Test::Unit::TestCase
+class FlushCacheOnPrivateMemoizationTest < Test::Unit::TestCase
   ActiveSupport::Deprecation.silence do
     extend ActiveSupport::Memoizable
   end
diff --git a/activesupport/test/inflector_test.rb b/activesupport/test/inflector_test.rb
index 5c956e0075..6b7e839e43 100644
--- a/activesupport/test/inflector_test.rb
+++ b/activesupport/test/inflector_test.rb
@@ -194,6 +194,20 @@ class InflectorTest < Test::Unit::TestCase
 
   def test_demodulize
     assert_equal "Account", ActiveSupport::Inflector.demodulize("MyApplication::Billing::Account")
+    assert_equal "Account", ActiveSupport::Inflector.demodulize("Account")
+    assert_equal "", ActiveSupport::Inflector.demodulize("")
+  end
+
+  def test_deconstantize
+    assert_equal "MyApplication::Billing", ActiveSupport::Inflector.deconstantize("MyApplication::Billing::Account")
+    assert_equal "::MyApplication::Billing", ActiveSupport::Inflector.deconstantize("::MyApplication::Billing::Account")
+
+    assert_equal "MyApplication", ActiveSupport::Inflector.deconstantize("MyApplication::Billing")
+    assert_equal "::MyApplication", ActiveSupport::Inflector.deconstantize("::MyApplication::Billing")
+
+    assert_equal "", ActiveSupport::Inflector.deconstantize("Account")
+    assert_equal "", ActiveSupport::Inflector.deconstantize("::Account")
+    assert_equal "", ActiveSupport::Inflector.deconstantize("")
   end
 
   def test_foreign_key
diff --git a/activesupport/test/inflector_test_cases.rb b/activesupport/test/inflector_test_cases.rb
index 0cb1f70657..e3a343af52 100644
--- a/activesupport/test/inflector_test_cases.rb
+++ b/activesupport/test/inflector_test_cases.rb
@@ -14,6 +14,7 @@ module InflectorTestCases
     "fish"        => "fish",
     "jeans"       => "jeans",
     "funky jeans" => "funky jeans",
+    "my money"    => "my money",
 
     "category"    => "categories",
     "query"       => "queries",
diff --git a/activesupport/test/message_encryptor_test.rb b/activesupport/test/message_encryptor_test.rb
index 83a19f8106..3e6a5c6602 100644
--- a/activesupport/test/message_encryptor_test.rb
+++ b/activesupport/test/message_encryptor_test.rb
@@ -11,46 +11,50 @@ require 'active_support/time'
 require 'active_support/json'
 
 class MessageEncryptorTest < ActiveSupport::TestCase
-  
   class JSONSerializer
     def dump(value)
       ActiveSupport::JSON.encode(value)
     end
-    
+
     def load(value)
       ActiveSupport::JSON.decode(value)
     end
   end
-  
+
   def setup
-    @encryptor = ActiveSupport::MessageEncryptor.new(SecureRandom.hex(64))
+    @secret    = SecureRandom.hex(64)
+    @verifier  = ActiveSupport::MessageVerifier.new(@secret, :serializer => ActiveSupport::MessageEncryptor::NullSerializer)
+    @encryptor = ActiveSupport::MessageEncryptor.new(@secret)
     @data = { :some => "data", :now => Time.local(2010) }
   end
 
-  def test_simple_round_tripping
-    message = @encryptor.encrypt(@data)
-    assert_equal @data, @encryptor.decrypt(message)
-  end
-
   def test_encrypting_twice_yields_differing_cipher_text
-    first_messqage = @encryptor.encrypt(@data)
-    second_message = @encryptor.encrypt(@data)
+    first_messqage = @encryptor.encrypt_and_sign(@data).split("--").first
+    second_message = @encryptor.encrypt_and_sign(@data).split("--").first
     assert_not_equal first_messqage, second_message
   end
 
-  def test_messing_with_either_value_causes_failure
-    text, iv = @encryptor.encrypt(@data).split("--")
+  def test_messing_with_either_encrypted_values_causes_failure
+    text, iv = @verifier.verify(@encryptor.encrypt_and_sign(@data)).split("--")
     assert_not_decrypted([iv, text] * "--")
     assert_not_decrypted([text, munge(iv)] * "--")
     assert_not_decrypted([munge(text), iv] * "--")
     assert_not_decrypted([munge(text), munge(iv)] * "--")
   end
 
+  def test_messing_with_verified_values_causes_failures
+    text, iv = @encryptor.encrypt_and_sign(@data).split("--")
+    assert_not_verified([iv, text] * "--")
+    assert_not_verified([text, munge(iv)] * "--")
+    assert_not_verified([munge(text), iv] * "--")
+    assert_not_verified([munge(text), munge(iv)] * "--")
+  end
+
   def test_signed_round_tripping
     message = @encryptor.encrypt_and_sign(@data)
     assert_equal @data, @encryptor.decrypt_and_verify(message)
   end
-  
+
   def test_alternative_serialization_method
     encryptor = ActiveSupport::MessageEncryptor.new(SecureRandom.hex(64), :serializer => JSONSerializer.new)
     message = encryptor.encrypt_and_sign({ :foo => 123, 'bar' => Time.utc(2010) })
@@ -62,19 +66,26 @@ class MessageEncryptorTest < ActiveSupport::TestCase
       ActiveSupport::MessageEncryptor.new(SecureRandom.hex(64), 'aes-256-cbc')
     end
   end
-  
+
   private
-    def assert_not_decrypted(value)
-      assert_raise(ActiveSupport::MessageEncryptor::InvalidMessage) do
-        @encryptor.decrypt(value)
-      end
+
+  def assert_not_decrypted(value)
+    assert_raise(ActiveSupport::MessageEncryptor::InvalidMessage) do
+      @encryptor.decrypt_and_verify(@verifier.generate(value))
     end
+  end
 
-    def munge(base64_string)
-      bits = ActiveSupport::Base64.decode64(base64_string)
-      bits.reverse!
-      ActiveSupport::Base64.encode64s(bits)
+  def assert_not_verified(value)
+    assert_raise(ActiveSupport::MessageVerifier::InvalidSignature) do
+      @encryptor.decrypt_and_verify(value)
     end
-end
+  end
 
+  def munge(base64_string)
+    bits = ActiveSupport::Base64.decode64(base64_string)
+    bits.reverse!
+    ActiveSupport::Base64.encode64s(bits)
+  end
 end
+
+end
\ No newline at end of file
diff --git a/activesupport/test/notifications_test.rb b/activesupport/test/notifications_test.rb
index 884ee61547..fc9fa90d07 100644
--- a/activesupport/test/notifications_test.rb
+++ b/activesupport/test/notifications_test.rb
@@ -24,6 +24,26 @@ module Notifications
     end
   end
 
+  class SubscribedTest < TestCase
+    def test_subscribed
+      name     = "foo"
+      name2    = name * 2
+      expected = [name, name]
+
+      events   = []
+      callback = lambda {|*_| events << _.first}
+      ActiveSupport::Notifications.subscribed(callback, name) do
+        ActiveSupport::Notifications.instrument(name)
+        ActiveSupport::Notifications.instrument(name2)
+        ActiveSupport::Notifications.instrument(name)
+      end
+      assert_equal expected, events
+
+      ActiveSupport::Notifications.instrument(name)
+      assert_equal expected, events
+    end
+  end
+
   class UnsubscribeTest < TestCase
     def test_unsubscribing_removes_a_subscription
       @notifier.publish :foo
diff --git a/activesupport/test/tagged_logging_test.rb b/activesupport/test/tagged_logging_test.rb
new file mode 100644
index 0000000000..17c4214dfc
--- /dev/null
+++ b/activesupport/test/tagged_logging_test.rb
@@ -0,0 +1,67 @@
+require 'abstract_unit'
+require 'active_support/core_ext/logger'
+require 'active_support/tagged_logging'
+
+class TaggedLoggingTest < ActiveSupport::TestCase
+  class MyLogger < ::Logger
+    def flush(*)
+      info "[FLUSHED]"
+    end
+  end
+
+  setup do
+    @output = StringIO.new
+    @logger = ActiveSupport::TaggedLogging.new(MyLogger.new(@output))
+  end
+
+  test "tagged once" do
+    @logger.tagged("BCX") { @logger.info "Funky time" }
+    assert_equal "[BCX] Funky time\n", @output.string
+  end
+  
+  test "tagged twice" do
+    @logger.tagged("BCX") { @logger.tagged("Jason") { @logger.info "Funky time" } }
+    assert_equal "[BCX] [Jason] Funky time\n", @output.string
+  end
+
+  test "tagged thrice at once" do
+    @logger.tagged("BCX", "Jason", "New") { @logger.info "Funky time" }
+    assert_equal "[BCX] [Jason] [New] Funky time\n", @output.string
+  end
+
+  test "tagged once with blank and nil" do
+    @logger.tagged(nil, "", "New") { @logger.info "Funky time" }
+    assert_equal "[New] Funky time\n", @output.string
+  end
+
+  test "keeps each tag in their own thread" do
+    @logger.tagged("BCX") do
+      Thread.new do
+        @logger.tagged("OMG") { @logger.info "Cool story bro" }
+      end.join
+      @logger.info "Funky time"
+    end
+    assert_equal "[OMG] Cool story bro\n[BCX] Funky time\n", @output.string
+  end
+
+  test "cleans up the taggings on flush" do
+    @logger.tagged("BCX") do
+      Thread.new do
+        @logger.tagged("OMG") do
+          @logger.flush
+          @logger.info "Cool story bro"
+        end
+      end.join
+    end
+    assert_equal "[FLUSHED]\nCool story bro\n", @output.string
+  end
+
+  test "mixed levels of tagging" do
+    @logger.tagged("BCX") do
+      @logger.tagged("Jason") { @logger.info "Funky time" }
+      @logger.info "Junky time!"
+    end
+
+    assert_equal "[BCX] [Jason] Funky time\n[BCX] Junky time!\n", @output.string
+  end
+end