Merge branch 'master' of git@github.com:rails/rails

15 files changed, 502 insertions, 41 deletions

diff --git a/activesupport/test/buffered_logger_test.rb b/activesupport/test/buffered_logger_test.rb
index 97649518b7..6319c09210 100644
--- a/activesupport/test/buffered_logger_test.rb
+++ b/activesupport/test/buffered_logger_test.rb
@@ -70,7 +70,7 @@ class BufferedLoggerTest < Test::Unit::TestCase
       end
 
       @logger.flush
-      assert !@output.string.empty?, @logger.buffer.size
+      assert !@output.string.empty?, @logger.send(:buffer).size
     end
 
     define_method "test_disabling_auto_flush_with_#{disable.inspect}_should_flush_at_max_buffer_size_as_failsafe" do
@@ -83,10 +83,10 @@ class BufferedLoggerTest < Test::Unit::TestCase
       end
 
       @logger.info 'there it is.'
-      assert !@output.string.empty?, @logger.buffer.size
+      assert !@output.string.empty?, @logger.send(:buffer).size
     end
   end
-  
+
   def test_should_know_if_its_loglevel_is_below_a_given_level
     ActiveSupport::BufferedLogger::Severity.constants.each do |level|
       @logger.level = ActiveSupport::BufferedLogger::Severity.const_get(level) - 1
@@ -105,7 +105,7 @@ class BufferedLoggerTest < Test::Unit::TestCase
     @logger.info 'there it is.'
     assert !@output.string.empty?, @output.string
   end
-  
+
   def test_should_create_the_log_directory_if_it_doesnt_exist
     tmp_directory = File.join(File.dirname(__FILE__), "tmp")
     log_file = File.join(tmp_directory, "development.log")
@@ -115,4 +115,25 @@ class BufferedLoggerTest < Test::Unit::TestCase
   ensure
     FileUtils.rm_rf(tmp_directory)
   end
+
+  def test_logger_should_maintain_separate_buffers_for_each_thread
+    @logger.auto_flushing = false
+
+    a = Thread.new do
+      @logger.info("a"); Thread.pass;
+      @logger.info("b"); Thread.pass;
+      @logger.info("c"); @logger.flush
+    end
+
+    b = Thread.new do
+      @logger.info("x"); Thread.pass;
+      @logger.info("y"); Thread.pass;
+      @logger.info("z"); @logger.flush
+    end
+
+    a.join
+    b.join
+
+    assert_equal "a\nb\nc\nx\ny\nz\n", @output.string
+  end
 end
diff --git a/activesupport/test/caching_test.rb b/activesupport/test/caching_test.rb
index f3220d27aa..9ea9389448 100644
--- a/activesupport/test/caching_test.rb
+++ b/activesupport/test/caching_test.rb
@@ -70,3 +70,60 @@ uses_mocha 'high-level cache store tests' do
     end
   end
 end
+
+class FileStoreTest < Test::Unit::TestCase
+  def setup
+    @cache = ActiveSupport::Cache.lookup_store(:file_store, Dir.pwd)
+  end
+
+  def test_should_read_and_write_strings
+    @cache.write('foo', 'bar')
+    assert_equal 'bar', @cache.read('foo')
+  ensure
+    File.delete("foo.cache")
+  end
+
+  def test_should_read_and_write_hash
+    @cache.write('foo', {:a => "b"})
+    assert_equal({:a => "b"}, @cache.read('foo'))
+  ensure
+    File.delete("foo.cache")
+  end
+
+  def test_should_read_and_write_nil
+    @cache.write('foo', nil)
+    assert_equal nil, @cache.read('foo')
+  ensure
+    File.delete("foo.cache")
+  end
+end
+
+class MemoryStoreTest < Test::Unit::TestCase
+  def setup
+    @cache = ActiveSupport::Cache.lookup_store(:memory_store)
+  end
+
+  def test_should_read_and_write
+    @cache.write('foo', 'bar')
+    assert_equal 'bar', @cache.read('foo')
+  end
+
+  def test_fetch_without_cache_miss
+    @cache.write('foo', 'bar')
+    assert_equal 'bar', @cache.fetch('foo') { 'baz' }
+  end
+
+  def test_fetch_with_cache_miss
+    assert_equal 'baz', @cache.fetch('foo') { 'baz' }
+  end
+
+  def test_fetch_with_forced_cache_miss
+    @cache.fetch('foo', :force => true) { 'bar' }
+  end
+
+  def test_store_objects_should_be_immutable
+    @cache.write('foo', 'bar')
+    assert_raise(ActiveSupport::FrozenObjectError) { @cache.read('foo').gsub!(/.*/, 'baz') }
+    assert_equal 'bar', @cache.read('foo')
+  end
+end
diff --git a/activesupport/test/callbacks_test.rb b/activesupport/test/callbacks_test.rb
index 7f71ca2262..25b8eecef5 100644
--- a/activesupport/test/callbacks_test.rb
+++ b/activesupport/test/callbacks_test.rb
@@ -134,10 +134,10 @@ class CallbackChainTest < Test::Unit::TestCase
     assert_equal :bacon, @chain.find(:bacon).method
   end
 
