ibm_db 0.9.5 → 0.10.0

data/test/{base_test.rb → cases/base_test.rb}

@@ -1,17 +1,21 @@
-require 'abstract_unit'
-require 'fixtures/topic'
-require 'fixtures/reply'
-require 'fixtures/company'
-require 'fixtures/customer'
-require 'fixtures/developer'
-require 'fixtures/project'
-require 'fixtures/default'
-require 'fixtures/auto_id'
-require 'fixtures/column_name'
-require 'fixtures/subscriber'
-require 'fixtures/keyboard'
-require 'fixtures/post'
-require 'fixtures/minimalistic'
+require "cases/helper"
+require 'models/author'
+require 'models/topic'
+require 'models/reply'
+require 'models/category'
+require 'models/company'
+require 'models/customer'
+require 'models/developer'
+require 'models/project'
+require 'models/default'
+require 'models/auto_id'
+require 'models/column_name'
+require 'models/subscriber'
+require 'models/keyboard'
+require 'models/post'
+require 'models/comment'
+require 'models/minimalistic'
+require 'models/warehouse_thing'
 require 'rexml/document'
 
 class Category < ActiveRecord::Base; end
@@ -64,15 +68,15 @@ class Task < ActiveRecord::Base
   attr_protected :starting
 end
 
-class TopicWithProtectedContentAndAccessibleAuthorName < ActiveRecord::Base 
-  self.table_name = 'topics' 
+class TopicWithProtectedContentAndAccessibleAuthorName < ActiveRecord::Base
+  self.table_name = 'topics'
   attr_accessible :author_name
   attr_protected  :content
 end
 
-class IBMDBBasicsTest < Test::Unit::TestCase
-  fixtures :topics, :companies, :developers, :projects, :computers, :accounts, :minimalistics
-
+class BasicsTest < ActiveRecord::TestCase
+  fixtures :topics, :companies, :developers, :projects, :computers, :accounts, :minimalistics, :warehouse_things, :authors
+  
   def test_table_exists
     assert !NonExistentTable.table_exists?
     assert Topic.table_exists?
@@ -86,7 +90,7 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     assert_equal("Jason", topic.author_name)
     assert_equal(topics(:first).author_email_address, Topic.find(1).author_email_address)
   end
-
+  
   def test_integers_as_nil
     test = AutoId.create('value' => '')
     assert_nil AutoId.find(test.id).value
@@ -97,7 +101,7 @@ class IBMDBBasicsTest < Test::Unit::TestCase
       t.title       = "Budget"
       t.author_name = "Jason"
     end
-
+    
     assert_equal("Budget", topic.title)
     assert_equal("Jason", topic.author_name)
   end
@@ -120,44 +124,63 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     topic = Topic.new
     topic.content = %w( one two three )
     topic.save
-
+    
     assert_equal(%w( one two three ), Topic.find(topic.id).content)
   end
-
+  
+  def test_read_attributes_before_type_cast
+    category = Category.new({:name=>"Test categoty", :type => nil})
+    category_attrs = {"name"=>"Test categoty", "type" => nil}
+    assert_equal category_attrs , category.attributes_before_type_cast
+  end
+  
+  if current_adapter?(:MysqlAdapter)
+    def test_read_attributes_before_type_cast_on_boolean
+      bool = Booleantest.create({ "value" => false })
+      assert_equal 0, bool.attributes_before_type_cast["value"]
+    end
+  end
+  
+  def test_read_attributes_before_type_cast_on_datetime
+    developer = Developer.find(:first)
+    assert_equal developer.created_at.to_s(:db) , developer.attributes_before_type_cast["created_at"]
+  end
+  
   def test_hash_content
     topic = Topic.new
     topic.content = { "one" => 1, "two" => 2 }
     topic.save
-
+    
     assert_equal 2, Topic.find(topic.id).content["two"]
     
+    topic.content_will_change!
     topic.content["three"] = 3
     topic.save
-
+    
     assert_equal 3, Topic.find(topic.id).content["three"]
   end
   
   def test_update_array_content
     topic = Topic.new
     topic.content = %w( one two three )
-
+    
     topic.content.push "four"
     assert_equal(%w( one two three four ), topic.content)
-
+    
     topic.save
     
     topic = Topic.find(topic.id)
     topic.content << "five"
     assert_equal(%w( one two three four five ), topic.content)
   end
- 
+  
   def test_case_sensitive_attributes_hash
     # DB2 is not case-sensitive
     return true if current_adapter?(:DB2Adapter, :IBM_DBAdapter)
-
+    
     assert_equal @loaded_fixtures['computers']['workstation'].to_hash, Computer.find(:first).attributes
   end
-
+  
   def test_create
     topic = Topic.new
     topic.title = "New Topic"
@@ -173,7 +196,7 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     reply = Reply.new
     assert_raise(ActiveRecord::RecordInvalid) { reply.save! }
   end
-
+  
   def test_save_null_string_attributes
     topic = Topic.find(1)
     topic.attributes = { "title" => "null", "author_name" => "null" }
@@ -182,7 +205,7 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     assert_equal("null", topic.title)
     assert_equal("null", topic.author_name)
   end
-
+  
   def test_save_nil_string_attributes
     topic = Topic.find(1)
     topic.title = nil
@@ -190,23 +213,23 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     topic.reload
     assert_nil topic.title
   end
-
+  
   def test_save_for_record_with_only_primary_key
     minimalistic = Minimalistic.new
     assert_nothing_raised { minimalistic.save }
   end
-
+  
   def test_save_for_record_with_only_primary_key_that_is_provided
     assert_nothing_raised { Minimalistic.create!(:id => 2) }
   end
-
+  
   def test_hashes_not_mangled
     new_topic = { :title => "New Topic" }
     new_topic_values = { :title => "AnotherTopic" }
-
+    
     topic = Topic.new(new_topic)
     assert_equal new_topic[:title], topic.title
-
+    
     topic.attributes= new_topic_values
     assert_equal new_topic_values[:title], topic.title
   end
@@ -216,20 +239,41 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     assert_equal 2, topics.size
     assert_equal "first", topics.first.title
   end
-
+  
   def test_create_columns_not_equal_attributes
     topic = Topic.new
     topic.title = 'Another New Topic'
     topic.send :write_attribute, 'does_not_exist', 'test'
     assert_nothing_raised { topic.save }
   end
-
+  
   def test_create_through_factory
     topic = Topic.create("title" => "New Topic")
     topicReloaded = Topic.find(topic.id)
     assert_equal(topic, topicReloaded)
+  end  
+  
+  def test_create_through_factory_with_block
+    topic = Topic.create("title" => "New Topic") do |t|
+      t.author_name = "David"
+    end
+    topicReloaded = Topic.find(topic.id)
+    assert_equal("New Topic", topic.title)
+    assert_equal("David", topic.author_name)
   end
-
+  
+  def test_create_many_through_factory_with_block
+    topics = Topic.create([ { "title" => "first" }, { "title" => "second" }]) do |t|
+      t.author_name = "David"
+    end
+    assert_equal 2, topics.size
+    topic1, topic2 = Topic.find(topics[0].id), Topic.find(topics[1].id)
+    assert_equal "first", topic1.title
+    assert_equal "David", topic1.author_name
+    assert_equal "second", topic2.title
+    assert_equal "David", topic2.author_name
+  end
+  
   def test_update
     topic = Topic.new
     topic.title = "Another New Topic"
@@ -237,7 +281,7 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     topic.save
     topicReloaded = Topic.find(topic.id)
     assert_equal("Another New Topic", topicReloaded.title)
-
+    
     topicReloaded.title = "Updated topic"
     topicReloaded.save
     
@@ -245,7 +289,7 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     
     assert_equal("Updated topic", topicReloadedAgain.title)
   end
-
+  
   def test_update_columns_not_equal_attributes
     topic = Topic.new
     topic.title = "Still another topic"
@@ -256,7 +300,7 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     topicReloaded.send :write_attribute, 'does_not_exist', 'test'
     assert_nothing_raised { topicReloaded.save }
   end
-
+  
   def test_update_for_record_with_only_primary_key
     minimalistic = minimalistics(:first)
     assert_nothing_raised { minimalistic.save }
@@ -266,21 +310,21 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     topic = Topic.new
     topic.send(:write_attribute, :title, "Still another topic")
     assert_equal "Still another topic", topic.title
-
+    
     topic.send(:write_attribute, "title", "Still another topic: part 2")
     assert_equal "Still another topic: part 2", topic.title
   end
-
+  
   def test_read_attribute
     topic = Topic.new
     topic.title = "Don't change the topic"
     assert_equal "Don't change the topic", topic.send(:read_attribute, "title")
     assert_equal "Don't change the topic", topic["title"]
-
+    
     assert_equal "Don't change the topic", topic.send(:read_attribute, :title)
     assert_equal "Don't change the topic", topic[:title]
   end
-
+  
   def test_read_attribute_when_false
     topic = topics(:first)
     topic.approved = false
@@ -288,7 +332,7 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     topic.approved = "false"
     assert !topic.approved?, "approved should be false"
   end
-
+  
   def test_read_attribute_when_true
     topic = topics(:first)
     topic.approved = true
@@ -296,7 +340,7 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     topic.approved = "true"
     assert topic.approved?, "approved should be true"
   end
-
+  
   def test_read_write_boolean_attribute
     topic = Topic.new
     # puts ""
@@ -347,7 +391,7 @@ class IBMDBBasicsTest < Test::Unit::TestCase
       assert_equal true, Topic.new(:approved => value).approved?
     end
   end