-  def test_union
-    assert_equal [:bacon, :lettuce, :tomato], (@chain | Callback.new(:make, :bacon)).map(&:method)
-    assert_equal [:bacon, :lettuce, :tomato, :turkey], (@chain | CallbackChain.build(:make, :bacon, :lettuce, :tomato, :turkey)).map(&:method)
-    assert_equal [:bacon, :lettuce, :tomato, :turkey, :mayo], (@chain | Callback.new(:make, :mayo)).map(&:method)
+  def test_replace_or_append
+    assert_equal [:bacon, :lettuce, :tomato], (@chain.replace_or_append!(Callback.new(:make, :bacon))).map(&:method)
+    assert_equal [:bacon, :lettuce, :tomato, :turkey], (@chain.replace_or_append!(Callback.new(:make, :turkey))).map(&:method)
+    assert_equal [:bacon, :lettuce, :tomato, :turkey, :mayo], (@chain.replace_or_append!(Callback.new(:make, :mayo))).map(&:method)
   end
 
   def test_delete
diff --git a/activesupport/test/core_ext/date_ext_test.rb b/activesupport/test/core_ext/date_ext_test.rb
index ddfe1f904f..0f3cf4c75c 100644
--- a/activesupport/test/core_ext/date_ext_test.rb
+++ b/activesupport/test/core_ext/date_ext_test.rb
@@ -198,10 +198,6 @@ class DateExtCalculationsTest < Test::Unit::TestCase
     assert_equal Time.local(2005,2,21,23,59,59), Date.new(2005,2,21).end_of_day
   end
 
-  def test_date_acts_like_date
-    assert Date.new.acts_like_date?
-  end
-
   def test_xmlschema
     with_env_tz 'US/Eastern' do
       assert_match(/^1980-02-28T00:00:00-05:?00$/, Date.new(1980, 2, 28).xmlschema)
@@ -245,3 +241,15 @@ class DateExtCalculationsTest < Test::Unit::TestCase
       old_tz ? ENV['TZ'] = old_tz : ENV.delete('TZ')
     end
 end
+
+class DateExtBehaviorTest < Test::Unit::TestCase
+  def test_date_acts_like_date
+    assert Date.new.acts_like_date?
+  end
+
+  def test_freeze_doesnt_clobber_memoized_instance_methods
+    assert_nothing_raised do
+      Date.today.freeze.inspect
+    end
+  end
+end
diff --git a/activesupport/test/core_ext/duplicable_test.rb b/activesupport/test/core_ext/duplicable_test.rb
index 3ccfedccd7..8b6127f31e 100644
--- a/activesupport/test/core_ext/duplicable_test.rb
+++ b/activesupport/test/core_ext/duplicable_test.rb
@@ -1,7 +1,7 @@
 require 'abstract_unit'
 
 class DuplicableTest < Test::Unit::TestCase
-  NO  = [nil, false, true, :symbol, 1, 2.3, BigDecimal.new('4.56')]
+  NO  = [nil, false, true, :symbol, 1, 2.3, BigDecimal.new('4.56'), Class.new]
   YES = ['1', Object.new, /foo/, [], {}, Time.now]
 
   def test_duplicable