-
+  
   def test_query_attribute_with_custom_fields
     object = Company.find_by_sql(<<-SQL).first
       SELECT c1.*, c2.ruby_type as string_value, c2.rating as int_value
@@ -355,63 +399,63 @@ class IBMDBBasicsTest < Test::Unit::TestCase
        WHERE c1.firm_id = c2.id
          AND c1.id = 2
     SQL
-
+    
     assert_equal "Firm", object.string_value
     assert object.string_value?
-
+    
     object.string_value = "  "
     assert !object.string_value?
-
+    
     assert_equal 1, object.int_value.to_i
     assert object.int_value?
-
+    
     object.int_value = "0"
     assert !object.int_value?
   end
-
-
+  
+  
   def test_reader_for_invalid_column_names
     Topic.send(:define_read_method, "mumub-jumbo".to_sym, "mumub-jumbo", nil)
     assert !Topic.generated_methods.include?("mumub-jumbo")
   end
-
+  
   def test_non_attribute_access_and_assignment
     topic = Topic.new
     assert !topic.respond_to?("mumbo")
     assert_raises(NoMethodError) { topic.mumbo }
     assert_raises(NoMethodError) { topic.mumbo = 5 }
   end
-
+  
   def test_preserving_date_objects
     # SQL Server doesn't have a separate column type just for dates, so all are returned as time
     return true if current_adapter?(:SQLServerAdapter)
-
+    
     if current_adapter?(:SybaseAdapter, :OracleAdapter)
       # Sybase ctlib does not (yet?) support the date type; use datetime instead.
       # Oracle treats all dates/times as Time.
       assert_kind_of(
-        Time, Topic.find(1).last_read, 
+                     Time, Topic.find(1).last_read,
         "The last_read attribute should be of the Time class"
       )
     else
       assert_kind_of(
-        Date, Topic.find(1).last_read, 
+                     Date, Topic.find(1).last_read,
         "The last_read attribute should be of the Date class"
       )
     end
   end
-
+  
   def test_preserving_time_objects
     assert_kind_of(
-      Time, Topic.find(1).bonus_time,
+                   Time, Topic.find(1).bonus_time,
       "The bonus_time attribute should be of the Time class"
     )
-
+    
     assert_kind_of(
-      Time, Topic.find(1).written_on,
+                   Time, Topic.find(1).written_on,
       "The written_on attribute should be of the Time class"
     )
-
+    
     # For adapters which support microsecond resolution.
     if current_adapter?(:PostgreSQLAdapter)
       assert_equal 11, Topic.find(1).written_on.sec
@@ -426,20 +470,20 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     topic.send(:approved=, true)
     assert topic.instance_variable_get("@custom_approved")
   end
-
+  
   def test_destroy
     topic = Topic.find(1)
     assert_equal topic, topic.destroy, 'topic.destroy did not return self'
     assert topic.frozen?, 'topic not frozen after destroy'
     assert_raise(ActiveRecord::RecordNotFound) { Topic.find(topic.id) }
   end
-
+  
   def test_record_not_found_exception
     assert_raises(ActiveRecord::RecordNotFound) { topicReloaded = Topic.find(99999) }
   end
   
   def test_initialize_with_attributes
-    topic = Topic.new({ 
+    topic = Topic.new({
       "title" => "initialized from attributes", "written_on" => "2003-12-12 23:23"
     })
     
@@ -448,7 +492,7 @@ class IBMDBBasicsTest < Test::Unit::TestCase
   
   def test_initialize_with_invalid_attribute
     begin
-      topic = Topic.new({ "title" => "test", 
+      topic = Topic.new({ "title" => "test",
         "last_read(1i)" => "2005", "last_read(2i)" => "2", "last_read(3i)" => "31"})
     rescue ActiveRecord::MultiparameterAssignmentErrors => ex
       assert_equal(1, ex.errors.size)
@@ -457,8 +501,8 @@ class IBMDBBasicsTest < Test::Unit::TestCase
   end
   
   def test_load
-    topics = Topic.find(:all, :order => 'id')    
-    assert_equal(2, topics.size)
+    topics = Topic.find(:all, :order => 'id')
+    assert_equal(4, topics.size)
     assert_equal(topics(:first).title, topics.first.title)
   end
   
@@ -468,12 +512,12 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     assert_equal(1, topics.size)
     assert_equal(topics(:second).title, topics.first.title)
   end
-
+  
   def test_table_name_guesses
     classes = [Category, Smarts, CreditCard, CreditCard::PinNumber, CreditCard::PinNumber::CvvCode, CreditCard::SubPinNumber, CreditCard::Brand, MasterCreditCard]
-
+    
     assert_equal "topics", Topic.table_name
-
+    
     assert_equal "categories", Category.table_name
     assert_equal "smarts", Smarts.table_name
     assert_equal "credit_cards", CreditCard.table_name
@@ -482,10 +526,10 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     assert_equal "credit_card_pin_numbers", CreditCard::SubPinNumber.table_name
     assert_equal "categories", CreditCard::Brand.table_name
     assert_equal "master_credit_cards", MasterCreditCard.table_name
-
+    
     ActiveRecord::Base.pluralize_table_names = false
     classes.each(&:reset_table_name)
-
+    
     assert_equal "category", Category.table_name
     assert_equal "smarts", Smarts.table_name
     assert_equal "credit_card", CreditCard.table_name
@@ -494,10 +538,10 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     assert_equal "credit_card_pin_number", CreditCard::SubPinNumber.table_name
     assert_equal "category", CreditCard::Brand.table_name
     assert_equal "master_credit_card", MasterCreditCard.table_name
-
+    
     ActiveRecord::Base.pluralize_table_names = true
     classes.each(&:reset_table_name)
-
+    
     ActiveRecord::Base.table_name_prefix = "test_"
     Category.reset_table_name
     assert_equal "test_categories", Category.table_name
@@ -510,7 +554,7 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     ActiveRecord::Base.table_name_suffix = ""
     Category.reset_table_name
     assert_equal "categories", Category.table_name
-
+    
     ActiveRecord::Base.pluralize_table_names = false
     ActiveRecord::Base.table_name_prefix = "test_"
     Category.reset_table_name
@@ -524,29 +568,31 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     ActiveRecord::Base.table_name_suffix = ""
     Category.reset_table_name
     assert_equal "category", Category.table_name
-
+    
     ActiveRecord::Base.pluralize_table_names = true
     classes.each(&:reset_table_name)
   end
   
   def test_destroy_all
-    assert_equal 2, Topic.count
-
-    Topic.destroy_all "author_name = 'Mary'"
-    assert_equal 1, Topic.count
+    original_count = Topic.count
+    topics_by_mary = Topic.count(:conditions => mary = "author_name = 'Mary'")
+    
+    Topic.destroy_all mary
+    assert_equal original_count - topics_by_mary, Topic.count
   end
-
+  
   def test_destroy_many
     assert_equal 3, Client.count
     Client.destroy([2, 3])
     assert_equal 1, Client.count
   end
-
+  
   def test_delete_many
-    Topic.delete([1, 2])
-    assert_equal 0, Topic.count
+    original_count = Topic.count
+    Topic.delete(deleting = [1, 2])
+    assert_equal original_count - deleting.size, Topic.count
   end
-
+  
   def test_boolean_attributes
     assert ! Topic.find(1).approved?
     assert Topic.find(2).approved?
@@ -555,7 +601,7 @@ class IBMDBBasicsTest < Test::Unit::TestCase
   def test_increment_counter
     Topic.increment_counter("replies_count", 1)
     assert_equal 2, Topic.find(1).replies_count
-
+    
     Topic.increment_counter("replies_count", 1)
     assert_equal 3, Topic.find(1).replies_count
   end
@@ -563,58 +609,72 @@ class IBMDBBasicsTest < Test::Unit::TestCase
   def test_decrement_counter
     Topic.decrement_counter("replies_count", 2)
     assert_equal -1, Topic.find(2).replies_count
-
+    
     Topic.decrement_counter("replies_count", 2)
     assert_equal -2, Topic.find(2).replies_count
   end
-
+  
   def test_update_all
-    assert_equal 2, Topic.update_all("content = 'bulk updated!'")
+    assert_equal Topic.count, Topic.update_all("content = 'bulk updated!'")
     assert_equal "bulk updated!", Topic.find(1).content
     assert_equal "bulk updated!", Topic.find(2).content
-
-    assert_equal 2, Topic.update_all(['content = ?', 'bulk updated again!'])
+    
+    assert_equal Topic.count, Topic.update_all(['content = ?', 'bulk updated again!'])
     assert_equal "bulk updated again!", Topic.find(1).content
     assert_equal "bulk updated again!", Topic.find(2).content
-
-    assert_equal 2, Topic.update_all(['content = ?', nil])
+    
+    assert_equal Topic.count, Topic.update_all(['content = ?', nil])
     assert_nil Topic.find(1).content
   end
-
+  
   def test_update_all_with_hash
     assert_not_nil Topic.find(1).last_read
-    assert_equal 2, Topic.update_all(:content => 'bulk updated with hash!', :last_read => nil)
+    assert_equal Topic.count, Topic.update_all(:content => 'bulk updated with hash!', :last_read => nil)
     assert_equal "bulk updated with hash!", Topic.find(1).content
     assert_equal "bulk updated with hash!", Topic.find(2).content
     assert_nil Topic.find(1).last_read
     assert_nil Topic.find(2).last_read
   end
-
+  
+  def test_update_all_with_non_standard_table_name
+    assert_equal 1, WarehouseThing.update_all(['value = ?', 0], ['id = ?', 1])
+    assert_equal 0, WarehouseThing.find(1).value
+  end
+  
   if current_adapter?(:MysqlAdapter)
     def test_update_all_with_order_and_limit
       assert_equal 1, Topic.update_all("content = 'bulk updated!'", nil, :limit => 1, :order => 'id DESC')
     end
   end
-
+  
+  def test_update_all_ignores_order_limit_from_association
+    author = Author.find(1)
+    assert_nothing_raised do
+      assert_equal author.posts_with_comments_and_categories.length, author.posts_with_comments_and_categories.update_all("body = 'bulk update!'")
+    end
+  end
+  
   def test_update_many
     topic_data = { 1 => { "content" => "1 updated" }, 2 => { "content" => "2 updated" } }
     updated = Topic.update(topic_data.keys, topic_data.values)
-
+    
     assert_equal 2, updated.size
     assert_equal "1 updated", Topic.find(1).content
     assert_equal "2 updated", Topic.find(2).content
   end
-
+  
   def test_delete_all
-    assert_equal 2, Topic.delete_all
+    assert Topic.count > 0
+    
+    assert_equal Topic.count, Topic.delete_all
   end
-
+  
   def test_update_by_condition
     Topic.update_all "content = 'bulk updated!'", ["approved = ?", true]
     assert_equal "Have a nice day", Topic.find(1).content
     assert_equal "bulk updated!", Topic.find(2).content
   end
-    
+  
   def test_attribute_present
     t = Topic.new
     t.title = "hello there!"
@@ -634,11 +694,11 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     assert_equal "Firm", ActiveRecord::Base.class_name("firms")
     assert_equal "Category", ActiveRecord::Base.class_name("categories")
     assert_equal "AccountHolder", ActiveRecord::Base.class_name("account_holder")
-
+    
     ActiveRecord::Base.pluralize_table_names = false
     assert_equal "Firms", ActiveRecord::Base.class_name( "firms" )
     ActiveRecord::Base.pluralize_table_names = true
-
+    
     ActiveRecord::Base.table_name_prefix = "test_"
     assert_equal "Firm", ActiveRecord::Base.class_name( "test_firms" )
     ActiveRecord::Base.table_name_suffix = "_tests"
@@ -662,12 +722,12 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     assert_nil topic.last_read
     
     topic.save
-
+    
     topic = Topic.find(topic.id)
     assert topic.approved?
     assert_nil topic.last_read
-
-    # Oracle has some funky default handling, so it requires a bit of 
+    
+    # Oracle has some funky default handling, so it requires a bit of
     # extra testing. See ticket #2788.
     if current_adapter?(:OracleAdapter)
       test = TestOracleDefault.new
@@ -676,7 +736,7 @@ class IBMDBBasicsTest < Test::Unit::TestCase
       assert_equal 3, test.test_int
     end
   end
-
+  
   # Oracle, SQLServer, and Sybase do not have a TIME datatype.
   unless current_adapter?(:SQLServerAdapter, :OracleAdapter, :SybaseAdapter)
     def test_utc_as_time_zone
@@ -687,7 +747,7 @@ class IBMDBBasicsTest < Test::Unit::TestCase
       assert_equal Time.utc(2000, 1, 1, 5, 42, 0), topic.bonus_time
       Topic.default_timezone = :local
     end
-
+    
     def test_utc_as_time_zone_and_new
       Topic.default_timezone = :utc
       attributes = { "bonus_time(1i)"=>"2000",
@@ -701,17 +761,17 @@ class IBMDBBasicsTest < Test::Unit::TestCase
       Topic.default_timezone = :local
     end
   end
-
+  
   def test_default_values_on_empty_strings
     topic = Topic.new
     topic.approved  = nil
     topic.last_read = nil
-
+    
     topic.save
-
+    
     topic = Topic.find(topic.id)
     assert_nil topic.last_read
-
+    
     # Sybase adapter does not allow nulls in boolean columns
     if current_adapter?(:SybaseAdapter)
       assert topic.approved == false
@@ -719,7 +779,7 @@ class IBMDBBasicsTest < Test::Unit::TestCase
       assert_nil topic.approved
     end
   end
-
+  
   def test_equality
     assert_equal Topic.find(1), Topic.find(2).topic
   end
@@ -743,14 +803,14 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     client.destroy
     assert client.frozen?
     assert_kind_of Firm, client.firm
-    assert_raises(TypeError) { client.name = "something else" }
+    assert_raises(ActiveSupport::FrozenObjectError) { client.name = "something else" }
   end
   
   def test_update_attribute
     assert !Topic.find(1).approved?
     Topic.find(1).update_attribute("approved", true)
     assert Topic.find(1).approved?
-
+    
     Topic.find(1).update_attribute(:approved, false)
     assert !Topic.find(1).approved?
   end
@@ -764,7 +824,7 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     topic.reload
     assert topic.approved?
     assert_equal "The First Topic Updated", topic.title
-
+    
     topic.update_attributes(:approved => false, :title => "The First Topic")
     topic.reload
     assert !topic.approved?
@@ -773,17 +833,17 @@ class IBMDBBasicsTest < Test::Unit::TestCase
   
   def test_update_attributes!
     reply = Reply.find(2)
-    assert_equal "The Second Topic's of the day", reply.title
+    assert_equal "The Second Topic of the day", reply.title
     assert_equal "Have a nice day", reply.content
     
-    reply.update_attributes!("title" => "The Second Topic's of the day updated", "content" => "Have a nice evening")
+    reply.update_attributes!("title" => "The Second Topic of the day updated", "content" => "Have a nice evening")
     reply.reload
-    assert_equal "The Second Topic's of the day updated", reply.title
+    assert_equal "The Second Topic of the day updated", reply.title
     assert_equal "Have a nice evening", reply.content
     
-    reply.update_attributes!(:title => "The Second Topic's of the day", :content => "Have a nice day")
+    reply.update_attributes!(:title => "The Second Topic of the day", :content => "Have a nice day")
     reply.reload
-    assert_equal "The Second Topic's of the day", reply.title
+    assert_equal "The Second Topic of the day", reply.title
     assert_equal "Have a nice day", reply.content
     
     assert_raise(ActiveRecord::RecordInvalid) { reply.update_attributes!(:title => nil, :content => "Have a nice evening") }
@@ -803,26 +863,26 @@ class IBMDBBasicsTest < Test::Unit::TestCase
   
   def test_mass_assignment_protection_against_class_attribute_writers
     [:logger, :configurations, :primary_key_prefix_type, :table_name_prefix, :table_name_suffix, :pluralize_table_names, :colorize_logging,
-      :default_timezone, :allow_concurrency, :schema_format, :verification_timeout, :lock_optimistically, :record_timestamps].each do |method|
+    :default_timezone, :allow_concurrency, :schema_format, :verification_timeout, :lock_optimistically, :record_timestamps].each do |method|
       assert  Task.respond_to?(method)
       assert  Task.respond_to?("#{method}=")
       assert  Task.new.respond_to?(method)
       assert !Task.new.respond_to?("#{method}=")
     end
   end
-
+  
   def test_customized_primary_key_remains_protected
     subscriber = Subscriber.new(:nick => 'webster123', :name => 'nice try')
     assert_nil subscriber.id
-
+    
     keyboard = Keyboard.new(:key_number => 9, :name => 'nice try')
     assert_nil keyboard.id
   end
-
+  
   def test_customized_primary_key_remains_protected_when_referred_to_as_id
     subscriber = Subscriber.new(:id => 'webster123', :name => 'nice try')
     assert_nil subscriber.id
-
+    
     keyboard = Keyboard.new(:id => 9, :name => 'nice try')
     assert_nil keyboard.id
   end
@@ -837,34 +897,34 @@ class IBMDBBasicsTest < Test::Unit::TestCase
   def test_mass_assignment_accessible
     reply = Reply.new("title" => "hello", "content" => "world", "approved" => true)
     reply.save
-
+    
     assert reply.approved?
     
     reply.approved = false
     reply.save
-
+    
     assert !reply.approved?
   end
   
   def test_mass_assignment_protection_inheritance
     assert_nil LoosePerson.accessible_attributes
     assert_equal Set.new([ 'credit_rating', 'administrator' ]), LoosePerson.protected_attributes
-
+    
     assert_nil LooseDescendant.accessible_attributes
     assert_equal Set.new([ 'credit_rating', 'administrator', 'phone_number' ]), LooseDescendant.protected_attributes
-
+    
     assert_nil LooseDescendantSecond.accessible_attributes
     assert_equal Set.new([ 'credit_rating', 'administrator', 'phone_number', 'name' ]), LooseDescendantSecond.protected_attributes, 'Running attr_protected twice in one class should merge the protections'
-
+    
     assert_nil TightPerson.protected_attributes
     assert_equal Set.new([ 'name', 'address' ]), TightPerson.accessible_attributes
-
+    
     assert_nil TightDescendant.protected_attributes
     assert_equal Set.new([ 'name', 'address', 'phone_number' ]), TightDescendant.accessible_attributes
   end
   
   def test_readonly_attributes
-    assert_equal Set.new([ 'title' ]), ReadonlyTitlePost.readonly_attributes
+    assert_equal Set.new([ 'title' , 'comments_count' ]), ReadonlyTitlePost.readonly_attributes
     
     post = ReadonlyTitlePost.create(:title => "cannot change this", :body => "changeable")
     post.reload
@@ -875,103 +935,181 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     assert_equal "cannot change this", post.title
     assert_equal "changed", post.body
   end
-
+  
   def test_multiparameter_attributes_on_date
     attributes = { "last_read(1i)" => "2004", "last_read(2i)" => "6", "last_read(3i)" => "24" }
     topic = Topic.find(1)
     topic.attributes = attributes
-    # note that extra #to_date call allows test to pass for Oracle, which 
+    # note that extra #to_date call allows test to pass for Oracle, which
     # treats dates/times the same
     assert_date_from_db Date.new(2004, 6, 24), topic.last_read.to_date
   end
-
+  
   def test_multiparameter_attributes_on_date_with_empty_date
     attributes = { "last_read(1i)" => "2004", "last_read(2i)" => "6", "last_read(3i)" => "" }
     topic = Topic.find(1)
     topic.attributes = attributes
-    # note that extra #to_date call allows test to pass for Oracle, which 
+    # note that extra #to_date call allows test to pass for Oracle, which
     # treats dates/times the same
     assert_date_from_db Date.new(2004, 6, 1), topic.last_read.to_date
   end
-
+  
   def test_multiparameter_attributes_on_date_with_all_empty
     attributes = { "last_read(1i)" => "", "last_read(2i)" => "", "last_read(3i)" => "" }
     topic = Topic.find(1)
     topic.attributes = attributes
     assert_nil topic.last_read
   end
-
+  
   def test_multiparameter_attributes_on_time
-    attributes = { 
-      "written_on(1i)" => "2004", "written_on(2i)" => "6", "written_on(3i)" => "24", 
+    attributes = {
+      "written_on(1i)" => "2004", "written_on(2i)" => "6", "written_on(3i)" => "24",
       "written_on(4i)" => "16", "written_on(5i)" => "24", "written_on(6i)" => "00"
     }
     topic = Topic.find(1)
     topic.attributes = attributes
     assert_equal Time.local(2004, 6, 24, 16, 24, 0), topic.written_on
   end
-
-  def test_multiparameter_attributes_on_time_with_empty_seconds
-    attributes = { 
-      "written_on(1i)" => "2004", "written_on(2i)" => "6", "written_on(3i)" => "24", 
-      "written_on(4i)" => "16", "written_on(5i)" => "24", "written_on(6i)" => ""
+  
+  def test_multiparameter_attributes_on_time_with_old_date
+    attributes = {
+      "written_on(1i)" => "1850", "written_on(2i)" => "6", "written_on(3i)" => "24",
+      "written_on(4i)" => "16", "written_on(5i)" => "24", "written_on(6i)" => "00"
     }
     topic = Topic.find(1)
     topic.attributes = attributes
-    assert_equal Time.local(2004, 6, 24, 16, 24, 0), topic.written_on
-  end
-
-  def test_multiparameter_mass_assignment_protector
-    task = Task.new
-    time = Time.mktime(2000, 1, 1, 1)
-    task.starting = time 
-    attributes = { "starting(1i)" => "2004", "starting(2i)" => "6", "starting(3i)" => "24" }
-    task.attributes = attributes
-    assert_equal time, task.starting
+    # testing against to_s(:db) representation because either a Time or a DateTime might be returned, depending on platform
+    assert_equal "1850-06-24 16:24:00", topic.written_on.to_s(:db)
   end
   
-  def test_multiparameter_assignment_of_aggregation
-    customer = Customer.new
-    address = Address.new("The Street", "The City", "The Country")
-    attributes = { "address(1)" => address.street, "address(2)" => address.city, "address(3)" => address.country }
-    customer.attributes = attributes
-    assert_equal address, customer.address
+  def test_multiparameter_attributes_on_time_with_utc
+    ActiveRecord::Base.default_timezone = :utc
+    attributes = {
+      "written_on(1i)" => "2004", "written_on(2i)" => "6", "written_on(3i)" => "24",
+      "written_on(4i)" => "16", "written_on(5i)" => "24", "written_on(6i)" => "00"
+    }
+    topic = Topic.find(1)
+    topic.attributes = attributes
+    assert_equal Time.utc(2004, 6, 24, 16, 24, 0), topic.written_on
+  ensure
+    ActiveRecord::Base.default_timezone = :local
   end
-
-  def test_attributes_on_dummy_time
-    # Oracle, SQL Server, and Sybase do not have a TIME datatype.
-    return true if current_adapter?(:SQLServerAdapter, :OracleAdapter, :SybaseAdapter)
-
+  
+  def test_multiparameter_attributes_on_time_with_time_zone_aware_attributes
+    ActiveRecord::Base.time_zone_aware_attributes = true
+    ActiveRecord::Base.default_timezone = :utc
+    Time.zone = TimeZone[-28800]
     attributes = {
-      "bonus_time" => "5:42:00AM"
+      "written_on(1i)" => "2004", "written_on(2i)" => "6", "written_on(3i)" => "24",
+      "written_on(4i)" => "16", "written_on(5i)" => "24", "written_on(6i)" => "00"
     }
     topic = Topic.find(1)
     topic.attributes = attributes
-    assert_equal Time.local(2000, 1, 1, 5, 42, 0), topic.bonus_time
+    assert_equal Time.utc(2004, 6, 24, 23, 24, 0), topic.written_on
+    assert_equal Time.utc(2004, 6, 24, 16, 24, 0), topic.written_on.time
+    assert_equal Time.zone, topic.written_on.time_zone
+  ensure
+    ActiveRecord::Base.time_zone_aware_attributes = false
+    ActiveRecord::Base.default_timezone = :local
+    Time.zone = nil
   end
-
+  
+  def test_multiparameter_attributes_on_time_with_time_zone_aware_attributes_false
+    ActiveRecord::Base.time_zone_aware_attributes = false
+    Time.zone = TimeZone[-28800]
+    attributes = {
+      "written_on(1i)" => "2004", "written_on(2i)" => "6", "written_on(3i)" => "24",
+      "written_on(4i)" => "16", "written_on(5i)" => "24", "written_on(6i)" => "00"
+    }
+    topic = Topic.find(1)
+    topic.attributes = attributes
+    assert_equal Time.local(2004, 6, 24, 16, 24, 0), topic.written_on
+    assert_equal false, topic.written_on.respond_to?(:time_zone)
+  ensure
+    Time.zone = nil
+  end
+  
+  def test_multiparameter_attributes_on_time_with_skip_time_zone_conversion_for_attributes
+    ActiveRecord::Base.time_zone_aware_attributes = true
+    ActiveRecord::Base.default_timezone = :utc
+    Time.zone = TimeZone[-28800]
+    Topic.skip_time_zone_conversion_for_attributes = [:written_on]
+    attributes = {
+      "written_on(1i)" => "2004", "written_on(2i)" => "6", "written_on(3i)" => "24",
+      "written_on(4i)" => "16", "written_on(5i)" => "24", "written_on(6i)" => "00"
+    }
+    topic = Topic.find(1)
+    topic.attributes = attributes
+    assert_equal Time.utc(2004, 6, 24, 16, 24, 0), topic.written_on
+    assert_equal false, topic.written_on.respond_to?(:time_zone)
+  ensure
+    ActiveRecord::Base.time_zone_aware_attributes = false
+    ActiveRecord::Base.default_timezone = :local
+    Time.zone = nil
+    Topic.skip_time_zone_conversion_for_attributes = []
+  end
+  
+  def test_multiparameter_attributes_on_time_with_empty_seconds
+    attributes = {
+      "written_on(1i)" => "2004", "written_on(2i)" => "6", "written_on(3i)" => "24",
+      "written_on(4i)" => "16", "written_on(5i)" => "24", "written_on(6i)" => ""
+    }
+    topic = Topic.find(1)
+    topic.attributes = attributes
+    assert_equal Time.local(2004, 6, 24, 16, 24, 0), topic.written_on
+  end
+  
+  def test_multiparameter_mass_assignment_protector
+    task = Task.new
+    time = Time.mktime(2000, 1, 1, 1)
+    task.starting = time
+    attributes = { "starting(1i)" => "2004", "starting(2i)" => "6", "starting(3i)" => "24" }
+    task.attributes = attributes
+    assert_equal time, task.starting
+  end
+  
+  def test_multiparameter_assignment_of_aggregation
+    customer = Customer.new
+    address = Address.new("The Street", "The City", "The Country")
+    attributes = { "address(1)" => address.street, "address(2)" => address.city, "address(3)" => address.country }
+    customer.attributes = attributes
+    assert_equal address, customer.address
+  end
+  
+  def test_attributes_on_dummy_time
+    # Oracle, SQL Server, and Sybase do not have a TIME datatype.
+    return true if current_adapter?(:SQLServerAdapter, :OracleAdapter, :SybaseAdapter)
+    
+    attributes = {
+      "bonus_time" => "5:42:00AM"
+    }
+    topic = Topic.find(1)
+    topic.attributes = attributes
+    assert_equal Time.local(2000, 1, 1, 5, 42, 0), topic.bonus_time
+  end
+  
   def test_boolean
     b_false = Booleantest.create({ "value" => false })
     false_id = b_false.id
     b_true = Booleantest.create({ "value" => true })
     true_id = b_true.id
-
+    
     b_false = Booleantest.find(false_id)
     assert !b_false.value?
     b_true = Booleantest.find(true_id)
     assert b_true.value?
   end
-
+  
   def test_boolean_cast_from_string
     b_false = Booleantest.create({ "value" => "0" })
     false_id = b_false.id
     b_true = Booleantest.create({ "value" => "1" })
     true_id = b_true.id
-
+    
     b_false = Booleantest.find(false_id)
     assert !b_false.value?
     b_true = Booleantest.find(true_id)
-    assert b_true.value?    
+    assert b_true.value?
   end
   
   def test_clone
@@ -980,54 +1118,54 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     assert_nothing_raised { cloned_topic = topic.clone }
     assert_equal topic.title, cloned_topic.title
     assert cloned_topic.new_record?
-
+    
     # test if the attributes have been cloned
-    topic.title = "a" 
-    cloned_topic.title = "b" 
+    topic.title = "a"
+    cloned_topic.title = "b"
     assert_equal "a", topic.title
     assert_equal "b", cloned_topic.title
-
+    
     # test if the attribute values have been cloned
     topic.title = {"a" => "b"}
     cloned_topic = topic.clone
-    cloned_topic.title["a"] = "c" 
+    cloned_topic.title["a"] = "c"
     assert_equal "b", topic.title["a"]
-
+    
     #test if attributes set as part of after_initialize are cloned correctly
     assert_equal topic.author_email_address, cloned_topic.author_email_address
-
+    
     # test if saved clone object differs from original
     cloned_topic.save
     assert !cloned_topic.new_record?
     assert cloned_topic.id != topic.id
   end
-
+  
   def test_clone_with_aggregate_of_same_name_as_attribute
     dev = DeveloperWithAggregate.find(1)
     assert_kind_of DeveloperSalary, dev.salary
-
+    
     clone = nil
     assert_nothing_raised { clone = dev.clone }
     assert_kind_of DeveloperSalary, clone.salary
     assert_equal dev.salary.amount, clone.salary.amount
     assert clone.new_record?
-
+    
     # test if the attributes have been cloned
     original_amount = clone.salary.amount
     dev.salary.amount = 1
     assert_equal original_amount, clone.salary.amount
-
+    
     assert clone.save
     assert !clone.new_record?
     assert clone.id != dev.id
   end
-
+  
   def test_clone_preserves_subtype
     clone = nil
     assert_nothing_raised { clone = Company.find(3).clone }
     assert_kind_of Client, clone
   end
-
+  
   def test_bignum
     company = Company.find(1)
     company.rating = 2147483647
@@ -1035,69 +1173,69 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     company = Company.find(1)
     assert_equal 2147483647, company.rating
   end
-
+  
   # TODO: extend defaults tests to other databases!
   if current_adapter?(:PostgreSQLAdapter)
     def test_default
       default = Default.new
-  
+      
       # fixed dates / times
       assert_equal Date.new(2004, 1, 1), default.fixed_date
       assert_equal Time.local(2004, 1,1,0,0,0,0), default.fixed_time
-  
+      
       # char types
       assert_equal 'Y', default.char1
       assert_equal 'a varchar field', default.char2
       assert_equal 'a text field', default.char3
     end
-
+    
     class Geometric < ActiveRecord::Base; end
     def test_geometric_content
-
+      
       # accepted format notes:
       # ()'s aren't required
       # values can be a mix of float or integer
-
+      
       g = Geometric.new(
-        :a_point        => '(5.0, 6.1)',
-        #:a_line         => '((2.0, 3), (5.5, 7.0))' # line type is currently unsupported in postgresql
-        :a_line_segment => '(2.0, 3), (5.5, 7.0)',
-        :a_box          => '2.0, 3, 5.5, 7.0',
-        :a_path         => '[(2.0, 3), (5.5, 7.0), (8.5, 11.0)]',  # [ ] is an open path
-        :a_polygon      => '((2.0, 3), (5.5, 7.0), (8.5, 11.0))',
-        :a_circle       => '<(5.3, 10.4), 2>'
+                        :a_point        => '(5.0, 6.1)',
+      #:a_line         => '((2.0, 3), (5.5, 7.0))' # line type is currently unsupported in postgresql
+      :a_line_segment => '(2.0, 3), (5.5, 7.0)',
+      :a_box          => '2.0, 3, 5.5, 7.0',
+      :a_path         => '[(2.0, 3), (5.5, 7.0), (8.5, 11.0)]',  # [ ] is an open path
+      :a_polygon      => '((2.0, 3), (5.5, 7.0), (8.5, 11.0))',
+      :a_circle       => '<(5.3, 10.4), 2>'
       )
-        
+      
       assert g.save
-
+      
       # Reload and check that we have all the geometric attributes.
       h = Geometric.find(g.id)
-
+      
       assert_equal '(5,6.1)', h.a_point
       assert_equal '[(2,3),(5.5,7)]', h.a_line_segment
       assert_equal '(5.5,7),(2,3)', h.a_box   # reordered to store upper right corner then bottom left corner
       assert_equal '[(2,3),(5.5,7),(8.5,11)]', h.a_path
       assert_equal '((2,3),(5.5,7),(8.5,11))', h.a_polygon
       assert_equal '<(5.3,10.4),2>', h.a_circle
-
+      
       # use a geometric function to test for an open path
       objs = Geometric.find_by_sql ["select isopen(a_path) from geometrics where id = ?", g.id]
       assert_equal objs[0].isopen, 't'
-
+      
       # test alternate formats when defining the geometric types
       
       g = Geometric.new(
-        :a_point        => '5.0, 6.1',
-        #:a_line         => '((2.0, 3), (5.5, 7.0))' # line type is currently unsupported in postgresql
-        :a_line_segment => '((2.0, 3), (5.5, 7.0))',
-        :a_box          => '(2.0, 3), (5.5, 7.0)',
-        :a_path         => '((2.0, 3), (5.5, 7.0), (8.5, 11.0))',  # ( ) is a closed path
-        :a_polygon      => '2.0, 3, 5.5, 7.0, 8.5, 11.0',
-        :a_circle       => '((5.3, 10.4), 2)'
+                        :a_point        => '5.0, 6.1',
+      #:a_line         => '((2.0, 3), (5.5, 7.0))' # line type is currently unsupported in postgresql
+      :a_line_segment => '((2.0, 3), (5.5, 7.0))',
+      :a_box          => '(2.0, 3), (5.5, 7.0)',
+      :a_path         => '((2.0, 3), (5.5, 7.0), (8.5, 11.0))',  # ( ) is a closed path
+      :a_polygon      => '2.0, 3, 5.5, 7.0, 8.5, 11.0',
+      :a_circle       => '((5.3, 10.4), 2)'
       )
-
+      
       assert g.save
-
+      
       # Reload and check that we have all the geometric attributes.
       h = Geometric.find(g.id)
       
@@ -1107,63 +1245,62 @@ class IBMDBBasicsTest < Test::Unit::TestCase
       assert_equal '((2,3),(5.5,7),(8.5,11))', h.a_path
       assert_equal '((2,3),(5.5,7),(8.5,11))', h.a_polygon
       assert_equal '<(5.3,10.4),2>', h.a_circle
-
+      
       # use a geometric function to test for an closed path
       objs = Geometric.find_by_sql ["select isclosed(a_path) from geometrics where id = ?", g.id]
       assert_equal objs[0].isclosed, 't'
     end
   end
-
+  
   class NumericData < ActiveRecord::Base
     self.table_name = 'numeric_data'
   end
-
+  
   def test_numeric_fields
     m = NumericData.new(
-      :bank_balance => 1586.43,
-      :big_bank_balance => BigDecimal("1000234000567.95"),
-      :world_population => 6000000000,
-      :my_house_population => 3
+                        :bank_balance => 1586.43,
+                        :big_bank_balance => BigDecimal("1000234000567.95"),
+    :world_population => 6000000000,
+    :my_house_population => 3
     )
     assert m.save
-
+    
     m1 = NumericData.find(m.id)
     assert_not_nil m1
-
+    
     # As with migration_test.rb, we should make world_population >= 2**62
     # to cover 64-bit platforms and test it is a Bignum, but the main thing
     # is that it's an Integer.
-  unless current_adapter?(:IBM_DBAdapter)
-    assert_kind_of Integer, m1.world_population
-  else
-    assert_kind_of BigDecimal, m1.world_population
-  end 
+    unless current_adapter?(:IBM_DBAdapter)
+      assert_kind_of Integer, m1.world_population
+    else
+      assert_kind_of BigDecimal, m1.world_population
+    end 
     assert_equal 6000000000, m1.world_population
-
-  unless current_adapter?(:IBM_DBAdapter)
-    assert_kind_of Fixnum, m1.my_house_population
-  else
-    assert_kind_of BigDecimal, m1.my_house_population
-  end 
+    unless current_adapter?(:IBM_DBAdapter)
+      assert_kind_of Fixnum, m1.my_house_population
+    else
+      assert_kind_of BigDecimal, m1.my_house_population
+    end 
     assert_equal 3, m1.my_house_population
-
+    
     assert_kind_of BigDecimal, m1.bank_balance
     assert_equal BigDecimal("1586.43"), m1.bank_balance
-
+    
     assert_kind_of BigDecimal, m1.big_bank_balance
     assert_equal BigDecimal("1000234000567.95"), m1.big_bank_balance
   end
-
+  
   def test_auto_id
     auto = AutoId.new
     auto.save
     assert (auto.id > 0)
   end
-
+  
   def quote_column_name(name)
     "<#{name}>"
   end
-
+  
   def test_quote_keys
     ar = AutoId.new
     source = {"foo" => "bar", "baz" => "quux"}
@@ -1172,13 +1309,13 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     assert_equal("<foo>", inverted["bar"])
     assert_equal("<baz>", inverted["quux"])
   end
-
+  
   def test_sql_injection_via_find
     assert_raises(ActiveRecord::RecordNotFound, ActiveRecord::StatementInvalid) do
       Topic.find("123456 OR id > 0")
     end
   end
-
+  
   def test_column_name_properly_quoted
     col_record = ColumnName.new
     col_record.references = 40
@@ -1188,30 +1325,30 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     assert_not_nil c2 = ColumnName.find(col_record.id)
     assert_equal(41, c2.references)
   end
-
+  
   def test_quoting_arrays
     replies = Reply.find(:all, :conditions => [ "id IN (?)", topics(:first).replies.collect(&:id) ])
     assert_equal topics(:first).replies.size, replies.size
-
+    
     replies = Reply.find(:all, :conditions => [ "id IN (?)", [] ])
     assert_equal 0, replies.size
   end
-
+  
   MyObject = Struct.new :attribute1, :attribute2
   
   def test_serialized_attribute
     myobj = MyObject.new('value1', 'value2')
-    topic = Topic.create("content" => myobj)  
+    topic = Topic.create("content" => myobj)
     Topic.serialize("content", MyObject)
     assert_equal(myobj, topic.content)
   end
-
+  
   def test_nil_serialized_attribute_with_class_constraint
     myobj = MyObject.new('value1', 'value2')
     topic = Topic.new
     assert_nil topic.content
   end
-
+  
   def test_should_raise_exception_on_serialized_attribute_with_type_mismatch
     myobj = MyObject.new('value1', 'value2')
     topic = Topic.new(:content => myobj)
@@ -1221,7 +1358,7 @@ class IBMDBBasicsTest < Test::Unit::TestCase
   ensure
     Topic.serialize(:content)
   end
-
+  
   def test_serialized_attribute_with_class_constraint
     settings = { "color" => "blue" }
     Topic.serialize(:content, Hash)
@@ -1231,48 +1368,50 @@ class IBMDBBasicsTest < Test::Unit::TestCase
   ensure
     Topic.serialize(:content)
   end
-
+  
   def test_quote
     author_name = "\\ \001 ' \n \\n \""
     topic = Topic.create('author_name' => author_name)
     assert_equal author_name, Topic.find(topic.id).author_name
   end
   
-  def test_quote_chars
-    str = 'The Narrator'
-    topic = Topic.create(:author_name => str)
-    assert_equal str, topic.author_name
-    
-    assert_kind_of ActiveSupport::Multibyte::Chars, str.chars
-    topic = Topic.find_by_author_name(str.chars)
-    
-    assert_kind_of Topic, topic
-    assert_equal str, topic.author_name, "The right topic should have been found by name even with name passed as Chars"
+  if RUBY_VERSION < '1.9'
+    def test_quote_chars
+      str = 'The Narrator'
+      topic = Topic.create(:author_name => str)
+      assert_equal str, topic.author_name
+      
+      assert_kind_of ActiveSupport::Multibyte::Chars, str.chars
+      topic = Topic.find_by_author_name(str.chars)
+      
+      assert_kind_of Topic, topic
+      assert_equal str, topic.author_name, "The right topic should have been found by name even with name passed as Chars"
+    end
   end
   
   def test_class_level_destroy
     should_be_destroyed_reply = Reply.create("title" => "hello", "content" => "world")
     Topic.find(1).replies << should_be_destroyed_reply
-
+    
     Topic.destroy(1)
     assert_raise(ActiveRecord::RecordNotFound) { Topic.find(1) }
     assert_raise(ActiveRecord::RecordNotFound) { Reply.find(should_be_destroyed_reply.id) }
   end
-
+  
   def test_class_level_delete
     should_be_destroyed_reply = Reply.create("title" => "hello", "content" => "world")
     Topic.find(1).replies << should_be_destroyed_reply
-
+    
     Topic.delete(1)
     assert_raise(ActiveRecord::RecordNotFound) { Topic.find(1) }
     assert_nothing_raised { Reply.find(should_be_destroyed_reply.id) }
   end
-
+  
   def test_increment_attribute
     assert_equal 50, accounts(:signals37).credit_limit
     accounts(:signals37).increment! :credit_limit
-    assert_equal 51, accounts(:signals37, :reload).credit_limit    
-
+    assert_equal 51, accounts(:signals37, :reload).credit_limit
+    
     accounts(:signals37).increment(:credit_limit).increment!(:credit_limit)
     assert_equal 53, accounts(:signals37, :reload).credit_limit
   end
@@ -1283,16 +1422,34 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     assert_equal 1, topics(:first).parent_id
   end
   
+  def test_increment_attribute_by
+    assert_equal 50, accounts(:signals37).credit_limit
+    accounts(:signals37).increment! :credit_limit, 5
+    assert_equal 55, accounts(:signals37, :reload).credit_limit
+    
+    accounts(:signals37).increment(:credit_limit, 1).increment!(:credit_limit, 3)
+    assert_equal 59, accounts(:signals37, :reload).credit_limit
+  end
+  
   def test_decrement_attribute
     assert_equal 50, accounts(:signals37).credit_limit
-
+    
     accounts(:signals37).decrement!(:credit_limit)
     assert_equal 49, accounts(:signals37, :reload).credit_limit
-  
+    
     accounts(:signals37).decrement(:credit_limit).decrement!(:credit_limit)
     assert_equal 47, accounts(:signals37, :reload).credit_limit
   end
   
+  def test_decrement_attribute_by
+    assert_equal 50, accounts(:signals37).credit_limit
+    accounts(:signals37).decrement! :credit_limit, 5
+    assert_equal 45, accounts(:signals37, :reload).credit_limit
+    
+    accounts(:signals37).decrement(:credit_limit, 1).decrement!(:credit_limit, 3)
+    assert_equal 41, accounts(:signals37, :reload).credit_limit
+  end
+  
   def test_toggle_attribute
     assert !topics(:first).approved?
     topics(:first).toggle!(:approved)
@@ -1303,7 +1460,7 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     topic.reload
     assert topic.approved?
   end
-
+  
   def test_reload
     t1 = Topic.find(1)
     t2 = Topic.find(1)
@@ -1312,19 +1469,19 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     t2.reload
     assert_equal t1.title, t2.title
   end
-
+  
   def test_define_attr_method_with_value
     k = Class.new( ActiveRecord::Base )
     k.send(:define_attr_method, :table_name, "foo")
     assert_equal "foo", k.table_name
   end
-
+  
   def test_define_attr_method_with_block
     k = Class.new( ActiveRecord::Base )
     k.send(:define_attr_method, :primary_key) { "sys_" + original_primary_key }
     assert_equal "sys_id", k.primary_key
   end
-
+  
   def test_set_table_name_with_value
     k = Class.new( ActiveRecord::Base )
     k.table_name = "foo"
@@ -1332,13 +1489,13 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     k.set_table_name "bar"
     assert_equal "bar", k.table_name
   end
-
+  
   def test_set_table_name_with_block
     k = Class.new( ActiveRecord::Base )
     k.set_table_name { "ks" }
     assert_equal "ks", k.table_name
   end
-
+  
   def test_set_primary_key_with_value
     k = Class.new( ActiveRecord::Base )
     k.primary_key = "foo"
@@ -1346,13 +1503,13 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     k.set_primary_key "bar"
     assert_equal "bar", k.primary_key
   end
-
+  
   def test_set_primary_key_with_block
     k = Class.new( ActiveRecord::Base )
     k.set_primary_key { "sys_" + original_primary_key }
     assert_equal "sys_id", k.primary_key
   end
-
+  
   def test_set_inheritance_column_with_value
     k = Class.new( ActiveRecord::Base )
     k.inheritance_column = "foo"
@@ -1360,13 +1517,13 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     k.set_inheritance_column "bar"
     assert_equal "bar", k.inheritance_column
   end
-
+  
   def test_set_inheritance_column_with_block
     k = Class.new( ActiveRecord::Base )
     k.set_inheritance_column { original_inheritance_column + "_id" }
     assert_equal "type_id", k.inheritance_column
   end
-
+  
   def test_count_with_join
     res = Post.count_by_sql "SELECT COUNT(*) FROM posts LEFT JOIN comments ON posts.id=comments.post_id WHERE posts.#{QUOTED_TYPE} = 'Post'"
     
@@ -1376,7 +1533,7 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     res3 = nil
     assert_nothing_raised do
       res3 = Post.count(:conditions => "posts.#{QUOTED_TYPE} = 'Post'",
-                        :joins => "LEFT JOIN comments ON posts.id=comments.post_id")
+      :joins => "LEFT JOIN comments ON posts.id=comments.post_id")
     end
     assert_equal res, res3
     
@@ -1384,53 +1541,53 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     res5 = nil
     assert_nothing_raised do
       res5 = Post.count(:conditions => "p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id",
-                        :joins => "p, comments co",
-                        :select => "p.id")
+      :joins => "p, comments co",
+      :select => "p.id")
     end
-
-    assert_equal res4, res5 
-
+    
+    assert_equal res4, res5
+    
     unless current_adapter?(:SQLite2Adapter, :DeprecatedSQLiteAdapter)
       res6 = Post.count_by_sql "SELECT COUNT(DISTINCT p.id) FROM posts p, comments co WHERE p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id"
       res7 = nil
       assert_nothing_raised do
         res7 = Post.count(:conditions => "p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id",
-                          :joins => "p, comments co",
-                          :select => "p.id",
-                          :distinct => true)
+        :joins => "p, comments co",
+        :select => "p.id",
+        :distinct => true)
       end
       assert_equal res6, res7
     end
   end
   
-  def test_clear_association_cache_stored     
+  def test_clear_association_cache_stored
     firm = Firm.find(1)
     assert_kind_of Firm, firm
-
+    
     firm.clear_association_cache
     assert_equal Firm.find(1).clients.collect{ |x| x.name }.sort, firm.clients.collect{ |x| x.name }.sort
   end
   
   def test_clear_association_cache_new_record
-     firm            = Firm.new
-     client_stored   = Client.find(3)
-     client_new      = Client.new
-     client_new.name = "The Joneses"
-     clients         = [ client_stored, client_new ]
-
-     firm.clients    << clients
-     assert_equal clients.map(&:name).to_set, firm.clients.map(&:name).to_set
-
-     firm.clear_association_cache
-     assert_equal clients.map(&:name).to_set, firm.clients.map(&:name).to_set
+    firm            = Firm.new
+    client_stored   = Client.find(3)
+    client_new      = Client.new
+    client_new.name = "The Joneses"
+    clients         = [ client_stored, client_new ]
+    
+    firm.clients    << clients
+    assert_equal clients.map(&:name).to_set, firm.clients.map(&:name).to_set
+    
+    firm.clear_association_cache
+    assert_equal clients.map(&:name).to_set, firm.clients.map(&:name).to_set
   end
-
+  
   def test_interpolate_sql
     assert_nothing_raised { Category.new.send(:interpolate_sql, 'foo@bar') }
     assert_nothing_raised { Category.new.send(:interpolate_sql, 'foo bar) baz') }
     assert_nothing_raised { Category.new.send(:interpolate_sql, 'foo bar} baz') }
   end
-
+  
   def test_scoped_find_conditions
     scoped_developers = Developer.with_scope(:find => { :conditions => 'salary > 90000' }) do
       Developer.find(:all, :conditions => 'id < 5')
@@ -1442,7 +1599,7 @@ class IBMDBBasicsTest < Test::Unit::TestCase
   def test_scoped_find_limit_offset
     scoped_developers = Developer.with_scope(:find => { :limit => 3, :offset => 2 }) do
       Developer.find(:all, :order => 'id')
-    end    
+    end
     assert !scoped_developers.include?(developers(:david))
     assert !scoped_developers.include?(developers(:jamis))
     assert_equal 3, scoped_developers.size
@@ -1451,18 +1608,18 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     developers = Developer.find(:all, :order => 'id')
     assert_equal Developer.count, developers.size
   end
-
-  def test_scoped_find_order   
-    # Test order in scope   
+  
+  def test_scoped_find_order
+    # Test order in scope
     scoped_developers = Developer.with_scope(:find => { :limit => 1, :order => 'salary DESC' }) do
       Developer.find(:all)
-    end   
+    end
     assert_equal 'Jamis', scoped_developers.first.name
     assert scoped_developers.include?(developers(:jamis))
     # Test scope without order and order in find
     scoped_developers = Developer.with_scope(:find => { :limit => 1 }) do
       Developer.find(:all, :order => 'salary DESC')
-    end   
+    end
     # Test scope order + find order, find has priority
     scoped_developers = Developer.with_scope(:find => { :limit => 3, :order => 'id DESC' }) do
       Developer.find(:all, :order => 'salary ASC')
@@ -1474,7 +1631,7 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     developers = Developer.find(:all, :order => 'id', :limit => 1)
     assert scoped_developers.include?(developers(:david))
   end
-
+  
   def test_scoped_find_limit_offset_including_has_many_association
     topics = Topic.with_scope(:find => {:limit => 1, :offset => 1, :include => :replies}) do
       Topic.find(:all, :order => "topics.id")
@@ -1482,7 +1639,7 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     assert_equal 1, topics.size
     assert_equal 2, topics.first.id
   end
-
+  
   def test_scoped_find_order_including_has_many_association
     developers = Developer.with_scope(:find => { :order => 'developers.salary DESC', :include => :projects }) do
       Developer.find(:all)
@@ -1492,105 +1649,136 @@ class IBMDBBasicsTest < Test::Unit::TestCase
       assert developers[i-1].salary >= developers[i].salary
     end
   end
-
+  
+  def test_find_last
+    last  = Developer.find :last
+    assert_equal last, Developer.find(:first, :order => 'id desc')
+  end
+  
+  def test_last
+    assert_equal Developer.find(:first, :order => 'id desc'), Developer.last
+  end
+  
+  def test_all_with_conditions
+    assert_equal Developer.find(:all, :order => 'id desc'), Developer.all(:order => 'id desc')
+  end
+  
+  def test_find_ordered_last
+    last  = Developer.find :last, :order => 'developers.salary ASC'
+    assert_equal last, Developer.find(:all, :order => 'developers.salary ASC').last
+  end
+  
+  def test_find_reverse_ordered_last
+    last  = Developer.find :last, :order => 'developers.salary DESC'
+    assert_equal last, Developer.find(:all, :order => 'developers.salary DESC').last
+  end
+  
+  def test_find_multiple_ordered_last
+    last  = Developer.find :last, :order => 'developers.name, developers.salary DESC'
+    assert_equal last, Developer.find(:all, :order => 'developers.name, developers.salary DESC').last
+  end
+  
+  def test_find_scoped_ordered_last
+    last_developer = Developer.with_scope(:find => { :order => 'developers.salary ASC' }) do
+      Developer.find(:last)
+    end
+    assert_equal last_developer, Developer.find(:all, :order => 'developers.salary ASC').last
+  end
+  
   def test_abstract_class
     assert !ActiveRecord::Base.abstract_class?
     assert LoosePerson.abstract_class?
     assert !LooseDescendant.abstract_class?
   end
-
+  
   def test_base_class
     assert_equal LoosePerson,     LoosePerson.base_class
     assert_equal LooseDescendant, LooseDescendant.base_class
     assert_equal TightPerson,     TightPerson.base_class
     assert_equal TightPerson,     TightDescendant.base_class
-
+    
     assert_equal Post, Post.base_class
     assert_equal Post, SpecialPost.base_class
     assert_equal Post, StiPost.base_class
     assert_equal SubStiPost, SubStiPost.base_class
   end
-
+  
   def test_descends_from_active_record
     # Tries to call Object.abstract_class?
     assert_raise(NoMethodError) do
       ActiveRecord::Base.descends_from_active_record?
     end
-
+    
     # Abstract subclass of AR::Base.
     assert LoosePerson.descends_from_active_record?
-
+    
     # Concrete subclass of an abstract class.
     assert LooseDescendant.descends_from_active_record?
-
+    
     # Concrete subclass of AR::Base.
     assert TightPerson.descends_from_active_record?
-
+    
     # Concrete subclass of a concrete class but has no type column.
     assert TightDescendant.descends_from_active_record?
-
+    
     # Concrete subclass of AR::Base.
     assert Post.descends_from_active_record?
-
+    
     # Abstract subclass of a concrete class which has a type column.
     # This is pathological, as you'll never have Sub < Abstract < Concrete.
     assert !StiPost.descends_from_active_record?
-
+    
     # Concrete subclasses an abstract class which has a type column.
     assert !SubStiPost.descends_from_active_record?
   end
-
+  
   def test_find_on_abstract_base_class_doesnt_use_type_condition
     old_class = LooseDescendant
     Object.send :remove_const, :LooseDescendant
-
-    descendant = old_class.create!
+    
+    descendant = old_class.create! :first_name => 'bob'
     assert_not_nil LoosePerson.find(descendant.id), "Should have found instance of LooseDescendant when finding abstract LoosePerson: #{descendant.inspect}"
   ensure
     unless Object.const_defined?(:LooseDescendant)
       Object.const_set :LooseDescendant, old_class
     end
   end
-
+  
   def test_assert_queries
     query = lambda { ActiveRecord::Base.connection.execute 'select count(*) from developers' }
     assert_queries(2) { 2.times { query.call } }
     assert_queries 1, &query
     assert_no_queries { assert true }
   end
-
+  
   def test_to_xml
     xml = REXML::Document.new(topics(:first).to_xml(:indent => 0))
     bonus_time_in_current_timezone = topics(:first).bonus_time.xmlschema
     written_on_in_current_timezone = topics(:first).written_on.xmlschema
     last_read_in_current_timezone = topics(:first).last_read.xmlschema
-
+    
     assert_equal "topic", xml.root.name
     assert_equal "The First Topic" , xml.elements["//title"].text
     assert_equal "David" , xml.elements["//author-name"].text
-
+    
     assert_equal "1", xml.elements["//id"].text
-  unless ActiveRecord::Base.connection.servertype.class.name.include?('::IBM_IDS')
     assert_equal "integer" , xml.elements["//id"].attributes['type']
-  else
-    assert_equal "serial" , xml.elements["//id"].attributes['type']
-  end 
-
+    
     assert_equal "1", xml.elements["//replies-count"].text
     assert_equal "integer" , xml.elements["//replies-count"].attributes['type']
-
+    
     assert_equal written_on_in_current_timezone, xml.elements["//written-on"].text
     assert_equal "datetime" , xml.elements["//written-on"].attributes['type']
-
+    
     assert_equal "--- Have a nice day\n" , xml.elements["//content"].text
     assert_equal "yaml" , xml.elements["//content"].attributes['type']
-
+    
     assert_equal "david@loudthinking.com", xml.elements["//author-email-address"].text
-
+    
     assert_equal nil, xml.elements["//parent-id"].text
     assert_equal "integer", xml.elements["//parent-id"].attributes['type']
     assert_equal "true", xml.elements["//parent-id"].attributes['nil']
-
+    
     if current_adapter?(:SybaseAdapter, :SQLServerAdapter, :OracleAdapter)
       assert_equal last_read_in_current_timezone, xml.elements["//last-read"].text
       assert_equal "datetime" , xml.elements["//last-read"].attributes['type']
@@ -1598,40 +1786,40 @@ class IBMDBBasicsTest < Test::Unit::TestCase
       assert_equal "2004-04-15", xml.elements["//last-read"].text
       assert_equal "date" , xml.elements["//last-read"].attributes['type']
     end
-
+    
     # Oracle and DB2 don't have true boolean or time-only fields
     unless current_adapter?(:OracleAdapter, :DB2Adapter)
       assert_equal "false", xml.elements["//approved"].text
       assert_equal "boolean" , xml.elements["//approved"].attributes['type']
-
+      
       assert_equal bonus_time_in_current_timezone, xml.elements["//bonus-time"].text
       assert_equal "datetime" , xml.elements["//bonus-time"].attributes['type']
     end
   end
-
+  
   def test_to_xml_skipping_attributes
     xml = topics(:first).to_xml(:indent => 0, :skip_instruct => true, :except => [:title, :replies_count])
     assert_equal "<topic>", xml.first(7)
     assert !xml.include?(%(<title>The First Topic</title>))
-    assert xml.include?(%(<author-name>David</author-name>))    
-
+    assert xml.include?(%(<author-name>David</author-name>))
+    
     xml = topics(:first).to_xml(:indent => 0, :skip_instruct => true, :except => [:title, :author_name, :replies_count])
     assert !xml.include?(%(<title>The First Topic</title>))
-    assert !xml.include?(%(<author-name>David</author-name>))    
+    assert !xml.include?(%(<author-name>David</author-name>))
   end
-
+  
   def test_to_xml_including_has_many_association
     xml = topics(:first).to_xml(:indent => 0, :skip_instruct => true, :include => :replies, :except => :replies_count)
     assert_equal "<topic>", xml.first(7)
     assert xml.include?(%(<replies type="array"><reply>))
-    assert xml.include?(%(<title>The Second Topic's of the day</title>))
+    assert xml.include?(%(<title>The Second Topic of the day</title>))
   end
-
+  
   def test_array_to_xml_including_has_many_association
     xml = [ topics(:first), topics(:second) ].to_xml(:indent => 0, :skip_instruct => true, :include => :replies)
     assert xml.include?(%(<replies type="array"><reply>))
   end
-
+  
   def test_array_to_xml_including_methods
     xml = [ topics(:first), topics(:second) ].to_xml(:indent => 0, :skip_instruct => true, :methods => [ :topic_id ])
     assert xml.include?(%(<topic-id type="integer">#{topics(:first).topic_id}</topic-id>)), xml
@@ -1643,18 +1831,18 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     assert xml.include?(companies(:first_firm).account.to_xml(:indent => 0, :skip_instruct => true))
     assert xml.include?(companies(:rails_core).account.to_xml(:indent => 0, :skip_instruct => true))
   end
-
+  
   def test_array_to_xml_including_belongs_to_association
     xml = [ companies(:first_client), companies(:second_client), companies(:another_client) ].to_xml(:indent => 0, :skip_instruct => true, :include => :firm)
     assert xml.include?(companies(:first_client).to_xml(:indent => 0, :skip_instruct => true))
     assert xml.include?(companies(:second_client).firm.to_xml(:indent => 0, :skip_instruct => true))
     assert xml.include?(companies(:another_client).firm.to_xml(:indent => 0, :skip_instruct => true))
   end
-
+  
   def test_to_xml_including_belongs_to_association
     xml = companies(:first_client).to_xml(:indent => 0, :skip_instruct => true, :include => :firm)
     assert !xml.include?("<firm>")
-
+    
     xml = companies(:second_client).to_xml(:indent => 0, :skip_instruct => true, :include => :firm)
     assert xml.include?("<firm>")
   end
@@ -1665,11 +1853,11 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     assert xml.include?(%(<account>))
     assert xml.include?(%(<clients type="array"><client>))
   end
-
+  
   def test_to_xml_including_multiple_associations_with_options
     xml = companies(:first_firm).to_xml(
-      :indent  => 0, :skip_instruct => true, 
-      :include => { :clients => { :only => :name } }
+                                        :indent  => 0, :skip_instruct => true,
+                                        :include => { :clients => { :only => :name } }
     )
     
     assert_equal "<firm>", xml.first(6)
@@ -1692,23 +1880,6 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     assert xml.include?(%(<arbitrary-element>#{value}</arbitrary-element>))
   end
   
-  def test_except_attributes
-    assert_equal(
-      %w( author_name type id approved replies_count bonus_time written_on content author_email_address parent_id last_read), 
-      topics(:first).attributes(:except => :title).keys
-    )
-
-    assert_equal(
-      %w( replies_count bonus_time written_on content author_email_address parent_id last_read), 
-      topics(:first).attributes(:except => [ :title, :id, :type, :approved, :author_name ]).keys
-    )
-  end
-  
-  def test_include_attributes
-    assert_equal(%w( title ), topics(:first).attributes(:only => :title).keys)
-    assert_equal(%w( title author_name type id approved ), topics(:first).attributes(:only => [ :title, :id, :type, :approved, :author_name ]).keys)
-  end
-  
   def test_type_name_with_module_should_handle_beginning
     assert_equal 'ActiveRecord::Person', ActiveRecord::Base.send(:type_name_with_module, 'Person')
     assert_equal '::Person', ActiveRecord::Base.send(:type_name_with_module, '::Person')
@@ -1721,22 +1892,18 @@ class IBMDBBasicsTest < Test::Unit::TestCase
   def test_inspect_class
     assert_equal 'ActiveRecord::Base', ActiveRecord::Base.inspect
     assert_equal 'LoosePerson(abstract)', LoosePerson.inspect
-  unless ActiveRecord::Base.connection.servertype.class.name.include?('::IBM_IDS')
     assert_match(/^Topic\(id: integer, title: string/, Topic.inspect)
-  else
-    assert_match(/^Topic\(id: serial, title: string/, Topic.inspect)
-  end 
   end
-
+  
   def test_inspect_instance
     topic = topics(:first)
     assert_equal %(#<Topic id: 1, title: "The First Topic", author_name: "David", author_email_address: "david@loudthinking.com", written_on: "#{topic.written_on.to_s(:db)}", bonus_time: "#{topic.bonus_time.to_s(:db)}", last_read: "#{topic.last_read.to_s(:db)}", content: "Have a nice day", approved: false, replies_count: 1, parent_id: nil, type: nil>), topic.inspect
   end
-
+  
   def test_inspect_new_instance
     assert_match /Topic id: nil/, Topic.new.inspect
   end
-
+  
   def test_inspect_limited_select_instance
     assert_equal %(#<Topic id: 1>), Topic.find(:first, :select => 'id', :conditions => 'id = 1').inspect
     assert_equal %(#<Topic id: 1, title: "The First Topic">), Topic.find(:first, :select => 'id, title', :conditions => 'id = 1').inspect
@@ -1745,11 +1912,11 @@ class IBMDBBasicsTest < Test::Unit::TestCase
   def test_inspect_class_without_table
     assert_equal "NonExistentTable(Table doesn't exist)", NonExistentTable.inspect
   end
-
+  
   def test_attribute_for_inspect
     t = topics(:first)
     t.title = "The First Topic Now Has A Title With\nNewlines And More Than 50 Characters"
-
+    
     assert_equal %("#{t.written_on.to_s(:db)}"), t.attribute_for_inspect(:written_on)
     assert_equal '"The First Topic Now Has A Title With\nNewlines And M..."', t.attribute_for_inspect(:title)
   end
@@ -1758,4 +1925,57 @@ class IBMDBBasicsTest < Test::Unit::TestCase
     assert_kind_of Reply, topics(:first).becomes(Reply)
     assert_equal "The First Topic", topics(:first).becomes(Reply).title
   end
+  
+  def test_silence_sets_log_level_to_error_in_block
+    original_logger = ActiveRecord::Base.logger
+    log = StringIO.new
+    ActiveRecord::Base.logger = Logger.new(log)
+    ActiveRecord::Base.logger.level = Logger::DEBUG
+    ActiveRecord::Base.silence do
+      ActiveRecord::Base.logger.warn "warn"
+      ActiveRecord::Base.logger.error "error"
+    end
+    assert_equal "error\n", log.string
+  ensure
+    ActiveRecord::Base.logger = original_logger
+  end
+  
+  def test_silence_sets_log_level_back_to_level_before_yield
+    original_logger = ActiveRecord::Base.logger
+    log = StringIO.new
+    ActiveRecord::Base.logger = Logger.new(log)
+    ActiveRecord::Base.logger.level = Logger::WARN
+    ActiveRecord::Base.silence do
+    end
+    assert_equal Logger::WARN, ActiveRecord::Base.logger.level
+  ensure
+    ActiveRecord::Base.logger = original_logger
+  end
+  
+  def test_benchmark_with_log_level
+    original_logger = ActiveRecord::Base.logger
+    log = StringIO.new
+    ActiveRecord::Base.logger = Logger.new(log)
+    ActiveRecord::Base.logger.level = Logger::WARN
+    ActiveRecord::Base.benchmark("Debug Topic Count", Logger::DEBUG) { Topic.count }
+    ActiveRecord::Base.benchmark("Warn Topic Count",  Logger::WARN)  { Topic.count }
+    ActiveRecord::Base.benchmark("Error Topic Count", Logger::ERROR) { Topic.count }
+    assert_no_match /Debug Topic Count/, log.string
+    assert_match /Warn Topic Count/, log.string
+    assert_match /Error Topic Count/, log.string
+  ensure
+    ActiveRecord::Base.logger = original_logger
+  end
+  
+  def test_benchmark_with_use_silence
+    original_logger = ActiveRecord::Base.logger
+    log = StringIO.new
+    ActiveRecord::Base.logger = Logger.new(log)
+    ActiveRecord::Base.benchmark("Logging", Logger::DEBUG, true) { ActiveRecord::Base.logger.debug "Loud" }
+    ActiveRecord::Base.benchmark("Logging", Logger::DEBUG, false)  { ActiveRecord::Base.logger.debug "Quiet" }
+    assert_no_match /Loud/, log.string
+    assert_match /Quiet/, log.string
+  ensure
+    ActiveRecord::Base.logger = original_logger
+  end
 end