diff --git a/activesupport/test/core_ext/file_test.rb b/activesupport/test/core_ext/file_test.rb
index 5efe357e9f..eedc6b592b 100644
--- a/activesupport/test/core_ext/file_test.rb
+++ b/activesupport/test/core_ext/file_test.rb
@@ -1,9 +1,8 @@
 require 'abstract_unit'
 
 class AtomicWriteTest < Test::Unit::TestCase
-  
   def test_atomic_write_without_errors
-    contents  = "Atomic Text"
+    contents = "Atomic Text"
     File.atomic_write(file_name, Dir.pwd) do |file|
       file.write(contents)
       assert !File.exist?(file_name)
@@ -13,7 +12,7 @@ class AtomicWriteTest < Test::Unit::TestCase
   ensure
     File.unlink(file_name) rescue nil
   end
-  
+
   def test_atomic_write_doesnt_write_when_block_raises
     File.atomic_write(file_name) do |file|
       file.write("testing")
@@ -22,8 +21,47 @@ class AtomicWriteTest < Test::Unit::TestCase
   rescue
     assert !File.exist?(file_name)
   end
-  
-  def file_name
-    "atomic.file"
+
+  def test_atomic_write_preserves_file_permissions
+    contents = "Atomic Text"
+    File.open(file_name, "w", 0755) do |file|
+      file.write(contents)
+      assert File.exist?(file_name)
+    end
+    assert File.exist?(file_name)
+    assert_equal 0100755, file_mode
+    assert_equal contents, File.read(file_name)
+
+    File.atomic_write(file_name, Dir.pwd) do |file|
+      file.write(contents)
+      assert File.exist?(file_name)
+    end
+    assert File.exist?(file_name)
+    assert_equal 0100755, file_mode
+    assert_equal contents, File.read(file_name)
+  ensure
+    File.unlink(file_name) rescue nil
+  end
+
+  def test_atomic_write_preserves_default_file_permissions
+    contents = "Atomic Text"
+    File.atomic_write(file_name, Dir.pwd) do |file|
+      file.write(contents)
+      assert !File.exist?(file_name)
+    end
+    assert File.exist?(file_name)
+    assert_equal 0100666 ^ File.umask, file_mode
+    assert_equal contents, File.read(file_name)
+  ensure
+    File.unlink(file_name) rescue nil
   end
+
+  private
+    def file_name
+      "atomic.file"
+    end
+
+    def file_mode
+      File.stat(file_name).mode
+    end
 end
diff --git a/activesupport/test/core_ext/hash_ext_test.rb b/activesupport/test/core_ext/hash_ext_test.rb
index 69028a123f..fc8ed45358 100644
--- a/activesupport/test/core_ext/hash_ext_test.rb
+++ b/activesupport/test/core_ext/hash_ext_test.rb
@@ -245,6 +245,16 @@ class HashExtTest < Test::Unit::TestCase
     assert(!indiff.keys.any? {|k| k.kind_of? String}, "A key was converted to a string!")
   end
 
+  def test_deep_merge
+    hash_1 = { :a => "a", :b => "b", :c => { :c1 => "c1", :c2 => "c2", :c3 => { :d1 => "d1" } } }
+    hash_2 = { :a => 1, :c => { :c1 => 2, :c3 => { :d2 => "d2" } } }
+    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)
+    assert_equal expected, hash_1
+  end
+
   def test_reverse_merge
     defaults = { :a => "x", :b => "y", :c => 10 }.freeze
     options  = { :a => 1, :b => 2 }
@@ -282,6 +292,27 @@ class HashExtTest < Test::Unit::TestCase
     assert_equal expected, original
   end
 
+  def test_slice_with_an_array_key
+    original = { :a => 'x', :b => 'y', :c => 10, [:a, :b] => "an array key" }
+    expected = { [:a, :b] => "an array key", :c => 10 }
+
+    # Should return a new hash with only the given keys when given an array key.
+    assert_equal expected, original.slice([:a, :b], :c)
+    assert_not_equal expected, original
+
+    # Should replace the hash with only the given keys when given an array key.
+    assert_equal expected, original.slice!([:a, :b], :c)
+    assert_equal expected, original
+  end
+
+  def test_slice_with_splatted_keys
+    original = { :a => 'x', :b => 'y', :c => 10, [:a, :b] => "an array key" }
+    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
diff --git a/activesupport/test/core_ext/object_and_class_ext_test.rb b/activesupport/test/core_ext/object_and_class_ext_test.rb
index 16f4ab888e..b0a746fdc7 100644
--- a/activesupport/test/core_ext/object_and_class_ext_test.rb
+++ b/activesupport/test/core_ext/object_and_class_ext_test.rb
@@ -173,6 +173,14 @@ class ObjectTests < Test::Unit::TestCase
     assert duck.acts_like?(:time)
     assert !duck.acts_like?(:date)
   end
+
+  def test_metaclass
+    string = "Hello"
+    string.metaclass.instance_eval do
+      define_method(:foo) { "bar" }
+    end
+    assert_equal "bar", string.foo
+  end
 end
 
 class ObjectInstanceVariableTest < Test::Unit::TestCase
diff --git a/activesupport/test/core_ext/string_ext_test.rb b/activesupport/test/core_ext/string_ext_test.rb
index 19a30f1730..c9f959ef32 100644
--- a/activesupport/test/core_ext/string_ext_test.rb
+++ b/activesupport/test/core_ext/string_ext_test.rb
@@ -32,6 +32,10 @@ class StringInflectionsTest < Test::Unit::TestCase
     end
   end
 
+  def test_camelize_lower
+    assert_equal('capital', 'Capital'.camelize(:lower))
+  end
+
   def test_underscore
     CamelToUnderscore.each do |camel, underscore|
       assert_equal(underscore, camel.underscore)
diff --git a/activesupport/test/core_ext/time_ext_test.rb b/activesupport/test/core_ext/time_ext_test.rb
index 17a0968c0e..8740497b3d 100644
--- a/activesupport/test/core_ext/time_ext_test.rb
+++ b/activesupport/test/core_ext/time_ext_test.rb
@@ -528,8 +528,13 @@ class TimeExtCalculationsTest < Test::Unit::TestCase
     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, 2005, 2, 21, 17, 44, 30, 1), Time.utc(2005, 2, 21, 17, 44, 30, 1) #with usec
-    assert_equal Time.time_with_datetime_fallback(:utc, 2039, 2, 21, 17, 44, 30, 1), DateTime.civil(2039, 2, 21, 17, 44, 30, 0, 0)
-    assert_equal ::Date::ITALY, Time.time_with_datetime_fallback(:utc, 2039, 2, 21, 17, 44, 30, 1).start # use Ruby's default start value
+    # This won't overflow on 64bit linux
+    expected_to_overflow = Time.time_with_datetime_fallback(:utc, 2039, 2, 21, 17, 44, 30, 1)
+    unless expected_to_overflow.is_a?(Time)
+      assert_equal Time.time_with_datetime_fallback(:utc, 2039, 2, 21, 17, 44, 30, 1),
+                   DateTime.civil(2039, 2, 21, 17, 44, 30, 0, 0)
+      assert_equal ::Date::ITALY, Time.time_with_datetime_fallback(:utc, 2039, 2, 21, 17, 44, 30, 1).start # use Ruby's default start value
+    end
   end
 
   def test_utc_time
diff --git a/activesupport/test/dependencies_test.rb b/activesupport/test/dependencies_test.rb
index 038547a862..39c9c74c94 100644
--- a/activesupport/test/dependencies_test.rb
+++ b/activesupport/test/dependencies_test.rb
@@ -762,4 +762,16 @@ class DependenciesTest < Test::Unit::TestCase
   ensure
     ActiveSupport::Dependencies.load_once_paths = []
   end
+
+  def test_hook_called_multiple_times
+    assert_nothing_raised { ActiveSupport::Dependencies.hook! }
+  end
+
+  def test_unhook
+    ActiveSupport::Dependencies.unhook!
+    assert !Module.new.respond_to?(:const_missing_without_dependencies)
+    assert !Module.new.respond_to?(:load_without_new_constant_marking)
+  ensure
+    ActiveSupport::Dependencies.hook!
+  end
 end
diff --git a/activesupport/test/i18n_test.rb b/activesupport/test/i18n_test.rb
new file mode 100644
index 0000000000..4b17e3c523
--- /dev/null
+++ b/activesupport/test/i18n_test.rb
@@ -0,0 +1,75 @@
+require 'abstract_unit'
+
+class I18nTest < Test::Unit::TestCase
+  def setup
+    @date = Date.parse("2008-7-2")
+    @time = Time.utc(2008, 7, 2, 16, 47, 1)
+  end
+  
+  uses_mocha 'I18nTimeZoneTest' do
+    def test_time_zone_localization_with_default_format
+      Time.zone.stubs(:now).returns Time.local(2000)
+      assert_equal Time.zone.now.strftime("%a, %d %b %Y %H:%M:%S %z"), I18n.localize(Time.zone.now)
+    end
+  end
+  
+  def test_date_localization_should_use_default_format
+    assert_equal @date.strftime("%Y-%m-%d"), I18n.localize(@date)
+  end
+  
+  def test_date_localization_with_default_format
+    assert_equal @date.strftime("%Y-%m-%d"), I18n.localize(@date, :format => :default)
+  end
+  
+  def test_date_localization_with_short_format
+    assert_equal @date.strftime("%b %d"), I18n.localize(@date, :format => :short)
+  end
+  
+  def test_date_localization_with_long_format
+    assert_equal @date.strftime("%B %d, %Y"), I18n.localize(@date, :format => :long)
+  end
+  
+  def test_time_localization_should_use_default_format    
+    assert_equal @time.strftime("%a, %d %b %Y %H:%M:%S %z"), I18n.localize(@time)
+  end
+  
+  def test_time_localization_with_default_format
+    assert_equal @time.strftime("%a, %d %b %Y %H:%M:%S %z"), I18n.localize(@time, :format => :default)
+  end
+  
+  def test_time_localization_with_short_format
+    assert_equal @time.strftime("%d %b %H:%M"), I18n.localize(@time, :format => :short)
+  end
+  
+  def test_time_localization_with_long_format
+    assert_equal @time.strftime("%B %d, %Y %H:%M"), I18n.localize(@time, :format => :long)
+  end
+    
+  def test_day_names
+    assert_equal Date::DAYNAMES, I18n.translate(:'date.day_names')
+  end
+  
+  def test_abbr_day_names
+    assert_equal Date::ABBR_DAYNAMES, I18n.translate(:'date.abbr_day_names')
+  end
+  
+  def test_month_names
+    assert_equal Date::MONTHNAMES, I18n.translate(:'date.month_names')
+  end
+  
+  def test_abbr_month_names
+    assert_equal Date::ABBR_MONTHNAMES, I18n.translate(:'date.abbr_month_names')
+  end
+  
+  def test_date_order
+    assert_equal [:year, :month, :day], I18n.translate(:'date.order')
+  end
+  
+  def test_time_am
+    assert_equal 'am', I18n.translate(:'time.am')
+  end
+  
+  def test_time_pm
+    assert_equal 'pm', I18n.translate(:'time.pm')
+  end
+end
diff --git a/activesupport/test/inflector_test.rb b/activesupport/test/inflector_test.rb
index 6c0c14e866..8eebe1be25 100644
--- a/activesupport/test/inflector_test.rb
+++ b/activesupport/test/inflector_test.rb
@@ -34,6 +34,13 @@ class InflectorTest < Test::Unit::TestCase
     end
   end
 
+  def test_overwrite_previous_inflectors
+    assert_equal("series", ActiveSupport::Inflector.singularize("series"))
+    ActiveSupport::Inflector.inflections.singular "series", "serie"
+    assert_equal("serie", ActiveSupport::Inflector.singularize("series"))
+    ActiveSupport::Inflector.inflections.uncountable "series" # Return to normal
+  end
+
   MixtureToTitleCase.each do |before, titleized|
     define_method "test_titleize_#{before}" do
       assert_equal(titleized, ActiveSupport::Inflector.titleize(before))
@@ -46,6 +53,10 @@ class InflectorTest < Test::Unit::TestCase
     end
   end
 
+  def test_camelize_with_lower_downcases_the_first_letter
+    assert_equal('capital', ActiveSupport::Inflector.camelize('Capital', false))
+  end
+
   def test_underscore
     CamelToUnderscore.each do |camel, underscore|
       assert_equal(underscore, ActiveSupport::Inflector.underscore(camel))
diff --git a/activesupport/test/memoizable_test.rb b/activesupport/test/memoizable_test.rb
index fc24a2942d..135d56f14a 100644
--- a/activesupport/test/memoizable_test.rb
+++ b/activesupport/test/memoizable_test.rb
@@ -3,47 +3,211 @@ require 'abstract_unit'
 uses_mocha 'Memoizable' do
   class MemoizableTest < Test::Unit::TestCase
     class Person
-      include ActiveSupport::Memoizable
+      extend ActiveSupport::Memoizable
+
+      attr_reader :name_calls, :age_calls
+      def initialize
+        @name_calls = 0
+        @age_calls = 0
+      end
 
       def name
-        fetch_name_from_floppy
+        @name_calls += 1
+        "Josh"
+      end
+
+      def name?
+        true
       end
-      memoize :name
+      memoize :name?
+
+      def update(name)
+        "Joshua"
+      end
+      memoize :update
 
       def age
+        @age_calls += 1
         nil
       end
-      memoize :age
 
-      private
-        def fetch_name_from_floppy
-          "Josh"
+      memoize :name, :age
+    end
+
+    class Company
+      attr_reader :name_calls
+      def initialize
+        @name_calls = 0
+      end
+
+      def name
+        @name_calls += 1
+        "37signals"
+      end
+    end
+
+    module Rates
+      extend ActiveSupport::Memoizable
+
+      attr_reader :sales_tax_calls
+      def sales_tax(price)
+        @sales_tax_calls ||= 0
+        @sales_tax_calls += 1
+        price * 0.1025
+      end
+      memoize :sales_tax
+    end
+
+    class Calculator
+      extend ActiveSupport::Memoizable
+      include Rates
+
+      attr_reader :fib_calls
+      def initialize
+        @fib_calls = 0
+      end
+
+      def fib(n)
+        @fib_calls += 1
+
+        if n == 0 || n == 1
+          n
+        else
+          fib(n - 1) + fib(n - 2)
         end
+      end
+      memoize :fib
+
+      def counter
+        @count ||= 0
+        @count += 1
+      end
+      memoize :counter
+    end
+
+    def setup
+      @person = Person.new
+      @calculator = Calculator.new
     end
 
     def test_memoization
-      person = Person.new
-      assert_equal "Josh", person.name
+      assert_equal "Josh", @person.name
+      assert_equal 1, @person.name_calls
 
-      person.expects(:fetch_name_from_floppy).never
-      2.times { assert_equal "Josh", person.name }
+      3.times { assert_equal "Josh", @person.name }
+      assert_equal 1, @person.name_calls
     end
 
-    def test_memoized_methods_are_frozen
-      person = Person.new
-      person.freeze
-      assert_equal "Josh", person.name
-      assert_equal true, person.name.frozen?
+    def test_memoization_with_punctuation
+      assert_equal true, @person.name?
     end
 
-    def test_memoization_frozen_with_nil_value
-      person = Person.new
-      person.freeze
-      assert_equal nil, person.age
+    def test_memoization_with_nil_value
+      assert_equal nil, @person.age
+      assert_equal 1, @person.age_calls
+
+      3.times { assert_equal nil, @person.age }
+      assert_equal 1, @person.age_calls
+    end
+
+    def test_memorized_results_are_immutable
+      assert_equal "Josh", @person.name
+      assert_raise(ActiveSupport::FrozenObjectError) { @person.name.gsub!("Josh", "Gosh") }
+    end
+
+    def test_reloadable
+      counter = @calculator.counter
+      assert_equal 1, @calculator.counter
+      assert_equal 2, @calculator.counter(:reload)
+      assert_equal 2, @calculator.counter
+      assert_equal 3, @calculator.counter(true)
+      assert_equal 3, @calculator.counter
+    end
+
+    def test_unmemoize_all
+      assert_equal 1, @calculator.counter
+
+      assert @calculator.instance_variable_get(:@_memoized_counter).any?
+      @calculator.unmemoize_all
+      assert @calculator.instance_variable_get(:@_memoized_counter).empty?
+
+      assert_equal 2, @calculator.counter
+    end
+
+    def test_memoize_all
+      @calculator.memoize_all
+      assert @calculator.instance_variable_defined?(:@_memoized_counter)
+    end
+
+    def test_memoization_cache_is_different_for_each_instance
+      assert_equal 1, @calculator.counter
+      assert_equal 2, @calculator.counter(:reload)
+      assert_equal 1, Calculator.new.counter
+    end
+
+    def test_memoized_is_not_affected_by_freeze
+      @person.freeze
+      assert_equal "Josh", @person.name
+      assert_equal "Joshua", @person.update("Joshua")
+    end
+
+    def test_memoization_with_args
+      assert_equal 55, @calculator.fib(10)
+      assert_equal 11, @calculator.fib_calls
+    end
+
+    def test_reloadable_with_args
+      assert_equal 55, @calculator.fib(10)
+      assert_equal 11, @calculator.fib_calls
+      assert_equal 55, @calculator.fib(10, :reload)
+      assert_equal 12, @calculator.fib_calls
+      assert_equal 55, @calculator.fib(10, true)
+      assert_equal 13, @calculator.fib_calls
+    end
+
+    def test_object_memoization
+      [Company.new, Company.new, Company.new].each do |company|
+        company.extend ActiveSupport::Memoizable
+        company.memoize :name
+
+        assert_equal "37signals", company.name
+        assert_equal 1, company.name_calls
+        assert_equal "37signals", company.name
+        assert_equal 1, company.name_calls
+      end
+    end
+
+    def test_memoized_module_methods
+      assert_equal 1.025, @calculator.sales_tax(10)
+      assert_equal 1, @calculator.sales_tax_calls
+      assert_equal 1.025, @calculator.sales_tax(10)
+      assert_equal 1, @calculator.sales_tax_calls
+      assert_equal 2.5625, @calculator.sales_tax(25)
+      assert_equal 2, @calculator.sales_tax_calls
+    end
+
+    def test_object_memoized_module_methods
+      company = Company.new
+      company.extend(Rates)
+
+      assert_equal 1.025, company.sales_tax(10)
+      assert_equal 1, company.sales_tax_calls
+      assert_equal 1.025, company.sales_tax(10)
+      assert_equal 1, company.sales_tax_calls
+      assert_equal 2.5625, company.sales_tax(25)
+      assert_equal 2, company.sales_tax_calls
     end
 
     def test_double_memoization
       assert_raise(RuntimeError) { Person.memoize :name }
+      person = Person.new
+      person.extend ActiveSupport::Memoizable
+      assert_raise(RuntimeError) { person.memoize :name }
+
+      company = Company.new
+      company.extend ActiveSupport::Memoizable
+      company.memoize :name
+      assert_raise(RuntimeError) { company.memoize :name }
     end
   end
 end
diff --git a/activesupport/test/option_merger_test.rb b/activesupport/test/option_merger_test.rb
index 509c6d3bad..0d72314880 100644
--- a/activesupport/test/option_merger_test.rb
+++ b/activesupport/test/option_merger_test.rb
@@ -38,6 +38,33 @@ class OptionMergerTest < Test::Unit::TestCase
     end
   end
 
+  def test_nested_method_with_options_containing_hashes_merge
+    with_options :conditions => { :method => :get } do |outer|
+      outer.with_options :conditions => { :domain => "www" } do |inner|
+        expected = { :conditions => { :method => :get, :domain => "www" } }
+        assert_equal expected, inner.method_with_options
+      end
+    end
+  end
+
+  def test_nested_method_with_options_containing_hashes_overwrite
+    with_options :conditions => { :method => :get, :domain => "www" } do |outer|
+      outer.with_options :conditions => { :method => :post } do |inner|
+        expected = { :conditions => { :method => :post, :domain => "www" } }
+        assert_equal expected, inner.method_with_options
+      end
+    end
+  end
+
+  def test_nested_method_with_options_containing_hashes_going_deep
+    with_options :html => { :class => "foo", :style => { :margin => 0, :display => "block" } } do |outer|
+      outer.with_options :html => { :title => "bar", :style => { :margin => "1em", :color => "#fff" } } do |inner|
+        expected = { :html => { :class => "foo", :title => "bar", :style => { :margin => "1em", :display => "block", :color => "#fff" } } }
+        assert_equal expected, inner.method_with_options
+      end
+    end
+  end
+
   # Needed when counting objects with the ObjectSpace
   def test_option_merger_class_method
     assert_equal ActiveSupport::OptionMerger, ActiveSupport::OptionMerger.new('', '').class